SYMBOL INDEX (2877 symbols across 196 files)

FILE: .ci/build.py
  function run_conan (line 8) | def run_conan(args):
  function build (line 15) | def build(argv):

FILE: .ci/test-install.cpp
  function main (line 5) | int main() {

FILE: conanfile.py
  function get_gtirb_version (line 9) | def get_gtirb_version():
  function branch_to_channel (line 34) | def branch_to_channel(branch):
  class Properties (line 41) | class Properties:
    method version (line 47) | def version(self):
    method version (line 53) | def version(self, ver):
    method description (line 57) | def description(self):
    method url (line 61) | def url(self):
    method conan_channel (line 65) | def conan_channel(self):
    method archived_channels (line 73) | def archived_channels(self):
    method conan_ref (line 85) | def conan_ref(self):
    method conan_recipe (line 90) | def conan_recipe(self):
  class GtirbConan (line 94) | class GtirbConan(Properties, ConanFile):
    method configure (line 104) | def configure(self):
    method build_requirements (line 113) | def build_requirements(self):
    method build (line 117) | def build(self):
    method build_cmake (line 126) | def build_cmake(self):
    method package (line 170) | def package(self):
    method package_info (line 173) | def package_info(self):
    method package_id (line 176) | def package_id(self):

FILE: doc/examples/api-walkthrough.cpp
  function main (line 8) | int main() {

FILE: doc/examples/cfg-paths.cpp
  class PrintPathsVisitor (line 25) | class PrintPathsVisitor {
    method PrintPathsVisitor (line 29) | PrintPathsVisitor(const CFG& G, const CodeBlock& B)
    method visit (line 32) | void visit(Vertex V) {
  function main (line 67) | int main(int argc, char** argv) {

FILE: doc/examples/cfgpaths.java
  class cfgpaths (line 60) | class cfgpaths {
    method printPath (line 67) | static void printPath(Stack<Long> path) {
    method printPathsRec (line 79) | static int printPathsRec(ByteString src, ByteString targ,
    method printPaths (line 108) | static void printPaths(Block source, Block target, CFG cfg) {
    method findBlockByAddr (line 129) | static Block findBlockByAddr(Long addr, CFG cfg) {
    method main (line 138) | public static void main(String[] args) {

FILE: doc/examples/data-symbols.cpp
  function main (line 19) | int main(int argc, char** argv) {

FILE: doc/examples/datasymbols.java
  class datasymbols (line 57) | class datasymbols {
    method main (line 59) | public static void main(String[] args) {

FILE: doc/examples/functions.cpp
  function register_aux_data_types (line 21) | void register_aux_data_types() {
  function main (line 27) | int main(int argc, char** argv) {

FILE: doc/examples/jumps.cpp
  function main (line 20) | int main(int argc, char** argv) {

FILE: doc/preprocmd.py
  function anchor_page_headings (line 15) | def anchor_page_headings(pagetxt):
  function makePyApiLink (line 51) | def makePyApiLink(pymatch):
  function makeDoxyExampleLink (line 67) | def makeDoxyExampleLink(exname, linktext, pathadj):

FILE: include/gtirb/Addr.hpp
  type gtirb (line 28) | namespace gtirb {
    function Addr (line 37) | class GTIRB_EXPORT_API Addr {
    function AddrRange (line 205) | class GTIRB_EXPORT_API AddrRange {
    function asOptionalSize (line 255) | std::optional<uint64_t> inline asOptionalSize(uint64_t X) {
    function asOptionalSize (line 260) | std::optional<uint64_t> inline asOptionalSize(std::optional<uint64_t> ...
    function addressRange (line 275) | std::optional<AddrRange> addressRange(const T& Object) {
    function addressLimit (line 294) | std::optional<Addr> addressLimit(const T& Object) {
    function containsAddr (line 314) | bool containsAddr(const T& Object, Addr Ea) {
  type std (line 359) | namespace std {
    type hash<gtirb::Addr> (line 362) | struct hash<gtirb::Addr> {

FILE: include/gtirb/Allocator.hpp
  type gtirb (line 43) | namespace gtirb {
    type allocator (line 48) | namespace allocator {
      function GTIRB_DEPRECATED_UTILS (line 56) | GTIRB_DEPRECATED_UTILS inline uint64_t NextPowerOf2(uint64_t A) {
      function GTIRB_DEPRECATED_UTILS (line 70) | GTIRB_DEPRECATED_UTILS constexpr inline bool isPowerOf2_64(uint64_t ...
      function GTIRB_DEPRECATED_UTILS (line 81) | GTIRB_DEPRECATED_UTILS inline uintptr_t alignAddr(const void* Addr,
      function GTIRB_DEPRECATED_UTILS (line 96) | GTIRB_DEPRECATED_UTILS inline size_t alignmentAdjustment(const void*...
      function BumpPtrAllocatorImpl (line 112) | class GTIRB_DEPRECATED_UTILS BumpPtrAllocatorImpl {
      function SpecificBumpPtrAllocator (line 299) | class GTIRB_DEPRECATED_UTILS SpecificBumpPtrAllocator {
  type S (line 390) | struct S {

FILE: include/gtirb/AuxData.hpp
  type gtirb (line 40) | namespace gtirb {
    type proto (line 41) | namespace proto {
      class AuxData (line 42) | class AuxData
    class Context (line 44) | class Context
    type is_sequence (line 110) | struct is_sequence : std::false_type {}
    type is_sequence<std::vector<T>> (line 113) | struct is_sequence<std::vector<T>> : std::true_type {}
    type is_sequence<std::list<T>> (line 114) | struct is_sequence<std::list<T>> : std::true_type {}
    type is_sequence<std::deque<T>> (line 115) | struct is_sequence<std::deque<T>> : std::true_type {}
    type is_mapping (line 123) | struct is_mapping : std::false_type {}
    type is_mapping<std::map<T, U>> (line 126) | struct is_mapping<std::map<T, U>> : std::true_type {}
    type is_mapping<std::unordered_map<T, U>> (line 128) | struct is_mapping<std::unordered_map<T, U>> : std::true_type {}
    type is_mapping<std::multimap<T, U>> (line 132) | struct is_mapping<std::multimap<T, U>> : std::false_type {}
    type is_mapping<std::unordered_multimap<T, U>> (line 134) | struct is_mapping<std::unordered_multimap<T, U>> : std::false_type {}
    type is_set (line 142) | struct is_set : std::false_type {}
    type is_tuple (line 160) | struct is_tuple : std::false_type {}
    class ToByteRange (line 169) | class ToByteRange {
      method ToByteRange (line 171) | explicit ToByteRange(std::string& Bytes) : It(std::back_inserter(Byt...
      method write (line 173) | void write(std::byte Byte) { *It = static_cast<char>(Byte); }
    class FromByteRange (line 180) | class FromByteRange {
      method FromByteRange (line 182) | explicit FromByteRange(const std::string& Bytes)
      method read (line 185) | bool read(std::byte& Byte) {
      method remainingBytesToRead (line 194) | uint64_t remainingBytesToRead() const {
    type auxdata_traits (line 211) | struct auxdata_traits {
      method toBytes (line 216) | static void toBytes(const T& Object, ToByteRange& TBR) = delete;
      method fromBytes (line 224) | static bool fromBytes(T& Object, FromByteRange& FBR) = delete;
      method type_name (line 232) | static std::string type_name() = delete;
    type TypeId (line 236) | struct TypeId {}
    type is_endian_type (line 239) | struct is_endian_type
    type default_serialization (line 244) | struct default_serialization {}
    type default_serialization<
    T, typename std::enable_if_t<is_endian_type<T>::value ||
                                 std::is_floating_point<T>::value ||
                                 std::is_same<T, bool>::value>> (line 248) | struct default_serialization<
      method toBytes (line 252) | static void toBytes(const T& object, ToByteRange& TBR) {
      method fromBytes (line 268) | static bool fromBytes(T& object, FromByteRange& FBR) {
    type auxdata_traits<std::byte> (line 293) | struct auxdata_traits<std::byte> : default_serialization<std::byte> {
      method type_name (line 294) | static std::string type_name() { return "byte"; }
      method toBytes (line 296) | static void toBytes(std::byte object, ToByteRange& TBR) { TBR.write(...
      method fromBytes (line 298) | static bool fromBytes(std::byte& object, FromByteRange& FBR) {
    type auxdata_traits<Addr> (line 303) | struct auxdata_traits<Addr> : default_serialization<Addr> {
      method type_name (line 304) | static std::string type_name() { return "Addr"; }
    type auxdata_traits<UUID> (line 307) | struct auxdata_traits<UUID> : default_serialization<UUID> {
      method type_name (line 308) | static std::string type_name() { return "UUID"; }
    type auxdata_traits<T, typename std::enable_if_t<std::is_integral<T>::value &&
                                                   std::is_signed<T>::value>> (line 312) | struct auxdata_traits<T, typename std::enable_if_t<std::is_integral<T>...
      method type_name (line 315) | static std::string type_name() {
    type auxdata_traits<T, typename std::enable_if_t<std::is_integral<T>::value &&
                                                   std::is_unsigned<T>::value>> (line 321) | struct auxdata_traits<T, typename std::enable_if_t<std::is_integral<T>...
      method type_name (line 324) | static std::string type_name() {
    type auxdata_traits<bool> (line 329) | struct auxdata_traits<bool> : default_serialization<bool> {
      method type_name (line 330) | static std::string type_name() { return "bool"; }
    type auxdata_traits<float> (line 333) | struct auxdata_traits<float> : default_serialization<float> {
      method type_name (line 334) | static std::string type_name() { return "float"; }
    type auxdata_traits<double> (line 337) | struct auxdata_traits<double> : default_serialization<double> {
      method type_name (line 338) | static std::string type_name() { return "double"; }
    type auxdata_traits<std::string> (line 341) | struct auxdata_traits<std::string> {
      method type_name (line 342) | static std::string type_name() { return "string"; }
      method toBytes (line 344) | static void toBytes(const std::string& Object, ToByteRange& TBR) {
      method fromBytes (line 350) | static bool fromBytes(std::string& Object, FromByteRange& FBR) {
    type auxdata_traits<Offset> (line 369) | struct auxdata_traits<Offset> {
      method type_name (line 370) | static std::string type_name() { return "Offset"; }
      method toBytes (line 372) | static void toBytes(const Offset& Object, ToByteRange& TBR) {
      method fromBytes (line 377) | static bool fromBytes(Offset& Object, FromByteRange& FBR) {
    type auxdata_traits<T, typename std::enable_if_t<is_sequence<T>::value>> (line 385) | struct auxdata_traits<T, typename std::enable_if_t<is_sequence<T>::val...
      method type_name (line 386) | static std::string type_name() {
      method toBytes (line 390) | static void toBytes(const T& Object, ToByteRange& TBR) {
      method fromBytes (line 397) | static bool fromBytes(T& Object, FromByteRange& FBR) {
    type auxdata_traits<T, typename std::enable_if_t<is_set<T>::value>> (line 417) | struct auxdata_traits<T, typename std::enable_if_t<is_set<T>::value>> {
      method type_name (line 418) | static std::string type_name() {
      method toBytes (line 422) | static void toBytes(const T& Object, ToByteRange& TBR) {
      method fromBytes (line 428) | static bool fromBytes(T& Object, FromByteRange& FBR) {
    type auxdata_traits<T, typename std::enable_if_t<is_mapping<T>::value>> (line 448) | struct auxdata_traits<T, typename std::enable_if_t<is_mapping<T>::valu...
      method type_name (line 449) | static std::string type_name() {
      method toBytes (line 454) | static void toBytes(const T& Object, ToByteRange& TBR) {
      method fromBytes (line 462) | static bool fromBytes(T& Object, FromByteRange& FBR) {
    type tuple_traits (line 549) | struct tuple_traits {}
    function static_for (line 567) | constexpr void static_for(Func&& f, std::integer_sequence<size_t, Is.....
    type auxdata_traits<T, typename std::enable_if_t<is_tuple<T>::value>> (line 572) | struct auxdata_traits<T, typename std::enable_if_t<is_tuple<T>::value>>
      method toBytes (line 574) | static void toBytes(const T& Object, ToByteRange& TBR) {
      method fromBytes (line 584) | static bool fromBytes(T& Object, FromByteRange& FBR) {
    type TypeId<T> (line 601) | struct TypeId<T> {
      method value (line 602) | static std::string value() { return auxdata_traits<T>::type_name(); }
    function AuxData (line 613) | class GTIRB_EXPORT_API AuxData {
    class AuxDataImpl (line 699) | class AuxDataImpl : public AuxData {
      method AuxDataImpl (line 701) | AuxDataImpl() = default;
      method AuxDataImpl (line 702) | AuxDataImpl(typename Schema::Type&& Val) : Object(std::move(Val)){}
      method staticGetApiTypeId (line 705) | static std::size_t staticGetApiTypeId() {
      method getApiTypeId (line 710) | virtual std::size_t getApiTypeId() const override {
      method fromProtobuf (line 717) | static std::unique_ptr<AuxData> fromProtobuf(const MessageType& Mess...
      method toProtobuf (line 741) | virtual void toProtobuf(MessageType* Message) const override {
      method save (line 754) | void save(std::ostream& Out) const { AuxData::save(Out); }
      method load (line 757) | static std::unique_ptr<AuxDataImpl> load([[maybe_unused]] Context& C,
  type is_set<std::set<Args...>> (line 144) | struct is_set<std::set<Args...>> : std::true_type {}
  type is_set<std::unordered_set<Args...>> (line 146) | struct is_set<std::unordered_set<Args...>> : std::true_type {}
  type is_set<std::multiset<Args...>> (line 150) | struct is_set<std::multiset<Args...>> : std::false_type {}
  type is_set<std::unordered_multiset<Args...>> (line 152) | struct is_set<std::unordered_multiset<Args...>> : std::false_type {}
  type is_tuple<std::tuple<Args...>> (line 163) | struct is_tuple<std::tuple<Args...>> : std::true_type {}
  type is_tuple<std::pair<Args...>> (line 166) | struct is_tuple<std::pair<Args...>> : std::true_type {}
  type auxdata_traits<std::variant<Args...>> (line 487) | struct auxdata_traits<std::variant<Args...>> {
    method type_name (line 490) | static std::string type_name() {
    method expand_type (line 495) | static std::optional<std::variant<Args...>> expand_type(uint64_t i) {
    method toBytes (line 505) | static void toBytes(const T& Object, ToByteRange& TBR) {
    method fromBytes (line 517) | static bool fromBytes(T& Object, FromByteRange& FBR) {
  type tuple_traits<std::tuple<Ts...>> (line 550) | struct tuple_traits<std::tuple<Ts...>> {
    method type_name (line 553) | static std::string type_name() {
  type tuple_traits<std::pair<Ts...>> (line 558) | struct tuple_traits<std::pair<Ts...>> {
    method type_name (line 561) | static std::string type_name() {
  type TypeId<T, Ts...> (line 605) | struct TypeId<T, Ts...> {
    method value (line 606) | static std::string value() {

FILE: include/gtirb/AuxDataContainer.hpp
  type gtirb (line 28) | namespace gtirb {
    type proto (line 30) | namespace proto {
      class IR (line 31) | class IR
      class Module (line 32) | class Module
    type message_has_aux_data_container (line 36) | struct message_has_aux_data_container {
    type message_has_aux_data_container<proto::IR> (line 39) | struct message_has_aux_data_container<proto::IR> {
    type message_has_aux_data_container<proto::Module> (line 42) | struct message_has_aux_data_container<proto::Module> {
    function AuxDataContainer (line 56) | class GTIRB_EXPORT_API AuxDataContainer : public Node {

FILE: include/gtirb/AuxDataSchema.hpp
  type gtirb (line 32) | namespace gtirb {
    type schema (line 33) | namespace schema {
      type FunctionBlocks (line 36) | struct FunctionBlocks {
      type FunctionEntries (line 42) | struct FunctionEntries {
      type FunctionNames (line 48) | struct FunctionNames {
      type Types (line 54) | struct Types {
      type Alignment (line 60) | struct Alignment {
      type Comments (line 66) | struct Comments {
      type SymbolForwarding (line 72) | struct SymbolForwarding {
      type Padding (line 78) | struct Padding {
      type ElfDynamicInit (line 85) | struct ElfDynamicInit {
      type ElfDynamicFini (line 92) | struct ElfDynamicFini {
      type ElfSoname (line 99) | struct ElfSoname {
      type ElfStackExec (line 106) | struct ElfStackExec {
      type ElfStackSize (line 113) | struct ElfStackSize {
    type provisional_schema (line 120) | namespace provisional_schema {
      type Profile (line 123) | struct Profile {
      type ElfSymbolVersions (line 151) | struct ElfSymbolVersions {

FILE: include/gtirb/ByteInterval.hpp
  type gtirb (line 52) | namespace gtirb {
    type proto (line 53) | namespace proto {
      class ByteInterval (line 54) | class ByteInterval
    class Section (line 57) | class Section
    class CodeBlock (line 58) | class CodeBlock
    class DataBlock (line 59) | class DataBlock
    class ByteIntervalObserver (line 60) | class ByteIntervalObserver
    class ErrorOr (line 62) | class ErrorOr
    function CodeBlockObserver (line 68) | class GTIRB_EXPORT_API CodeBlockObserver {
    function DataBlockObserver (line 94) | class GTIRB_EXPORT_API DataBlockObserver {
    function ByteInterval (line 124) | class GTIRB_EXPORT_API ByteInterval : public Node {
    function ByteInterval (line 271) | static ByteInterval* Create(Context& C, uint64_t Size,
    function ByteInterval (line 285) | static ByteInterval* Create(Context& C, std::optional<Addr> Address,
    function ByteInterval (line 306) | static ByteInterval* Create(Context& C, InputIterator Begin,
    function ByteInterval (line 331) | static ByteInterval* Create(Context& C, std::optional<Addr> Address,
    function Section (line 341) | Section* getSection() { return Parent; }
    function Section (line 343) | const Section* getSection() const { return Parent; }
    function getAddress (line 352) | std::optional<Addr> getAddress() const { return Address; }
    function block_iterator (line 394) | block_iterator blocks_begin() { return block_iterator(Blocks.begin()); }
    function const_block_iterator (line 396) | const_block_iterator blocks_begin() const {
    function block_iterator (line 400) | block_iterator blocks_end() { return block_iterator(Blocks.end()); }
    function const_block_iterator (line 403) | const_block_iterator blocks_end() const {
    function block_range (line 407) | block_range blocks() {
    function const_block_range (line 411) | const_block_range blocks() const {
    function block_subrange (line 421) | block_subrange findBlocksOnOffset(uint64_t Off) {
    function const_block_subrange (line 434) | const_block_subrange findBlocksOnOffset(uint64_t Off) const {
    function block_subrange (line 448) | block_subrange findBlocksOn(Addr A) {
    function const_block_subrange (line 462) | const_block_subrange findBlocksOn(Addr A) const {
    function block_range (line 475) | block_range findBlocksAtOffset(uint64_t Off) {
    function block_range (line 488) | block_range findBlocksAtOffset(uint64_t Low, uint64_t High) {
    function block_range (line 502) | block_range findBlocksAt(Addr A) {
    function block_range (line 517) | block_range findBlocksAt(Addr Low, Addr High) {
    function const_block_range (line 532) | const_block_range findBlocksAtOffset(uint64_t Off) const {
    function const_block_range (line 545) | const_block_range findBlocksAtOffset(uint64_t Low, uint64_t High) const {
    function const_block_range (line 559) | const_block_range findBlocksAt(Addr A) const {
    function const_block_range (line 574) | const_block_range findBlocksAt(Addr Low, Addr High) const {
    function code_block_iterator (line 634) | code_block_iterator code_blocks_begin() {
    function const_code_block_iterator (line 639) | const_code_block_iterator code_blocks_begin() const {
    function code_block_iterator (line 645) | code_block_iterator code_blocks_end() {
    function const_code_block_iterator (line 651) | const_code_block_iterator code_blocks_end() const {
    function code_block_range (line 656) | code_block_range code_blocks() {
    function const_code_block_range (line 661) | const_code_block_range code_blocks() const {
    function code_block_subrange (line 670) | code_block_subrange findCodeBlocksOnOffset(uint64_t Off) {
    function const_code_block_subrange (line 686) | const_code_block_subrange findCodeBlocksOnOffset(uint64_t Off) const {
    function code_block_subrange (line 703) | code_block_subrange findCodeBlocksOn(Addr A) {
    function const_code_block_subrange (line 716) | const_code_block_subrange findCodeBlocksOn(Addr A) const {
    function code_block_range (line 728) | code_block_range findCodeBlocksAtOffset(uint64_t Off) {
    function code_block_range (line 743) | code_block_range findCodeBlocksAtOffset(uint64_t Low, uint64_t High) {
    function code_block_range (line 757) | code_block_range findCodeBlocksAt(Addr A) {
    function code_block_range (line 771) | code_block_range findCodeBlocksAt(Addr Low, Addr High) {
    function const_code_block_range (line 785) | const_code_block_range findCodeBlocksAtOffset(uint64_t Off) const {
    function const_code_block_range (line 800) | const_code_block_range findCodeBlocksAtOffset(uint64_t Low,
    function const_code_block_range (line 817) | const_code_block_range findCodeBlocksAt(Addr A) const {
    function const_code_block_range (line 831) | const_code_block_range findCodeBlocksAt(Addr Low, Addr High) const {
    function data_block_iterator (line 891) | data_block_iterator data_blocks_begin() {
    function const_data_block_iterator (line 896) | const_data_block_iterator data_blocks_begin() const {
    function data_block_iterator (line 902) | data_block_iterator data_blocks_end() {
    function const_data_block_iterator (line 908) | const_data_block_iterator data_blocks_end() const {
    function data_block_range (line 913) | data_block_range data_blocks() {
    function const_data_block_range (line 918) | const_data_block_range data_blocks() const {
    function data_block_subrange (line 927) | data_block_subrange findDataBlocksOnOffset(uint64_t Off) {
    function const_data_block_subrange (line 943) | const_data_block_subrange findDataBlocksOnOffset(uint64_t Off) const {
    function data_block_subrange (line 960) | data_block_subrange findDataBlocksOn(Addr A) {
    function const_data_block_subrange (line 973) | const_data_block_subrange findDataBlocksOn(Addr A) const {
    function data_block_range (line 985) | data_block_range findDataBlocksAtOffset(uint64_t Off) {
    function data_block_range (line 1000) | data_block_range findDataBlocksAtOffset(uint64_t Low, uint64_t High) {
    function data_block_range (line 1014) | data_block_range findDataBlocksAt(Addr A) {
    function data_block_range (line 1028) | data_block_range findDataBlocksAt(Addr Low, Addr High) {
    function const_data_block_range (line 1042) | const_data_block_range findDataBlocksAtOffset(uint64_t Off) const {
    function const_data_block_range (line 1057) | const_data_block_range findDataBlocksAtOffset(uint64_t Low,
    function const_data_block_range (line 1074) | const_data_block_range findDataBlocksAt(Addr A) const {
    function const_data_block_range (line 1088) | const_data_block_range findDataBlocksAt(Addr Low, Addr High) const {
    function ByteIntervalType (line 1116) | ByteIntervalType* getByteInterval() { return BI; }
    function ByteIntervalType (line 1119) | const ByteIntervalType* getByteInterval() const { return BI; }
    function getOffset (line 1122) | uint64_t getOffset() const { return Off; }
    function SymbolicExpression (line 1126) | const SymbolicExpression& getSymbolicExpression() const { return SE; }
    type AddressLess (line 1138) | struct AddressLess {
      method key_type (line 1140) | static key_type
    class SymExprPairToElement (line 1167) | class SymExprPairToElement {
      method SymExprPairToElement (line 1173) | explicit SymExprPairToElement(ByteIntervalType BI_) : BI{BI_} {}
      method SymExprElementType (line 1175) | SymExprElementType
    function symbolic_expression_iterator (line 1215) | symbolic_expression_iterator symbolic_expressions_begin() {
    function const_symbolic_expression_iterator (line 1221) | const_symbolic_expression_iterator symbolic_expressions_begin() const {
    function symbolic_expression_iterator (line 1228) | symbolic_expression_iterator symbolic_expressions_end() {
    function const_symbolic_expression_iterator (line 1235) | const_symbolic_expression_iterator symbolic_expressions_end() const {
    function symbolic_expression_range (line 1242) | symbolic_expression_range symbolic_expressions() {
    function const_symbolic_expression_range (line 1248) | const_symbolic_expression_range symbolic_expressions() const {
    function symbolic_expression_range (line 1264) | symbolic_expression_range findSymbolicExpressionsAtOffset(uint64_t Off) {
    function symbolic_expression_range (line 1282) | symbolic_expression_range findSymbolicExpressionsAtOffset(uint64_t Low,
    function symbolic_expression_range (line 1304) | symbolic_expression_range findSymbolicExpressionsAt(Addr A) {
    function symbolic_expression_range (line 1320) | symbolic_expression_range findSymbolicExpressionsAt(Addr Low, Addr Hig...
    function const_symbolic_expression_range (line 1339) | const_symbolic_expression_range
    function const_symbolic_expression_range (line 1359) | const_symbolic_expression_range
    function const_symbolic_expression_range (line 1381) | const_symbolic_expression_range findSymbolicExpressionsAt(Addr A) const {
    function const_symbolic_expression_range (line 1397) | const_symbolic_expression_range findSymbolicExpressionsAt(Addr Low,
    function BlockType (line 1453) | BlockType* addBlock(Context& C, uint64_t O, Args&&... A) {
    function SymbolicExpression (line 1470) | SymbolicExpression& addSymbolicExpression(uint64_t Off,
    function SymbolicExpression (line 1485) | SymbolicExpression& addSymbolicExpression(uint64_t Off, Args... A) {
    function removeSymbolicExpression (line 1498) | bool removeSymbolicExpression(uint64_t Off) {
    function SymbolicExpression (line 1510) | SymbolicExpression* getSymbolicExpression(uint64_t Off) {
    function SymbolicExpression (line 1524) | const SymbolicExpression* getSymbolicExpression(uint64_t Off) const {
    function getSize (line 1545) | uint64_t getSize() const { return Size; }
    function getInitializedSize (line 1568) | uint64_t getInitializedSize() const { return Bytes.size(); }
    function setInitializedSize (line 1584) | void setInitializedSize(uint64_t S) {
  function endian_flip (line 1603) | static inline std::enable_if_t<sizeof(T) == 1, T>
  class BytesReference (line 1617) | class BytesReference {
    method BytesReference (line 1619) | BytesReference(ByteIntervalType* BI_, size_t I_,
  class BytesBaseIterator (line 1695) | class BytesBaseIterator
    method BytesBaseIterator (line 1702) | BytesBaseIterator(ByteIntervalType* BI_, size_t I_,
    method BytesBaseIterator (line 1716) | BytesBaseIterator() = default;
    method reference (line 1719) | reference dereference() const {
    method equal (line 1724) | bool equal(const self& other) const {
    method increment (line 1728) | void increment() {
    method decrement (line 1733) | void decrement() {
    method advance (line 1738) | void advance(typename self::difference_type n) {
    method distance_to (line 1743) | typename self::difference_type distance_to(const self& other) const {
  function bytes_begin (line 1793) | bytes_iterator<T> bytes_begin() {
  function bytes_begin (line 1805) | bytes_iterator<T>
  function bytes_end (line 1815) | bytes_iterator<T> bytes_end() {
  function bytes_end (line 1827) | bytes_iterator<T>
  function bytes (line 1837) | bytes_range<T> bytes() {
  function bytes (line 1849) | bytes_range<T>
  function bytes_begin (line 1860) | const_bytes_iterator<T> bytes_begin() const {
  function bytes_begin (line 1872) | const_bytes_iterator<T> bytes_begin(
  function bytes_end (line 1882) | const_bytes_iterator<T> bytes_end() const {
  function bytes_end (line 1894) | const_bytes_iterator<T> bytes_end(
  function bytes (line 1904) | const_bytes_range<T> bytes() const {
  function bytes (line 1916) | const_bytes_range<T>
  function BytesIterator (line 1980) | BytesIterator insertSingleByte(
  function insertBytes (line 2014) | bytes_iterator<T> insertBytes(bytes_iterator<T> Pos, const T& X) {
  function insertBytes (line 2031) | const_bytes_iterator<T> insertBytes(
  function insertBytes (line 2051) | bytes_iterator<T> insertBytes(
  function insertBytes (line 2072) | const_bytes_iterator<T> insertBytes(const const_bytes_iterator<T> Pos,
  function insertBytes (line 2090) | bytes_iterator<T> insertBytes(bytes_iterator<T> Pos, InputIterator Begin,
  function insertBytes (line 2111) | const_bytes_iterator<T> insertBytes(
  function insertBytes (line 2134) | bytes_iterator<T> insertBytes(
  function eraseBytes (line 2152) | const_bytes_iterator<T> eraseBytes(const const_bytes_iterator<T> Begin,
  function T (line 2184) | T* rawBytes() {
  function T (line 2198) | const T* rawBytes() const {
  function classof (line 2203) | static bool classof(const Node* N) {
  function ByteInterval (line 2222) | ByteInterval(Context& C, std::optional<Addr> A, uint64_t S, uint64_t Ini...
  function ByteInterval (line 2230) | ByteInterval(Context& C, std::optional<Addr> A, uint64_t S, uint64_t Ini...
  function setParent (line 2237) | void setParent(Section* S, ByteIntervalObserver* O) {
  function ByteInterval (line 2243) | static ByteInterval* Create(Context& C, std::optional<Addr> Address,
  function ByteIntervalObserver (line 2324) | class GTIRB_EXPORT_API ByteIntervalObserver {

FILE: include/gtirb/CFG.hpp
  type gtirb (line 35) | namespace gtirb {
    class CfgNode (line 36) | class CfgNode
    class CodeBlock (line 37) | class CodeBlock
    type ConditionalEdge (line 49) | enum class ConditionalEdge : bool {
    type DirectEdge (line 60) | enum class DirectEdge : bool { IsIndirect, IsDirect }
    type EdgeType (line 66) | enum class EdgeType { Branch, Call, Fallthrough, Return, Syscall, Sysr...
    type CfgBuilder (line 84) | struct CfgBuilder {
    class cfg_node_iter_base (line 107) | class cfg_node_iter_base
      method cfg_node_iter_base (line 112) | cfg_node_iter_base() = default;
      method cfg_node_iter_base (line 113) | cfg_node_iter_base(const CFG& cfg_, CFG::vertex_iterator& it_)
      method cfg_node_iter_base (line 117) | cfg_node_iter_base(const cfg_node_iter_base&) = default;
      method cfg_node_iter_base (line 118) | cfg_node_iter_base(cfg_node_iter_base&&) = default;
      method cfg_node_iter_base (line 119) | cfg_node_iter_base& operator=(const cfg_node_iter_base&) = default;
      method cfg_node_iter_base (line 120) | cfg_node_iter_base& operator=(cfg_node_iter_base&&) = default;
      method increment (line 125) | void increment() { ++it; }
      method decrement (line 126) | void decrement() { --it; }
      method distance_to (line 128) | std::ptrdiff_t distance_to(const cfg_node_iter_base& other) const {
      method equal (line 132) | bool equal(const cfg_node_iter_base& other) const { return it == oth...
    type downcast (line 142) | struct downcast {
    type not_null (line 148) | struct not_null {
    class cfg_node_cast_iter (line 162) | class cfg_node_cast_iter
      method cfg_node_cast_iter (line 170) | cfg_node_cast_iter() : parent() {}
      method cfg_node_cast_iter (line 172) | cfg_node_cast_iter(const CFG& g, CFG::vertex_iterator& first,
      method cfg_node_cast_iter (line 178) | cfg_node_cast_iter(const cfg_node_cast_iter<OtherT>& other) : parent...
    type CfgPredecessorTraits (line 320) | struct CfgPredecessorTraits {
      method CfgNode (line 322) | static CfgNode* getNode(const CFG::edge_descriptor& EDesc, const CFG...
      method getEdges (line 325) | static std::pair<edge_iterator, edge_iterator>
    type CfgSuccessorTraits (line 334) | struct CfgSuccessorTraits {
      method CfgNode (line 336) | static CfgNode* getNode(const CFG::edge_descriptor& EDesc, const CFG...
      method getEdges (line 339) | static std::pair<edge_iterator, edge_iterator>
    type EdgeDescrToNodeLabel (line 351) | struct EdgeDescrToNodeLabel {
      method EdgeDescrToNodeLabel (line 359) | EdgeDescrToNodeLabel() = default;
      method EdgeDescrToNodeLabel (line 360) | EdgeDescrToNodeLabel(const CFG* G) : Cfg(G) {}
      method EdgeDescrToNodeLabel (line 363) | EdgeDescrToNodeLabel(const EdgeDescrToNodeLabel<Traits, CfgNode*>& Rhs)
    function cfgEdgeIters (line 388) | auto cfgEdgeIters(const CFG& G, const CfgNode* N) {
    function cfg_predecessors_range (line 437) | inline cfg_predecessors_range cfgPredecessors(CFG& G, const CfgNode* N) {
    function const_cfg_predecessors_range (line 440) | inline const_cfg_predecessors_range cfgPredecessors(const CFG& G,
    function cfg_successors_range (line 457) | inline cfg_successors_range cfgSuccessors(CFG& G, const CfgNode* N) {
    function const_cfg_successors_range (line 460) | inline const_cfg_successors_range cfgSuccessors(const CFG& G,

FILE: include/gtirb/Casting.hpp
  type gtirb (line 37) | namespace gtirb {
    type casting (line 42) | namespace casting {
      type simplify_type (line 238) | struct simplify_type {
        method SimpleType (line 242) | static SimpleType& getSimplifiedValue(From& Val) { return Val; }
      type isa_impl (line 250) | struct isa_impl {
        method doit (line 251) | static inline bool doit(const From& Val) { return To::classof(&Val...
      type isa_impl<
    To, From, typename std::enable_if<std::is_base_of<To, From>::value>::type> (line 258) | struct isa_impl<
        method doit (line 260) | static inline bool doit(const From&) { return true; }
      type isa_impl_cl (line 265) | struct isa_impl_cl {
        method doit (line 266) | static inline bool doit(const From& Val) {
      type isa_impl_cl<To, const From> (line 273) | struct isa_impl_cl<To, const From> {
        method doit (line 274) | static inline bool doit(const From& Val) {
      type isa_impl_cl<To, From*> (line 281) | struct isa_impl_cl<To, From*> {
        method doit (line 282) | static inline bool doit(const From* Val) {
      type isa_impl_cl<To, From* const> (line 290) | struct isa_impl_cl<To, From* const> {
        method doit (line 291) | static inline bool doit(const From* Val) {
      type isa_impl_cl<To, const From*> (line 299) | struct isa_impl_cl<To, const From*> {
        method doit (line 300) | static inline bool doit(const From* Val) {
      type isa_impl_cl<To, const From* const> (line 309) | struct isa_impl_cl<To, const From* const> {
        method doit (line 310) | static inline bool doit(const From* Val) {
      type isa_impl_wrap (line 319) | struct isa_impl_wrap {
        method doit (line 322) | static bool doit(const From& Val) {
      type isa_impl_wrap<To, FromTy, FromTy> (line 332) | struct isa_impl_wrap<To, FromTy, FromTy> {
        method doit (line 334) | static bool doit(const FromTy& Val) {
      function GTIRB_DEPRECATED_UTILS (line 346) | GTIRB_DEPRECATED_UTILS [[nodiscard]] inline bool isa(const Y& Val) {
      type cast_retty (line 355) | struct cast_retty
      type cast_retty_impl (line 361) | struct cast_retty_impl {
      type cast_retty_impl<To, const From> (line 364) | struct cast_retty_impl<To, const From> {
      type cast_retty_impl<To, From*> (line 368) | struct cast_retty_impl<To, From*> {
      type cast_retty_impl<To, const From*> (line 372) | struct cast_retty_impl<To, const From*> {
      type cast_retty_impl<To, const From* const> (line 376) | struct cast_retty_impl<To, const From* const> {
      type cast_retty_wrap (line 382) | struct cast_retty_wrap {
      type cast_retty_wrap<To, FromTy, FromTy> (line 389) | struct cast_retty_wrap<To, FromTy, FromTy> {
      type cast_retty (line 394) | struct cast_retty {
      type cast_convert_val (line 404) | struct cast_convert_val {
        method doit (line 406) | static typename cast_retty<To, From>::ret_type doit(From& Val) {
      type cast_convert_val<To, FromTy, FromTy> (line 413) | struct cast_convert_val<To, FromTy, FromTy> {
        method doit (line 415) | static typename cast_retty<To, FromTy>::ret_type doit(const FromTy...
      type is_simple_type (line 424) | struct is_simple_type {
      function GTIRB_DEPRECATED_UTILS (line 438) | GTIRB_DEPRECATED_UTILS inline
      function GTIRB_DEPRECATED_UTILS (line 448) | GTIRB_DEPRECATED_UTILS inline typename cast_retty<X, Y>::ret_type ca...
      function GTIRB_DEPRECATED_UTILS (line 455) | GTIRB_DEPRECATED_UTILS inline typename cast_retty<X, Y*>::ret_type
      function GTIRB_DEPRECATED_UTILS (line 466) | GTIRB_DEPRECATED_UTILS [[nodiscard]] inline
      function GTIRB_DEPRECATED_UTILS (line 477) | GTIRB_DEPRECATED_UTILS [[nodiscard]] inline
      function GTIRB_DEPRECATED_UTILS (line 488) | GTIRB_DEPRECATED_UTILS [[nodiscard]] inline typename cast_retty<X, Y...
      function GTIRB_DEPRECATED_UTILS (line 505) | GTIRB_DEPRECATED_UTILS [[nodiscard]] inline
      function GTIRB_DEPRECATED_UTILS (line 513) | GTIRB_DEPRECATED_UTILS [[nodiscard]] inline typename cast_retty<X, Y...
      function GTIRB_DEPRECATED_UTILS (line 519) | GTIRB_DEPRECATED_UTILS [[nodiscard]] inline typename cast_retty<X, Y...
      function GTIRB_DEPRECATED_UTILS (line 528) | GTIRB_DEPRECATED_UTILS [[nodiscard]] inline
      function GTIRB_DEPRECATED_UTILS (line 536) | GTIRB_DEPRECATED_UTILS [[nodiscard]] inline
      function GTIRB_DEPRECATED_UTILS (line 544) | GTIRB_DEPRECATED_UTILS [[nodiscard]] inline typename cast_retty<X, Y...

FILE: include/gtirb/CfgNode.hpp
  type gtirb (line 25) | namespace gtirb {
    function CfgNode (line 30) | class GTIRB_EXPORT_API CfgNode : public Node {
    function classofKind (line 34) | static bool classofKind(Kind K) {
    function CfgNode (line 40) | CfgNode(Context& C, Kind Knd, const UUID& U) : Node(C, Knd, U) {}

FILE: include/gtirb/CodeBlock.hpp
  type gtirb (line 36) | namespace gtirb {
    class ErrorOr (line 37) | class ErrorOr
    type proto (line 39) | namespace proto {
      class CodeBlock (line 40) | class CodeBlock
    function CodeBlock (line 47) | class GTIRB_EXPORT_API CodeBlock : public CfgNode {
    function CodeBlock (line 61) | static CodeBlock* Create(Context& C, uint64_t Size,
    function ByteInterval (line 67) | ByteInterval* getByteInterval() { return Parent; }
    function ByteInterval (line 69) | const ByteInterval* getByteInterval() const { return Parent; }
    function getSize (line 77) | uint64_t getSize() const { return Size; }
    function getDecodeMode (line 85) | gtirb::DecodeMode getDecodeMode() const { return this->DecodeMode; }
    function setSize (line 101) | void setSize(uint64_t S) {
    function setDecodeMode (line 117) | void setDecodeMode(gtirb::DecodeMode DM) {
    function bytes_begin (line 160) | bytes_iterator<T> bytes_begin() {
    function bytes_begin (line 176) | bytes_iterator<T>
    function bytes_end (line 190) | bytes_iterator<T> bytes_end() {
    function bytes_end (line 206) | bytes_iterator<T>
    function bytes (line 220) | bytes_range<T> bytes() {
    function bytes (line 236) | bytes_range<T>
    function bytes_begin (line 251) | const_bytes_iterator<T> bytes_begin() const {
    function bytes_begin (line 267) | const_bytes_iterator<T> bytes_begin(
    function bytes_end (line 281) | const_bytes_iterator<T> bytes_end() const {
    function bytes_end (line 297) | const_bytes_iterator<T> bytes_end(
    function bytes (line 311) | const_bytes_range<T> bytes() const {
    function bytes (line 327) | const_bytes_range<T>
    function T (line 350) | T* rawBytes() {
    function T (line 370) | const T* rawBytes() const {
    function classof (line 377) | static bool classof(const Node* N) { return N->getKind() == Kind::Code...
    function CodeBlock (line 382) | CodeBlock(Context& C, uint64_t S, gtirb::DecodeMode DMode)
    function CodeBlock (line 384) | CodeBlock(Context& C, uint64_t S, gtirb::DecodeMode DMode, const UUID& U)
    function setParent (line 387) | void setParent(ByteInterval* BI, CodeBlockObserver* O) {
    function CodeBlock (line 392) | static CodeBlock* Create(Context& C, uint64_t Size, gtirb::DecodeMode ...

FILE: include/gtirb/Context.hpp
  type gtirb (line 30) | namespace gtirb {
    class Node (line 39) | class Node
    class CfgNode (line 40) | class CfgNode
    class ByteInterval (line 41) | class ByteInterval
    class CodeBlock (line 42) | class CodeBlock
    class DataBlock (line 43) | class DataBlock
    class IR (line 44) | class IR
    class Module (line 45) | class Module
    class ProxyBlock (line 46) | class ProxyBlock
    class Section (line 47) | class Section
    class Symbol (line 48) | class Symbol
    function Context (line 64) | class GTIRB_EXPORT_API Context {

FILE: include/gtirb/DataBlock.hpp
  type gtirb (line 29) | namespace gtirb {
    type proto (line 30) | namespace proto {
      class DataBlock (line 31) | class DataBlock
    class ErrorOr (line 34) | class ErrorOr
    function DataBlock (line 44) | class GTIRB_EXPORT_API DataBlock : public Node {
    function DataBlock (line 65) | static DataBlock* Create(Context& C, uint64_t Size) {
    function ByteInterval (line 70) | ByteInterval* getByteInterval() { return Parent; }
    function ByteInterval (line 72) | const ByteInterval* getByteInterval() const { return Parent; }
    function getSize (line 78) | uint64_t getSize() const { return Size; }
    function setSize (line 94) | void setSize(uint64_t S) {
    function bytes_begin (line 136) | bytes_iterator<T> bytes_begin() {
    function bytes_begin (line 152) | bytes_iterator<T>
    function bytes_end (line 166) | bytes_iterator<T> bytes_end() {
    function bytes_end (line 182) | bytes_iterator<T>
    function bytes (line 196) | bytes_range<T> bytes() {
    function bytes (line 212) | bytes_range<T>
    function bytes_begin (line 227) | const_bytes_iterator<T> bytes_begin() const {
    function bytes_begin (line 243) | const_bytes_iterator<T> bytes_begin(
    function bytes_end (line 257) | const_bytes_iterator<T> bytes_end() const {
    function bytes_end (line 273) | const_bytes_iterator<T> bytes_end(
    function bytes (line 287) | const_bytes_range<T> bytes() const {
    function bytes (line 303) | const_bytes_range<T>
    function T (line 326) | T* rawBytes() {
    function T (line 346) | const T* rawBytes() const {
    function classof (line 353) | static bool classof(const Node* N) { return N->getKind() == Kind::Data...
    function setParent (line 361) | void setParent(ByteInterval* BI, DataBlockObserver* O) {

FILE: include/gtirb/DecodeMode.hpp
  type gtirb (line 21) | namespace gtirb {
    type DecodeMode (line 26) | enum class DecodeMode : uint8_t {

FILE: include/gtirb/ErrorOr.hpp
  type gtirb (line 32) | namespace gtirb {
    function ErrorInfo (line 36) | struct GTIRB_EXPORT_API ErrorInfo {
    class ErrorOr (line 81) | class ErrorOr {
      method ErrorOr (line 99) | ErrorOr(E ErrorCode, const std::string& Msg = "",
      method ErrorOr (line 107) | ErrorOr(std::error_code EC, const std::string& Msg = "") : HasError(...
      method ErrorOr (line 111) | ErrorOr(const ErrorInfo& EI) : HasError(true) {
      method ErrorOr (line 116) | ErrorOr(OtherT&& Val,
      method ErrorOr (line 122) | ErrorOr(const ErrorOr& Other) { copyConstruct(Other); }
      method ErrorOr (line 125) | ErrorOr(const ErrorOr<OtherT>& Other,
      method ErrorOr (line 131) | explicit ErrorOr(
      method ErrorOr (line 138) | ErrorOr(ErrorOr&& Other) { moveConstruct(std::move(Other)); }
      method ErrorOr (line 141) | ErrorOr(ErrorOr<OtherT>&& Other,
      method ErrorOr (line 149) | explicit ErrorOr(
      method ErrorOr (line 155) | ErrorOr& operator=(const ErrorOr& Other) {
      method ErrorOr (line 160) | ErrorOr& operator=(ErrorOr&& Other) {
      method reference (line 173) | reference get() { return *getStorage(); }
      method const_reference (line 174) | const_reference get() const { return const_cast<ErrorOr<T>*>(this)->...
      method ErrorInfo (line 176) | ErrorInfo getError() const {
      method pointer (line 180) | pointer operator->() { return toPointer(getStorage()); }
      method const_pointer (line 182) | const_pointer operator->() const { return toPointer(getStorage()); }
      method reference (line 184) | reference operator*() { return *getStorage(); }
      method const_reference (line 186) | const_reference operator*() const { return *getStorage(); }
      method copyConstruct (line 189) | void copyConstruct(const ErrorOr<OtherT>& Other) {
      method compareThisIfSameType (line 202) | static bool compareThisIfSameType(const T1& a, const T1& b) {
      method compareThisIfSameType (line 207) | static bool compareThisIfSameType(const T1&, const T2&) {
      method copyAssign (line 211) | void copyAssign(const ErrorOr<OtherT>& Other) {
      method moveConstruct (line 219) | void moveConstruct(ErrorOr<OtherT>&& Other) {
      method moveAssign (line 231) | void moveAssign(ErrorOr<OtherT>&& Other) {
      method pointer (line 239) | pointer toPointer(pointer Val) { return Val; }
      method const_pointer (line 241) | const_pointer toPointer(const_pointer Val) const { return Val; }
      method pointer (line 243) | pointer toPointer(wrap* Val) { return &Val->get(); }
      method const_pointer (line 245) | const_pointer toPointer(const wrap* Val) const { return &Val->get(); }
      method storage_type (line 247) | storage_type* getStorage() {
      method storage_type (line 252) | const storage_type* getStorage() const {
      method ErrorInfo (line 257) | ErrorInfo* getErrorStorage() {
      method ErrorInfo (line 262) | const ErrorInfo* getErrorStorage() const {

FILE: include/gtirb/IR.hpp
  type gtirb (line 38) | namespace gtirb {
    type proto (line 39) | namespace proto {
      class IR (line 40) | class IR
    function AuxDataContainer (line 76) | class GTIRB_EXPORT_API IR : public AuxDataContainer {
    function CFG (line 108) | const CFG& getCFG() const { return Cfg; }
    function CFG (line 114) | CFG& getCFG() { return Cfg; }
    function module_iterator (line 131) | module_iterator modules_begin() { return Modules.begin(); }
    function module_iterator (line 133) | module_iterator modules_end() { return Modules.end(); }
    function const_module_iterator (line 135) | const_module_iterator modules_begin() const { return Modules.begin(); }
    function const_module_iterator (line 138) | const_module_iterator modules_end() const { return Modules.end(); }
    function module_range (line 152) | module_range modules() {
    function const_module_range (line 156) | const_module_range modules() const {
    function removeModule (line 192) | bool removeModule(Module* M) {
    function Module (line 207) | Module* addModule(Module* M) {
    function Module (line 227) | Module* addModule(Context& C, Args... A) {
    function module_name_range (line 237) | module_name_range findModules(const std::string& N) {
    function const_module_name_range (line 248) | const_module_name_range findModules(const std::string& N) const {
    type load_error (line 273) | enum class load_error {
    function proxy_block_iterator (line 318) | proxy_block_iterator proxy_blocks_begin() {
    function proxy_block_iterator (line 328) | proxy_block_iterator proxy_blocks_end() { return proxy_block_iterator(...
    function proxy_block_range (line 331) | proxy_block_range proxy_blocks() {
    function const_proxy_block_iterator (line 336) | const_proxy_block_iterator proxy_blocks_begin() const {
    function const_proxy_block_iterator (line 346) | const_proxy_block_iterator proxy_blocks_end() const {
    function const_proxy_block_range (line 351) | const_proxy_block_range proxy_blocks() const {
    function symbol_iterator (line 380) | symbol_iterator symbols_begin() {
    function symbol_iterator (line 389) | symbol_iterator symbols_end() { return symbol_iterator(); }
    function symbol_range (line 392) | symbol_range symbols() {
    function const_symbol_iterator (line 397) | const_symbol_iterator symbols_begin() const {
    function const_symbol_iterator (line 406) | const_symbol_iterator symbols_end() const { return const_symbol_iterat...
    function const_symbol_range (line 409) | const_symbol_range symbols() const {
    function section_iterator (line 447) | section_iterator sections_begin() {
    function section_iterator (line 456) | section_iterator sections_end() { return section_iterator(); }
    function section_range (line 459) | section_range sections() {
    function const_section_iterator (line 464) | const_section_iterator sections_begin() const {
    function const_section_iterator (line 473) | const_section_iterator sections_end() const {
    function const_section_range (line 478) | const_section_range sections() const {
    function section_subrange (line 487) | section_subrange findSectionsOn(Addr A) {
    function const_section_subrange (line 502) | const_section_subrange findSectionsOn(Addr A) const {
    function section_range (line 517) | section_range findSectionsAt(Addr A) {
    function section_range (line 533) | section_range findSectionsAt(Addr Low, Addr High) {
    function const_section_range (line 548) | const_section_range findSectionsAt(Addr A) const {
    function const_section_range (line 564) | const_section_range findSectionsAt(Addr Low, Addr High) const {
    function section_name_range (line 580) | section_name_range findSections(const std::string& X) {
    function const_section_name_range (line 595) | const_section_name_range findSections(const std::string& X) const {
    function byte_interval_iterator (line 630) | byte_interval_iterator byte_intervals_begin() {
    function byte_interval_iterator (line 640) | byte_interval_iterator byte_intervals_end() {
    function byte_interval_range (line 645) | byte_interval_range byte_intervals() {
    function const_byte_interval_iterator (line 651) | const_byte_interval_iterator byte_intervals_begin() const {
    function const_byte_interval_iterator (line 661) | const_byte_interval_iterator byte_intervals_end() const {
    function const_byte_interval_range (line 666) | const_byte_interval_range byte_intervals() const {
    function byte_interval_subrange (line 678) | byte_interval_subrange findByteIntervalsOn(Addr A) {
    function const_byte_interval_subrange (line 695) | const_byte_interval_subrange findByteIntervalsOn(Addr A) const {
    function byte_interval_range (line 710) | byte_interval_range findByteIntervalsAt(Addr A) {
    function byte_interval_range (line 727) | byte_interval_range findByteIntervalsAt(Addr Low, Addr High) {
    function const_byte_interval_range (line 744) | const_byte_interval_range findByteIntervalsAt(Addr A) const {
    function const_byte_interval_range (line 761) | const_byte_interval_range findByteIntervalsAt(Addr Low, Addr High) con...
    function block_iterator (line 814) | block_iterator blocks_begin() {
    function block_iterator (line 823) | block_iterator blocks_end() { return block_iterator(); }
    function block_range (line 826) | block_range blocks() {
    function const_block_iterator (line 831) | const_block_iterator blocks_begin() const {
    function const_block_iterator (line 840) | const_block_iterator blocks_end() const { return const_block_iterator(...
    function const_block_range (line 843) | const_block_range blocks() const {
    function block_subrange (line 854) | block_subrange findBlocksOn(Addr A) {
    function const_block_subrange (line 871) | const_block_subrange findBlocksOn(Addr A) const {
    function block_range (line 887) | block_range findBlocksAt(Addr A) {
    function block_range (line 903) | block_range findBlocksAt(Addr Low, Addr High) {
    function const_block_range (line 919) | const_block_range findBlocksAt(Addr A) const {
    function const_block_range (line 936) | const_block_range findBlocksAt(Addr Low, Addr High) const {
    function code_block_iterator (line 991) | code_block_iterator code_blocks_begin() {
    function code_block_iterator (line 1001) | code_block_iterator code_blocks_end() { return code_block_iterator(); }
    function code_block_range (line 1004) | code_block_range code_blocks() {
    function const_code_block_iterator (line 1009) | const_code_block_iterator code_blocks_begin() const {
    function const_code_block_iterator (line 1019) | const_code_block_iterator code_blocks_end() const {
    function const_code_block_range (line 1024) | const_code_block_range code_blocks() const {
    function code_block_subrange (line 1034) | code_block_subrange findCodeBlocksOn(Addr A) {
    function const_code_block_subrange (line 1050) | const_code_block_subrange findCodeBlocksOn(Addr A) const {
    function code_block_range (line 1065) | code_block_range findCodeBlocksAt(Addr A) {
    function code_block_range (line 1081) | code_block_range findCodeBlocksAt(Addr Low, Addr High) {
    function const_code_block_range (line 1097) | const_code_block_range findCodeBlocksAt(Addr A) const {
    function const_code_block_range (line 1113) | const_code_block_range findCodeBlocksAt(Addr Low, Addr High) const {
    function data_block_iterator (line 1168) | data_block_iterator data_blocks_begin() {
    function data_block_iterator (line 1178) | data_block_iterator data_blocks_end() { return data_block_iterator(); }
    function data_block_range (line 1181) | data_block_range data_blocks() {
    function const_data_block_iterator (line 1186) | const_data_block_iterator data_blocks_begin() const {
    function const_data_block_iterator (line 1196) | const_data_block_iterator data_blocks_end() const {
    function const_data_block_range (line 1201) | const_data_block_range data_blocks() const {
    function data_block_subrange (line 1211) | data_block_subrange findDataBlocksOn(Addr A) {
    function const_data_block_subrange (line 1227) | const_data_block_subrange findDataBlocksOn(Addr A) const {
    function data_block_range (line 1242) | data_block_range findDataBlocksAt(Addr A) {
    function data_block_range (line 1258) | data_block_range findDataBlocksAt(Addr Low, Addr High) {
    function const_data_block_range (line 1274) | const_data_block_range findDataBlocksAt(Addr A) const {
    function const_data_block_range (line 1290) | const_data_block_range findDataBlocksAt(Addr Low, Addr High) const {
    function symbolic_expression_iterator (line 1331) | symbolic_expression_iterator symbolic_expressions_begin() {
    function symbolic_expression_iterator (line 1341) | symbolic_expression_iterator symbolic_expressions_end() {
    function symbolic_expression_range (line 1346) | symbolic_expression_range symbolic_expressions() {
    function const_symbolic_expression_iterator (line 1352) | const_symbolic_expression_iterator symbolic_expressions_begin() const {
    function const_symbolic_expression_iterator (line 1364) | const_symbolic_expression_iterator symbolic_expressions_end() const {
    function const_symbolic_expression_range (line 1369) | const_symbolic_expression_range symbolic_expressions() const {
    function symbolic_expression_range (line 1380) | symbolic_expression_range findSymbolicExpressionsAt(Addr A) {
    function symbolic_expression_range (line 1398) | symbolic_expression_range findSymbolicExpressionsAt(Addr Low, Addr Hig...
    function const_symbolic_expression_range (line 1414) | const_symbolic_expression_range findSymbolicExpressionsAt(Addr A) const {
    function const_symbolic_expression_range (line 1432) | const_symbolic_expression_range findSymbolicExpressionsAt(Addr Low,
    function classof (line 1448) | static bool classof(const Node* N) { return N->getKind() == Kind::IR; }
    function getVersion (line 1455) | uint32_t getVersion() const { return Version; }
    function setVersion (line 1463) | void setVersion(uint32_t V) { Version = V; }
  function make_error_code (line 1502) | inline std::error_code make_error_code(gtirb::IR::load_error e) {
  type std (line 1508) | namespace std {
    type is_error_code_enum<gtirb::IR::load_error> (line 1510) | struct is_error_code_enum<gtirb::IR::load_error> : std::true_type {}

FILE: include/gtirb/Module.hpp
  type gtirb (line 48) | namespace gtirb {
    class ByteInterval (line 49) | class ByteInterval
    class IR (line 50) | class IR
    class ModuleObserver (line 51) | class ModuleObserver
    class ErrorOr (line 53) | class ErrorOr
    type FileFormat (line 58) | enum class FileFormat : uint8_t {
    type ISA (line 75) | enum class ISA : uint8_t {
    type ByteOrder (line 97) | enum class ByteOrder : uint8_t {
    function AuxDataContainer (line 107) | class GTIRB_EXPORT_API Module : public AuxDataContainer {
    function IR (line 180) | const IR* getIR() const { return Parent; }
    function IR (line 182) | IR* getIR() { return Parent; }
    function setBinaryPath (line 190) | void setBinaryPath(const std::string& X) { BinaryPath = X; }
    function setFileFormat (line 201) | void setFileFormat(gtirb::FileFormat X) { this->FileFormat = X; }
    function getFileFormat (line 207) | gtirb::FileFormat getFileFormat() const { return this->FileFormat; }
    function setRebaseDelta (line 216) | void setRebaseDelta(int64_t X) { RebaseDelta = X; }
    function getRebaseDelta (line 223) | int64_t getRebaseDelta() const { return RebaseDelta; }
    function setPreferredAddr (line 231) | void setPreferredAddr(gtirb::Addr X) { PreferredAddr = X; }
    function getPreferredAddr (line 237) | gtirb::Addr getPreferredAddr() const { return PreferredAddr; }
    function isRelocated (line 247) | bool isRelocated() const { return RebaseDelta != 0; }
    function setISA (line 252) | void setISA(gtirb::ISA X) { Isa = X; }
    function getISA (line 257) | gtirb::ISA getISA() const { return Isa; }
    function setByteOrder (line 262) | void setByteOrder(gtirb::ByteOrder X) { ByteOrder = X; }
    function getByteOrder (line 267) | gtirb::ByteOrder getByteOrder() const { return ByteOrder; }
    function CodeBlock (line 270) | const CodeBlock* getEntryPoint() const { return EntryPoint; }
    function CodeBlock (line 272) | CodeBlock* getEntryPoint() { return EntryPoint; }
    function setEntryPoint (line 277) | void setEntryPoint(CodeBlock* CB) { EntryPoint = CB; }
    function proxy_block_iterator (line 295) | proxy_block_iterator proxy_blocks_begin() {
    function const_proxy_block_iterator (line 299) | const_proxy_block_iterator proxy_blocks_begin() const {
    function proxy_block_iterator (line 303) | proxy_block_iterator proxy_blocks_end() {
    function const_proxy_block_iterator (line 308) | const_proxy_block_iterator proxy_blocks_end() const {
    function proxy_block_range (line 312) | proxy_block_range proxy_blocks() {
    function const_proxy_block_range (line 316) | const_proxy_block_range proxy_blocks() const {
    function ProxyBlock (line 347) | ProxyBlock* addProxyBlock(Context& C, Args&&... A) {
    function symbol_iterator (line 453) | symbol_iterator symbols_begin() {
    function const_symbol_iterator (line 457) | const_symbol_iterator symbols_begin() const {
    function symbol_iterator (line 461) | symbol_iterator symbols_end() {
    function const_symbol_iterator (line 466) | const_symbol_iterator symbols_end() const {
    function symbol_range (line 470) | symbol_range symbols() {
    function const_symbol_range (line 474) | const_symbol_range symbols() const {
    function symbol_name_iterator (line 479) | symbol_name_iterator symbols_by_name_begin() {
    function const_symbol_name_iterator (line 483) | const_symbol_name_iterator symbols_by_name_begin() const {
    function symbol_name_iterator (line 488) | symbol_name_iterator symbols_by_name_end() {
    function const_symbol_name_iterator (line 493) | const_symbol_name_iterator symbols_by_name_end() const {
    function symbol_name_range (line 497) | symbol_name_range symbols_by_name() {
    function const_symbol_name_range (line 503) | const_symbol_name_range symbols_by_name() const {
    function symbol_addr_iterator (line 509) | symbol_addr_iterator symbols_by_addr_begin() {
    function const_symbol_addr_iterator (line 513) | const_symbol_addr_iterator symbols_by_addr_begin() const {
    function symbol_addr_iterator (line 518) | symbol_addr_iterator symbols_by_addr_end() {
    function const_symbol_addr_iterator (line 523) | const_symbol_addr_iterator symbols_by_addr_end() const {
    function symbol_addr_range (line 527) | symbol_addr_range symbols_by_addr() {
    function const_symbol_addr_range (line 533) | const_symbol_addr_range symbols_by_addr() const {
    function removeSymbol (line 545) | bool removeSymbol(Symbol* S) {
    function Symbol (line 558) | Symbol* addSymbol(Symbol* S) {
    function Symbol (line 572) | Symbol* addSymbol(Context& C, Args... A) {
    function symbol_name_range (line 582) | symbol_name_range findSymbols(const std::string& N) {
    function const_symbol_name_range (line 593) | const_symbol_name_range findSymbols(const std::string& N) const {
    function symbol_addr_range (line 604) | symbol_addr_range findSymbols(Addr X) {
    function const_symbol_addr_range (line 615) | const_symbol_addr_range findSymbols(Addr X) const {
    function symbol_addr_range (line 627) | symbol_addr_range findSymbols(Addr Lower, Addr Upper) {
    function const_symbol_addr_range (line 640) | const_symbol_addr_range findSymbols(Addr Lower, Addr Upper) const {
    function symbol_ref_range (line 652) | symbol_ref_range findSymbols(const Node& Referent) {
    function const_symbol_ref_range (line 662) | const_symbol_ref_range findSymbols(const Node& Referent) const {
    function section_iterator (line 729) | section_iterator sections_begin() { return Sections.begin(); }
    function const_section_iterator (line 731) | const_section_iterator sections_begin() const { return Sections.begin(...
    function section_name_iterator (line 733) | section_name_iterator sections_by_name_begin() {
    function const_section_name_iterator (line 737) | const_section_name_iterator sections_by_name_begin() const {
    function section_iterator (line 741) | section_iterator sections_end() { return Sections.end(); }
    function const_section_iterator (line 744) | const_section_iterator sections_end() const { return Sections.end(); }
    function section_name_iterator (line 746) | section_name_iterator sections_by_name_end() {
    function const_section_name_iterator (line 751) | const_section_name_iterator sections_by_name_end() const {
    function section_range (line 755) | section_range sections() {
    function const_section_range (line 759) | const_section_range sections() const {
    function Section (line 789) | Section* addSection(Context& C, Args&&... A) {
    function section_subrange (line 804) | section_subrange findSectionsOn(Addr X) {
    function const_section_subrange (line 816) | const_section_subrange findSectionsOn(Addr X) const {
    function section_range (line 828) | section_range findSectionsAt(Addr A) {
    function section_range (line 840) | section_range findSectionsAt(Addr Low, Addr High) {
    function const_section_range (line 852) | const_section_range findSectionsAt(Addr A) const {
    function const_section_range (line 864) | const_section_range findSectionsAt(Addr Low, Addr High) const {
    function section_name_range (line 877) | section_name_range findSections(const std::string& X) {
    function const_section_name_range (line 888) | const_section_name_range findSections(const std::string& X) const {
    function byte_interval_iterator (line 920) | byte_interval_iterator byte_intervals_begin() {
    function byte_interval_iterator (line 930) | byte_interval_iterator byte_intervals_end() {
    function byte_interval_range (line 935) | byte_interval_range byte_intervals() {
    function const_byte_interval_iterator (line 941) | const_byte_interval_iterator byte_intervals_begin() const {
    function const_byte_interval_iterator (line 951) | const_byte_interval_iterator byte_intervals_end() const {
    function const_byte_interval_range (line 956) | const_byte_interval_range byte_intervals() const {
    function byte_interval_subrange (line 967) | byte_interval_subrange findByteIntervalsOn(Addr A) {
    function const_byte_interval_subrange (line 984) | const_byte_interval_subrange findByteIntervalsOn(Addr A) const {
    function byte_interval_range (line 1000) | byte_interval_range findByteIntervalsAt(Addr A) {
    function byte_interval_range (line 1018) | byte_interval_range findByteIntervalsAt(Addr Low, Addr High) {
    function const_byte_interval_range (line 1033) | const_byte_interval_range findByteIntervalsAt(Addr A) const {
    function const_byte_interval_range (line 1051) | const_byte_interval_range findByteIntervalsAt(Addr Low, Addr High) con...
    function block_iterator (line 1101) | block_iterator blocks_begin() {
    function block_iterator (line 1110) | block_iterator blocks_end() { return block_iterator(); }
    function block_range (line 1113) | block_range blocks() {
    function const_block_iterator (line 1118) | const_block_iterator blocks_begin() const {
    function const_block_iterator (line 1127) | const_block_iterator blocks_end() const { return const_block_iterator(...
    function const_block_range (line 1130) | const_block_range blocks() const {
    function block_subrange (line 1141) | block_subrange findBlocksOn(Addr A) {
    function const_block_subrange (line 1159) | const_block_subrange findBlocksOn(Addr A) const {
    function block_range (line 1176) | block_range findBlocksAt(Addr A) {
    function block_range (line 1193) | block_range findBlocksAt(Addr Low, Addr High) {
    function const_block_range (line 1208) | const_block_range findBlocksAt(Addr A) const {
    function const_block_range (line 1226) | const_block_range findBlocksAt(Addr Low, Addr High) const {
  function code_block_iterator (line 1303) | code_block_iterator code_blocks_end() { return code_block_iterator(); }
  function code_block_range (line 1306) | code_block_range code_blocks() {
  function const_code_block_iterator (line 1311) | const_code_block_iterator code_blocks_begin() const {
  function const_code_block_iterator (line 1321) | const_code_block_iterator code_blocks_end() const {
  function const_code_block_range (line 1326) | const_code_block_range code_blocks() const {
  function code_block_subrange (line 1336) | code_block_subrange findCodeBlocksOn(Addr A) {
  function const_code_block_subrange (line 1353) | const_code_block_subrange findCodeBlocksOn(Addr A) const {
  function code_block_range (line 1369) | code_block_range findCodeBlocksAt(Addr A) {
  function code_block_range (line 1386) | code_block_range findCodeBlocksAt(Addr Low, Addr High) {
  function const_code_block_range (line 1400) | const_code_block_range findCodeBlocksAt(Addr A) const {
  function const_code_block_range (line 1417) | const_code_block_range findCodeBlocksAt(Addr Low, Addr High) const {
  function data_block_iterator (line 1471) | data_block_iterator data_blocks_begin() {
  function data_block_iterator (line 1481) | data_block_iterator data_blocks_end() { return data_block_iterator(); }
  function data_block_range (line 1484) | data_block_range data_blocks() {
  function const_data_block_iterator (line 1489) | const_data_block_iterator data_blocks_begin() const {
  function const_data_block_iterator (line 1499) | const_data_block_iterator data_blocks_end() const {
  function const_data_block_range (line 1504) | const_data_block_range data_blocks() const {
  function data_block_subrange (line 1514) | data_block_subrange findDataBlocksOn(Addr A) {
  function const_data_block_subrange (line 1531) | const_data_block_subrange findDataBlocksOn(Addr A) const {
  function data_block_range (line 1547) | data_block_range findDataBlocksAt(Addr A) {
  function data_block_range (line 1564) | data_block_range findDataBlocksAt(Addr Low, Addr High) {
  function const_data_block_range (line 1578) | const_data_block_range findDataBlocksAt(Addr A) const {
  function const_data_block_range (line 1595) | const_data_block_range findDataBlocksAt(Addr Low, Addr High) const {
  function symbolic_expression_iterator (line 1634) | symbolic_expression_iterator symbolic_expressions_begin() {
  function symbolic_expression_iterator (line 1644) | symbolic_expression_iterator symbolic_expressions_end() {
  function symbolic_expression_range (line 1649) | symbolic_expression_range symbolic_expressions() {
  function const_symbolic_expression_iterator (line 1655) | const_symbolic_expression_iterator symbolic_expressions_begin() const {
  function const_symbolic_expression_iterator (line 1667) | const_symbolic_expression_iterator symbolic_expressions_end() const {
  function const_symbolic_expression_range (line 1672) | const_symbolic_expression_range symbolic_expressions() const {
  function symbolic_expression_range (line 1683) | symbolic_expression_range findSymbolicExpressionsAt(Addr A) {
  function symbolic_expression_range (line 1701) | symbolic_expression_range findSymbolicExpressionsAt(Addr Low, Addr High) {
  function const_symbolic_expression_range (line 1718) | const_symbolic_expression_range findSymbolicExpressionsAt(Addr A) const {
  function const_symbolic_expression_range (line 1736) | const_symbolic_expression_range findSymbolicExpressionsAt(Addr Low,
  function classof (line 1752) | static bool classof(const Node* N) { return N->getKind() == Kind::Module; }
  function setParent (line 1789) | void setParent(IR* I, ModuleObserver* O) {
  function ModuleObserver (line 1824) | class GTIRB_EXPORT_API ModuleObserver {

FILE: include/gtirb/Node.hpp
  type gtirb (line 27) | namespace gtirb {
    class Node (line 28) | class Node
    function Node (line 39) | class GTIRB_EXPORT_API Node {

FILE: include/gtirb/Observer.hpp
  type gtirb (line 18) | namespace gtirb {
    type ChangeStatus (line 19) | enum class ChangeStatus {

FILE: include/gtirb/Offset.hpp
  type gtirb (line 24) | namespace gtirb {
    type proto (line 25) | namespace proto {
      class Offset (line 26) | class Offset
    function Offset (line 32) | struct GTIRB_EXPORT_API Offset {
  type std (line 111) | namespace std {
    type hash<gtirb::Offset> (line 114) | struct hash<gtirb::Offset> {

FILE: include/gtirb/ProxyBlock.hpp
  type gtirb (line 26) | namespace gtirb {
    type proto (line 27) | namespace proto {
      class ProxyBlock (line 28) | class ProxyBlock
    class ErrorOr (line 31) | class ErrorOr
    class Module (line 32) | class Module
    function ProxyBlock (line 49) | class GTIRB_EXPORT_API ProxyBlock : public CfgNode {
    function Module (line 57) | Module* getModule() { return Parent; }
    function Module (line 59) | const Module* getModule() const { return Parent; }
    function classof (line 61) | static bool classof(const Node* N) {
    function ProxyBlock (line 68) | ProxyBlock(Context& C, const UUID& U) : CfgNode(C, Kind::ProxyBlock, U...
    function ProxyBlock (line 70) | static ProxyBlock* Create(Context& C, const UUID& U) {
    function setModule (line 74) | void setModule(Module* M) { Parent = M; }

FILE: include/gtirb/Section.hpp
  type gtirb (line 42) | namespace gtirb {
    class Module (line 43) | class Module
    class SectionObserver (line 44) | class SectionObserver
    class ErrorOr (line 45) | class ErrorOr
    type SectionFlag (line 50) | enum class SectionFlag : uint8_t {
    function Section (line 66) | class GTIRB_EXPORT_API Section : public Node {
    function Section (line 104) | static Section* Create(Context& C, const std::string& Name) {
    function Module (line 115) | Module* getModule() { return Parent; }
    function Module (line 117) | const Module* getModule() const { return Parent; }
    function addFlag (line 127) | void addFlag(SectionFlag F) { Flags.insert(F); }
    function addFlags (line 132) | void addFlags(Fs... F) { (addFlag(F), ...); }
    function removeFlag (line 137) | void removeFlag(SectionFlag F) { Flags.erase(F); }
    function isFlagSet (line 143) | bool isFlagSet(SectionFlag F) const {
    function const_section_flag_iterator (line 154) | const_section_flag_iterator flags_begin() const { return Flags.begin(); }
    function const_section_flag_iterator (line 157) | const_section_flag_iterator flags_end() const { return Flags.end(); }
    function const_section_flag_range (line 159) | const_section_flag_range flags() const {
    function byte_interval_iterator (line 184) | byte_interval_iterator byte_intervals_begin() {
    function const_byte_interval_iterator (line 188) | const_byte_interval_iterator byte_intervals_begin() const {
    function byte_interval_iterator (line 193) | byte_interval_iterator byte_intervals_end() { return ByteIntervals.end...
    function const_byte_interval_iterator (line 196) | const_byte_interval_iterator byte_intervals_end() const {
    function byte_interval_range (line 200) | byte_interval_range byte_intervals() {
    function const_byte_interval_range (line 206) | const_byte_interval_range byte_intervals() const {
    function byte_interval_subrange (line 218) | byte_interval_subrange findByteIntervalsOn(Addr A) {
    function const_byte_interval_subrange (line 234) | const_byte_interval_subrange findByteIntervalsOn(Addr A) const {
    function byte_interval_range (line 248) | byte_interval_range findByteIntervalsAt(Addr A) {
    function byte_interval_range (line 261) | byte_interval_range findByteIntervalsAt(Addr Low, Addr High) {
    function const_byte_interval_range (line 276) | const_byte_interval_range findByteIntervalsAt(Addr A) const {
    function const_byte_interval_range (line 290) | const_byte_interval_range findByteIntervalsAt(Addr Low, Addr High) con...
    function getAddress (line 309) | std::optional<Addr> getAddress() const {
    function getSize (line 325) | std::optional<uint64_t> getSize() const {
    function ByteInterval (line 353) | ByteInterval* addByteInterval(Context& C, Args&&... A) {
    function block_iterator (line 404) | block_iterator blocks_begin() {
    function block_iterator (line 413) | block_iterator blocks_end() { return block_iterator(); }
    function block_range (line 416) | block_range blocks() {
    function const_block_iterator (line 421) | const_block_iterator blocks_begin() const {
    function const_block_iterator (line 430) | const_block_iterator blocks_end() const { return const_block_iterator(...
    function const_block_range (line 433) | const_block_range blocks() const {
    function block_subrange (line 444) | block_subrange findBlocksOn(Addr A) {
    function const_block_subrange (line 462) | const_block_subrange findBlocksOn(Addr A) const {
    function block_range (line 479) | block_range findBlocksAt(Addr A) {
    function block_range (line 497) | block_range findBlocksAt(Addr Low, Addr High) {
    function const_block_range (line 512) | const_block_range findBlocksAt(Addr A) const {
    function const_block_range (line 530) | const_block_range findBlocksAt(Addr Low, Addr High) const {
  function code_block_iterator (line 602) | code_block_iterator code_blocks_end() { return code_block_iterator(); }
  function code_block_range (line 605) | code_block_range code_blocks() {
  function const_code_block_iterator (line 610) | const_code_block_iterator code_blocks_begin() const {
  function const_code_block_iterator (line 622) | const_code_block_iterator code_blocks_end() const {
  function const_code_block_range (line 627) | const_code_block_range code_blocks() const {
  function code_block_subrange (line 637) | code_block_subrange findCodeBlocksOn(Addr A) {
  function const_code_block_subrange (line 654) | const_code_block_subrange findCodeBlocksOn(Addr A) const {
  function code_block_range (line 670) | code_block_range findCodeBlocksAt(Addr A) {
  function code_block_range (line 687) | code_block_range findCodeBlocksAt(Addr Low, Addr High) {
  function const_code_block_range (line 701) | const_code_block_range findCodeBlocksAt(Addr A) const {
  function const_code_block_range (line 718) | const_code_block_range findCodeBlocksAt(Addr Low, Addr High) const {
  function data_block_iterator (line 767) | data_block_iterator data_blocks_begin() {
  function data_block_iterator (line 777) | data_block_iterator data_blocks_end() { return data_block_iterator(); }
  function data_block_range (line 780) | data_block_range data_blocks() {
  function const_data_block_iterator (line 785) | const_data_block_iterator data_blocks_begin() const {
  function const_data_block_iterator (line 797) | const_data_block_iterator data_blocks_end() const {
  function const_data_block_range (line 802) | const_data_block_range data_blocks() const {
  function data_block_subrange (line 812) | data_block_subrange findDataBlocksOn(Addr A) {
  function const_data_block_subrange (line 829) | const_data_block_subrange findDataBlocksOn(Addr A) const {
  function data_block_range (line 845) | data_block_range findDataBlocksAt(Addr A) {
  function data_block_range (line 862) | data_block_range findDataBlocksAt(Addr Low, Addr High) {
  function const_data_block_range (line 876) | const_data_block_range findDataBlocksAt(Addr A) const {
  function const_data_block_range (line 893) | const_data_block_range findDataBlocksAt(Addr Low, Addr High) const {
  function symbolic_expression_iterator (line 927) | symbolic_expression_iterator symbolic_expressions_begin() {
  function symbolic_expression_iterator (line 939) | symbolic_expression_iterator symbolic_expressions_end() {
  function symbolic_expression_range (line 944) | symbolic_expression_range symbolic_expressions() {
  function const_symbolic_expression_iterator (line 950) | const_symbolic_expression_iterator symbolic_expressions_begin() const {
  function const_symbolic_expression_iterator (line 962) | const_symbolic_expression_iterator symbolic_expressions_end() const {
  function const_symbolic_expression_range (line 967) | const_symbolic_expression_range symbolic_expressions() const {
  function symbolic_expression_range (line 978) | symbolic_expression_range findSymbolicExpressionsAt(Addr A) {
  function symbolic_expression_range (line 996) | symbolic_expression_range findSymbolicExpressionsAt(Addr Low, Addr High) {
  function const_symbolic_expression_range (line 1014) | const_symbolic_expression_range findSymbolicExpressionsAt(Addr A) const {
  function const_symbolic_expression_range (line 1034) | const_symbolic_expression_range findSymbolicExpressionsAt(Addr Low,
  function classof (line 1048) | static bool classof(const Node* N) { return N->getKind() == Kind::Sectio...
  function setParent (line 1074) | void setParent(Module* M, SectionObserver* O) {
  function SectionObserver (line 1115) | class GTIRB_EXPORT_API SectionObserver {

FILE: include/gtirb/Symbol.hpp
  type gtirb (line 31) | namespace gtirb {
    type proto (line 32) | namespace proto {
      class Symbol (line 33) | class Symbol
    class ErrorOr (line 36) | class ErrorOr
    class Module (line 37) | class Module
    class SymbolObserver (line 38) | class SymbolObserver
    function Symbol (line 43) | class GTIRB_EXPORT_API Symbol : public Node {
    function SymbolObserver (line 412) | class GTIRB_EXPORT_API SymbolObserver {

FILE: include/gtirb/SymbolicExpression.hpp
  type gtirb (line 33) | namespace gtirb {
    class Symbol (line 34) | class Symbol
    type SymAttribute (line 47) | enum class SymAttribute : uint16_t {
    type SymAddrConst (line 129) | struct SymAddrConst {
    type SymAddrAddr (line 147) | struct SymAddrAddr {
  type std (line 173) | namespace std {
    type hash<gtirb::SymAddrConst> (line 174) | struct hash<gtirb::SymAddrConst> {
      method result_type (line 178) | result_type operator()(const argument_type& Obj) const noexcept {
    type hash<gtirb::SymAddrAddr> (line 185) | struct hash<gtirb::SymAddrAddr> {
      method result_type (line 189) | result_type operator()(const argument_type& Obj) const noexcept {
      method comb (line 198) | void comb(result_type& One, result_type Two) const noexcept {

FILE: include/gtirb/Utility.hpp
  type gtirb (line 33) | namespace gtirb {
    class MergeSortedIterator (line 54) | class MergeSortedIterator
      method MergeSortedIterator (line 65) | MergeSortedIterator() = default;
      method MergeSortedIterator (line 79) | MergeSortedIterator(
      method MergeSortedIterator (line 93) | explicit MergeSortedIterator(RangeIteratorRange RangeRange) {
      method MergeSortedIterator (line 111) | MergeSortedIterator(RangeIterator Begin, RangeIterator End)
      method dereference (line 115) | typename std::iterator_traits<ForwardIterator>::reference
      method equal (line 121) | bool equal(const MergeSortedIterator<ForwardIterator, Compare>& Othe...
      method increment (line 125) | void increment() {
      method rangeGreaterThan (line 148) | static bool rangeGreaterThan(const RangeType& R1, const RangeType& R...
    function AddressLess (line 171) | struct GTIRB_EXPORT_API AddressLess {
    function BlockAddressLess (line 221) | struct GTIRB_EXPORT_API BlockAddressLess {
    function BlockOffsetPairLess (line 232) | struct GTIRB_EXPORT_API BlockOffsetPairLess {
    type ArbitraryLess (line 243) | struct ArbitraryLess {
    type NodeToChildRange (line 258) | struct NodeToChildRange {
    type FindNodesAt (line 407) | struct FindNodesAt {
      method FindNodesAt (line 410) | FindNodesAt(Addr A_) : A{A_} {}
    type FindNodes (line 426) | struct FindNodes {
      method FindNodes (line 429) | FindNodes(std::string X_) : X{X_} {}
    type FindNodesBetween (line 446) | struct FindNodesBetween {
      method FindNodesBetween (line 449) | FindNodesBetween(Addr Low_, Addr High_) : Low{Low_}, High{High_} {}

FILE: java/com/grammatech/gtirb/AuxDataContainer.java
  class AuxDataContainer (line 32) | public abstract class AuxDataContainer extends Node {
    class AuxData (line 37) | public static class AuxData {
      method AuxData (line 57) | AuxData(String name, AuxDataOuterClass.AuxData protoAuxData) {
      method AuxData (line 70) | <T> AuxData(AuxDataSchema<T> schema, T value) {
      method getName (line 83) | public String getName() { return this.name; }
      method getTypeName (line 90) | public String getTypeName() { return this.typeName; }
      method getDecodedData (line 98) | public <T> T getDecodedData(AuxDataSchema<T> sch) throws IOException {
      method toProtobuf (line 133) | AuxDataOuterClass.AuxData.Builder toProtobuf() {
    method AuxDataContainer (line 168) | AuxDataContainer(ByteString protoUuid,
    method AuxDataContainer (line 182) | AuxDataContainer() {
    method getAuxData (line 194) | public <T> Optional<T> getAuxData(AuxDataSchema<T> schema) {
    method putAuxData (line 218) | public <T> void putAuxData(AuxDataSchema<T> schema, T data) {
    method removeAuxData (line 230) | public boolean removeAuxData(AuxDataSchema<?> schema) {
    method removeAuxData (line 244) | public boolean removeAuxData(String name) {
    method clearAuxData (line 252) | public void clearAuxData() { this.auxDataMap.clear(); }
    method getAuxDataMap (line 260) | public Map<String, AuxData> getAuxDataMap() {

FILE: java/com/grammatech/gtirb/AuxDataSchema.java
  class AuxDataSchema (line 12) | public final class AuxDataSchema<T> {
    method AuxDataSchema (line 23) | public AuxDataSchema(String name, Codec<T> codec) {
    method getName (line 31) | public String getName() { return this.name; }
    method getCodec (line 36) | public Codec<T> getCodec() { return this.codec; }

FILE: java/com/grammatech/gtirb/AuxDataSchemas.java
  class AuxDataSchemas (line 33) | public class AuxDataSchemas {

FILE: java/com/grammatech/gtirb/ByteBlock.java
  class ByteBlock (line 26) | public abstract class ByteBlock extends Node implements TreeListItem {
    method ByteBlock (line 38) | ByteBlock(ByteString protoUuid, ByteIntervalOuterClass.Block protoBlock,
    method ByteBlock (line 51) | public ByteBlock(long size, long offset) {
    method getSize (line 63) | public long getSize() { return this.size; }
    method setSize (line 71) | public long setSize(long newSize) {
    method getOffset (line 82) | public long getOffset() { return this.offset; }
    method getIndex (line 92) | public long getIndex() { return this.offset; }
    method getAddress (line 100) | public OptionalLong getAddress() {
    method getByteInterval (line 115) | public Optional<ByteInterval> getByteInterval() {
    method setByteInterval (line 124) | void setByteInterval(Optional<ByteInterval> byteInterval) {
    method toProtobuf (line 135) | ByteIntervalOuterClass.Block.Builder toProtobuf() {

FILE: java/com/grammatech/gtirb/ByteInterval.java
  class ByteInterval (line 44) | public final class ByteInterval extends Node implements TreeListItem {
    method ByteInterval (line 59) | private ByteInterval(ByteIntervalOuterClass.ByteInterval protoByteInte...
    method ByteInterval (line 121) | public ByteInterval(byte[] bytes, long address) {
    method ByteInterval (line 135) | public ByteInterval(long size) {
    method ByteInterval (line 145) | public ByteInterval() {
    method getAddress (line 156) | public OptionalLong getAddress() { return this.address; }
    method setAddress (line 163) | public void setAddress(long address) {
    method clearAddress (line 170) | public void clearAddress() { this.address = OptionalLong.empty(); }
    method hasAddress (line 178) | public boolean hasAddress() { return address.isPresent(); }
    method getBlockList (line 186) | public List<ByteBlock> getBlockList() {
    method getSize (line 199) | public long getSize() { return this.size; }
    method setSize (line 209) | public void setSize(long size) {
    method getBytes (line 222) | public byte[] getBytes() { return this.bytes; }
    method setBytes (line 229) | public void setBytes(byte[] bytes) {
    method getInitializedSize (line 241) | public long getInitializedSize() {
    method getSection (line 253) | public Optional<Section> getSection() { return this.section; }
    method setSection (line 261) | void setSection(Optional<Section> section) { this.section = section; }
    method getIndex (line 271) | public long getIndex() { return this.address.orElse(0); }
    method getItemsIntersectingAddress (line 311) | private <T extends TreeListItem> List<T>
    method getItemsIntersectingAddressRange (line 327) | private <T extends TreeListItem> List<T>
    method getItemsAtStartAddress (line 350) | private <T extends TreeListItem> List<T>
    method getItemsAtStartAddressRange (line 365) | private <T extends TreeListItem> List<T>
    method insertByteBlock (line 397) | public List<ByteBlock> insertByteBlock(ByteBlock block) {
    method removeByteBlock (line 417) | public boolean removeByteBlock(ByteBlock block) {
    method findBlocksAtOffset (line 451) | public List<ByteBlock> findBlocksAtOffset(long offset) {
    method byteBlockIterator (line 461) | public Iterator<ByteBlock> byteBlockIterator() {
    method findCodeBlocksOn (line 479) | public List<CodeBlock> findCodeBlocksOn(long address) {
    method findCodeBlocksOn (line 505) | public List<CodeBlock> findCodeBlocksOn(long startAddress,
    method findCodeBlocksAt (line 528) | public List<CodeBlock> findCodeBlocksAt(long address) {
    method findCodeBlocksAt (line 554) | public List<CodeBlock> findCodeBlocksAt(long startAddress,
    method findDataBlocksOn (line 582) | public List<DataBlock> findDataBlocksOn(long address) {
    method findDataBlocksOn (line 608) | public List<DataBlock> findDataBlocksOn(long startAddress,
    method findDataBlocksAt (line 631) | public List<DataBlock> findDataBlocksAt(long address) {
    method findDataBlocksAt (line 656) | public List<DataBlock> findDataBlocksAt(long startAddress,
    method insertSymbolicExpression (line 685) | public void
    method removeSymbolicExpression (line 699) | public boolean removeSymbolicExpression(long offset) {
    method symbolicExpressionIterator (line 711) | public Iterator<Map.Entry<Long, SymbolicExpression>>
    method findSymbolicExpressionAt (line 726) | public SymbolicExpression findSymbolicExpressionAt(long address) {
    method findSymbolicExpressionsAt (line 742) | public Iterator<Map.Entry<Long, SymbolicExpression>>
    method fromProtobuf (line 765) | static ByteInterval
    method toProtobuf (line 776) | public ByteIntervalOuterClass.ByteInterval.Builder toProtobuf() {

FILE: java/com/grammatech/gtirb/CFG.java
  class CFG (line 26) | public class CFG {
    method CFG (line 35) | public CFG(CFGOuterClass.CFG protoCfg) throws IOException {
    method CFG (line 54) | public CFG(List<Edge> edgeList, List<byte[]> verticeList) {
    method getEdgeList (line 64) | public List<Edge> getEdgeList() { return this.edgeList; }
    method setEdgeList (line 71) | public void setEdgeList(List<Edge> edgeList) { this.edgeList = edgeLis...
    method getVerticeList (line 78) | public List<byte[]> getVerticeList() { return this.verticeList; }
    method setVerticeList (line 85) | public void setVerticeList(List<byte[]> verticeList) {
    method fromProtobuf (line 102) | public static CFG fromProtobuf(CFGOuterClass.CFG protoCFG)
    method toProtobuf (line 112) | public CFGOuterClass.CFG.Builder toProtobuf() {

FILE: java/com/grammatech/gtirb/CfiDirective.java
  class CfiDirective (line 10) | public class CfiDirective extends Tuple3<String, List<Long>, UUID> {
    method CfiDirective (line 19) | public CfiDirective(String name, List<Long> args, UUID symbolUuid) {
    method getName (line 26) | public String getName() { return this.get0(); }
    method getArgs (line 31) | public List<Long> getArgs() { return this.get1(); }
    method getSymbolUuid (line 37) | public UUID getSymbolUuid() { return this.get2(); }

FILE: java/com/grammatech/gtirb/CodeBlock.java
  class CodeBlock (line 25) | public class CodeBlock extends ByteBlock {
    type DecodeMode (line 29) | public enum DecodeMode {
    method CodeBlock (line 40) | private CodeBlock(ByteString protoUuid,
    method CodeBlock (line 54) | public CodeBlock(long size, long offset, DecodeMode decodeMode) {
    method getDecodeMode (line 64) | public DecodeMode getDecodeMode() { return decodeMode; }
    method setDecodeMode (line 71) | public void setDecodeMode(DecodeMode decodeMode) {
    method fromProtobuf (line 80) | static CodeBlock fromProtobuf(ByteIntervalOuterClass.Block protoBlock)
    method toProtobuf (line 98) | @Override

FILE: java/com/grammatech/gtirb/DataBlock.java
  class DataBlock (line 25) | public class DataBlock extends ByteBlock {
    method DataBlock (line 31) | private DataBlock(ByteString protoUuid,
    method DataBlock (line 40) | public DataBlock(long size, long offset) { super(size, offset); }
    method fromProtobuf (line 47) | static DataBlock fromProtobuf(ByteIntervalOuterClass.Block protoBlock)
    method toProtobuf (line 65) | @Override

FILE: java/com/grammatech/gtirb/Edge.java
  class Edge (line 25) | public class Edge {
    type EdgeType (line 30) | public enum EdgeType {
    method Edge (line 50) | public Edge(CFGOuterClass.Edge protoEdge) throws IOException {
    method Edge (line 71) | public Edge(UUID sourceUuid, UUID targetUuid, EdgeType edgeType,
    method getSourceUuid (line 85) | public UUID getSourceUuid() { return this.sourceUuid; }
    method setSourceUuid (line 92) | public void setSourceUuid(UUID sourceUuid) { this.sourceUuid = sourceU...
    method getTargetUuid (line 99) | public UUID getTargetUuid() { return this.targetUuid; }
    method setTargetUuid (line 106) | public void setTargetUuid(UUID targetUuid) { this.targetUuid = targetU...
    method getEdgeType (line 113) | public EdgeType getEdgeType() { return this.edgeType; }
    method setEdgeType (line 120) | public void setEdgeType(EdgeType edgeType) { this.edgeType = edgeType; }
    method isConditional (line 127) | public boolean isConditional() { return this.edgeLabelConditional; }
    method setEdgeLabelConditional (line 134) | public void setEdgeLabelConditional(boolean conditional) {
    method isDirect (line 143) | public boolean isDirect() { return this.edgeLabelDirect; }
    method setEdgeLabelDirect (line 150) | public void setEdgeLabelDirect(boolean direct) {
    method fromProtobuf (line 160) | public static Edge fromProtobuf(CFGOuterClass.Edge protoEdge)
    method toProtobuf (line 170) | public CFGOuterClass.Edge.Builder toProtobuf() {

FILE: java/com/grammatech/gtirb/ElfSymbolInfoTuple.java
  class ElfSymbolInfoTuple (line 8) | public class ElfSymbolInfoTuple
    method ElfSymbolInfoTuple (line 19) | public ElfSymbolInfoTuple(Long size, String type, String binding,
    method getSize (line 27) | public Long getSize() { return this.get0(); }
    method getType (line 32) | public String getType() { return this.get1(); }
    method getBinding (line 37) | public String getBinding() { return this.get2(); }
    method getVisibility (line 42) | public String getVisibility() { return this.get3(); }
    method getSecIndex (line 47) | public Long getSecIndex() { return this.get4(); }

FILE: java/com/grammatech/gtirb/ElfSymbolVersionsTable.java
  class ElfSymbolVersionsTable (line 12) | public class ElfSymbolVersionsTable
    class SymVerDef (line 20) | public static class SymVerDef extends Tuple2<List<String>, Short> {
      method SymVerDef (line 27) | public SymVerDef(List<String> versions, Short verdef) {
      method getVersions (line 34) | public List<String> getVersions() { return this.get0(); }
      method getVerdef (line 39) | public Short getVerdef() { return this.get1(); }
    class SymVerEntry (line 45) | public static class SymVerEntry extends Tuple2<Short, Boolean> {
      method SymVerEntry (line 52) | public SymVerEntry(Short verId, Boolean hidden) {
      method getVerId (line 59) | public Short getVerId() { return this.get0(); }
      method isHidden (line 64) | public Boolean isHidden() { return this.get1(); }
    method ElfSymbolVersionsTable (line 75) | public ElfSymbolVersionsTable(
    method getSymVerDefMap (line 85) | public Map<Short, ElfSymbolVersionsTable.SymVerDef> getSymVerDefMap() {
    method getVerNeededMap (line 92) | public Map<String, Map<Short, String>> getVerNeededMap() {
    method getSymVerEntriesMap (line 99) | public Map<UUID, ElfSymbolVersionsTable.SymVerEntry> getSymVerEntriesM...

FILE: java/com/grammatech/gtirb/IR.java
  class IR (line 38) | public class IR extends AuxDataContainer {
    method IR (line 51) | public IR() {
    method IR (line 60) | private IR(IROuterClass.IR protoIr) throws IOException {
    method loadProtobuf (line 69) | private static IR loadProtobuf(IROuterClass.IR protoIr) throws IOExcep...
    method loadFile (line 91) | public static IR loadFile(InputStream fileIn) {
    method loadFile (line 133) | public static IR loadFile(String fileInName) {
    method getModules (line 150) | public List<Module> getModules() {
    method findModules (line 160) | public List<Module> findModules(String name) {
    method addModule (line 175) | public void addModule(Module module) {
    method addModules (line 185) | public void addModules(List<Module> modules) {
    method removeModule (line 197) | public boolean removeModule(Module module) {
    method getCfg (line 211) | public CFG getCfg() { return this.cfg; }
    method setCfg (line 218) | public void setCfg(CFG cfg) { this.cfg = cfg; }
    method getVersion (line 225) | public int getVersion() { return this.version; }
    method setVersion (line 232) | public void setVersion(int version) { this.version = version; }
    method toProtobuf (line 239) | public IROuterClass.IR.Builder toProtobuf() {
    method saveFile (line 258) | public void saveFile(OutputStream fileOut) throws IOException {
    method saveFile (line 271) | public void saveFile(String fileOutName) throws IOException {

FILE: java/com/grammatech/gtirb/Module.java
  class Module (line 35) | public class Module extends AuxDataContainer {
    type FileFormat (line 40) | public enum FileFormat {
    type ISA (line 55) | public enum ISA {
    type ByteOrder (line 71) | public enum ByteOrder { ByteOrder_Undefined, BigEndian, LittleEndian }
    method Module (line 90) | Module(ModuleOuterClass.Module protoModule) throws IOException {
    method Module (line 125) | public Module(String binaryPath, long preferredAddr, long rebaseDelta,
    method Module (line 153) | public Module(String binaryPath, long preferredAddr, long rebaseDelta,
    method getIr (line 175) | public Optional<IR> getIr() { return this.ir; }
    method setIr (line 183) | void setIr(Optional<IR> ir) { this.ir = ir; }
    method getBinaryPath (line 190) | public String getBinaryPath() { return this.binaryPath; }
    method setBinaryPath (line 201) | public void setBinaryPath(String binaryPath) {
    method getPreferredAddr (line 210) | public long getPreferredAddr() { return this.preferredAddr; }
    method setPreferredAddr (line 217) | public void setPreferredAddr(long preferredAddr) {
    method getRebaseDelta (line 227) | public long getRebaseDelta() { return this.rebaseDelta; }
    method setRebaseDelta (line 235) | public void setRebaseDelta(long rebaseDelta) {
    method getFileFormat (line 245) | public FileFormat getFileFormat() { return this.fileFormat; }
    method setFileFormat (line 252) | public void setFileFormat(FileFormat fileFormat) {
    method getIsa (line 261) | public ISA getIsa() { return this.isa; }
    method setIsa (line 268) | public void setIsa(ISA isa) { this.isa = isa; }
    method getName (line 275) | public String getName() { return this.name; }
    method setName (line 282) | public void setName(String name) { this.name = name; }
    method getSections (line 290) | public List<Section> getSections() {
    method setSections (line 303) | private void setSections(List<Section> sectionList) {
    method addSection (line 320) | public void addSection(Section section) {
    method removeSection (line 332) | public boolean removeSection(Section section) {
    method getSymbols (line 348) | public List<Symbol> getSymbols() {
    method addSymbol (line 357) | public void addSymbol(Symbol symbol) {
    method removeSymbol (line 369) | public boolean removeSymbol(Symbol symbol) {
    method setSymbols (line 384) | private void setSymbols(List<Symbol> symbolList) {
    method getProxyBlocks (line 398) | public List<ProxyBlock> getProxyBlocks() {
    method addProxyBlock (line 408) | public void addProxyBlock(ProxyBlock proxyBlock) {
    method removeProxyBlock (line 421) | public boolean removeProxyBlock(ProxyBlock proxyBlock) {
    method setProxyBlocks (line 436) | private void setProxyBlocks(List<ProxyBlock> proxyBlockList) {
    method getEntryPoint (line 450) | public CodeBlock getEntryPoint() { return entryPoint; }
    method setEntryPoint (line 457) | public void setEntryPoint(CodeBlock entryCodeBlock) {
    method getByteOrder (line 466) | public ByteOrder getByteOrder() { return this.byteOrder; }
    method setByteOrder (line 473) | public void setByteOrder(ByteOrder byteOrder) {
    method initializeSectionList (line 485) | private void
    method initializeSymbolList (line 504) | private void
    method initializeProxyBlockList (line 523) | private void initializeProxyBlockList(
    method findSectionsOn (line 544) | public List<Section> findSectionsOn(long address) {
    method findSectionsOn (line 560) | public List<Section> findSectionsOn(long startAddress, long endAddress) {
    method findSectionsAt (line 572) | public List<Section> findSectionsAt(long address) {
    method findSectionsAt (line 586) | public List<Section> findSectionsAt(long startAddress, long endAddress) {
    method fromProtobuf (line 597) | static Module fromProtobuf(ModuleOuterClass.Module protoModule)
    method toProtobuf (line 607) | ModuleOuterClass.Module.Builder toProtobuf() {

FILE: java/com/grammatech/gtirb/Node.java
  class Node (line 24) | public class Node {
    method Node (line 32) | public Node() { this(UUID.randomUUID()); }
    method Node (line 37) | public Node(UUID uuid) {
    method getByUuid (line 47) | public static Node getByUuid(UUID uuid) {
    method getByUuid (line 59) | public static <T extends Node> T getByUuid(UUID uuid, Class<T> type) {
    method getUuid (line 75) | public UUID getUuid() { return uuid; }

FILE: java/com/grammatech/gtirb/Offset.java
  class Offset (line 23) | public class Offset {
    method Offset (line 35) | public Offset(UUID elementId, long displacement) {
    method getElementId (line 45) | public UUID getElementId() { return this.elementId; }
    method getDisplacement (line 52) | public long getDisplacement() { return this.displacement; }
    method equals (line 54) | @Override

FILE: java/com/grammatech/gtirb/PeExportEntry.java
  class PeExportEntry (line 8) | public class PeExportEntry extends Tuple3<Long, Long, String> {
    method PeExportEntry (line 16) | public PeExportEntry(Long address, Long ordinal, String name) {
    method getAddress (line 23) | public Long getAddress() { return this.get0(); }
    method getOrdinal (line 28) | public Long getOrdinal() { return this.get1(); }
    method getName (line 33) | public String getName() { return this.get2(); }

FILE: java/com/grammatech/gtirb/PeImportEntry.java
  class PeImportEntry (line 8) | public class PeImportEntry extends Tuple4<Long, Long, String, String> {
    method PeImportEntry (line 17) | public PeImportEntry(Long address, Long ordinal, String funcName,
    method getAddress (line 25) | public Long getAddress() { return this.get0(); }
    method getOrdinal (line 30) | public Long getOrdinal() { return this.get1(); }
    method getFuncName (line 35) | public String getFuncName() { return this.get2(); }
    method getLibName (line 40) | public String getLibName() { return this.get3(); }

FILE: java/com/grammatech/gtirb/PeResourceEntry.java
  class PeResourceEntry (line 10) | public class PeResourceEntry extends Tuple3<List<Byte>, Offset, Long> {
    method PeResourceEntry (line 18) | public PeResourceEntry(List<Byte> header, Offset offset, Long size) {
    method getHeader (line 25) | public List<Byte> getHeader() { return this.get0(); }
    method getOffset (line 30) | public Offset getOffset() { return this.get1(); }
    method getSize (line 35) | public Long getSize() { return this.get2(); }

FILE: java/com/grammatech/gtirb/ProbFuncName.java
  class ProbFuncName (line 8) | public class ProbFuncName extends Tuple3<String, String, Float> {
    method ProbFuncName (line 17) | public ProbFuncName(String name, String binaryName, Float prob) {
    method getName (line 24) | public String getName() { return this.get0(); }
    method getBinaryName (line 29) | public String getBinaryName() { return this.get1(); }
    method getProbability (line 34) | public Float getProbability() { return this.get2(); }

FILE: java/com/grammatech/gtirb/ProxyBlock.java
  class ProxyBlock (line 26) | public class ProxyBlock extends Node {
    method ProxyBlock (line 35) | private ProxyBlock(ProxyBlockOuterClass.ProxyBlock protoProxyBlock)
    method ProxyBlock (line 44) | public ProxyBlock() {
    method ProxyBlock (line 49) | public ProxyBlock(UUID uuid) {
    method getModule (line 60) | public Optional<Module> getModule() { return this.module; }
    method setModule (line 68) | void setModule(Optional<Module> module) { this.module = module; }
    method fromProtobuf (line 78) | static ProxyBlock
    method toProtobuf (line 89) | ProxyBlockOuterClass.ProxyBlock.Builder toProtobuf() {

FILE: java/com/grammatech/gtirb/Section.java
  class Section (line 36) | public class Section extends Node implements TreeListItem {
    type SectionFlag (line 41) | public enum SectionFlag {
    method Section (line 60) | private Section(SectionOuterClass.Section protoSection) throws IOExcep...
    method Section (line 90) | public Section(String name, Set<SectionFlag> flags,
    method getModule (line 111) | public Optional<Module> getModule() { return this.module; }
    method setModule (line 119) | public void setModule(Optional<Module> module) { this.module = module; }
    method getName (line 126) | public String getName() { return this.name; }
    method setName (line 133) | public void setName(String name) { this.name = name; }
    method getByteIntervalIterator (line 141) | private Iterator<ByteInterval> getByteIntervalIterator() {
    method getByteIntervals (line 153) | public List<ByteInterval> getByteIntervals() {
    method addByteInterval (line 166) | public void addByteInterval(ByteInterval byteInterval) {
    method removeByteInterval (line 178) | public boolean removeByteInterval(ByteInterval byteInterval) {
    method getSectionFlags (line 194) | public Set<SectionFlag> getSectionFlags() {
    method addSectionFlag (line 204) | public void addSectionFlag(SectionFlag sectionFlag) {
    method removeSectionFlag (line 216) | public boolean removeSectionFlag(SectionFlag sectionFlag) {
    method getSize (line 233) | public long getSize() {
    method getAddress (line 280) | public OptionalLong getAddress() {
    method getIndex (line 311) | public long getIndex() { return this.getAddress().orElse(0); }
    method findByteIntervalsOn (line 320) | public List<ByteInterval> findByteIntervalsOn(long address) {
    method findByteIntervalsOn (line 335) | public List<ByteInterval> findByteIntervalsOn(long startAddress,
    method findByteIntervalsAt (line 348) | public List<ByteInterval> findByteIntervalsAt(long address) {
    method findByteIntervalsAt (line 363) | public List<ByteInterval> findByteIntervalsAt(long startAddress,
    method fromProtobuf (line 374) | static Section fromProtobuf(SectionOuterClass.Section protoSection)
    method toProtobuf (line 384) | SectionOuterClass.Section.Builder toProtobuf() {

FILE: java/com/grammatech/gtirb/SectionPropertyTuple.java
  class SectionPropertyTuple (line 8) | public class SectionPropertyTuple extends Tuple2<Long, Long> {
    method SectionPropertyTuple (line 15) | public SectionPropertyTuple(Long type, Long flags) { super(type, flags...
    method getType (line 22) | public Long getType() { return this.get0(); }
    method getFlags (line 29) | public Long getFlags() { return this.get1(); }

FILE: java/com/grammatech/gtirb/SymAddrAddr.java
  class SymAddrAddr (line 28) | public class SymAddrAddr extends SymbolicExpression {
    method SymAddrAddr (line 41) | public SymAddrAddr(
    method SymAddrAddr (line 63) | public SymAddrAddr(long offset, long scale, UUID symbol1_uuid,
    method getSymbol1Uuid (line 77) | public UUID getSymbol1Uuid() { return symbol1_uuid; }
    method setSymbol1Uuid (line 85) | public void setSymbol1Uuid(UUID symbol_uuid) {
    method getSymbol2Uuid (line 94) | public UUID getSymbol2Uuid() { return symbol2_uuid; }
    method setSymbol2Uuid (line 102) | public void setSymbol2Uuid(UUID symbol_uuid) {
    method getScale (line 111) | public long getScale() { return scale; }
    method setScale (line 118) | public void setScale(long scale) { this.scale = scale; }
    method getOffset (line 124) | public long getOffset() { return this.offset; }
    method setOffset (line 130) | public void setOffset(long offset) { this.offset = offset; }
    method fromProtobuf (line 139) | public static SymAddrAddr fromProtobuf(
    method toProtobuf (line 150) | @Override

FILE: java/com/grammatech/gtirb/SymAddrConst.java
  class SymAddrConst (line 26) | public class SymAddrConst extends SymbolicExpression {
    method SymAddrConst (line 36) | public SymAddrConst(
    method SymAddrConst (line 53) | public SymAddrConst(long offset, UUID symbol_uuid,
    method getSymbolUuid (line 65) | public UUID getSymbolUuid() { return symbol_uuid; }
    method setSymbolUuid (line 73) | public void setSymbolUuid(UUID symbol_uuid) {
    method getOffset (line 81) | public long getOffset() { return this.offset; }
    method setOffset (line 87) | public void setOffset(long offset) { this.offset = offset; }
    method fromProtobuf (line 96) | public static SymAddrConst fromProtobuf(
    method toProtobuf (line 107) | @Override

FILE: java/com/grammatech/gtirb/Symbol.java
  class Symbol (line 30) | public class Symbol extends Node {
    type PayloadType (line 35) | public enum PayloadType { REFERENT, VALUE, NONE }
    method Symbol (line 48) | private Symbol(SymbolOuterClass.Symbol protoSymbol) throws IOException {
    method Symbol (line 76) | public Symbol(String name, UUID referentUuid) {
    method Symbol (line 91) | public Symbol(String name, long value) {
    method Symbol (line 105) | public Symbol(String name) {
    method getModule (line 121) | public Optional<Module> getModule() { return this.module; }
    method setModule (line 129) | public void setModule(Optional<Module> module) { this.module = module; }
    method getName (line 136) | public String getName() { return name; }
    method setName (line 143) | public void setName(String name) { this.name = name; }
    method getReferent (line 150) | public Node getReferent() {
    method getReferentUuid (line 162) | public Optional<UUID> getReferentUuid() {
    method setReferentUuid (line 175) | public void setReferentUuid(UUID uuid) {
    method getValue (line 185) | public OptionalLong getValue() {
    method setValue (line 196) | public void setValue(long value) {
    method getPayloadType (line 206) | public PayloadType getPayloadType() { return this.payloadType; }
    method isAtEnd (line 213) | public boolean isAtEnd() { return this.atEnd; }
    method setAtEnd (line 220) | public void setAtEnd(boolean atEnd) { this.atEnd = atEnd; }
    method fromProtobuf (line 228) | static Symbol fromProtobuf(SymbolOuterClass.Symbol protoSymbol)
    method toProtobuf (line 238) | SymbolOuterClass.Symbol.Builder toProtobuf() {

FILE: java/com/grammatech/gtirb/SymbolicExpression.java
  class SymbolicExpression (line 29) | public class SymbolicExpression {
    type AttributeFlag (line 37) | public enum AttributeFlag {
      method AttributeFlag (line 108) | AttributeFlag(int value) { this.value = value; }
      method value (line 110) | public int value() { return this.value; }
      method fromInteger (line 112) | public static AttributeFlag fromInteger(int value) {
      method initMap (line 116) | private static Map<Integer, AttributeFlag> initMap() {
    method SymbolicExpression (line 134) | protected SymbolicExpression(
    method SymbolicExpression (line 156) | protected SymbolicExpression(Set<AttributeFlag> attributeFlags) {
    method getAttributeFlags (line 169) | public Set<AttributeFlag> getAttributeFlags() {
    method addAttributeFlag (line 179) | public void addAttributeFlag(AttributeFlag attributeFlag) {
    method removeAttributeFlag (line 191) | public boolean removeAttributeFlag(AttributeFlag attributeFlag) {
    method getUnknownAttributeFlags (line 201) | public Set<Integer> getUnknownAttributeFlags() {
    method addUnknownFlag (line 211) | public void addUnknownFlag(Integer unknownFlag) {
    method removeUnknownFlag (line 223) | public boolean removeUnknownFlag(Integer unknownFlag) {
    method fromProtobuf (line 234) | public static SymbolicExpression fromProtobuf(
    method toProtobuf (line 247) | public SymbolicExpressionOuterClass.SymbolicExpression.Builder

FILE: java/com/grammatech/gtirb/TreeListItem.java
  type TreeListItem (line 20) | public interface TreeListItem {
    method getIndex (line 29) | long getIndex();
    method getSize (line 38) | long getSize();

FILE: java/com/grammatech/gtirb/TreeListUtils.java
  class TreeListUtils (line 32) | public class TreeListUtils<Type> implements Iterable<Type> {
    method TreeListUtils (line 36) | public TreeListUtils(TreeMap<Long, List<Type>> treeMap) {
    method insertItem (line 47) | public static <T extends TreeListItem> List<T>
    method removeItem (line 67) | public static <T extends TreeListItem> List<T>
    method getItemsIntersectingIndex (line 95) | public static <T extends TreeListItem> List<T>
    method getItemsIntersectingIndexRange (line 126) | public static <T extends TreeListItem> List<T>
    method getItemsAtStartIndex (line 166) | public static <T extends TreeListItem> List<T>
    method getItemsAtStartIndexRange (line 183) | public static <T extends TreeListItem> List<T>
    method iterator (line 209) | @Override

FILE: java/com/grammatech/gtirb/TypeTableEntry.java
  class TypeTableEntry (line 14) | public class TypeTableEntry
    class BoolType (line 23) | public static class BoolType extends Tuple1<Byte> {
      method BoolType (line 29) | public BoolType(Byte b) { super((byte)0); }
    class IntType (line 35) | public static class IntType extends Tuple2<Byte, Long> {
      method IntType (line 43) | public IntType(Byte signedness, Long width) {
      method isSigned (line 50) | public boolean isSigned() { return this.get0() == 1; }
      method getWidth (line 55) | public Long getWidth() { return this.get1(); }
    class FunctionType (line 61) | public static class FunctionType extends Tuple2<UUID, List<UUID>> {
      method FunctionType (line 68) | public FunctionType(UUID returnType, List<UUID> paramTypes) {
      method getReturnType (line 75) | public UUID getReturnType() { return this.get0(); }
      method getParamTypes (line 80) | public List<UUID> getParamTypes() { return this.get1(); }
    class ArrayType (line 86) | public static class ArrayType extends Tuple2<UUID, Long> {
      method ArrayType (line 93) | public ArrayType(UUID elemType, Long size) { super(elemType, size); }
      method getElemType (line 98) | public UUID getElemType() { return this.get0(); }
      method getSize (line 103) | public Long getSize() { return this.get1(); }
    class StructField (line 109) | public static class StructField extends Tuple2<Long, UUID> {
      method StructField (line 116) | public StructField(Long offset, UUID type) { super(offset, type); }
      method getOffset (line 121) | public Long getOffset() { return this.get0(); }
      method getType (line 126) | public UUID getType() { return this.get1(); }
    class StructType (line 132) | public static class StructType extends Tuple2<Long, List<StructField>> {
      method StructType (line 139) | public StructType(Long size, List<StructField> fields) {
      method getSize (line 146) | public Long getSize() { return this.get0(); }
      method getFields (line 151) | public List<StructField> getFields() { return this.get1(); }
    class VoidType (line 157) | public static class VoidType extends Tuple1<Byte> {
      method VoidType (line 163) | public VoidType(Byte b) { super((byte)0); }
    method TypeTableEntry (line 167) | private TypeTableEntry(Token.T0 tok, Long v) { super(tok, v); }
    method TypeTableEntry (line 168) | private TypeTableEntry(Token.T1 tok, BoolType v) { super(tok, v); }
    method TypeTableEntry (line 169) | private TypeTableEntry(Token.T2 tok, IntType v) { super(tok, v); }
    method TypeTableEntry (line 170) | private TypeTableEntry(Token.T3 tok, Long v) { super(tok, v); }
    method TypeTableEntry (line 171) | private TypeTableEntry(Token.T4 tok, Long v) { super(tok, v); }
    method TypeTableEntry (line 172) | private TypeTableEntry(Token.T5 tok, FunctionType v) { super(tok, v); }
    method TypeTableEntry (line 173) | private TypeTableEntry(Token.T6 tok, UUID v) { super(tok, v); }
    method TypeTableEntry (line 174) | private TypeTableEntry(Token.T7 tok, ArrayType v) { super(tok, v); }
    method TypeTableEntry (line 175) | private TypeTableEntry(Token.T8 tok, UUID v) { super(tok, v); }
    method TypeTableEntry (line 176) | private TypeTableEntry(Token.T9 tok, StructType v) { super(tok, v); }
    method TypeTableEntry (line 177) | private TypeTableEntry(Token.T10 tok, VoidType v) { super(tok, v); }
    method getSizeIfUnknown (line 182) | public Optional<Long> getSizeIfUnknown() { return this.get0(); }
    method isBool (line 187) | public boolean isBool() { return this.get1().isPresent(); }
    method getAsInt (line 192) | public Optional<IntType> getAsInt() { return this.get2(); }
    method getSizeIfChar (line 197) | public Optional<Long> getSizeIfChar() { return this.get3(); }
    method getSizeIfFloat (line 202) | public Optional<Long> getSizeIfFloat() { return this.get4(); }
    method getAsFunction (line 207) | public Optional<FunctionType> getAsFunction() { return this.get5(); }
    method getUuidIfPointer (line 212) | public Optional<UUID> getUuidIfPointer() { return this.get6(); }
    method getAsArray (line 217) | public Optional<ArrayType> getAsArray() { return this.get7(); }
    method getUuidIfAlias (line 222) | public Optional<UUID> getUuidIfAlias() { return this.get8(); }
    method getAsStruct (line 227) | public Optional<StructType> getAsStruct() { return this.get9(); }
    method isVoid (line 232) | public boolean isVoid() { return this.get10().isPresent(); }
    method makeUnknown (line 237) | public static TypeTableEntry makeUnknown(Long size) {
    method makeBool (line 244) | public static TypeTableEntry makeBool(BoolType boolType) {
    method makeInt (line 251) | public static TypeTableEntry makeInt(IntType intType) {
    method makeChar (line 258) | public static TypeTableEntry makeChar(Long size) {
    method makeFloat (line 265) | public static TypeTableEntry makeFloat(Long size) {
    method makeFunction (line 272) | public static TypeTableEntry makeFunction(FunctionType funcType) {
    method makePointer (line 279) | public static TypeTableEntry makePointer(UUID pointedToType) {
    method makeArray (line 286) | public static TypeTableEntry makeArray(ArrayType arrType) {
    method makeAlias (line 293) | public static TypeTableEntry makeAlias(UUID aliasedType) {
    method makeStruct (line 300) | public static TypeTableEntry makeStruct(StructType structType) {
    method makeVoid (line 307) | public static TypeTableEntry makeVoid(VoidType voidType) {

FILE: java/com/grammatech/gtirb/Util.java
  class Util (line 30) | public class Util {
    method byteArrayToUUID (line 41) | public static UUID byteArrayToUUID(byte[] b)
    method readUUID (line 57) | public static UUID readUUID(InputStream in) throws IOException {
    method byteStringToUuid (line 78) | public static UUID
    method uuidToByteArray (line 99) | public static byte[] uuidToByteArray(UUID uuid) {
    method writeUUID (line 113) | public static void writeUUID(OutputStream out, UUID uuid)
    method uuidToByteString (line 125) | public static com.google.protobuf.ByteString uuidToByteString(UUID uui...

FILE: java/com/grammatech/gtirb/auxdatacodec/BoolCodec.java
  class BoolCodec (line 25) | public class BoolCodec implements Codec<Boolean> {
    method getTypeName (line 27) | public String getTypeName() { return "bool"; }
    method decode (line 29) | public Boolean decode(InputStream in) throws IOException {
    method encode (line 38) | public void encode(OutputStream out, Boolean val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/ByteCodec.java
  class ByteCodec (line 8) | public class ByteCodec implements Codec<Byte> {
    method ByteCodec (line 12) | private ByteCodec(String tn) { this.typeName = tn; }
    method getTypeName (line 14) | public String getTypeName() { return this.typeName; }
    method decode (line 16) | public Byte decode(InputStream in) throws IOException {
    method encode (line 24) | public void encode(OutputStream out, Byte val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/Codec.java
  type Codec (line 24) | public interface Codec<T> {
    method getTypeName (line 31) | public String getTypeName();
    method decode (line 39) | public T decode(InputStream in) throws IOException;
    method encode (line 47) | public void encode(OutputStream out, T val) throws IOException;

FILE: java/com/grammatech/gtirb/auxdatacodec/FloatCodec.java
  class FloatCodec (line 24) | public class FloatCodec implements Codec<Float> {
    method getTypeName (line 26) | public String getTypeName() { return "float"; }
    method decode (line 28) | public Float decode(InputStream in) throws IOException {
    method encode (line 38) | public void encode(OutputStream out, Float val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/IntegerCodec.java
  class IntegerCodec (line 24) | public class IntegerCodec implements Codec<Integer> {
    method IntegerCodec (line 28) | private IntegerCodec(String tn) { this.typeName = tn; }
    method getTypeName (line 30) | public String getTypeName() { return this.typeName; }
    method decode (line 32) | public Integer decode(InputStream in) throws IOException {
    method encode (line 43) | public void encode(OutputStream out, Integer val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/ListCodec.java
  class ListCodec (line 23) | public class ListCodec<T> implements Codec<List<T>> {
    method ListCodec (line 27) | public ListCodec(Codec<T> tc, Supplier<List<T>> s) {
    method getTypeName (line 32) | public String getTypeName() {
    method decode (line 36) | public List<T> decode(InputStream in) throws IOException {
    method encode (line 45) | public void encode(OutputStream out, List<T> al) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/LongCodec.java
  class LongCodec (line 24) | public class LongCodec implements Codec<Long> {
    method LongCodec (line 28) | private LongCodec(String tn) { this.typeName = tn; }
    method getTypeName (line 30) | public String getTypeName() { return this.typeName; }
    method decodeStatic (line 32) | public static long decodeStatic(InputStream in) throws IOException {
    method decode (line 42) | public Long decode(InputStream in) throws IOException {
    method encodeStatic (line 46) | public static void encodeStatic(OutputStream out, long val)
    method encode (line 55) | public void encode(OutputStream out, Long val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/MapCodec.java
  class MapCodec (line 23) | public class MapCodec<K, V> implements Codec<Map<K, V>> {
    method MapCodec (line 28) | public MapCodec(Codec<K> kc, Codec<V> vc, Supplier<Map<K, V>> s) {
    method getTypeName (line 34) | public String getTypeName() {
    method decode (line 39) | public Map<K, V> decode(InputStream in) throws IOException {
    method encode (line 54) | public void encode(OutputStream out, Map<K, V> map) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/OffsetCodec.java
  class OffsetCodec (line 23) | public class OffsetCodec implements Codec<Offset> {
    method getTypeName (line 25) | public String getTypeName() { return "Offset"; }
    method decode (line 27) | public Offset decode(InputStream in) throws IOException {
    method encode (line 33) | public void encode(OutputStream out, Offset val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/SetCodec.java
  class SetCodec (line 23) | public class SetCodec<T> implements Codec<Set<T>> {
    method SetCodec (line 27) | public SetCodec(Codec<T> tc, Supplier<Set<T>> s) {
    method getTypeName (line 32) | public String getTypeName() {
    method decode (line 36) | public Set<T> decode(InputStream in) throws IOException {
    method encode (line 50) | public void encode(OutputStream out, Set<T> set) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/ShortCodec.java
  class ShortCodec (line 10) | public class ShortCodec implements Codec<Short> {
    method ShortCodec (line 14) | private ShortCodec(String tn) { this.typeName = tn; }
    method getTypeName (line 16) | public String getTypeName() { return this.typeName; }
    method decode (line 18) | public Short decode(InputStream in) throws IOException {
    method encode (line 28) | public void encode(OutputStream out, Short val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/StringCodec.java
  class StringCodec (line 26) | public class StringCodec implements Codec<String> {
    method getTypeName (line 28) | public String getTypeName() { return "string"; }
    method decode (line 30) | public String decode(InputStream in) throws IOException {
    method encode (line 44) | public void encode(OutputStream out, String val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/Tuple1Codec.java
  class Tuple1Codec (line 8) | public class Tuple1Codec<T extends Tuple1<A>, A> implements Codec<T> {
    type Tuple1Maker (line 13) | public interface Tuple1Maker<T, A> { public T make(A a); }
      method make (line 13) | public T make(A a);
    method Tuple1Codec (line 15) | public Tuple1Codec(Codec<A> ac, Tuple1Maker<T, A> maker) {
    method getTypeName (line 20) | public String getTypeName() {
    method decode (line 24) | public T decode(InputStream in) throws IOException {
    method encode (line 29) | public void encode(OutputStream out, T val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/Tuple2Codec.java
  class Tuple2Codec (line 22) | public class Tuple2Codec<T extends Tuple2<A, B>, A, B> implements Codec<...
    type Tuple2Maker (line 28) | public interface Tuple2Maker<T, A, B> { public T make(A a, B b); }
      method make (line 28) | public T make(A a, B b);
    method Tuple2Codec (line 30) | public Tuple2Codec(Codec<A> ac, Codec<B> bc, Tuple2Maker<T, A, B> make...
    method getTypeName (line 36) | public String getTypeName() {
    method decode (line 41) | public T decode(InputStream in) throws IOException {
    method encode (line 47) | public void encode(OutputStream out, T val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/Tuple3Codec.java
  class Tuple3Codec (line 22) | public class Tuple3Codec<T extends Tuple3<A, B, C>, A, B, C>
    type Tuple3Maker (line 30) | public interface Tuple3Maker<T, A, B, C> { public T make(A a, B b, C c...
      method make (line 30) | public T make(A a, B b, C c);
    method Tuple3Codec (line 32) | public Tuple3Codec(Codec<A> ac, Codec<B> bc, Codec<C> cc,
    method getTypeName (line 40) | public String getTypeName() {
    method decode (line 45) | public T decode(InputStream in) throws IOException {
    method encode (line 52) | public void encode(OutputStream out, T val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/Tuple4Codec.java
  class Tuple4Codec (line 22) | public class Tuple4Codec<T extends Tuple4<A, B, C, D>, A, B, C, D>
    type Tuple4Maker (line 31) | public interface Tuple4Maker<T, A, B, C, D> {
      method make (line 32) | public T make(A a, B b, C c, D d);
    method Tuple4Codec (line 35) | public Tuple4Codec(Codec<A> ac, Codec<B> bc, Codec<C> cc, Codec<D> dc,
    method getTypeName (line 44) | public String getTypeName() {
    method decode (line 49) | public T decode(InputStream in) throws IOException {
    method encode (line 57) | public void encode(OutputStream out, T val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/Tuple5Codec.java
  class Tuple5Codec (line 22) | public class Tuple5Codec<T extends Tuple5<A, B, C, D, E>, A, B, C, D, E>
    type Tuple5Maker (line 32) | public interface Tuple5Maker<T, A, B, C, D, E> {
      method make (line 33) | public T make(A a, B b, C c, D d, E e);
    method Tuple5Codec (line 36) | public Tuple5Codec(Codec<A> ac, Codec<B> bc, Codec<C> cc, Codec<D> dc,
    method getTypeName (line 46) | public String getTypeName() {
    method decode (line 52) | public T decode(InputStream in) throws IOException {
    method encode (line 61) | public void encode(OutputStream out, T val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/UuidCodec.java
  class UuidCodec (line 23) | public class UuidCodec implements Codec<UUID> {
    method getTypeName (line 25) | public String getTypeName() { return "UUID"; }
    method decodeStatic (line 27) | public static UUID decodeStatic(InputStream in) throws IOException {
    method decode (line 31) | public UUID decode(InputStream in) throws IOException {
    method encodeStatic (line 35) | public static void encodeStatic(OutputStream out, UUID val)
    method encode (line 40) | public void encode(OutputStream out, UUID val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/Variant11Codec.java
  class Variant11Codec (line 11) | public class Variant11Codec<
    type Variant11Maker (line 38) | public interface Variant11Maker<T, X> { public T make(X x); }
      method make (line 38) | public T make(X x);
    method Variant11Codec (line 77) | public Variant11Codec(
    method getTypeName (line 110) | public String getTypeName() {
    method decode (line 119) | public T decode(InputStream in) throws IOException {
    method encode (line 170) | public void encode(OutputStream out, T val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/Variant2Codec.java
  class Variant2Codec (line 11) | public class Variant2Codec<T extends Variant2<A, B>, A, B> implements Co...
    type Variant2Maker (line 18) | public interface Variant2Maker<T, X> { public T make(X x); }
      method make (line 18) | public T make(X x);
    method Variant2Codec (line 30) | public Variant2Codec(Codec<A> ac, Codec<B> bc, Variant2Maker<T, A> aMa...
    method getTypeName (line 38) | public String getTypeName() {
    method decode (line 43) | public T decode(InputStream in) throws IOException {
    method encode (line 58) | public void encode(OutputStream out, T val) throws IOException {

FILE: java/com/grammatech/gtirb/auxdatacodec/Variant3Codec.java
  class Variant3Codec (line 11) | public class Variant3Codec<T extends Variant3<A, B, C>, A, B, C>
    type Variant3Maker (line 21) | public interface Variant3Maker<T, X> { public T make(X a); }
      method make (line 21) | public T make(X a);
    method Variant3Codec (line 36) | public Variant3Codec(Codec<A> ac, Codec<B> bc, Codec<C> cc,
    method getTypeName (line 47) | public String getTypeName() {
    method decode (line 52) | public T decode(InputStream in) throws IOException {
    method encode (line 71) | public void encode(OutputStream out, T val) throws IOException {

FILE: java/com/grammatech/gtirb/tuple/Tuple1.java
  class Tuple1 (line 9) | public abstract class Tuple1<A> {
    method Tuple1 (line 18) | protected Tuple1(A first) { this.first = first; }
    method get0 (line 25) | public A get0() { return this.first; }
    method equals (line 32) | @Override

FILE: java/com/grammatech/gtirb/tuple/Tuple2.java
  class Tuple2 (line 23) | public abstract class Tuple2<A, B> {
    method Tuple2 (line 34) | protected Tuple2(A first, B second) {
    method get0 (line 44) | public A get0() { return this.first; }
    method get1 (line 51) | public B get1() { return this.second; }
    method equals (line 58) | @Override

FILE: java/com/grammatech/gtirb/tuple/Tuple3.java
  class Tuple3 (line 23) | public abstract class Tuple3<A, B, C> {
    method Tuple3 (line 36) | protected Tuple3(A first, B second, C third) {
    method get0 (line 47) | public A get0() { return this.first; }
    method get1 (line 54) | public B get1() { return this.second; }
    method get2 (line 61) | public C get2() { return this.third; }
    method equals (line 68) | @Override

FILE: java/com/grammatech/gtirb/tuple/Tuple4.java
  class Tuple4 (line 23) | public abstract class Tuple4<A, B, C, D> {
    method Tuple4 (line 38) | protected Tuple4(A first, B second, C third, D fourth) {
    method get0 (line 50) | public A get0() { return this.first; }
    method get1 (line 57) | public B get1() { return this.second; }
    method get2 (line 64) | public C get2() { return this.third; }
    method get3 (line 71) | public D get3() { return this.fourth; }
    method equals (line 78) | @Override

FILE: java/com/grammatech/gtirb/tuple/Tuple5.java
  class Tuple5 (line 23) | public abstract class Tuple5<A, B, C, D, E> {
    method Tuple5 (line 40) | protected Tuple5(A first, B second, C third, D fourth, E fifth) {
    method get0 (line 53) | public A get0() { return this.first; }
    method get1 (line 60) | public B get1() { return this.second; }
    method get2 (line 67) | public C get2() { return this.third; }
    method get3 (line 74) | public D get3() { return this.fourth; }
    method get4 (line 81) | public E get4() { return this.fifth; }
    method equals (line 88) | @Override

FILE: java/com/grammatech/gtirb/variant/Token.java
  class Token (line 10) | public class Token {
    class T0 (line 11) | public static class T0 {}
    class T1 (line 12) | public static class T1 {}
    class T2 (line 13) | public static class T2 {}
    class T3 (line 14) | public static class T3 {}
    class T4 (line 15) | public static class T4 {}
    class T5 (line 16) | public static class T5 {}
    class T6 (line 17) | public static class T6 {}
    class T7 (line 18) | public static class T7 {}
    class T8 (line 19) | public static class T8 {}
    class T9 (line 20) | public static class T9 {}
    class T10 (line 21) | public static class T10 {}

FILE: java/com/grammatech/gtirb/variant/Variant11.java
  class Variant11 (line 12) | public abstract class Variant11<A, B, C, D, E, F, G, H, I, J, K> {
    method Variant11 (line 23) | protected Variant11(Token.T0 tok, A o) {
    method Variant11 (line 35) | protected Variant11(Token.T1 tok, B o) {
    method Variant11 (line 47) | protected Variant11(Token.T2 tok, C o) {
    method Variant11 (line 59) | protected Variant11(Token.T3 tok, D o) {
    method Variant11 (line 71) | protected Variant11(Token.T4 tok, E o) {
    method Variant11 (line 83) | protected Variant11(Token.T5 tok, F o) {
    method Variant11 (line 95) | protected Variant11(Token.T6 tok, G o) {
    method Variant11 (line 107) | protected Variant11(Token.T7 tok, H o) {
    method Variant11 (line 119) | protected Variant11(Token.T8 tok, I o) {
    method Variant11 (line 131) | protected Variant11(Token.T9 tok, J o) {
    method Variant11 (line 143) | protected Variant11(Token.T10 tok, K o) {
    method getIndex (line 153) | public int getIndex() { return this.index; }
    method get0 (line 162) | public Optional<A> get0() {
    method get1 (line 178) | public Optional<B> get1() {
    method get2 (line 194) | public Optional<C> get2() {
    method get3 (line 210) | public Optional<D> get3() {
    method get4 (line 227) | public Optional<E> get4() {
    method get5 (line 243) | public Optional<F> get5() {
    method get6 (line 259) | public Optional<G> get6() {
    method get7 (line 275) | public Optional<H> get7() {
    method get8 (line 291) | public Optional<I> get8() {
    method get9 (line 307) | public Optional<J> get9() {
    method get10 (line 323) | public Optional<K> get10() {
    method set0 (line 338) | public void set0(A o) {
    method set1 (line 349) | public void set1(B o) {
    method set2 (line 360) | public void set2(C o) {
    method set3 (line 371) | public void set3(D o) {
    method set4 (line 382) | public void set4(E o) {
    method set5 (line 393) | public void set5(F o) {
    method set6 (line 404) | public void set6(G o) {
    method set7 (line 415) | public void set7(H o) {
    method set8 (line 426) | public void set8(I o) {
    method set9 (line 437) | public void set9(J o) {
    method set10 (line 448) | public void set10(K o) {
    method equals (line 458) | @Override

FILE: java/com/grammatech/gtirb/variant/Variant2.java
  class Variant2 (line 12) | public abstract class Variant2<A, B> {
    method Variant2 (line 23) | protected Variant2(Token.T0 tok, A o) {
    method Variant2 (line 35) | protected Variant2(Token.T1 tok, B o) {
    method getIndex (line 45) | public int getIndex() { return this.index; }
    method get0 (line 54) | public Optional<A> get0() {
    method get1 (line 70) | public Optional<B> get1() {
    method set0 (line 85) | public void set0(A o) {
    method set1 (line 96) | public void set1(B o) {
    method equals (line 106) | @Override

FILE: java/com/grammatech/gtirb/variant/Variant3.java
  class Variant3 (line 12) | public abstract class Variant3<A, B, C> {
    method Variant3 (line 23) | protected Variant3(Token.T0 tok, A o) {
    method Variant3 (line 35) | protected Variant3(Token.T1 tok, B o) {
    method Variant3 (line 47) | protected Variant3(Token.T2 tok, C o) {
    method getIndex (line 57) | public int getIndex() { return this.index; }
    method get0 (line 66) | public Optional<A> get0() {
    method get1 (line 82) | public Optional<B> get1() {
    method get2 (line 98) | public Optional<C> get2() {
    method set0 (line 113) | public void set0(A o) {
    method set1 (line 124) | public void set1(B o) {
    method set2 (line 135) | public void set2(C o) {
    method equals (line 145) | @Override

FILE: java/tests/TestAuxData.java
  class FooSingle (line 62) | class FooSingle extends Tuple1<String> {
    method FooSingle (line 63) | public FooSingle(String s) { super(s); }
  class FooPair (line 66) | class FooPair extends Tuple2<String, Long> {
    method FooPair (line 67) | public FooPair(String s, Long l) { super(s, l); }
  class FooTriple (line 70) | class FooTriple extends Tuple3<String, Long, Float> {
    method FooTriple (line 71) | public FooTriple(String s, Long l, Float f) { super(s, l, f); }
  class FooQuadruple (line 74) | class FooQuadruple extends Tuple4<String, Long, Float, Boolean> {
    method FooQuadruple (line 75) | public FooQuadruple(String s, Long l, Float f, Boolean b) {
  class FooQuintuple (line 80) | class FooQuintuple extends Tuple5<String, Long, Float, Boolean, Integer> {
    method FooQuintuple (line 81) | public FooQuintuple(String s, Long l, Float f, Boolean b, Integer i) {
  class FooVariant2 (line 86) | class FooVariant2 extends Variant2<Long, Float> {
    method FooVariant2 (line 87) | private FooVariant2(Token.T0 tok, Long l) { super(tok, l); }
    method FooVariant2 (line 88) | private FooVariant2(Token.T1 tok, Float f) { super(tok, f); }
    method ofLong (line 89) | public static FooVariant2 ofLong(Long l) {
    method ofFloat (line 92) | public static FooVariant2 ofFloat(Float f) {
  class FooVariant3 (line 97) | class FooVariant3 extends Variant3<Long, Float, Boolean> {
    method FooVariant3 (line 98) | private FooVariant3(Token.T0 tok, Long l) { super(tok, l); }
    method FooVariant3 (line 99) | private FooVariant3(Token.T1 tok, Float f) { super(tok, f); }
    method FooVariant3 (line 100) | private FooVariant3(Token.T2 tok, Boolean b) { super(tok, b); }
    method ofLong (line 101) | public static FooVariant3 ofLong(Long l) {
    method ofFloat (line 104) | public static FooVariant3 ofFloat(Float f) {
    method ofBoolean (line 107) | public static FooVariant3 ofBoolean(Boolean b) {
  class FooVariant11 (line 112) | class FooVariant11
    method FooVariant11 (line 115) | private FooVariant11(Token.T0 tok, Long l) { super(tok, l); }
    method FooVariant11 (line 116) | private FooVariant11(Token.T1 tok, Float f) { super(tok, f); }
    method FooVariant11 (line 117) | private FooVariant11(Token.T2 tok, Boolean b) { super(tok, b); }
    method FooVariant11 (line 118) | private FooVariant11(Token.T3 tok, Integer i) { super(tok, i); }
    method FooVariant11 (line 119) | private FooVariant11(Token.T4 tok, String s) { super(tok, s); }
    method FooVariant11 (line 120) | private FooVariant11(Token.T5 tok, Long l) { super(tok, l); }
    method FooVariant11 (line 121) | private FooVariant11(Token.T6 tok, Float f) { super(tok, f); }
    method FooVariant11 (line 122) | private FooVariant11(Token.T7 tok, Boolean b) { super(tok, b); }
    method FooVariant11 (line 123) | private FooVariant11(Token.T8 tok, Integer i) { super(tok, i); }
    method FooVariant11 (line 124) | private FooVariant11(Token.T9 tok, String s) { super(tok, s); }
    method FooVariant11 (line 125) | private FooVariant11(Token.T10 tok, Offset o) { super(tok, o); }
    method ofLong1 (line 126) | public static FooVariant11 ofLong1(Long l) {
    method ofFloat1 (line 129) | public static FooVariant11 ofFloat1(Float f) {
    method ofBoolean1 (line 132) | public static FooVariant11 ofBoolean1(Boolean b) {
    method ofInteger1 (line 135) | public static FooVariant11 ofInteger1(Integer i) {
    method ofString1 (line 138) | public static FooVariant11 ofString1(String s) {
    method ofLong2 (line 141) | public static FooVariant11 ofLong2(Long l) {
    method ofFloat2 (line 144) | public static FooVariant11 ofFloat2(Float f) {
    method ofBoolean2 (line 147) | public static FooVariant11 ofBoolean2(Boolean b) {
    method ofInteger2 (line 150) | public static FooVariant11 ofInteger2(Integer i) {
    method ofString2 (line 153) | public static FooVariant11 ofString2(String s) {
    method ofOffset (line 156) | public static FooVariant11 ofOffset(Offset o) {
  class TestAuxData (line 161) | public class TestAuxData {
    method argProviderForTestCodec (line 163) | private static Stream<Arguments> argProviderForTestCodec() {
    method testCodec (line 290) | @ParameterizedTest(name = "Test codec for protobuf type: {0}")
    method testAuxDataDecodeEncode (line 302) | @Test
    method testRemoveAuxData (line 346) | @Test
    method testClearAuxData (line 372) | @Test
    method testGetAuxDataMap (line 389) | @Test

FILE: java/tests/TestByteIntervals.java
  class TestByteIntervals (line 12) | public class TestByteIntervals {
    method testByteIntervalSaveAndLoad (line 14) | @Test
    method testByteIntervalTruncation (line 65) | @Test
    method testIterators (line 85) | @Test
    method testBlockRetrieval (line 125) | @Test

FILE: java/tests/TestIrSanity.java
  class TestIrSanity (line 15) | public class TestIrSanity {
    method testCreateSaveAndLoad (line 17) | @Test
    method testIrSetAndGet (line 55) | @Test
    method testNonGtirbContents (line 93) | @Test
    method testWrongVersion (line 105) | @Test
    method testCorruptedProtobuf (line 123) | @Test
    method testAddAndRemoveModules (line 142) | @Test
    method testIrFindModules (line 167) | @Test

FILE: java/tests/TestModules.java
  class TestModules (line 15) | public class TestModules {
    method testModuleSaveAndLoad (line 17) | @Test
    method testModuleSetAndGet (line 73) | @Test
    method testAddAndRemoveSections (line 114) | @Test
    method testAddAndRemoveSymbols (line 151) | @Test
    method testAddAndRemoveProxyBlocks (line 182) | @Test
    method testModuleFindSections (line 211) | @Test

FILE: java/tests/TestSections.java
  class TestSections (line 11) | public class TestSections {
    method testSectionSaveAndLoad (line 13) | @Test
    method testSectionSetAndGet (line 68) | @Test
    method testSectionWithIntervalAddresses (line 93) | @Test
    method testSectionNoAddressIntervals (line 134) | @Test
    method testAddAndRemoveFlags (line 158) | @Test
    method testAddAndRemoveByteIntervals (line 180) | @Test

FILE: java/tests/TestSymbolicExpressions.java
  class TestSymbolicExpressions (line 15) | class TestSymbolicExpressions {
    method testUnknownAttributes (line 18) | @Test
    method testSexprSetAndGet (line 59) | @Test

FILE: java/tests/TestSymbols.java
  class TestSymbols (line 11) | public class TestSymbols {
    method testSymbolSaveAndLoad (line 13) | @Test
    method testSymbolSetAndGet (line 81) | @Test

FILE: java/tests/TestTuple.java
  class BarSingle (line 12) | class BarSingle extends Tuple1<String> {
    method BarSingle (line 13) | public BarSingle(String s) { super(s); }
    method getString (line 14) | public String getString() { return this.get0(); }
  class BarPair (line 17) | class BarPair extends Tuple2<String, Long> {
    method BarPair (line 18) | public BarPair(String s, Long l) { super(s, l); }
    method getString (line 19) | public String getString() { return this.get0(); }
    method getLong (line 20) | public Long getLong() { return this.get1(); }
  class BarTriple (line 23) | class BarTriple extends Tuple3<String, Long, Float> {
    method BarTriple (line 24) | public BarTriple(String s, Long l, Float f) { super(s, l, f); }
    method getString (line 25) | public String getString() { return this.get0(); }
    method getLong (line 26) | public Long getLong() { return this.get1(); }
    method getFloat (line 27) | public Float getFloat() { return this.get2(); }
  class BarQuadruple (line 30) | class BarQuadruple extends Tuple4<String, Long, Float, Boolean> {
    method BarQuadruple (line 31) | public BarQuadruple(String s, Long l, Float f, Boolean b) {
    method getString (line 34) | public String getString() { return this.get0(); }
    method getLong (line 35) | public Long getLong() { return this.get1(); }
    method getFloat (line 36) | public Float getFloat() { return this.get2(); }
    method getBoolean (line 37) | public Boolean getBoolean() { return this.get3(); }
  class BarQuintuple (line 40) | class BarQuintuple extends Tuple5<String, Long, Float, Boolean, Integer> {
    method BarQuintuple (line 41) | public BarQuintuple(String s, Long l, Float f, Boolean b, Integer i) {
    method getString (line 44) | public String getString() { return this.get0(); }
    method getLong (line 45) | public Long getLong() { return this.get1(); }
    method getFloat (line 46) | public Float getFloat() { return this.get2(); }
    method getBoolean (line 47) | public Boolean getBoolean() { return this.get3(); }
    method getInteger (line 48) | public Integer getInteger() { return this.get4(); }
  class TestTuple (line 51) | public class TestTuple {
    method testTuple1 (line 52) | @Test
    method testTuple2 (line 62) | @Test
    method testTuple3 (line 75) | @Test
    method testTuple4 (line 91) | @Test
    method testTuple5 (line 110) | @Test

FILE: java/tests/TestVariant.java
  class BarVariant2 (line 14) | class BarVariant2 extends Variant2<Long, Float> {
    method BarVariant2 (line 15) | private BarVariant2(Token.T0 tok, Long l) { super(tok, l); }
    method BarVariant2 (line 16) | private BarVariant2(Token.T1 tok, Float f) { super(tok, f); }
    method getLong (line 17) | public Optional<Long> getLong() { return this.get0(); }
    method getFloat (line 18) | public Optional<Float> getFloat() { return this.get1(); }
    method setLong (line 19) | public void setLong(Long l) { this.set0(l); }
    method setFloat (line 20) | public void setFloat(Float f) { this.set1(f); }
    method ofLong (line 21) | public static BarVariant2 ofLong(Long l) {
    method ofFloat (line 24) | public static BarVariant2 ofFloat(Float f) {
  class BarVariant3 (line 29) | class BarVariant3 extends Variant3<Long, Float, Boolean> {
    method BarVariant3 (line 30) | private BarVariant3(Token.T0 tok, Long l) { super(tok, l); }
    method BarVariant3 (line 31) | private BarVariant3(Token.T1 tok, Float f) { super(tok, f); }
    method BarVariant3 (line 32) | private BarVariant3(Token.T2 tok, Boolean b) { super(tok, b); }
    method getLong (line 33) | public Optional<Long> getLong() { return this.get0(); }
    method getFloat (line 34) | public Optional<Float> getFloat() { return this.get1(); }
    method getBoolean (line 35) | public Optional<Boolean> getBoolean() { return this.get2(); }
    method setLong (line 36) | public void setLong(Long l) { this.set0(l); }
    method setFloat (line 37) | public void setFloat(Float f) { this.set1(f); }
    method setBoolean (line 38) | public void setBoolean(Boolean b) { this.set2(b); }
    method ofLong (line 39) | public static BarVariant3 ofLong(Long l) {
    method ofFloat (line 42) | public static BarVariant3 ofFloat(Float f) {
    method ofBoolean (line 45) | public static BarVariant3 ofBoolean(Boolean b) {
  class BarVariant11 (line 50) | class BarVariant11
    method BarVariant11 (line 53) | private BarVariant11(Token.T0 tok, Long l) { super(tok, l); }
    method BarVariant11 (line 54) | private BarVariant11(Token.T1 tok, Float f) { super(tok, f); }
    method BarVariant11 (line 55) | private BarVariant11(Token.T2 tok, Boolean b) { super(tok, b); }
    method BarVariant11 (line 56) | private BarVariant11(Token.T3 tok, Integer i) { super(tok, i); }
    method BarVariant11 (line 57) | private BarVariant11(Token.T4 tok, String s) { super(tok, s); }
    method BarVariant11 (line 58) | private BarVariant11(Token.T5 tok, Long l) { super(tok, l); }
    method BarVariant11 (line 59) | private BarVariant11(Token.T6 tok, Float f) { super(tok, f); }
    method BarVariant11 (line 60) | private BarVariant11(Token.T7 tok, Boolean b) { super(tok, b); }
    method BarVariant11 (line 61) | private BarVariant11(Token.T8 tok, Integer i) { super(tok, i); }
    method BarVariant11 (line 62) | private BarVariant11(Token.T9 tok, String s) { super(tok, s); }
    method BarVariant11 (line 63) | private BarVariant11(Token.T10 tok, Offset o) { super(tok, o); }
    method getLong1 (line 64) | public Optional<Long> getLong1() { return this.get0(); }
    method getFloat1 (line 65) | public Optional<Float> getFloat1() { return this.get1(); }
    method getBoolean1 (line 66) | public Optional<Boolean> getBoolean1() { return this.get2(); }
    method getInteger1 (line 67) | public Optional<Integer> getInteger1() { return this.get3(); }
    method getString1 (line 68) | public Optional<String> getString1() { return this.get4(); }
    method getLong2 (line 69) | public Optional<Long> getLong2() { return this.get5(); }
    method getFloat2 (line 70) | public Optional<Float> getFloat2() { return this.get6(); }
    method getBoolean2 (line 71) | public Optional<Boolean> getBoolean2() { return this.get7(); }
    method getInteger2 (line 72) | public Optional<Integer> getInteger2() { return this.get8(); }
    method getString2 (line 73) | public Optional<String> getString2() { return this.get9(); }
    method getOffset (line 74) | public Optional<Offset> getOffset() { return this.get10(); }
    method setLong1 (line 75) | public void setLong1(Long l) { this.set0(l); }
    method setFloat1 (line 76) | public void setFloat1(Float f) { this.set1(f); }
    method setBoolean1 (line 77) | public void setBoolean1(Boolean b) { this.set2(b); }
    method setInteger1 (line 78) | public void setInteger1(Integer i) { this.set3(i); }
    method setString1 (line 79) | public void setString1(String s) { this.set4(s); }
    method setLong2 (line 80) | public void setLong2(Long l) { this.set5(l); }
    method setFloat2 (line 81) | public void setFloat2(Float f) { this.set6(f); }
    method setBoolean2 (line 82) | public void setBoolean2(Boolean b) { this.set7(b); }
    method setInteger2 (line 83) | public void setInteger2(Integer i) { this.set8(i); }
    method setString2 (line 84) | public void setString2(String s) { this.set9(s); }
    method setOffset (line 85) | public void setOffset(Offset o) { this.set10(o); }
    method ofLong1 (line 86) | public static BarVariant11 ofLong1(Long l) {
    method ofFloat1 (line 89) | public static BarVariant11 ofFloat1(Float f) {
    method ofBoolean1 (line 92) | public static BarVariant11 ofBoolean1(Boolean b) {
    method ofInteger1 (line 95) | public static BarVariant11 ofInteger1(Integer i) {
    method ofString1 (line 98) | public static BarVariant11 ofString1(String s) {
    method ofLong2 (line 101) | public static BarVariant11 ofLong2(Long l) {
    method ofFloat2 (line 104) | public static BarVariant11 ofFloat2(Float f) {
    method ofBoolean2 (line 107) | public static BarVariant11 ofBoolean2(Boolean b) {
    method ofInteger2 (line 110) | public static BarVariant11 ofInteger2(Integer i) {
    method ofString2 (line 113) | public static BarVariant11 ofString2(String s) {
    method ofOffset (line 116) | public static BarVariant11 ofOffset(Offset o) {
  class TestVariant (line 121) | public class TestVariant {
    method testVariant2 (line 122) | @Test
    method testVariant3 (line 140) | @Test
    method testVariant11 (line 171) | @Test

FILE: python/gtirb/auxdata.py
  class _LazyDataContainer (line 17) | class _LazyDataContainer:
    method __init__ (line 24) | def __init__(
    method get_data (line 34) | def get_data(self) -> object:
    method get_raw_data (line 46) | def get_raw_data(self) -> bytes:
  class AuxData (line 52) | class AuxData:
    method __init__ (line 76) | def __init__(
    method data (line 98) | def data(self) -> Any:  # type: ignore[misc]
    method data (line 105) | def data(self, value: object) -> None:
    method _from_protobuf (line 110) | def _from_protobuf(
    method _to_protobuf (line 132) | def _to_protobuf(self) -> AuxData_pb2.AuxData:
    method __repr__ (line 149) | def __repr__(self) -> str:
  class AuxDataContainer (line 158) | class AuxDataContainer(Node):
    method __init__ (line 167) | def __init__(
    method _read_protobuf_aux_data (line 184) | def _read_protobuf_aux_data(
    method _write_protobuf_aux_data (line 202) | def _write_protobuf_aux_data(
    method deep_eq (line 216) | def deep_eq(self, other: object) -> bool:

FILE: python/gtirb/block.py
  class Block (line 19) | class Block(Node):
    method module (line 25) | def module(self) -> typing.Optional["Module"]:
    method references (line 31) | def references(self) -> typing.Iterator["Symbol"]:
    method _add_to_uuid_cache (line 41) | def _add_to_uuid_cache(self, cache: typing.Dict[UUID, Node]) -> None:
    method _remove_from_uuid_cache (line 46) | def _remove_from_uuid_cache(self, cache: typing.Dict[UUID, Node]) -> N...
  class ByteBlock (line 52) | class ByteBlock(Block):
    method __init__ (line 65) | def __init__(
    method byte_interval (line 91) | def byte_interval(self) -> typing.Optional["ByteInterval"]:
    method byte_interval (line 97) | def byte_interval(self, value: typing.Optional["ByteInterval"]) -> None:
    method deep_eq (line 103) | def deep_eq(self, other: object) -> bool:
    method contents (line 114) | def contents(self) -> bytes:
    method address (line 124) | def address(self) -> typing.Optional[int]:
    method section (line 132) | def section(self) -> typing.Optional["Section"]:
    method module (line 140) | def module(self) -> typing.Optional["Module"]:
    method ir (line 148) | def ir(self) -> typing.Optional["IR"]:
    method contains_offset (line 155) | def contains_offset(self, offset: int) -> bool:
    method contains_address (line 159) | def contains_address(self, address: int) -> bool:
  class CfgNode (line 171) | class CfgNode(Block):
    method incoming_edges (line 175) | def incoming_edges(self) -> typing.Iterable["Edge"]:
    method outgoing_edges (line 181) | def outgoing_edges(self) -> typing.Iterable["Edge"]:
  class DataBlock (line 187) | class DataBlock(ByteBlock):
    method __init__ (line 190) | def __init__(
    method _decode_protobuf (line 213) | def _decode_protobuf(
    method _to_protobuf (line 225) | def _to_protobuf(self) -> DataBlock_pb2.DataBlock:
    method __repr__ (line 231) | def __repr__(self) -> str:
  class CodeBlock (line 241) | class CodeBlock(ByteBlock, CfgNode):
    class DecodeMode (line 252) | class DecodeMode(Enum):
    method __init__ (line 261) | def __init__(
    method _decode_protobuf (line 290) | def _decode_protobuf(
    method _to_protobuf (line 306) | def _to_protobuf(self) -> CodeBlock_pb2.CodeBlock:
    method deep_eq (line 313) | def deep_eq(self, other: object) -> bool:
    method __repr__ (line 319) | def __repr__(self) -> str:
    method incoming_edges (line 335) | def incoming_edges(self) -> typing.Iterator["Edge"]:
    method outgoing_edges (line 342) | def outgoing_edges(self) -> typing.Iterator["Edge"]:
  class ProxyBlock (line 349) | class ProxyBlock(CfgNode):
    method __init__ (line 364) | def __init__(
    method _decode_protobuf (line 376) | def _decode_protobuf(
    method _to_protobuf (line 388) | def _to_protobuf(self) -> ProxyBlock_pb2.ProxyBlock:
    method deep_eq (line 393) | def deep_eq(self, other: object) -> bool:
    method __repr__ (line 399) | def __repr__(self) -> str:
    method module (line 403) | def module(self) -> typing.Optional["Module"]:
    method module (line 407) | def module(self, value: typing.Optional["Module"]) -> None:
    method incoming_edges (line 414) | def incoming_edges(self) -> typing.Iterator["Edge"]:
    method outgoing_edges (line 421) | def outgoing_edges(self) -> typing.Iterator["Edge"]:
    method ir (line 428) | def ir(self) -> typing.Optional["IR"]:

FILE: python/gtirb/byteinterval.py
  class ByteInterval (line 36) | class ByteInterval(Node):
    class _BlockSet (line 66) | class _BlockSet(SetWrapper[ByteBlock]):
      method __init__ (line 67) | def __init__(
      method add (line 74) | def add(self, v: ByteBlock) -> None:
      method update (line 79) | def update(self, *iterables: typing.Iterable[ByteBlock]) -> None:
      method discard (line 92) | def discard(self, v: ByteBlock) -> None:
    class _SymbolicExprDict (line 101) | class _SymbolicExprDict(DictWrapper[int, SymbolicExpression]):
      method __init__ (line 102) | def __init__(
      method __repr__ (line 115) | def __repr__(self) -> str:
    method __init__ (line 129) | def __init__(
    method _index_add_multiple (line 187) | def _index_add_multiple(
    method _index_add (line 195) | def _index_add(self, block: ByteBlock) -> None:
    method _index_discard (line 198) | def _index_discard(self, block: ByteBlock) -> None:
    method initialized_size (line 202) | def initialized_size(self) -> int:
    method initialized_size (line 218) | def initialized_size(self, value: int) -> None:
    method _decode_protobuf (line 225) | def _decode_protobuf(
    method _decode_symbolic_expressions (line 267) | def _decode_symbolic_expressions(self, ir: "IR") -> None:
    method _to_protobuf (line 302) | def _to_protobuf(self) -> ByteInterval_pb2.ByteInterval:
    method section (line 353) | def section(self) -> typing.Optional["Section"]:
    method section (line 359) | def section(self, value: typing.Optional["Section"]) -> None:
    method symbolic_expressions (line 366) | def symbolic_expressions(
    method symbolic_expressions (line 372) | def symbolic_expressions(
    method deep_eq (line 378) | def deep_eq(self, other: object) -> bool:
    method __repr__ (line 411) | def __repr__(self) -> str:
    method byte_blocks_on (line 431) | def byte_blocks_on(
    method byte_blocks_at (line 447) | def byte_blocks_at(
    method code_blocks_on (line 463) | def code_blocks_on(
    method code_blocks_at (line 476) | def code_blocks_at(
    method data_blocks_on (line 489) | def data_blocks_on(
    method data_blocks_at (line 502) | def data_blocks_at(
    method byte_blocks_on_offset (line 515) | def byte_blocks_on_offset(
    method byte_blocks_at_offset (line 528) | def byte_blocks_at_offset(
    method code_blocks_on_offset (line 541) | def code_blocks_on_offset(
    method code_blocks_at_offset (line 556) | def code_blocks_at_offset(
    method data_blocks_on_offset (line 571) | def data_blocks_on_offset(
    method data_blocks_at_offset (line 586) | def data_blocks_at_offset(
    method symbolic_expressions_at (line 601) | def symbolic_expressions_at(
    method symbolic_expressions_at_offset (line 624) | def symbolic_expressions_at_offset(
    method _add_to_uuid_cache (line 645) | def _add_to_uuid_cache(self, cache: typing.Dict[UUID, Node]) -> None:
    method _remove_from_uuid_cache (line 652) | def _remove_from_uuid_cache(self, cache: typing.Dict[UUID, Node]) -> N...
    method module (line 660) | def module(self) -> typing.Optional["Module"]:
    method ir (line 667) | def ir(self) -> typing.Optional["IR"]:

FILE: python/gtirb/cfg.py
  class EdgeType (line 24) | class EdgeType(Enum):
  class EdgeLabel (line 78) | class EdgeLabel(NamedTuple):
    method __repr__ (line 102) | def __repr__(self) -> str:
  class Edge (line 112) | class Edge(
    method __new__ (line 132) | def __new__(
  class CFG (line 144) | class CFG(MutableSet[Edge]):
    method __init__ (line 162) | def __init__(self, edges: Optional[Iterable[Edge]] = None):
    method _edge_key (line 169) | def _edge_key(self, edge: Edge) -> Optional[Hashable]:
    method __contains__ (line 178) | def __contains__(self, edge: object) -> bool:
    method __iter__ (line 181) | def __iter__(self) -> Iterator[Edge]:
    method __len__ (line 185) | def __len__(self) -> int:
    method update (line 188) | def update(self, edges: Iterable[Edge]) -> None:
    method add (line 192) | def add(self, edge: Edge) -> None:
    method clear (line 196) | def clear(self) -> None:
    method discard (line 199) | def discard(self, edge: Edge) -> None:
    method out_edges (line 204) | def out_edges(self, node: CfgNode) -> Iterator[Edge]:
    method in_edges (line 209) | def in_edges(self, node: CfgNode) -> Iterator[Edge]:
    method _from_protobuf (line 215) | def _from_protobuf(
    method _to_protobuf (line 247) | def _to_protobuf(self) -> Iterable[CFG_pb2.Edge]:
    method nx (line 260) | def nx(self) -> MultiDiGraph:  # type: ignore[type-arg]
    method deep_eq (line 263) | def deep_eq(self, other: "CFG") -> bool:
    method __repr__ (line 302) | def __repr__(self) -> str:

FILE: python/gtirb/ir.py
  class IR (line 38) | class IR(AuxDataContainer):
    class _ModuleList (line 46) | class _ModuleList(ListWrapper[Module]):
      method __init__ (line 47) | def __init__(self, node: "IR", *args: typing.Iterable[Module]):
      method _remove (line 51) | def _remove(self, v: Module) -> None:
      method _add (line 55) | def _add(self, v: Module) -> None:
    method __init__ (line 61) | def __init__(
    method _decode_protobuf (line 93) | def _decode_protobuf(
    method _to_protobuf (line 113) | def _to_protobuf(self) -> IR_pb2.IR:
    method deep_eq (line 125) | def deep_eq(self, other: object) -> bool:
    method load_protobuf_file (line 139) | def load_protobuf_file(protobuf_file: typing.BinaryIO) -> "IR":
    method load_protobuf (line 175) | def load_protobuf(
    method save_protobuf_file (line 186) | def save_protobuf_file(self, protobuf_file: typing.BinaryIO) -> None:
    method save_protobuf (line 199) | def save_protobuf(
    method __repr__ (line 210) | def __repr__(self) -> str:
    method proxy_blocks (line 221) | def proxy_blocks(self) -> typing.Iterator[ProxyBlock]:
    method sections (line 227) | def sections(self) -> typing.Iterator[Section]:
    method symbols (line 233) | def symbols(self) -> typing.Iterator[Symbol]:
    method byte_intervals (line 239) | def byte_intervals(self) -> typing.Iterator[ByteInterval]:
    method byte_blocks (line 247) | def byte_blocks(self) -> typing.Iterator[ByteBlock]:
    method code_blocks (line 255) | def code_blocks(self) -> typing.Iterator[CodeBlock]:
    method data_blocks (line 263) | def data_blocks(self) -> typing.Iterator[DataBlock]:
    method cfg_nodes (line 271) | def cfg_nodes(self) -> typing.Iterator[CfgNode]:
    method modules_named (line 276) | def modules_named(self, name: str) -> typing.Iterator[Module]:
    method sections_on (line 280) | def sections_on(
    method sections_at (line 291) | def sections_at(
    method byte_intervals_on (line 302) | def byte_intervals_on(
    method byte_intervals_at (line 315) | def byte_intervals_at(
    method byte_blocks_on (line 328) | def byte_blocks_on(
    method byte_blocks_at (line 341) | def byte_blocks_at(
    method code_blocks_on (line 354) | def code_blocks_on(
    method code_blocks_at (line 367) | def code_blocks_at(
    method data_blocks_on (line 380) | def data_blocks_on(
    method data_blocks_at (line 393) | def data_blocks_at(
    method symbolic_expressions_at (line 406) | def symbolic_expressions_at(
    method get_by_uuid (line 419) | def get_by_uuid(self, uuid: UUID) -> typing.Optional[Node]:

FILE: python/gtirb/lazyintervaltree.py
  class _EventType (line 33) | class _EventType(enum.Enum):
  class IntervalBuilder (line 40) | class IntervalBuilder(Protocol[_Kco, _V]):
    method __call__ (line 46) | def __call__(self, node: _V) -> Optional["Interval[_Kco, _V]"]:
  class LazyIntervalTree (line 50) | class LazyIntervalTree(Generic[_K, _V]):
    method __init__ (line 66) | def __init__(
    method add (line 81) | def add(self, value: _V) -> None:
    method discard (line 87) | def discard(self, value: _V) -> None:
    method get (line 96) | def get(self) -> "IntervalTree[_K, _V]":

FILE: python/gtirb/module.py
  class Module (line 32) | class Module(AuxDataContainer):
    class FileFormat (line 58) | class FileFormat(Enum):
    class ISA (line 95) | class ISA(Enum):
    class ByteOrder (line 136) | class ByteOrder(Enum):
    class _NodeSet (line 148) | class _NodeSet(SetWrapper[_T]):
      method __init__ (line 149) | def __init__(
      method add (line 156) | def add(self, v: _T) -> None:
      method discard (line 165) | def discard(self, v: _T) -> None:
    method __init__ (line 174) | def __init__(
    method _decode_protobuf (line 243) | def _decode_protobuf(
    method _to_protobuf (line 298) | def _to_protobuf(self) -> Module_pb2.Module:
    method deep_eq (line 316) | def deep_eq(self, other: object) -> bool:
    method __repr__ (line 352) | def __repr__(self) -> str:
    method _index_add (line 370) | def _index_add(
    method _index_discard (line 378) | def _index_discard(
    method symbols_named (line 393) | def symbols_named(self, name: str) -> typing.Iterator[Symbol]:
    method ir (line 400) | def ir(self) -> typing.Optional["IR"]:
    method ir (line 406) | def ir(self, value: typing.Optional["IR"]) -> None:
    method byte_intervals (line 413) | def byte_intervals(self) -> typing.Iterator[ByteInterval]:
    method byte_blocks (line 421) | def byte_blocks(self) -> typing.Iterator[ByteBlock]:
    method code_blocks (line 429) | def code_blocks(self) -> typing.Iterator[CodeBlock]:
    method data_blocks (line 437) | def data_blocks(self) -> typing.Iterator[DataBlock]:
    method cfg_nodes (line 445) | def cfg_nodes(self) -> typing.Iterator[CfgNode]:
    method sections_on (line 450) | def sections_on(
    method sections_at (line 461) | def sections_at(
    method byte_intervals_on (line 472) | def byte_intervals_on(
    method byte_intervals_at (line 485) | def byte_intervals_at(
    method byte_blocks_on (line 498) | def byte_blocks_on(
    method byte_blocks_at (line 511) | def byte_blocks_at(
    method code_blocks_on (line 524) | def code_blocks_on(
    method code_blocks_at (line 537) | def code_blocks_at(
    method data_blocks_on (line 550) | def data_blocks_on(
    method data_blocks_at (line 563) | def data_blocks_at(
    method symbolic_expressions_at (line 576) | def symbolic_expressions_at(
    method _add_to_uuid_cache (line 589) | def _add_to_uuid_cache(self, cache: typing.Dict[UUID, Node]) -> None:
    method _remove_from_uuid_cache (line 600) | def _remove_from_uuid_cache(self, cache: typing.Dict[UUID, Node]) -> N...

FILE: python/gtirb/node.py
  class _NodeMessage (line 17) | class _NodeMessage(typing_extensions.Protocol):
  class Node (line 21) | class Node:
    method __init__ (line 27) | def __init__(self, uuid: typing.Optional[UUID] = None) -> None:
    method _decode_protobuf (line 39) | def _decode_protobuf(
    method _from_protobuf (line 55) | def _from_protobuf(
    method _to_protobuf (line 81) | def _to_protobuf(self) -> Message:
    method deep_eq (line 88) | def deep_eq(self, other: object) -> bool:

FILE: python/gtirb/offset.py
  class Offset (line 13) | class Offset(
    method _from_protobuf (line 29) | def _from_protobuf(
    method _to_protobuf (line 46) | def _to_protobuf(self) -> Offset_pb2.Offset:

FILE: python/gtirb/section.py
  class Section (line 24) | class Section(Node):
    class Flag (line 35) | class Flag(Enum):
    class _ByteIntervalSet (line 59) | class _ByteIntervalSet(SetWrapper[ByteInterval]):
      method __init__ (line 60) | def __init__(
      method add (line 66) | def add(self, v: ByteInterval) -> None:
      method discard (line 75) | def discard(self, v: ByteInterval) -> None:
    method __init__ (line 84) | def __init__(
    method _index_add (line 120) | def _index_add(self, byte_interval: ByteInterval) -> None:
    method _index_discard (line 123) | def _index_discard(self, byte_interval: ByteInterval) -> None:
    method _decode_protobuf (line 127) | def _decode_protobuf(
    method _to_protobuf (line 147) | def _to_protobuf(self) -> Section_pb2.Section:
    method deep_eq (line 159) | def deep_eq(self, other: object) -> bool:
    method __repr__ (line 177) | def __repr__(self) -> str:
    method module (line 193) | def module(self) -> typing.Optional["Module"]:
    method module (line 199) | def module(self, value: typing.Optional["Module"]) -> None:
    method byte_blocks (line 206) | def byte_blocks(self) -> typing.Iterator[ByteBlock]:
    method code_blocks (line 214) | def code_blocks(self) -> typing.Iterator[CodeBlock]:
    method data_blocks (line 220) | def data_blocks(self) -> typing.Iterator[DataBlock]:
    method address (line 226) | def address(self) -> typing.Optional[int]:
    method size (line 245) | def size(self) -> typing.Optional[int]:
    method byte_intervals_on (line 263) | def byte_intervals_on(
    method byte_intervals_at (line 274) | def byte_intervals_at(
    method byte_blocks_on (line 285) | def byte_blocks_on(
    method byte_blocks_at (line 297) | def byte_blocks_at(
    method code_blocks_on (line 309) | def code_blocks_on(
    method code_blocks_at (line 324) | def code_blocks_at(
    method data_blocks_on (line 339) | def data_blocks_on(
    method data_blocks_at (line 354) | def data_blocks_at(
    method symbolic_expressions_at (line 369) | def symbolic_expressions_at(
    method _add_to_uuid_cache (line 383) | def _add_to_uuid_cache(self, cache: typing.Dict[UUID, Node]) -> None:
    method _remove_from_uuid_cache (line 390) | def _remove_from_uuid_cache(self, cache: typing.Dict[UUID, Node]) -> N...
    method ir (line 398) | def ir(self) -> typing.Optional["IR"]:

FILE: python/gtirb/serialization.py
  class CodecError (line 27) | class CodecError(Exception):
  class DecodeError (line 31) | class DecodeError(CodecError):
  class EncodeError (line 35) | class EncodeError(CodecError):
  class TypeNameError (line 39) | class TypeNameError(EncodeError):
    method __init__ (line 42) | def __init__(self, hint: str) -> None:
  class UnknownCodecError (line 46) | class UnknownCodecError(CodecError):
    method __init__ (line 53) | def __init__(self, name: str) -> None:
  class SubtypeTree (line 57) | class SubtypeTree:
    method __init__ (line 74) | def __init__(self, name: str, subtypes: Sequence["SubtypeTree"]) -> None:
    method __eq__ (line 78) | def __eq__(self, other: object) -> bool:
  class Variant (line 86) | class Variant:
    method __init__ (line 90) | def __init__(self, index: int, val: Any):  # type: ignore[misc]
    method __eq__ (line 94) | def __eq__(self, other: object) -> bool:
  class Codec (line 100) | class Codec:
    method decode (line 104) | def decode(
    method encode (line 124) | def encode(
  class MappingCodec (line 143) | class MappingCodec(Codec):
    method decode (line 147) | def decode(
    method encode (line 169) | def encode(
  class OffsetCodec (line 190) | class OffsetCodec(Codec):
    method decode (line 196) | def decode(
    method encode (line 211) | def encode(
  class SequenceCodec (line 226) | class SequenceCodec(Codec):
    method decode (line 230) | def decode(
    method encode (line 250) | def encode(
  class SetCodec (line 268) | class SetCodec(Codec):
    method decode (line 272) | def decode(
    method encode (line 292) | def encode(
  class TupleCodec (line 310) | class TupleCodec(Codec):
    method decode (line 314) | def decode(
    method encode (line 331) | def encode(
  class StringCodec (line 346) | class StringCodec(Codec):
    method decode (line 350) | def decode(
    method encode (line 363) | def encode(
  class BoolCodec (line 378) | class BoolCodec(Codec):
    method decode (line 382) | def decode(
    method encode (line 394) | def encode(
  class IntegerCodec (line 408) | class IntegerCodec(Codec):
    method decode (line 416) | def decode(
    method encode (line 431) | def encode(
  class Uint64Codec (line 448) | class Uint64Codec(IntegerCodec):
  class Uint32Codec (line 456) | class Uint32Codec(IntegerCodec):
  class Uint16Codec (line 464) | class Uint16Codec(IntegerCodec):
  class Uint8Codec (line 472) | class Uint8Codec(IntegerCodec):
  class Int64Codec (line 480) | class Int64Codec(IntegerCodec):
  class Int32Codec (line 488) | class Int32Codec(IntegerCodec):
  class Int16Codec (line 496) | class Int16Codec(IntegerCodec):
  class Int8Codec (line 504) | class Int8Codec(IntegerCodec):
  class FloatCodec (line 512) | class FloatCodec(Codec):
    method decode (line 520) | def decode(
    method encode (line 536) | def encode(
  class Float32Codec (line 552) | class Float32Codec(FloatCodec):
  class Float64Codec (line 558) | class Float64Codec(FloatCodec):
  class UUIDCodec (line 564) | class UUIDCodec(Codec):
    method decode (line 573) | def decode(
    method encode (line 587) | def encode(
  class VariantCodec (line 604) | class VariantCodec(Codec):
    method decode (line 613) | def decode(
    method encode (line 629) | def encode(
  class UnknownData (line 645) | class UnknownData(bytes):
  class Serialization (line 652) | class Serialization:
    method __init__ (line 674) | def __init__(self) -> None:
    method _decode_tree (line 702) | def _decode_tree(
    method _encode_tree (line 725) | def _encode_tree(
    method _parse_type (line 743) | def _parse_type(type_name: str) -> SubtypeTree:
    method decode (line 824) | def decode(
    method encode (line 854) | def encode(self, out: BinaryIO, val: object, type_name: str) -> None:

FILE: python/gtirb/symbol.py
  class Symbol (line 19) | class Symbol(Node):
    method __init__ (line 32) | def __init__(
    method value (line 61) | def value(self) -> typing.Optional[int]:
    method value (line 71) | def value(self, value: typing.Optional[int]) -> None:
    method referent (line 75) | def referent(self) -> typing.Optional[Block]:
    method referent (line 85) | def referent(self, referent: typing.Optional[Block]) -> None:
    method _decode_protobuf (line 89) | def _decode_protobuf(
    method _to_protobuf (line 113) | def _to_protobuf(self) -> Symbol_pb2.Symbol:
    method deep_eq (line 124) | def deep_eq(self, other: object) -> bool:
    method __repr__ (line 142) | def __repr__(self) -> str:
    method module (line 153) | def module(self) -> typing.Optional["Module"]:
    method module (line 157) | def module(self, value: typing.Optional["Module"]) -> None:
    method _add_to_uuid_cache (line 163) | def _add_to_uuid_cache(self, cache: typing.Dict[UUID, Node]) -> None:
    method _remove_from_uuid_cache (line 168) | def _remove_from_uuid_cache(self, cache: typing.Dict[UUID, Node]) -> N...
    method ir (line 174) | def ir(self) -> typing.Optional["IR"]:

FILE: python/gtirb/symbolicexpression.py
  class SymbolicExpression (line 18) | class SymbolicExpression:
    class Attribute (line 21) | class Attribute(Enum):
      method __repr__ (line 92) | def __repr__(self) -> str:
      method __int__ (line 95) | def __int__(self) -> int:
    method __init__ (line 98) | def __init__(
    method symbols (line 105) | def symbols(self) -> typing.Iterable[Symbol]:
    method deep_eq (line 112) | def deep_eq(self, other: object) -> bool:
    method _attributes_repr (line 115) | def _attributes_repr(self) -> str:
  class SymAddrAddr (line 122) | class SymAddrAddr(SymbolicExpression):
    method __init__ (line 132) | def __init__(
    method _from_protobuf (line 155) | def _from_protobuf(
    method _to_protobuf (line 176) | def _to_protobuf(self) -> SymbolicExpression_pb2.SymAddrAddr:
    method __eq__ (line 184) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 195) | def __hash__(self) -> int:
    method __repr__ (line 200) | def __repr__(self) -> str:
    method deep_eq (line 217) | def deep_eq(self, other: object) -> bool:
    method symbols (line 230) | def symbols(self) -> typing.Iterable[Symbol]:
  class SymAddrConst (line 235) | class SymAddrConst(SymbolicExpression):
    method __init__ (line 242) | def __init__(
    method _from_protobuf (line 259) | def _from_protobuf(
    method _to_protobuf (line 272) | def _to_protobuf(self) -> SymbolicExpression_pb2.SymAddrConst:
    method __eq__ (line 279) | def __eq__(self, other: object) -> bool:
    method __hash__ (line 288) | def __hash__(self) -> int:
    method __repr__ (line 291) | def __repr__(self) -> str:
    method deep_eq (line 304) | def deep_eq(self, other: object) -> bool:
    method symbols (line 315) | def symbols(self) -> typing.Iterable[Symbol]:

FILE: python/gtirb/util.py
  class GtirbError (line 26) | class GtirbError(Exception):
  class DeserializationError (line 30) | class DeserializationError(GtirbError):
  class _SymbolicExpressionContainer (line 34) | class _SymbolicExpressionContainer(typing_extensions.Protocol[T_cov]):
    method symbolic_expressions_at (line 37) | def symbolic_expressions_at(
  class ListWrapper (line 43) | class ListWrapper(typing.MutableSequence[T]):
    method __init__ (line 44) | def __init__(self, *args: typing.Iterable[T]):
    method _add (line 50) | def _add(self, value: T) -> None:
    method _remove (line 53) | def _remove(self, value: T) -> None:
    method __getitem__ (line 58) | def __getitem__(self, i: int) -> T:
    method __getitem__ (line 62) | def __getitem__(self, i: slice) -> typing.MutableSequence[T]:
    method __getitem__ (line 65) | def __getitem__(
    method __setitem__ (line 71) | def __setitem__(self, i: typing_extensions.SupportsIndex, v: T) -> None:
    method __setitem__ (line 75) | def __setitem__(self, i: slice, v: typing.Iterable[T]) -> None:
    method __setitem__ (line 78) | def __setitem__(
    method __delitem__ (line 102) | def __delitem__(self, i: int) -> None:
    method __delitem__ (line 106) | def __delitem__(self, i: slice) -> None:
    method __delitem__ (line 109) | def __delitem__(self, i: typing.Union[int, slice]) -> None:
    method __len__ (line 119) | def __len__(self) -> int:
    method insert (line 122) | def insert(self, i: int, v: T) -> None:
    method append (line 129) | def append(self, v: T) -> None:
    method remove (line 132) | def remove(self, v: T) -> None:
    method extend (line 137) | def extend(self, other: typing.Iterable[T]) -> None:
    method __str__ (line 142) | def __str__(self) -> str:
    method __repr__ (line 145) | def __repr__(self) -> str:
  class SetWrapper (line 159) | class SetWrapper(typing.MutableSet[T]):
    method __init__ (line 160) | def __init__(self, *args: typing.Iterable[T]):
    method __contains__ (line 167) | def __contains__(self, v: object) -> bool:
    method __iter__ (line 170) | def __iter__(self) -> typing.Iterator[T]:
    method __len__ (line 173) | def __len__(self) -> int:
    method add (line 176) | def add(self, v: T) -> None:
    method discard (line 179) | def discard(self, v: T) -> None:
    method __or__ (line 187) | def __or__(
    method __ior__ (line 200) | def __ior__(  # type: ignore
    method pop (line 207) | def pop(self) -> T:
    method clear (line 218) | def clear(self) -> None:
    method update (line 223) | def update(self, *others: typing.Iterable[T]) -> None:
    method __str__ (line 228) | def __str__(self) -> str:
    method __repr__ (line 231) | def __repr__(self) -> str:
  class DictWrapper (line 235) | class DictWrapper(typing.MutableMapping[K, V]):
    method __init__ (line 236) | def __init__(self, *args: DictLike[K, V]):
    method __getitem__ (line 245) | def __getitem__(self, i: K) -> V:
    method __setitem__ (line 248) | def __setitem__(self, i: K, v: V) -> None:
    method __delitem__ (line 251) | def __delitem__(self, i: K) -> None:
    method __iter__ (line 254) | def __iter__(self) -> typing.Iterator[K]:
    method __len__ (line 257) | def __len__(self) -> int:
    method __str__ (line 261) | def __str__(self) -> str:
    method __repr__ (line 264) | def __repr__(self) -> str:
  class IndexedContainer (line 272) | class IndexedContainer(typing_extensions.Protocol[T_contra]):
    method _index_discard (line 275) | def _index_discard(self, instance: T_contra) -> None:
    method _index_add (line 278) | def _index_add(self, instance: T_contra) -> None:
  class ParentGetter (line 282) | class ParentGetter(typing_extensions.Protocol[T_contra]):
    method __call__ (line 285) | def __call__(
  class _IndexedAttribute (line 291) | class _IndexedAttribute(typing.Generic[AttributeT]):
    class Descriptor (line 304) | class Descriptor(typing.Generic[InstanceT]):
      method __init__ (line 310) | def __init__(self, parent_getter: ParentGetter[InstanceT]):
      method __get__ (line 313) | def __get__(
      method __set__ (line 320) | def __set__(self, instance: InstanceT, value: AttributeT) -> None:
      method __delete__ (line 329) | def __delete__(self, instance: InstanceT) -> None:
      method __set_name__ (line 332) | def __set_name__(self, owner: InstanceT, name: str) -> None:
    method __call__ (line 336) | def __call__(self, parent_getter: ParentGetter[InstanceT]) -> AttributeT:
  function get_desired_range (line 351) | def get_desired_range(addrs: typing.Union[int, range]) -> range:
  class AddrRange (line 358) | class AddrRange(typing_extensions.Protocol):
    method address (line 366) | def address(self) -> typing.Optional[int]:
    method size (line 370) | def size(self) -> typing.Optional[int]:
  function nodes_on (line 379) | def nodes_on(
  function nodes_at (line 397) | def nodes_at(
  function _address_interval (line 408) | def _address_interval(
  class OffsetRange (line 426) | class OffsetRange(typing_extensions.Protocol):
    method offset (line 430) | def offset(self) -> int:
    method size (line 434) | def size(self) -> int:
  function _offset_interval (line 441) | def _offset_interval(
  function _nodes_on_interval_tree_impl (line 452) | def _nodes_on_interval_tree_impl(
  function _nodes_on_interval_tree (line 493) | def _nodes_on_interval_tree(
  function _nodes_on_interval_tree_offset (line 511) | def _nodes_on_interval_tree_offset(
  function _nodes_at_interval_tree_impl (line 526) | def _nodes_at_interval_tree_impl(
  function _nodes_at_interval_tree (line 557) | def _nodes_at_interval_tree(
  function _nodes_at_interval_tree_offset (line 575) | def _nodes_at_interval_tree_offset(
  function symbolic_expressions_at (line 590) | def symbolic_expressions_at(

FILE: python/stubs/intervaltree/interval.pyi
  class Interval (line 6) | class Interval(Generic[PointT, DataT]):
    method __init__ (line 10) | def __init__(self, begin: PointT, end: PointT, data: DataT): ...
    method length (line 11) | def length(self) -> PointT: ...

FILE: python/stubs/intervaltree/intervaltree.pyi
  class IntervalTree (line 8) | class IntervalTree(MutableSet[Interval[PointT, DataT]]):
    method __init__ (line 9) | def __init__(
    method __contains__ (line 12) | def __contains__(self, item: object) -> bool: ...
    method __iter__ (line 13) | def __iter__(self) -> Iterator[Interval[PointT, DataT]]: ...
    method __len__ (line 14) | def __len__(self) -> int: ...
    method add (line 15) | def add(self, interval: Interval[PointT, DataT]) -> None: ...
    method discard (line 16) | def discard(self, interval: Interval[PointT, DataT]) -> None: ...
    method begin (line 17) | def begin(self) -> PointT: ...
    method span (line 18) | def span(self) -> PointT: ...
    method overlap (line 20) | def overlap(
    method overlap (line 24) | def overlap(

FILE: python/stubs/networkx/classes/multidigraph.pyi
  class MultiDiGraph (line 16) | class MultiDiGraph(Generic[NodeT, KeyT, DataT]):
    method __contains__ (line 17) | def __contains__(self, n: object) -> bool: ...
    method __getitem__ (line 18) | def __getitem__(
    method add_edge (line 21) | def add_edge(
    method remove_edge (line 24) | def remove_edge(
    method number_of_edges (line 27) | def number_of_edges(
    method clear (line 30) | def clear(self) -> None: ...
    method edges (line 37) | def edges(
    method edges (line 43) | def edges(
    method out_edges (line 50) | def out_edges(
    method in_edges (line 57) | def in_edges(

FILE: python/stubs/sortedcontainers/sorteddict.pyi
  class SortedDict (line 6) | class SortedDict(MutableMapping[K, V]):
    method __delitem__ (line 7) | def __delitem__(self, key: K) -> None: ...
    method __getitem__ (line 8) | def __getitem__(self, key: K) -> V: ...
    method __iter__ (line 9) | def __iter__(self) -> Iterator[K]: ...
    method __len__ (line 10) | def __len__(self) -> int: ...
    method __setitem__ (line 11) | def __setitem__(self, key: K, value: V) -> None: ...
    method irange (line 12) | def irange(

FILE: python/tests/helpers.py
  class SearchScope (line 7) | class SearchScope(enum.Enum):
    method select (line 13) | def select(self, ir, m, s, bi):
  function parameterize_one (line 29) | def parameterize_one(name, values):
  function create_interval_etc (line 49) | def create_interval_etc(address, size):

FILE: python/tests/test_auxdata.py
  class AuxDataTest (line 7) | class AuxDataTest(unittest.TestCase):
    method setUp (line 8) | def setUp(self):
    method test_lazy (line 12) | def test_lazy(self):
    method test_lazy_never_deserialized (line 30) | def test_lazy_never_deserialized(self):

FILE: python/tests/test_block.py
  class BlockTest (line 8) | class BlockTest(unittest.TestCase):
    method test_contains_offset (line 9) | def test_contains_offset(self):
    method test_contains_address (line 14) | def test_contains_address(self):
    method test_block_references (line 22) | def test_block_references(self):

FILE: python/tests/test_blocks_at.py
  class BlocksAtTests (line 10) | class BlocksAtTests(unittest.TestCase):
    method test_blocks_at_simple (line 12) | def test_blocks_at_simple(self, scope):
    method test_blocks_at_zero (line 41) | def test_blocks_at_zero(self, scope):
    method test_blocks_at_overlapping (line 51) | def test_blocks_at_overlapping(self, scope):
    method test_blocks_at_zero_sized (line 64) | def test_blocks_at_zero_sized(self, scope):
    method test_blocks_at_range (line 78) | def test_blocks_at_range(self, scope):
    method test_blocks_at_no_address (line 99) | def test_blocks_at_no_address(self, scope):
    method test_code_blocks_at (line 111) | def test_code_blocks_at(self, scope):
    method test_data_blocks_at (line 123) | def test_data_blocks_at(self, scope):
  class SectionBlocksAtTests (line 135) | class SectionBlocksAtTests(unittest.TestCase):
    method test_blocks_at_simple (line 136) | def test_blocks_at_simple(self):
    method test_blocks_at_overlapping (line 150) | def test_blocks_at_overlapping(self):
    method test_blocks_on_with_blocks_outside_bi (line 165) | def test_blocks_on_with_blocks_outside_bi(self):

FILE: python/tests/test_blocks_at_offset.py
  class BlocksAtOffsetTests (line 10) | class BlocksAtOffsetTests(unittest.TestCase):
    method test_blocks_at_offset_simple (line 11) | def test_blocks_at_offset_simple(self):
    method test_blocks_at_offset_overlapping (line 42) | def test_blocks_at_offset_overlapping(self):
    method test_blocks_at_offset_zero_sized (line 53) | def test_blocks_at_offset_zero_sized(self):
    method test_blocks_at_offset_range (line 64) | def test_blocks_at_offset_range(self):
    method test_code_blocks_at_offset (line 83) | def test_code_blocks_at_offset(self):
    method test_data_blocks_at_offset (line 93) | def test_data_blocks_at_offset(self):

FILE: python/tests/test_blocks_on.py
  class BlocksOnTests (line 8) | class BlocksOnTests(unittest.TestCase):
    method test_blocks_on_simple (line 10) | def test_blocks_on_simple(self, scope):
    method test_blocks_on_zero (line 42) | def test_blocks_on_zero(self, scope):
    method test_blocks_on_with_overlapping_blocks (line 52) | def test_blocks_on_with_overlapping_blocks(self, scope):
    method test_blocks_on_with_zero_sized_blocks (line 65) | def test_blocks_on_with_zero_sized_blocks(self, scope):
    method test_blocks_on_with_range (line 81) | def test_blocks_on_with_range(self, scope):
    method test_blocks_on_with_no_address (line 102) | def test_blocks_on_with_no_address(self, scope):
    method test_code_blocks_on (line 115) | def test_code_blocks_on(self, scope):
    method test_data_blocks_on (line 127) | def test_data_blocks_on(self, scope):
  class SectionBlocksOnTests (line 139) | class SectionBlocksOnTests(unittest.TestCase):
    method test_blocks_on_simple (line 140) | def test_blocks_on_simple(self):
    method test_blocks_on_overlapping (line 154) | def test_blocks_on_overlapping(self):
    method test_blocks_on_with_blocks_outside_bi (line 169) | def test_blocks_on_with_blocks_outside_bi(self):

FILE: python/tests/test_blocks_on_offset.py
  class BlocksOnOffsetTests (line 8) | class BlocksOnOffsetTests(unittest.TestCase):
    method test_blocks_on_offset_simple (line 9) | def test_blocks_on_offset_simple(self):
    method test_blocks_on_offset_zero (line 39) | def test_blocks_on_offset_zero(self):
    method test_blocks_on_offset_with_overlapping_blocks (line 47) | def test_blocks_on_offset_with_overlapping_blocks(self):
    method test_blocks_on_offset_with_zero_sized_blocks (line 61) | def test_blocks_on_offset_with_zero_sized_blocks(self):
    method test_blocks_on_offset_with_range (line 75) | def test_blocks_on_offset_with_range(self):
    method test_code_blocks_on_offset (line 94) | def test_code_blocks_on_offset(self):
    method test_data_blocks_on_offset (line 104) | def test_data_blocks_on_offset(self):

FILE: python/tests/test_byte_intervals_at.py
  class ByteIntervalsAtTests (line 8) | class ByteIntervalsAtTests(unittest.TestCase):
    method test_byte_intervals_at (line 12) | def test_byte_intervals_at(self, scope):

FILE: python/tests/test_byte_intervals_on.py
  class ByteIntervalsOnTests (line 8) | class ByteIntervalsOnTests(unittest.TestCase):
    method test_byte_intervals_on (line 12) | def test_byte_intervals_on(self, scope):
    method test_byte_intervals_overlapping (line 56) | def test_byte_intervals_overlapping(self, scope):

FILE: python/tests/test_cfg.py
  class CFGTest (line 6) | class CFGTest(unittest.TestCase):
    method test_contains (line 7) | def test_contains(self):
    method test_add (line 23) | def test_add(self):
    method test_clear (line 35) | def test_clear(self):
    method test_discard (line 50) | def test_discard(self):
    method test_out_edges (line 70) | def test_out_edges(self):
    method test_in_edges (line 87) | def test_in_edges(self):
    method test_nx (line 104) | def test_nx(self):

FILE: python/tests/test_deep_eq.py
  class DeepEqTest (line 7) | class DeepEqTest(unittest.TestCase):
    method test_code_block (line 8) | def test_code_block(self):
    method test_data_block (line 28) | def test_data_block(self):
    method test_proxy_blocks (line 45) | def test_proxy_blocks(self):
    method test_symbol (line 56) | def test_symbol(self):
    method test_sym_exprs (line 104) | def test_sym_exprs(self):
    method test_byte_intervals (line 236) | def test_byte_intervals(self):
    method test_sections (line 456) | def test_sections(self):
    method test_cfg (line 549) | def test_cfg(self):
    method test_module (line 672) | def test_module(self):
    method test_ir (line 1048) | def test_ir(self):

FILE: python/tests/test_ir.py
  class IRTest (line 14) | class IRTest(unittest.TestCase):
    method __init__ (line 15) | def __init__(self, *args, **kwargs):
    method setUp (line 69) | def setUp(self):
    method tearDown (line 72) | def tearDown(self):
    method test_ir_protobuf_load (line 75) | def test_ir_protobuf_load(self):
    method test_load_pathlib (line 83) | def test_load_pathlib(self):
  class NotGTIRBTest (line 97) | class NotGTIRBTest(unittest.TestCase):
    method test (line 98) | def test(self):
  class BadVersionTest (line 109) | class BadVersionTest(unittest.TestCase):
    method test (line 110) | def test(self):
  class BadProtobufTest (line 120) | class BadProtobufTest(unittest.TestCase):
    method test (line 121) | def test(self):
  class IRMethodTests (line 130) | class IRMethodTests(unittest.TestCase):
    method test_modules_named (line 131) | def test_modules_named(self):

FILE: python/tests/test_module.py
  class ModuleTests (line 6) | class ModuleTests(unittest.TestCase):
    method test_symbols_named (line 7) | def test_symbols_named(self):

FILE: python/tests/test_node_from_uuid.py
  class NodeFromUUIDTest (line 7) | class NodeFromUUIDTest(unittest.TestCase):
    method test_get_by_uuid_failed (line 8) | def test_get_by_uuid_failed(self):
    method test_get_by_uuid (line 13) | def test_get_by_uuid(self):
    method test_remove_from_cache (line 88) | def test_remove_from_cache(self):

FILE: python/tests/test_properties.py
  class TestProperties (line 6) | class TestProperties(unittest.TestCase):
    method test_data_blocks (line 7) | def test_data_blocks(self):
    method test_code_blocks (line 36) | def test_code_blocks(self):
    method test_proxy_blocks (line 92) | def test_proxy_blocks(self):
    method test_sections (line 129) | def test_sections(self):
    method test_modules (line 165) | def test_modules(self):
    method test_byte_intervals (line 212) | def test_byte_intervals(self):
    method test_sym_exprs (line 242) | def test_sym_exprs(self):

FILE: python/tests/test_repr.py
  class ReprTest (line 12) | class ReprTest(unittest.TestCase):
    method test_auxdata (line 13) | def test_auxdata(self):
    method test_block (line 28) | def test_block(self):
    method test_proxy_block (line 36) | def test_proxy_block(self):
    method test_data_object (line 42) | def test_data_object(self):
    method test_ir (line 48) | def test_ir(self):
    method test_cfg (line 55) | def test_cfg(self):
    method test_module (line 83) | def test_module(self):
    method test_offset (line 90) | def test_offset(self):
    method test_section (line 97) | def test_section(self):
    method test_symbol (line 106) | def test_symbol(self):
    method test_sym_expr (line 122) | def test_sym_expr(self):
    method test_byte_interval (line 146) | def test_byte_interval(self):

FILE: python/tests/test_section.py
  class SectionTests (line 6) | class SectionTests(unittest.TestCase):
    method test_byte_blocks (line 7) | def test_byte_blocks(self):

FILE: python/tests/test_serialization.py
  class TestSerialization (line 8) | class TestSerialization(unittest.TestCase):
    method test_parse_type (line 9) | def test_parse_type(self):
    method test_unknown_codec (line 60) | def test_unknown_codec(self):
    method test_nested_unknown_codec (line 69) | def test_nested_unknown_codec(self):
    method test_uuid_codec (line 91) | def test_uuid_codec(self):
    method test_variant_codec (line 159) | def test_variant_codec(self):
    method _check_val (line 214) | def _check_val(self, typename, val):
    method test_int_serializers (line 220) | def test_int_serializers(self):
    method test_float_serializers (line 236) | def test_float_serializers(self):

FILE: python/tests/test_symbolic_expression.py
  class SymbolicExpressionAttributes (line 9) | class SymbolicExpressionAttributes(unittest.TestCase):
    method test_unknown_attributes (line 10) | def test_unknown_attributes(self):

FILE: python/tests/test_symbolic_expressions_at.py
  class SymbolicExpressionsAtTests (line 8) | class SymbolicExpressionsAtTests(unittest.TestCase):
    method test_symbolic_expressions_at (line 10) | def test_symbolic_expressions_at(self, scope):

FILE: python/tests/test_wrapper.py
  class RecordingList (line 6) | class RecordingList(gtirb.util.ListWrapper):
    method __init__ (line 7) | def __init__(self, *args):
    method _add (line 11) | def _add(self, value):
    method _remove (line 14) | def _remove(self, value):
  class ListWrapperTests (line 18) | class ListWrapperTests(unittest.TestCase):
    method test_empty_init (line 19) | def test_empty_init(self):
    method test_values_init (line 23) | def test_values_init(self):
    method test_getitem_int (line 29) | def test_getitem_int(self):
    method test_getitem_slice (line 35) | def test_getitem_slice(self):
    method test_setitem_int (line 41) | def test_setitem_int(self):
    method test_setitem_slice (line 56) | def test_setitem_slice(self):
    method test_delitem_int (line 72) | def test_delitem_int(self):
    method test_delitem_slice (line 80) | def test_delitem_slice(self):
    method test_len (line 95) | def test_len(self):
    method test_insert (line 99) | def test_insert(self):
    method test_append (line 107) | def test_append(self):
    method test_remove (line 115) | def test_remove(self):
    method test_extend (line 123) | def test_extend(self):
    method test_str (line 129) | def test_str(self):

FILE: src/AuxData.cpp
  type gtirb (line 18) | namespace gtirb {

FILE: src/AuxDataContainer.cpp
  type gtirb (line 24) | namespace gtirb {
    type AuxDataTypeMap (line 26) | struct AuxDataTypeMap {

FILE: src/ByteInterval.cpp
  class ByteInterval::CodeBlockObserverImpl (line 29) | class ByteInterval::CodeBlockObserverImpl : public CodeBlockObserver {
    method CodeBlockObserverImpl (line 31) | CodeBlockObserverImpl(ByteInterval* BI_) : BI(BI_) {}
  class ByteInterval::DataBlockObserverImpl (line 43) | class ByteInterval::DataBlockObserverImpl : public DataBlockObserver {
    method DataBlockObserverImpl (line 45) | DataBlockObserverImpl(ByteInterval* BI_) : BI(BI_) {}
  function ByteInterval (line 187) | ByteInterval* ByteInterval::load(Context& C, std::istream& In) {
  function ChangeStatus (line 235) | static inline ChangeStatus removeBlocks(ByteIntervalObserver* Observer,
  function ChangeStatus (line 241) | static inline ChangeStatus removeBlocks(ByteIntervalObserver* Observer,
  function ChangeStatus (line 248) | ChangeStatus ByteInterval::removeBlock(BlockType* B) {
  function ChangeStatus (line 275) | ChangeStatus ByteInterval::removeBlock(CodeBlock* B) {
  function ChangeStatus (line 279) | ChangeStatus ByteInterval::removeBlock(DataBlock* B) {
  function CodeBlockObserver (line 283) | static inline CodeBlockObserver* getObserver(CodeBlock*, CodeBlockObserv...
  function DataBlockObserver (line 288) | static inline DataBlockObserver* getObserver(DataBlock*, CodeBlockObserv...
  function ChangeStatus (line 293) | static inline ChangeStatus addBlocks(ByteIntervalObserver* Observer,
  function ChangeStatus (line 299) | static inline ChangeStatus addBlocks(ByteIntervalObserver* Observer,
  function ChangeStatus (line 305) | static inline ChangeStatus moveBlocks(ByteIntervalObserver* Observer,
  function ChangeStatus (line 311) | static inline ChangeStatus moveBlocks(ByteIntervalObserver* Observer,
  function ChangeStatus (line 318) | ChangeStatus ByteInterval::addBlock(uint64_t Off, BlockType* B) {
  function ChangeStatus (line 388) | ChangeStatus ByteInterval::addBlock(uint64_t Off, CodeBlock* B) {
  function ChangeStatus (line 392) | ChangeStatus ByteInterval::addBlock(uint64_t Off, DataBlock* B) {
  function ChangeStatus (line 396) | ChangeStatus ByteInterval::CodeBlockObserverImpl::sizeChange(CodeBlock* B,
  function ChangeStatus (line 402) | ChangeStatus ByteInterval::CodeBlockObserverImpl::decodeModeChange(
  function ChangeStatus (line 407) | ChangeStatus ByteInterval::DataBlockObserverImpl::sizeChange(DataBlock* B,
  function ChangeStatus (line 437) | ChangeStatus ByteInterval::sizeChange(Node* N, uint64_t OldSize,
  function ChangeStatus (line 444) | ChangeStatus ByteInterval::decodeModeChange(CodeBlock* B, DecodeMode,

FILE: src/CFG.cpp
  type gtirb (line 22) | namespace gtirb {
    function GTIRB_EXPORT_API (line 23) | GTIRB_EXPORT_API std::ostream& operator<<(std::ostream& OS,
    function GTIRB_EXPORT_API (line 36) | GTIRB_EXPORT_API std::ostream& operator<<(std::ostream& OS,
    function GTIRB_EXPORT_API (line 61) | GTIRB_EXPORT_API std::ostream& operator<<(std::ostream& OS,
    function GTIRB_EXPORT_API (line 74) | GTIRB_EXPORT_API std::ostream& operator<<(std::ostream& OS,
    function addVertex (line 87) | std::pair<CFG::vertex_descriptor, bool> addVertex(CfgNode* B, CFG& Cfg) {
    function removeVertex (line 99) | bool removeVertex(CfgNode* N, CFG& Cfg) {
    function getVertex (line 110) | std::optional<CFG::vertex_descriptor> getVertex(const CfgNode* N,
    function addEdge (line 119) | std::optional<CFG::edge_descriptor> addEdge(const CfgNode* From,
    function removeEdge (line 132) | bool removeEdge(const CfgNode* From, const CfgNode* To, CFG& Cfg) {
    function removeEdge (line 145) | bool removeEdge(const CfgNode* From, const CfgNode* To, const EdgeLabe...
    function nodes (line 172) | boost::iterator_range<const_cfg_iterator> nodes(const CFG& Cfg) {
    function nodes (line 179) | boost::iterator_range<cfg_iterator> nodes(CFG& Cfg) {
    function blocks (line 186) | boost::iterator_range<const_block_iterator> blocks(const CFG& Cfg) {
    function blocks (line 193) | boost::iterator_range<block_iterator> blocks(CFG& Cfg) {
    function toProtobuf (line 199) | proto::CFG toProtobuf(const CFG& Cfg) {
    function fromProtobuf (line 223) | bool fromProtobuf(Context& C, CFG& Result, const proto::CFG& Message) {

FILE: src/CFGSerialization.hpp
  type gtirb (line 21) | namespace gtirb {
    class Context (line 22) | class Context
    type proto (line 23) | namespace proto {
      class CFG (line 24) | class CFG

FILE: src/CodeBlock.cpp
  function CodeBlock (line 66) | CodeBlock* CodeBlock::load(Context& C, std::istream& In) {

FILE: src/Context.cpp
  function Node (line 48) | const Node* Context::findNode(const UUID& ID) const {
  function Node (line 53) | Node* Context::findNode(const UUID& ID) {

FILE: src/DataBlock.cpp
  function DataBlock (line 63) | DataBlock* DataBlock::load(Context& C, std::istream& In) {

FILE: src/ErrorOr.cpp
  type gtirb (line 4) | namespace gtirb {

FILE: src/IR.cpp
  class IR::ModuleObserverImpl (line 34) | class IR::ModuleObserverImpl : public ModuleObserver {
    method ModuleObserverImpl (line 36) | explicit ModuleObserverImpl(IR* I_) : I(I_) {}
    method ChangeStatus (line 38) | ChangeStatus nameChange(Module* M, const std::string& /*OldName*/,
    method ChangeStatus (line 50) | ChangeStatus addProxyBlocks(Module* /*M*/,
    method ChangeStatus (line 64) | ChangeStatus removeProxyBlocks(Module* /*M*/,
    method ChangeStatus (line 78) | ChangeStatus addCodeBlocks(Module* /*M*/,
    method ChangeStatus (line 92) | ChangeStatus removeCodeBlocks(Module* /*M*/,
  class IRLoadErrorCategory (line 118) | class IRLoadErrorCategory : public std::error_category {
    method message (line 123) | [[nodiscard]] std::string message(int Condition) const override {

FILE: src/Module.cpp
  class Module::SectionObserverImpl (line 26) | class Module::SectionObserverImpl : public SectionObserver {
    method SectionObserverImpl (line 28) | SectionObserverImpl(Module* M_) : M(M_) {}
  class Module::SymbolObserverImpl (line 58) | class Module::SymbolObserverImpl : public SymbolObserver {
    method SymbolObserverImpl (line 60) | explicit SymbolObserverImpl(Module* M_) : M(M_) {}
  function nodeMapFromProtobuf (line 105) | static void nodeMapFromProtobuf(Context& C, std::map<T, U*>& Values,
  function ChangeStatus (line 195) | ChangeStatus Module::removeProxyBlock(ProxyBlock* B) {
  function ChangeStatus (line 215) | ChangeStatus Module::addProxyBlock(ProxyBlock* B) {
  function Module (line 246) | Module* Module::load(Context& C, std::istream& In) {
  function ChangeStatus (line 256) | ChangeStatus Module::removeSection(Section* S) {
  function ChangeStatus (line 280) | ChangeStatus Module::addSection(Section* S) {
  function ChangeStatus (line 325) | ChangeStatus
  function ChangeStatus (line 339) | ChangeStatus
  function ChangeStatus (line 362) | ChangeStatus
  function ChangeStatus (line 388) | ChangeStatus Module::SectionObserverImpl::removeCodeBlocks(
  function ChangeStatus (line 410) | ChangeStatus
  function ChangeStatus (line 416) | ChangeStatus
  function ChangeStatus (line 442) | ChangeStatus Module::SectionObserverImpl::removeDataBlocks(
  function ChangeStatus (line 447) | ChangeStatus Module::SectionObserverImpl::changeExtent(
  function ChangeStatus (line 458) | ChangeStatus Module::SymbolObserverImpl::nameChange(Symbol* S,
  function ChangeStatus (line 471) | ChangeStatus Module::SymbolObserverImpl::referentChange(

FILE: src/ProxyBlock.cpp
  function ProxyBlock (line 43) | ProxyBlock* ProxyBlock::load(Context& C, std::istream& In) {

FILE: src/Section.cpp
  class Section::ByteIntervalObserverImpl (line 21) | class Section::ByteIntervalObserverImpl : public ByteIntervalObserver {
    method ByteIntervalObserverImpl (line 23) | ByteIntervalObserverImpl(Section* S_) : S(S_) {}
  function Section (line 112) | Section* Section::load(Context& C, std::istream& In) {
  function ChangeStatus (line 121) | ChangeStatus Section::removeByteInterval(ByteInterval* BI) {
  function ChangeStatus (line 148) | ChangeStatus Section::addByteInterval(ByteInterval* BI) {
  function ChangeStatus (line 195) | ChangeStatus Section::updateExtent() {
  function ChangeStatus (line 228) | ChangeStatus Section::ByteIntervalObserverImpl::addCodeBlocks(
  function ChangeStatus (line 244) | ChangeStatus Section::ByteIntervalObserverImpl::moveCodeBlocks(
  function ChangeStatus (line 260) | ChangeStatus Section::ByteIntervalObserverImpl::removeCodeBlocks(
  function ChangeStatus (line 276) | ChangeStatus Section::ByteIntervalObserverImpl::addDataBlocks(
  function ChangeStatus (line 292) | ChangeStatus Section::ByteIntervalObserverImpl::moveDataBlocks(
  function ChangeStatus (line 308) | ChangeStatus Section::ByteIntervalObserverImpl::removeDataBlocks(
  function ChangeStatus (line 324) | ChangeStatus Section::ByteIntervalObserverImpl::changeExtent(

FILE: src/Serialization.cpp
  type gtirb (line 18) | namespace gtirb {
    function uuidFromBytes (line 19) | bool uuidFromBytes(const std::string& Bytes, UUID& Uuid) {
    function uuidToBytes (line 27) | void uuidToBytes(UUID Uuid, std::string& Bytes) {
    function nodeUUIDToBytes (line 33) | void nodeUUIDToBytes(const Node* Node, std::string& Bytes) {
    function toProtobuf (line 37) | uint64_t toProtobuf(const Addr Val) { return static_cast<uint64_t>(Val...
    function toProtobuf (line 39) | std::string toProtobuf(const std::string& Val) { return Val; }
    function toProtobuf (line 41) | int64_t toProtobuf(const int64_t& Val) { return Val; }
    function toProtobuf (line 43) | uint64_t toProtobuf(const uint64_t& Val) { return Val; }
    function toProtobuf (line 45) | std::string toProtobuf(const UUID& Val) {
    function fromProtobuf (line 51) | bool fromProtobuf(Context&, Addr& Result, const uint64_t& Message) {
    function fromProtobuf (line 56) | bool fromProtobuf(Context&, UUID& Result, const std::string& Message) {

FILE: src/Serialization.hpp
  type gtirb (line 27) | namespace gtirb {
    function toProtobuf (line 53) | typename T::MessageType toProtobuf(const T& Val) {
    function T (line 68) | T& deref_if_ptr(T& V) { return V; }
    function T (line 69) | const T& deref_if_ptr(const T& V) { return V; }
    function T (line 70) | T& deref_if_ptr(T* V) { return *V; }
    function T (line 71) | const T& deref_if_ptr(const T* V) { return *V; }
    function T (line 72) | const T& deref_if_ptr(const std::unique_ptr<T>& V) {
    function toProtobuf (line 77) | auto toProtobuf(const std::pair<T, U>& Val) -> google::protobuf::MapPair<
    function initContainer (line 86) | void initContainer(google::protobuf::RepeatedField<T>* Container, size...
    function initContainer (line 91) | void initContainer(google::protobuf::RepeatedPtrField<T>* Container,
    function initContainer (line 97) | void initContainer(std::vector<T>& Container, size_t Size) {
    function initContainer (line 101) | void initContainer(T* Container, size_t) {
    function initContainer (line 104) | void initContainer(T& Container, size_t) {
    function addElement (line 110) | void addElement(google::protobuf::RepeatedField<T>* Container, T&& Ele...
    function addElement (line 114) | void addElement(google::protobuf::RepeatedPtrField<T>* Container, T&& ...
    function addElement (line 118) | void addElement(google::protobuf::Map<T, U>* Container,
    function addElement (line 122) | void addElement(std::vector<T>& Container, T&& Element) {
    function addElement (line 126) | void addElement(std::map<T, U>* Container,
    function addElement (line 131) | std::enable_if_t<std::is_destructible_v<
    function containerToProtobuf (line 139) | void containerToProtobuf(const ContainerT& Values, MessageT* Message) {
    function sequenceToProtobuf (line 147) | void sequenceToProtobuf(IterT First, IterT Last, MessageT* Message) {
    function T (line 154) | T* fromProtobuf(Context& C, const U& Message) {
    function fromProtobuf (line 159) | bool fromProtobuf(Context&, T& Result, const T& Message) {
    function fromProtobuf (line 164) | inline bool fromProtobuf(Context& C, Offset& Result,
    type details (line 170) | namespace details {
      type remove_pointer_ref_quals (line 171) | struct remove_pointer_ref_quals {
    function fromProtobuf (line 182) | bool fromProtobuf(Context& C, std::pair<T, U>& Val,
    function containerFromProtobuf (line 194) | bool containerFromProtobuf(
    function containerFromProtobuf (line 213) | bool containerFromProtobuf(
    function containerFromProtobuf (line 233) | bool containerFromProtobuf(Context& C, std::map<KeyType, ValueType>& V...

FILE: src/Symbol.cpp
  class StorePayload (line 25) | class StorePayload {
    method StorePayload (line 27) | StorePayload(proto::Symbol* Message) : M(Message) {}
  function Symbol (line 118) | Symbol* Symbol::load(Context& C, std::istream& In) {

FILE: src/SymbolicExpression.cpp
  type gtirb (line 22) | namespace gtirb {
    function symAttributeSetToProtobuf (line 24) | static void symAttributeSetToProtobuf(const SymAttributeSet& SASet,
    function SymAttributeSet (line 31) | static SymAttributeSet
    class SymbolicVisitor (line 40) | class SymbolicVisitor {
      method SymbolicVisitor (line 44) | SymbolicVisitor(proto::SymbolicExpression* M) : Message(M) {}
    function toProtobuf (line 69) | proto::SymbolicExpression toProtobuf(const SymbolicExpression& Value) {
    function Symbol (line 76) | Symbol* symbolFromProto(Context& C, const std::string& Bytes) {
    function fromProtobuf (line 83) | bool fromProtobuf(Context& C, SymbolicExpression& Result,

FILE: src/SymbolicExpressionSerialization.hpp
  type gtirb (line 21) | namespace gtirb {
    type proto (line 22) | namespace proto {
      class SymbolicExpression (line 23) | class SymbolicExpression
    class Context (line 25) | class Context

FILE: src/Utility.cpp
  function codeBlockSecondaryKey (line 9) | static inline auto codeBlockSecondaryKey(const CodeBlock* B) {
  function dataBlockSecondaryKey (line 14) | static inline auto dataBlockSecondaryKey(const DataBlock* B) {
  function blockSecondaryKey (line 21) | inline auto blockSecondaryKey(const Node* N) {
  function codeBlockAddressKey (line 30) | static inline auto codeBlockAddressKey(const CodeBlock* B) {
  function dataBlockAddressKey (line 34) | static inline auto dataBlockAddressKey(const DataBlock* B) {
  function blockAddressKey (line 38) | static inline auto blockAddressKey(const Node* N) {

FILE: src/test/Addr.test.cpp
  function TEST (line 27) | TEST(Unit_Addr, ctor_0) { EXPECT_EQ(Addr(), Addr()); }
  function TEST (line 29) | TEST(Unit_Addr, ctor_1) {
  function TEST (line 34) | TEST(Unit_Addr, fromIntegers) {
  function TEST (line 44) | TEST(Unit_Addr, toIntegers) {
  function TEST (line 50) | TEST(Unit_Addr, comparison) {
  function TEST (line 78) | TEST(Unit_Addr, arithmetic) {
  function TEST (line 98) | TEST(Unit_Addr, ostream) {
  function TEST (line 110) | TEST(Unit_Addr, Constexpr) {
  function TEST (line 183) | TEST(Unit_Addr, addressLimit) {
  function TEST (line 200) | TEST(Unit_Addr, hash) {

FILE: src/test/Allocator.test.cpp
  class AllocTest (line 20) | class AllocTest {
    method AllocTest (line 25) | AllocTest() { CtorCount++; }
  function TEST (line 39) | TEST(Unit_Allocator, allocate) {
  function TEST (line 48) | TEST(Unit_Allocator, deallocate) {

FILE: src/test/AuxData.test.cpp
  type MoveTest (line 23) | struct MoveTest
    method MoveTest (line 827) | MoveTest() = default;
    method MoveTest (line 828) | MoveTest(int X) : Val(X) {}
    method MoveTest (line 829) | MoveTest(const MoveTest& other) : Val(other.Val) { CopyCount++; }
    method MoveTest (line 830) | MoveTest(MoveTest&& other) : Val(std::move(other.Val)) { MoveCount++; }
  type gtirb (line 25) | namespace gtirb {
    type schema (line 26) | namespace schema {
      type MapAddrToString (line 28) | struct MapAddrToString {
      type MapInt64ToString (line 33) | struct MapInt64ToString {
      type MapStringToString (line 38) | struct MapStringToString {
      type MapUUIDToString (line 43) | struct MapUUIDToString {
      type VectorMapStringToInt (line 48) | struct VectorMapStringToInt {
      type VectorAddr (line 53) | struct VectorAddr {
      type VectorInt64 (line 58) | struct VectorInt64 {
      type VectorString (line 63) | struct VectorString {
      type VectorUUID (line 68) | struct VectorUUID {
      type SetUUID (line 73) | struct SetUUID {
      type AString (line 78) | struct AString {
      type AnAddr (line 83) | struct AnAddr {
      type MapCharToInt64 (line 88) | struct MapCharToInt64 {
      type SetOfInt (line 93) | struct SetOfInt {
      type TupleOfCharAndInt64 (line 98) | struct TupleOfCharAndInt64 {
      type TupleOfCharOrAddr (line 103) | struct TupleOfCharOrAddr {
      type PairOfCharAndInt64 (line 109) | struct PairOfCharAndInt64 {
      type AnInt64 (line 114) | struct AnInt64 {
      type AnInt32 (line 119) | struct AnInt32 {
      type AnDouble (line 124) | struct AnDouble {
      type AnFloat (line 129) | struct AnFloat {
      type ListInt64 (line 134) | struct ListInt64 {
      type AUUID (line 139) | struct AUUID {
      type AChar (line 144) | struct AChar {
      type AUint64 (line 149) | struct AUint64 {
      type AUint8 (line 154) | struct AUint8 {
      type AnInt (line 159) | struct AnInt {
      type AnUnsigned (line 164) | struct AnUnsigned {
      type ABool (line 169) | struct ABool {
      type AByte (line 174) | struct AByte {
      type AnOffset (line 179) | struct AnOffset {
      type VectorOfMapOfTuple (line 184) | struct VectorOfMapOfTuple {
      type MapOfVector (line 189) | struct MapOfVector {
      type TupleOfVector (line 194) | struct TupleOfVector {
      type AMoveTest (line 199) | struct AMoveTest {
      type SimpleVariant (line 204) | struct SimpleVariant {
      type OtherSimpleVariant (line 210) | struct OtherSimpleVariant {
      type ComplexVariant (line 215) | struct ComplexVariant {
      type DuplicateVariant (line 222) | struct DuplicateVariant {
      type MapCharToVariant (line 228) | struct MapCharToVariant {
      type VecOfVariants (line 233) | struct VecOfVariants {
  function TEST (line 246) | TEST(Unit_AuxData, eaMapProtobufRoundTrip) {
  function TEST (line 267) | TEST(Unit_AuxData, intMapProtobufRoundTrip) {
  function TEST (line 282) | TEST(Unit_AuxData, stringMapProtobufRoundTrip) {
  function TEST (line 297) | TEST(Unit_AuxData, uuidMapProtobufRoundTrip) {
  function TEST (line 314) | TEST(Unit_AuxData, mapVectorProtobufRoundTrip) {
  function TEST (line 328) | TEST(Unit_AuxData, eaVectorProtobufRoundTrip) {
  function TEST (line 340) | TEST(Unit_AuxData, intVectorProtobufRoundTrip) {
  function TEST (line 351) | TEST(Unit_AuxData, stringVectorProtobufRoundTrip) {
  function TEST (line 363) | TEST(Unit_AuxData, uuidVectorProtobufRoundTrip) {
  function TEST (line 376) | TEST(Unit_AuxData, uuidSetProtobufRoundTrip) {
  function TEST (line 390) | TEST(Unit_AuxData, simpleVariantProtobufFirst) {
  function TEST (line 408) | TEST(Unit_AuxData, simpleVariantProtobufSecond) {
  function TEST (line 426) | TEST(Unit_AuxData, simpleVariantProtobufThird) {
  function TEST (line 444) | TEST(Unit_AuxData, complexVariantProtobufThird) {
  function TEST (line 464) | TEST(Unit_AuxData, duplicateVariantProtobufFirst) {
  function TEST (line 480) | TEST(Unit_AuxData, TupleofVariants) {
  function TEST (line 493) | TEST(Unit_AuxData, VecOfVariants2) {
  function TEST (line 506) | TEST(Unit_AuxData, VecOfVariants) {
  function TEST (line 521) | TEST(Unit_AuxData, MapCharToVariant) {
  function TEST (line 540) | TEST(Unit_AuxData, auxdata_traits_type_name) {
  function TEST (line 567) | TEST(Unit_AuxData, getPrimitiveTypes) {
  function TEST (line 599) | TEST(Unit_AuxData, getVector) {
  function TEST (line 608) | TEST(Unit_AuxData, getString) {
  function TEST (line 615) | TEST(Unit_AuxData, getAddr) {
  function TEST (line 622) | TEST(Unit_AuxData, getMap) {
  function TEST (line 631) | TEST(Unit_AuxData, getSet) {
  function TEST (line 640) | TEST(Unit_AuxData, getTuple) {
  function TEST (line 649) | TEST(Unit_AuxData, protobufRoundTrip) {
  function TEST (line 662) | TEST(Unit_AuxData, vectorProtobufRoundTrip) {
  function TEST (line 675) | TEST(Unit_AuxData, listProtobufRoundTrip) {
  function TEST (line 688) | TEST(Unit_AuxData, stringProtobufRoundTrip) {
  function TEST (line 701) | TEST(Unit_AuxData, addrProtobufRoundTrip) {
  function TEST (line 714) | TEST(Unit_AuxData, mapProtobufRoundTrip) {
  function TEST (line 727) | TEST(Unit_AuxData, tupleProtobufRoundTrip) {
  function TEST (line 740) | TEST(Unit_AuxData, pairProtobufRoundTrip) {
  function TEST (line 753) | TEST(Unit_AuxData, uuidProtobufRoundTrip) {
  function TEST (line 766) | TEST(Unit_AuxData, OffsetProtobufRoundTrip) {
  function TEST (line 781) | TEST(Unit_AuxData, nestedProtobufRoundTrip) {
  function TEST (line 817) | TEST(Unit_AuxData, wrongTypeAfterProtobufRoundTrip) {
  type MoveTest (line 826) | struct MoveTest {
    method MoveTest (line 827) | MoveTest() = default;
    method MoveTest (line 828) | MoveTest(int X) : Val(X) {}
    method MoveTest (line 829) | MoveTest(const MoveTest& other) : Val(other.Val) { CopyCount++; }
    method MoveTest (line 830) | MoveTest(MoveTest&& other) : Val(std::move(other.Val)) { MoveCount++; }
  type gtirb::auxdata_traits<MoveTest> (line 839) | struct gtirb::auxdata_traits<MoveTest> : default_serialization<MoveTest> {
    method type_name (line 840) | static std::string type_name() { return "MoveTest"; }
  function TEST (line 843) | TEST(Unit_AuxData, movesAndCopies) {

FILE: src/test/AuxDataContainer.test.cpp
  function registerAuxDataContainerTestAuxDataTypes (line 38) | void registerAuxDataContainerTestAuxDataTypes() {
  function TEST (line 44) | TEST(Unit_AuxDataContainerDeathTest, registerSchemaTooLate) {
  function TEST (line 57) | TEST(Unit_AuxDataContainer, addAuxDataRegistered) {
  function TEST (line 93) | TEST(Unit_AuxDataContainerDeathTest, addAuxDataUnregistered) {
  function TEST (line 108) | TEST(Unit_AuxDataContainerDeathTest, addAuxDataDuplicateName) {
  function TEST (line 121) | TEST(Unit_AuxDataContainer, addAuxDataBadUnserialize) {
  function TEST (line 150) | TEST(Unit_AuxDataContainer, getAuxDataNotPresent) {
  function TEST (line 157) | TEST(Unit_AuxDataContainerDeathTest, getAuxDataIncompatibleSchema) {
  function TEST (line 170) | TEST(Unit_AuxDataContainerDeathTest, getAuxDataUnregisteredType) {
  function TEST (line 182) | TEST(Unit_AuxDataContainer, removeAuxDataBySchema) {
  function TEST (line 194) | TEST(Unit_AuxDataContainer, removeAuxDataByName) {
  function TEST (line 207) | TEST(Unit_AuxDataContainerDeathTest, removeAuxDataUnregistered) {
  function TEST (line 218) | TEST(Unit_AuxDataContainer, iteration) {

FILE: src/test/AuxDataContainerSchema.hpp
  type gtirb (line 9) | namespace gtirb {
    type schema (line 10) | namespace schema {
      type RegisteredType (line 12) | struct RegisteredType {
      type UnRegisteredType (line 17) | struct UnRegisteredType {
      type DuplicateNameType (line 22) | struct DuplicateNameType {
      type BadDeSerializationType (line 27) | struct BadDeSerializationType {
    type auxdata_traits<schema::BadDeSerializationType::Type> (line 50) | struct auxdata_traits<schema::BadDeSerializationType::Type> {
      method toBytes (line 52) | static void toBytes(const T& Object, ToByteRange& TBR) {
      method fromBytes (line 61) | static bool fromBytes(T& Object [[maybe_unused]],
      method type_name (line 67) | static std::string type_name() { return "badbadbad"; }

FILE: src/test/AuxDataSchemaRegistration.test.cpp
  function TEST (line 20) | TEST(Unit_AuxDataContainerDeathTest, SchemaRegistration) {

FILE: src/test/ByteInterval.test.cpp
  function TEST (line 29) | TEST(Unit_ByteInterval, compilationIteratorTypes) {
  function TEST (line 60) | TEST(Unit_ByteInterval, noCopyMoveConstructors) {
  function TEST (line 67) | TEST(Unit_ByteInterval, ctor) {
  function TEST (line 71) | TEST(Unit_ByteInterval, gettersSetters) {
  function TEST (line 109) | TEST(Unit_ByteInterval, protobufRoundTrip) {
  function TEST (line 413) | TEST(Unit_ByteInterval, byteVector) {
  function T (line 463) | static T str2(const char* S) {
  function TEST (line 468) | TEST(Unit_ByteInterval, byteVectorInts) {
  function TEST (line 538) | TEST(Unit_ByteInterval, byteVectorEndian) {
  function TEST (line 589) | TEST(Unit_ByteInterval, byteVectorInsert) {
  function TEST (line 640) | TEST(Unit_ByteInterval, byteVectorErase) {
  function TEST (line 691) | TEST(Unit_ByteInterval, removeBlock) {
  function TEST (line 752) | TEST(Unit_ByteInterval, addSymbolicExpression) {
  function TEST (line 796) | TEST(Unit_ByteInterval, updateSymbolicExpression) {
  function TEST (line 806) | TEST(Unit_ByteInterval, findSymbolicExpressionsAtOffset) {
  function TEST (line 836) | TEST(Unit_ByteInterval, removeSymbolicExpression) {
  function TEST (line 848) | TEST(Unit_ByteInterval, findBlocksOn) {
  function TEST (line 935) | TEST(Unit_ByteInterval, findCodeBlocksOn) {
  function TEST (line 1022) | TEST(Unit_ByteInterval, findDataBlocksOn) {
  function TEST (line 1109) | TEST(Unit_ByteInterval, findBlocksAt) {
  function TEST (line 1191) | TEST(Unit_ByteInterval, findCodeBlocksAt) {
  function TEST (line 1273) | TEST(Unit_ByteInterval, findDataBlocksAt) {
  function TEST (line 1355) | TEST(Unit_ByteInterval, moveBlock) {
  function TEST (line 1381) | TEST(Unit_ByteInterval, moveBlockIndices) {
  function TEST (line 1410) | TEST(Unit_ByteInterval, iterationOrder) {
  function TEST (line 1429) | TEST(Unit_ByteInterval, iterationOrderMoveBlock) {
  function TEST (line 1445) | TEST(Unit_ByteInterval, iterationOrderSetSize) {
  function TEST (line 1461) | TEST(Unit_ByteInterval, iterationOrderSetDecodeMode) {

FILE: src/test/CFG.test.cpp
  function TEST (line 27) | TEST(Unit_CFG, compilationIteratorTypes) {
  function TEST (line 80) | TEST(Unit_CFG, addVertex) {
  function TEST (line 106) | TEST(Unit_CFG, getVertex) {
  function TEST (line 116) | TEST(Unit_CFG, removeVertex) {
  function TEST (line 159) | TEST(Unit_CFG, cfgIterator) {
  function TEST (line 200) | TEST(Unit_CFG, blockIterator) {
  function NodeEdgeMMap (line 237) | NodeEdgeMMap toMultiMap(const ContainerT& C) {
  function TEST (line 249) | TEST(Unit_CFG, edges) {
  function TEST (line 345) | TEST(Unit_CFG, edgeLabelPrinting) {
  function TEST (line 358) | TEST(Unit_CFG, edgeLabels) {
  function TEST (line 483) | TEST(Unit_CFG, protobufRoundTrip) {

FILE: src/test/CodeBlock.test.cpp
  function TEST (line 26) | TEST(Unit_CodeBlock, noCopyMoveConstructors) {
  function TEST (line 33) | TEST(Unit_CodeBlock, ctor) { EXPECT_NE(CodeBlock::Create(Ctx, 0), nullpt...
  function TEST (line 35) | TEST(Unit_CodeBlock, getters) {
  function TEST (line 45) | TEST(Unit_CodeBlock, getAddress) {
  function TEST (line 61) | TEST(Unit_CodeBlock, byteVector) {
  function TEST (line 81) | TEST(Unit_CodeBlock, protobufRoundTrip) {

FILE: src/test/DataBlock.test.cpp
  function TEST (line 27) | TEST(Unit_DataBlock, noCopyMoveConstructors) {
  function TEST (line 34) | TEST(Unit_DataBlock, getters) {
  function TEST (line 43) | TEST(Unit_DataBlock, getAddress) {
  function TEST (line 59) | TEST(Unit_DataBlock, protobufRoundTrip) {
  function TEST (line 73) | TEST(Unit_DataBlock, byteVector) {

FILE: src/test/IR.test.cpp
  type gtirb (line 28) | namespace gtirb {
    type schema (line 29) | namespace schema {
      type TestVectorInt64 (line 31) | struct TestVectorInt64 {
      type FooVectorInt64 (line 36) | struct FooVectorInt64 {
      type AnAuxDataMap (line 41) | struct AnAuxDataMap {
      type BarVectorChar (line 46) | struct BarVectorChar {
      type TestInt32 (line 51) | struct TestInt32 {
  function registerIrTestAuxDataTypes (line 62) | void registerIrTestAuxDataTypes() {
  function hasPreferredAddr (line 70) | static bool hasPreferredAddr(const Module& M, Addr X) {
  function TEST (line 74) | TEST(Unit_IR, compilationIteratorTypes) {
  function TEST (line 86) | TEST(Unit_IR, noCopyMoveConstructors) {
  function TEST (line 94) | TEST(Unit_IR, ctor_0) { EXPECT_NE(IR::Create(Ctx), nullptr); }
  function TEST (line 96) | TEST(Unit_IR, addRemoveXferModules) {
  function TEST (line 133) | TEST(Unit_IR, moduleIterationOrder) {
  function TEST (line 154) | TEST(Unit_IR, findModules) {
  function TEST (line 177) | TEST(Unit_IR, getModulesWithPreferredAddr) {
  function TEST (line 205) | TEST(Unit_IR, addAuxData) {
  function TEST (line 215) | TEST(Unit_IR, getAuxData) {
  function TEST (line 234) | TEST(Unit_IR, auxDataRange) {
  function TEST (line 246) | TEST(Unit_IR, missingAuxData) {
  function TEST (line 251) | TEST(Unit_IR, protobufRoundTrip) {
  function TEST (line 273) | TEST(Unit_IR, jsonRoundTrip) {
  function TEST (line 299) | TEST(Unit_IR, loadNotGTIRB) {
  function TEST (line 311) | TEST(Unit_IR, loadWrongVersion) {
  function TEST (line 323) | TEST(Unit_IR, loadCorruptFile) {
  function TEST (line 337) | TEST(Unit_IR, setModuleName) {
  function TEST (line 351) | TEST(Unit_IR, CFG) {

FILE: src/test/Main.test.cpp
  function loadTestIr (line 22) | static void loadTestIr(std::string Filename) {
  function main (line 35) | int main(int argc, char** argv) {

FILE: src/test/Main.test.hpp
  type gtirb (line 4) | namespace gtirb {
    class IR (line 5) | class IR

FILE: src/test/MergeSortedIterator.test.cpp
  function TEST (line 22) | TEST(Unit_MergeSortedIterator, testCtor0) {
  function TEST (line 26) | TEST(Unit_MergeSortedIterator, testCtor1) {
  function TEST (line 50) | TEST(Unit_MergeSortedIterator, testCtor2) {
  type CustomCompare (line 74) | struct CustomCompare {
  function TEST (line 78) | TEST(Unit_MergeSortedIterator, testCustomCompare) {
  function TEST (line 102) | TEST(Unit_MergeSortedIterator, testEmptyRanges) {

FILE: src/test/Module.test.cpp
  type gtirb (line 33) | namespace gtirb {
    type schema (line 34) | namespace schema {
      type Foo (line 36) | struct Foo {
      type Bar (line 41) | struct Bar {
      type AnTest (line 46) | struct AnTest {
  function registerModuleTestAuxDataTypes (line 57) | void registerModuleTestAuxDataTypes() {
  function TEST (line 63) | TEST(Unit_Module, compilationIteratorTypes) {
  function TEST (line 112) | TEST(Unit_Module, noCopyMoveConstructors) {
  function TEST (line 121) | TEST(Unit_Module, ctor_0) { EXPECT_NE(Module::Create(Ctx, "M"), nullptr); }
  function TEST (line 123) | TEST(Unit_Module, setBinaryPath) {
  function TEST (line 133) | TEST(Unit_Module, getFileFormatDefault) {
  function TEST (line 138) | TEST(Unit_Module, auxDataRanges) {
  function TEST (line 150) | TEST(Unit_Module, setFileFormat) {
  function TEST (line 163) | TEST(Unit_Module, getRebaseDeltaDefault) {
  function TEST (line 168) | TEST(Unit_Module, setRebaseDelta) {
  function TEST (line 194) | TEST(Unit_Module, getPreferredAddrDefault) {
  function TEST (line 199) | TEST(Unit_Module, getISA) {
  function TEST (line 208) | TEST(Unit_Module, getByteOrder) {
  function TEST (line 217) | TEST(Unit_Module, setPreferredAddr) {
  function TEST (line 227) | TEST(Unit_Module, getSymbolSet) {
  function TEST (line 232) | TEST(Unit_Module, getName) {
  function TEST (line 237) | TEST(Unit_Module, setName) {
  function TEST (line 245) | TEST(Unit_Module, sections) {
  function TEST (line 254) | TEST(Unit_Module, byteIntervals) {
  function TEST (line 369) | TEST(Unit_Module, findByteIntervalsOn) {
  function TEST (line 462) | TEST(Unit_Module, findSections) {
  function TEST (line 545) | TEST(Unit_Module, sectionNameOrder) {
  function TEST (line 565) | TEST(Unit_Module, blocks) {
  function TEST (line 580) | TEST(Unit_Module, cfgNodes) {
  function TEST (line 598) | TEST(Unit_Module, findBlock) {
  function TEST (line 636) | TEST(Unit_Module, findBlocksOn) {
  function TEST (line 716) | TEST(Unit_Module, findCodeBlocksOn) {
  function TEST (line 796) | TEST(Unit_Module, findDataBlocksOn) {
  function TEST (line 876) | TEST(Unit_Module, findBlocksAt) {
  function TEST (line 956) | TEST(Unit_Module, findCodeBlocksAt) {
  function TEST (line 1036) | TEST(Unit_Module, findDataBlocksAt) {
  function TEST (line 1116) | TEST(Unit_Module, dataObjects) {
  function TEST (line 1125) | TEST(Unit_Module, findData) {
  function TEST (line 1164) | TEST(Unit_Module, symbolIterationOrder) {
  function TEST (line 1181) | TEST(Unit_Module, findSymbols) {
  function TEST (line 1259) | TEST(Unit_Module, symbolWithoutAddr) {
  function TEST (line 1265) | TEST(Unit_Module, renameSymbol) {
  function TEST (line 1301) | TEST(Unit_Module, setReferent) {
  function TEST (line 1354) | TEST(Unit_Module, setSymbolAddress) {
  function TEST (line 1389) | TEST(Unit_Module, symbolicExpressions) {
  function TEST (line 1401) | TEST(Unit_Module, findSymbolicExpressionsAts) {
  function TEST (line 1441) | TEST(Unit_Module, protobufRoundTrip) {
  function TEST (line 1537) | TEST(Unit_Module, protobufNodePointers) {
  function TEST (line 1570) | TEST(Unit_Module, removeNodes) {
  function TEST (line 1618) | TEST(Unit_Module, removeInvalidSection) {
  function TEST (line 1641) | TEST(Unit_Module, mutateBlocksWithSymbols) {
  function TEST (line 1677) | TEST(Unit_Module, addBlocksWithSymbols) {

FILE: src/test/Node.test.cpp
  function TEST (line 22) | TEST(Unit_Node, ctor_0) { EXPECT_NE(gtirb::Node::Create(Ctx), nullptr); }
  function TEST (line 24) | TEST(Unit_Node, uniqueUuids) {
  function TEST (line 49) | TEST(Unit_Node, getByUUID) {

FILE: src/test/Offset.test.cpp
  function TEST (line 21) | TEST(Unit_Offset, ordering) {
  function TEST (line 46) | TEST(Unit_Offset, hash) {

FILE: src/test/PrepDeathTest.hpp
  class PrepDeathTest (line 19) | class PrepDeathTest {
    method PrepDeathTest (line 21) | PrepDeathTest() {
  class PrepDeathTest (line 58) | class PrepDeathTest {}
    method PrepDeathTest (line 21) | PrepDeathTest() {

FILE: src/test/PrepTestGTIRB.cpp
  function registerAuxDataTypes (line 14) | void registerAuxDataTypes() {
  function main (line 20) | int main(int argc, char* argv[]) {

FILE: src/test/ProxyBlock.test.cpp
  function TEST (line 26) | TEST(Unit_ProxyBlock, noCopyMoveConstructors) {
  function TEST (line 33) | TEST(Unit_ProxyBlock, protobufRoundTrip) {

FILE: src/test/Section.test.cpp
  function TEST (line 28) | TEST(Unit_Section, compilationIteratorTypes) {
  function TEST (line 53) | TEST(Unit_Section, noCopyMoveConstructors) {
  function TEST (line 60) | TEST(Unit_Section, getAddress) {
  function TEST (line 81) | TEST(Unit_Section, flags) {
  function TEST (line 100) | TEST(Unit_Section, protobufRoundTrip) {
  function TEST (line 122) | TEST(Unit_Section, findByteIntervalsOn) {
  function TEST (line 212) | TEST(Unit_Section, findByteIntervalsAt) {
  function TEST (line 275) | TEST(Unit_Section, findBlocksOn) {
  function TEST (line 352) | TEST(Unit_Section, findCodeBlocksOn) {
  function TEST (line 429) | TEST(Unit_Section, findDataBlocksOn) {
  function TEST (line 506) | TEST(Unit_Section, findBlocksAt) {
  function TEST (line 583) | TEST(Unit_Section, findCodeBlocksAt) {
  function TEST (line 660) | TEST(Unit_Section, findDataBlocksAt) {
  function TEST (line 737) | TEST(Unit_Section, testIterationOrder) {

FILE: src/test/SerializationTestHarness.hpp
  type gtirb (line 29) | namespace gtirb {
    class SerializationTestHarness (line 42) | class SerializationTestHarness {
      method save (line 44) | static void save(const T& Val, std::ostream& Out) {
      method load (line 48) | static auto load(Context& C, std::istream& In) {
      method load (line 53) | static auto load(Context& C, P* Parent, std::istream& In) {
      method byteIntervalLoadSymbolicExpressions (line 57) | static bool byteIntervalLoadSymbolicExpressions(Context& Ctx,

FILE: src/test/Symbol.test.cpp
  function TEST (line 31) | TEST(Unit_Symbol, noCopyMoveConstructors) {
  function TEST (line 38) | TEST(Unit_Symbol, ctor_0) { EXPECT_NE(Symbol::Create(Ctx, "test"), nullp...
  function TEST (line 40) | TEST(Unit_Symbol, setReferent) {
  function TEST (line 81) | TEST(Unit_Symbol, protobufRoundTrip) {
  function TEST (line 151) | TEST(Unit_Symbol, visitation) {
  function TEST (line 228) | TEST(Unit_Symbol, atEnd) {

FILE: src/test/SymbolicExpression.test.cpp
  function TEST (line 27) | TEST(Unit_SymbolicExpression, protobufRoundTrip) {
  function TEST (line 65) | TEST(Unit_SymAttributeSet, unknownAttributes) {

FILE: src/test/TestHelpers.hpp
  function pointers (line 23) | auto pointers(const RangeTy& Range) {

FILE: src/test/TypedNodeTest.cpp
  function Create (line 53) | auto Create(gtirb::Context& C) { return T::Create(C); }
  class TypedNodeTest (line 62) | class TypedNodeTest : public testing::Test {
    method TypedNodeTest (line 64) | TypedNodeTest() = default;
  function TYPED_TEST_P (line 77) | TYPED_TEST_P(TypedNodeTest, ctor_0) { EXPECT_NE(Create<Type>(Ctx), nullp...
  function TYPED_TEST_P (line 79) | TYPED_TEST_P(TypedNodeTest, uniqueUuids) {
  function TYPED_TEST_P (line 94) | TYPED_TEST_P(TypedNodeTest, getByUUID) {
  function TYPED_TEST_P (line 99) | TYPED_TEST_P(TypedNodeTest, protobufUUIDRoundTrip) {
  function TYPED_TEST_P (line 115) | TYPED_TEST_P(TypedNodeTest, deserializeUpdatesUUIDMap) {

FILE: src/test/UtilsDeprecatedGlobals.test.cpp
  function TEST (line 22) | TEST(Unit_IR, globalNextPowerOfTwo) { EXPECT_EQ(NextPowerOf2(5), 8U); }

FILE: src/test/UtilsUsingGtirbNamespace.test.cpp
  function TEST (line 24) | TEST(Unit_IR, namespacedNextPowerOfTwo) { EXPECT_EQ(NextPowerOf2(5), 8U); }
  function TEST (line 25) | TEST(Unit_IR, explicitNamespacedNextPowerOfTwo) {

FILE: src/test/testInputBinary/TestInputBinary.cpp
  function Factorial (line 33) | int64_t Factorial(int64_t x) {
  function IndirectFoo (line 41) | std::string IndirectFoo() { return "Foo"; }
  function IndirectBar (line 43) | std::string IndirectBar() { return "Bar"; }
  class GeneratedClass (line 48) | class GeneratedClass {
    method GeneratedClass (line 50) | GeneratedClass() { this->setName("GeneratedClass"); }
    method printInteger (line 53) | void printInteger() {
    method randomThrow (line 63) | bool randomThrow() {
    method randomIndex (line 78) | std::string randomIndex() const { return std::string(Index8[rand() % 8...
    method randomIndirect (line 80) | std::string randomIndirect() {
    method setName (line 101) | void setName(const std::string& x) { this->name = x; }
  class GeneratedClass<0, I> (line 109) | class GeneratedClass<0, I> {
  function main (line 116) | int main() { GeneratedClass<GENERATION_CONSTANT, 0>()(); }

FILE: src/test/testInterop/test_floats.cpp
  type AFloat (line 22) | struct AFloat {
  type ADouble (line 27) | struct ADouble {
  function registerAuxData (line 32) | void registerAuxData() {
  function test_floats (line 37) | int test_floats(const std::string& filename) {
  function create_floats (line 51) | void create_floats(const std::string& filename) {
  function usage (line 60) | int usage(const char* argv0) {
  function main (line 65) | int main(int argc, char** argv) {

FILE: src/test/testInterop/test_floats.py
  function create_floats (line 21) | def create_floats(filename: str):
  function check_for_floats (line 28) | def check_for_floats(filename: str) -> bool:

FILE: src/test/testInterop/test_variants.cpp
  type SimpleVariantMap (line 9) | struct SimpleVariantMap {
  type ComplexVariantMap (line 14) | struct ComplexVariantMap {
  function register_schema (line 31) | void register_schema() {
  function add_auxdata (line 36) | void add_auxdata(gtirb::IR* Ir) {
  function write_ir (line 43) | bool write_ir(const std::string& filename) {
  function check_ir (line 54) | bool check_ir(const std::string& filename) {
  function usage (line 70) | int usage(const char* argv0) {
  function main (line 75) | int main(int argc, char** argv) {

FILE: src/test/testInterop/test_variants.py
  class V1 (line 9) | class V1(gtirb.Variant):
    method __init__ (line 15) | def __init__(self, val: Any):
  function compare_variant_maps (line 20) | def compare_variant_maps(m1, m2):
  function make_simple_variant_map (line 27) | def make_simple_variant_map():
  function test_mapvariant (line 36) | def test_mapvariant():
  class I1 (line 49) | class I1:
  class I2 (line 55) | class I2:
  class S1 (line 61) | class S1:
  class MyMap (line 67) | class MyMap:
    method __init__ (line 75) | def __init__(self, map_) -> None:
    method __eq__ (line 78) | def __eq__(self, __o: object) -> bool:
    method __repr__ (line 83) | def __repr__(self) -> str:
    method toAuxData (line 86) | def toAuxData(self):
    method fromAuxData (line 93) | def fromAuxData(cls, auxdata: gtirb.AuxData):
  function make_complex_variant_map (line 102) | def make_complex_variant_map():
  function test_complex_variant_map (line 114) | def test_complex_variant_map():
  function write_ir (line 126) | def write_ir(filename):
  function check_ir (line 133) | def check_ir(filename):