1 %feature("docstring", 2 "Represents a member of a type." 3 ) lldb::SBTypeMember; 4 5 %feature("docstring", 6 "Represents a member function of a type." 7 ) lldb::SBTypeMemberFunction; 8 9 %feature("docstring", 10 "Represents a data type in lldb. 11 12 The actual characteristics of each type are defined by the semantics of the 13 programming language and the specific language implementation that was used 14 to compile the target program. See the language-specific notes in the 15 documentation of each method. 16 17 SBType instances can be obtained by a variety of methods. 18 `SBTarget.FindFirstType` and `SBModule.FindFirstType` can be used to create 19 `SBType` representations of types in executables/libraries with debug 20 information. For some languages such as C, C++ and Objective-C it is possible 21 to create new types by evaluating expressions that define a new type. 22 23 Note that most `SBType` properties are computed independently of any runtime 24 information so for dynamic languages the functionality can be very limited. 25 `SBValue` can be used to represent runtime values which then can be more 26 accurately queried for certain information such as byte size. 27 28 29 SBType supports the eq/ne operator. For example,:: 30 31 //main.cpp: 32 33 class Task { 34 public: 35 int id; 36 Task *next; 37 Task(int i, Task *n): 38 id(i), 39 next(n) 40 {} 41 }; 42 43 int main (int argc, char const *argv[]) 44 { 45 Task *task_head = new Task(-1, NULL); 46 Task *task1 = new Task(1, NULL); 47 Task *task2 = new Task(2, NULL); 48 Task *task3 = new Task(3, NULL); // Orphaned. 49 Task *task4 = new Task(4, NULL); 50 Task *task5 = new Task(5, NULL); 51 52 task_head->next = task1; 53 task1->next = task2; 54 task2->next = task4; 55 task4->next = task5; 56 57 int total = 0; 58 Task *t = task_head; 59 while (t != NULL) { 60 if (t->id >= 0) 61 ++total; 62 t = t->next; 63 } 64 printf('We have a total number of %d tasks\\n', total); 65 66 // This corresponds to an empty task list. 67 Task *empty_task_head = new Task(-1, NULL); 68 69 return 0; // Break at this line 70 } 71 72 # find_type.py: 73 74 # Get the type 'Task'. 75 task_type = target.FindFirstType('Task') 76 self.assertTrue(task_type) 77 78 # Get the variable 'task_head'. 79 frame0.FindVariable('task_head') 80 task_head_type = task_head.GetType() 81 self.assertTrue(task_head_type.IsPointerType()) 82 83 # task_head_type is 'Task *'. 84 task_pointer_type = task_type.GetPointerType() 85 self.assertTrue(task_head_type == task_pointer_type) 86 87 # Get the child mmember 'id' from 'task_head'. 88 id = task_head.GetChildMemberWithName('id') 89 id_type = id.GetType() 90 91 # SBType.GetBasicType() takes an enum 'BasicType' (lldb-enumerations.h). 92 int_type = id_type.GetBasicType(lldb.eBasicTypeInt) 93 # id_type and int_type should be the same type! 94 self.assertTrue(id_type == int_type) 95 96 ") lldb::SBType; 97 98 %feature("docstring", 99 "Returns the number of bytes a variable with the given types occupies in memory. 100 101 Returns ``0`` if the size can't be determined. 102 103 If a type occupies ``N`` bytes + ``M`` bits in memory, this function returns 104 the rounded up amount of bytes (i.e., if ``M`` is ``0``, 105 this function returns ``N`` and otherwise ``N + 1``). 106 107 Language-specific behaviour: 108 109 * C: The output is expected to match the value of ``sizeof(Type)``. If 110 ``sizeof(Type)`` is not a valid expression for the given type, the 111 function returns ``0``. 112 * C++: Same as in C. 113 * Objective-C: Same as in C. For Objective-C classes this always returns 114 ``0`` as the actual size depends on runtime information. 115 " 116 ) lldb::SBType::GetByteSize; 117 118 %feature("docstring", 119 "Returns true if this type is a pointer type. 120 121 Language-specific behaviour: 122 123 * C: Returns true for C pointer types (or typedefs of these types). 124 * C++: Pointer types include the C pointer types as well as pointers to data 125 mebers or member functions. 126 * Objective-C: Pointer types include the C pointer types. ``id``, ``Class`` 127 and pointers to blocks are also considered pointer types. 128 " 129 ) lldb::SBType::IsPointerType; 130 131 %feature("docstring", 132 "Returns true if this type is a reference type. 133 134 Language-specific behaviour: 135 136 * C: Returns false for all types. 137 * C++: Both l-value and r-value references are considered reference types. 138 * Objective-C: Returns false for all types. 139 " 140 ) lldb::SBType::IsReferenceType; 141 142 %feature("docstring", 143 "Returns true if this type is a function type. 144 145 Language-specific behaviour: 146 147 * C: Returns true for types that represent functions. Note that function 148 pointers are not function types (but their `GetPointeeType()` are function 149 types). 150 * C++: Same as in C. 151 * Objective-C: Returns false for all types. 152 " 153 ) lldb::SBType::IsPolymorphicClass; 154 155 %feature("docstring", 156 "Returns true if this type is a polymorphic type. 157 158 Language-specific behaviour: 159 160 * C: Returns false for all types. 161 * C++: Returns true if the type is a class type that contains at least one 162 virtual member function or if at least one of its base classes is 163 considered a polymorphic type. 164 * Objective-C: Returns false for all types. 165 " 166 ) lldb::SBType::IsPolymorphicClass; 167 168 %feature("docstring", 169 "Returns true if this type is an array type. 170 171 Language-specific behaviour: 172 173 * C: Returns true if the types is an array type. This includes incomplete 174 array types ``T[]`` and array types with integer (``T[1]``) or variable 175 length (``T[some_variable]``). Pointer types are not considered arrays. 176 * C++: Includes C's array types and dependent array types (i.e., array types 177 in templates which size depends on template arguments). 178 * Objective-C: Same as in C. 179 " 180 ) lldb::SBType::IsArrayType; 181 182 %feature("docstring", 183 "Returns true if this type is a vector type. 184 185 Language-specific behaviour: 186 187 * C: Returns true if the types is a vector type created with 188 GCC's ``vector_size`` or Clang's ``ext_vector_type`` feature. 189 * C++: Same as in C. 190 * Objective-C: Same as in C. 191 " 192 ) lldb::SBType::IsVectorType; 193 194 %feature("docstring", 195 "Returns true if this type is a typedef. 196 197 Language-specific behaviour: 198 199 * C: Returns true if the type is a C typedef. 200 * C++: Same as in C. Also treats type aliases as typedefs. 201 * Objective-C: Same as in C. 202 " 203 ) lldb::SBType::IsTypedefType; 204 205 %feature("docstring", 206 "Returns true if this type is an anonymous type. 207 208 Language-specific behaviour: 209 210 * C: Returns true for anonymous unions. Also returns true for 211 anonymous structs (which are a GNU language extension). 212 * C++: Same as in C. 213 * Objective-C: Same as in C. 214 " 215 ) lldb::SBType::IsAnonymousType; 216 217 %feature("docstring", 218 "Returns true if this type is a scoped enum. 219 220 Language-specific behaviour: 221 222 * C: Returns false for all types. 223 * C++: Return true only for C++11 scoped enums. 224 * Objective-C: Returns false for all types. 225 " 226 ) lldb::SBType::IsScopedEnumerationType; 227 228 %feature("docstring", 229 "Returns true if this type is an aggregate type. 230 231 Language-specific behaviour: 232 233 * C: Returns true for struct values, arrays, and vectors. 234 * C++: Same a C. Also includes class instances. 235 * Objective-C: Same as C. Also includes class instances. 236 " 237 ) lldb::SBType::IsAggregateType; 238 239 %feature("docstring", 240 "Returns a type that represents a pointer to this type. 241 242 If the type system of the current language can't represent a pointer to this 243 type or this type is invalid, an invalid `SBType` is returned. 244 245 Language-specific behaviour: 246 247 * C: Returns the pointer type of this type. 248 * C++: Same as in C. 249 * Objective-C: Same as in C. 250 " 251 ) lldb::SBType::GetPointerType; 252 253 %feature("docstring", 254 "Returns the underlying pointee type. 255 256 If this type is a pointer type as specified by `IsPointerType` then this 257 returns the underlying type. If this is not a pointer type or an invalid 258 `SBType` then this returns an invalid `SBType`. 259 260 Language-specific behaviour: 261 262 * C: Returns the underlying type for for C pointer types or typedefs of 263 these types). For example, ``int *`` will return ``int``. 264 * C++: Same as in C. Returns an `SBType` representation for data members/ 265 member functions in case the `SBType` is a pointer to data member or 266 pointer to member function. 267 * Objective-C: Same as in C. The pointee type of ``id`` and ``Class`` is 268 an invalid `SBType`. The pointee type of pointers Objective-C types is an 269 `SBType` for the non-pointer type of the respective type. For example, 270 ``NSString *`` will return ``NSString`` as a pointee type. 271 " 272 ) lldb::SBType::GetPointeeType; 273 274 %feature("docstring", 275 "Returns a type that represents a reference to this type. 276 277 If the type system of the current language can't represent a reference to 278 this type, an invalid `SBType` is returned. 279 280 Language-specific behaviour: 281 282 * C: Currently assumes the type system is C++ and returns an l-value 283 reference type. For example, ``int`` will return ``int&``. This behavior 284 is likely to change in the future and shouldn't be relied on. 285 * C++: Same as in C. 286 * Objective-C: Same as in C. 287 " 288 ) lldb::SBType::GetReferenceType; 289 290 %feature("docstring", 291 "Returns the underlying type of a typedef. 292 293 If this type is a typedef as designated by `IsTypedefType`, then the 294 underlying type is being returned. Otherwise an invalid `SBType` is 295 returned. 296 297 Language-specific behaviour: 298 299 * C: Returns the underlying type of a typedef type. 300 * C++: Same as in C. For type aliases, the underlying type is returned. 301 * Objective-C: Same as in C. 302 " 303 ) lldb::SBType::GetTypedefedType; 304 305 %feature("docstring", 306 "Returns the underlying type of a reference type. 307 308 If this type is a reference as designated by `IsReferenceType`, then the 309 underlying type is being returned. Otherwise an invalid `SBType` is 310 returned. 311 312 Language-specific behaviour: 313 314 * C: Always returns an invalid type. 315 * C++: For l-value and r-value references the underlying type is returned. 316 For example, ``int &`` will return ``int``. 317 * Objective-C: Same as in C. 318 " 319 ) lldb::SBType::GetDereferencedType; 320 321 %feature("docstring", 322 "Returns the unqualified version of this type. 323 324 Language-specific behaviour: 325 326 * C: If this type with any const or volatile specifier removed. 327 * C++: Same as in C. 328 * Objective-C: Same as in C. 329 " 330 ) lldb::SBType::GetUnqualifiedType; 331 332 %feature("docstring", 333 "Returns the underlying integer type if this is an enumeration type. 334 335 If this type is an invalid `SBType` or not an enumeration type an invalid 336 `SBType` is returned. 337 338 Language-specific behaviour: 339 340 * C: Returns the underlying type for enums. 341 * C++: Same as in C but also returns the underlying type for scoped enums. 342 * Objective-C: Same as in C. 343 " 344 ) lldb::SBType::GetEnumerationIntegerType; 345 346 %feature("docstring", 347 "Returns the array element type if this type is an array type. 348 349 Otherwise returns an invalid `SBType` if this type is invalid or not an 350 array type. 351 352 Language-specific behaviour: 353 354 * C: If this is an array type (see `IsArrayType`) such as ``T[]``, returns 355 the element type. 356 * C++: Same as in C. 357 * Objective-C: Same as in C. 358 359 See also `IsArrayType`. 360 " 361 ) lldb::SBType::GetArrayElementType; 362 363 %feature("docstring", 364 "Returns the array type with the given constant size. 365 366 Language-specific behaviour: 367 368 * C: Returns a constant-size array ``T[size]`` for any non-void type. 369 * C++: Same as in C. 370 * Objective-C: Same as in C. 371 372 See also `IsArrayType` and `GetArrayElementType`. 373 " 374 ) lldb::SBType::GetArrayType; 375 376 %feature("docstring", 377 "Returns the vector element type if this type is a vector type. 378 379 Otherwise returns an invalid `SBType` if this type is invalid or not a 380 vector type. 381 382 Language-specific behaviour: 383 384 * C: If this is a vector type (see `IsVectorType`), returns the element 385 type. 386 * C++: Same as in C. 387 * Objective-C: Same as in C. 388 389 See also `IsVectorType`. 390 " 391 ) lldb::SBType::GetVectorElementType; 392 393 %feature("docstring", 394 "Returns the `BasicType` value that is most appropriate to this type. 395 396 Returns `eBasicTypeInvalid` if no appropriate `BasicType` was found or this 397 type is invalid. See the `BasicType` documentation for the language-specific 398 meaning of each `BasicType` value. 399 400 **Overload behaviour:** When called with a `BasicType` parameter, the 401 following behaviour applies: 402 403 Returns the `SBType` that represents the passed `BasicType` value. Returns 404 an invalid `SBType` if no fitting `SBType` could be created. 405 406 Language-specific behaviour: 407 408 * C: Returns the respective builtin type. Note that some types 409 (e.g. ``__uint128_t``) might even be successfully created even if they are 410 not available on the target platform. C++ and Objective-C specific types 411 might also be created even if the target program is not written in C++ or 412 Objective-C. 413 * C++: Same as in C. 414 * Objective-C: Same as in C. 415 " 416 ) lldb::SBType::GetBasicType; 417 418 %feature("docstring", 419 "Returns the number of fields of this type. 420 421 Returns ``0`` if this type does not have fields. 422 423 Language-specific behaviour: 424 425 * C: Returns the number of fields if the type is a struct. If the type 426 contains an anonymous struct/union it only counts as a single field (even 427 if the struct/union contains several fields). 428 * C++: Returns the number of non-static fields if the type is a 429 struct/class. If the type contains an anonymous struct/union it only 430 counts as a single field (even if the struct/union contains several 431 fields). The fields of any base classes are not included in the count. 432 * Objective-C: Same as in C for structs. For Objective-C classes the number 433 of ivars is returned. 434 435 See also `GetFieldAtIndex`. 436 " 437 ) lldb::SBType::GetNumberOfFields; 438 439 %feature("docstring", 440 "Returns the number of base/parent classes of this type. 441 442 Returns ``0`` if this type doesn't have any base classes. 443 444 Language-specific behaviour: 445 446 * C: Returns always ``0``. 447 * C++: The number of direct non-virtual base classes if this type is 448 a class. 449 * Objective-C: The number of super classes for Objective-C classes. 450 As Objective-C doesn't have multiple inheritance this is usually returns 1 451 except for NSObject. 452 " 453 ) lldb::SBType::GetNumberOfDirectBaseClasses; 454 455 %feature("docstring", 456 "Returns the number of virtual base/parent classes of this type 457 458 Returns ``0`` if this type doesn't have any base classes. 459 460 Language-specific behaviour: 461 462 * C: Returns always ``0``. 463 * C++: The number of direct virtual base classes if this type is a 464 class. 465 * Objective-C: Returns always ``0``. 466 " 467 ) lldb::SBType::GetNumberOfVirtualBaseClasses; 468 469 %feature("docstring", 470 "Returns the field at the given index. 471 472 Returns an invalid `SBType` if the index is out of range or the current 473 type doesn't have any fields. 474 475 Language-specific behaviour: 476 477 * C: Returns the field with the given index for struct types. Fields are 478 ordered/indexed starting from ``0`` for the first field in a struct (as 479 declared in the definition). 480 * C++: Returns the non-static field with the given index for struct types. 481 Fields are ordered/indexed starting from ``0`` for the first field in a 482 struct (as declared in the definition). 483 * Objective-C: Same as in C for structs. For Objective-C classes the ivar 484 with the given index is returned. ivars are indexed starting from ``0``. 485 " 486 ) lldb::SBType::GetFieldAtIndex; 487 488 %feature("docstring", 489 "Returns the direct base class as indexed by `GetNumberOfDirectBaseClasses`. 490 491 Returns an invalid SBTypeMember if the index is invalid or this SBType is 492 invalid. 493 " 494 ) lldb::SBType::GetDirectBaseClassAtIndex; 495 496 %feature("docstring", 497 "Returns the virtual base class as indexed by 498 `GetNumberOfVirtualBaseClasses`. 499 500 Returns an invalid SBTypeMember if the index is invalid or this SBType is 501 invalid. 502 " 503 ) lldb::SBType::GetVirtualBaseClassAtIndex; 504 505 %feature("docstring", 506 "Returns the `SBModule` this `SBType` belongs to. 507 508 Returns no `SBModule` if this type does not belong to any specific 509 `SBModule` or this `SBType` is invalid. An invalid `SBModule` might also 510 indicate that once came from an `SBModule` but LLDB could no longer 511 determine the original module. 512 " 513 ) lldb::SBType::GetModule; 514 515 %feature("autodoc", "GetName() -> string") lldb::SBType::GetName; 516 517 %feature("docstring", 518 "Returns the name of this type. 519 520 Returns an empty string if an error occurred or this type is invalid. 521 522 Use this function when trying to match a specific type by name in a script. 523 The names returned by this function try to uniquely identify a name but 524 conflicts can occur (for example, if a C++ program contains two different 525 classes with the same name in different translation units. `GetName` can 526 return the same name for both class types.) 527 528 529 Language-specific behaviour: 530 531 * C: The name of the type. For structs the ``struct`` prefix is omitted. 532 * C++: Returns the qualified name of the type (including anonymous/inline 533 namespaces and all template arguments). 534 * Objective-C: Same as in C. 535 " 536 ) lldb::SBType::GetName; 537 538 %feature("autodoc", "GetDisplayTypeName() -> string") lldb::SBType::GetDisplayTypeName; 539 540 %feature("docstring", 541 "Returns the name of this type in a user-friendly format. 542 543 Returns an empty string if an error occurred or this type is invalid. 544 545 Use this function when displaying a type name to the user. 546 547 Language-specific behaviour: 548 549 * C: Returns the type name. For structs the ``struct`` prefix is omitted. 550 * C++: Returns the qualified name. Anonymous/inline namespaces are omitted. 551 Template arguments that match their default value might also be hidden 552 (this functionality depends on whether LLDB can determine the template's 553 default arguments). 554 * Objective-C: Same as in C. 555 " 556 ) lldb::SBType::GetDisplayTypeName; 557 558 %feature("autodoc", "GetTypeClass() -> TypeClass") lldb::SBType::GetTypeClass; 559 560 %feature("docstring", 561 "Returns the `TypeClass` for this type. 562 563 Returns an `eTypeClassInvalid` if this `SBType` is invalid. 564 565 See `TypeClass` for the language-specific meaning of each `TypeClass` value. 566 " 567 ) lldb::SBType::GetTypeClass; 568 569 %feature("docstring", 570 "Returns the number of template arguments of this type. 571 572 Returns ``0`` if this type is not a template. 573 574 Language-specific behaviour: 575 576 * C: Always returns ``0``. 577 * C++: If this type is a class template instantiation then this returns the 578 number of template parameters that were used in this instantiation. This 579 includes both explicit and implicit template parameters. 580 * Objective-C: Always returns ``0``. 581 " 582 ) lldb::SBType::GetNumberOfTemplateArguments; 583 584 %feature("docstring", 585 "Returns the type of the template argument with the given index. 586 587 Returns an invalid `SBType` if there is no template argument with the given 588 index or this type is not a template. The first template argument has the 589 index ``0``. 590 591 Language-specific behaviour: 592 593 * C: Always returns an invalid SBType. 594 * C++: If this type is a class template instantiation and the template 595 parameter with the given index is a type template parameter, then this 596 returns the type of that parameter. Otherwise returns an invalid `SBType`. 597 * Objective-C: Always returns an invalid SBType. 598 " 599 ) lldb::SBType::GetTemplateArgumentType; 600 601 %feature("docstring", 602 "Returns the kind of the template argument with the given index. 603 604 Returns `eTemplateArgumentKindNull` if there is no template argument 605 with the given index or this type is not a template. The first template 606 argument has the index ``0``. 607 608 Language-specific behaviour: 609 610 * C: Always returns `eTemplateArgumentKindNull`. 611 * C++: If this type is a class template instantiation then this returns 612 the appropriate `TemplateArgument` value for the parameter with the given 613 index. See the documentation of `TemplateArgument` for how certain C++ 614 template parameter kinds are mapped to `TemplateArgument` values. 615 * Objective-C: Always returns `eTemplateArgumentKindNull`. 616 " 617 ) lldb::SBType::GetTemplateArgumentKind; 618 619 %feature("docstring", 620 "Returns the return type if this type represents a function. 621 622 Returns an invalid `SBType` if this type is not a function type or invalid. 623 624 Language-specific behaviour: 625 626 * C: For functions return the return type. Returns an invalid `SBType` if 627 this type is a function pointer type. 628 * C++: Same as in C for functions and instantiated template functions. 629 Member functions are also considered functions. For functions that have 630 their return type specified by a placeholder type specifier (``auto``) 631 this returns the deduced return type. 632 * Objective-C: Same as in C for functions. For Objective-C methods this 633 returns the return type of the method. 634 " 635 ) lldb::SBType::GetFunctionReturnType; 636 637 %feature("docstring", 638 "Returns the list of argument types if this type represents a function. 639 640 Returns an invalid `SBType` if this type is not a function type or invalid. 641 642 Language-specific behaviour: 643 644 * C: For functions return the types of each parameter. Returns an invalid 645 `SBType` if this type is a function pointer. For variadic functions this 646 just returns the list of parameters before the variadic arguments. 647 * C++: Same as in C for functions and instantiated template functions. 648 Member functions are also considered functions. 649 * Objective-C: Always returns an invalid SBType for Objective-C methods. 650 " 651 ) lldb::SBType::GetFunctionArgumentTypes; 652 653 %feature("docstring", 654 "Returns the number of member functions of this type. 655 656 Returns ``0`` if an error occurred or this type is invalid. 657 658 Language-specific behaviour: 659 660 * C: Always returns ``0``. 661 * C++: If this type represents a struct/class, then the number of 662 member functions (static and non-static) is returned. The count includes 663 constructors and destructors (both explicit and implicit). Member 664 functions of base classes are not included in the count. 665 * Objective-C: If this type represents a struct/class, then the 666 number of methods is returned. Methods in categories or super classes 667 are not counted. 668 " 669 ) lldb::SBType::GetNumberOfMemberFunctions; 670 671 %feature("docstring", 672 "Returns the member function of this type with the given index. 673 674 Returns an invalid `SBTypeMemberFunction` if the index is invalid or this 675 type is invalid. 676 677 Language-specific behaviour: 678 679 * C: Always returns an invalid `SBTypeMemberFunction`. 680 * C++: Returns the member function or constructor/destructor with the given 681 index. 682 * Objective-C: Returns the method with the given index. 683 684 See `GetNumberOfMemberFunctions` for what functions can be queried by this 685 function. 686 " 687 ) lldb::SBType::GetMemberFunctionAtIndex; 688 689 %feature("docstring", 690 "Returns true if the type is completely defined. 691 692 Language-specific behaviour: 693 694 * C: Returns false for struct types that were only forward declared in the 695 type's `SBTarget`/`SBModule`. Otherwise returns true. 696 * C++: Returns false for template/non-template struct/class types and 697 scoped enums that were only forward declared inside the type's 698 `SBTarget`/`SBModule`. Otherwise returns true. 699 * Objective-C: Follows the same behavior as C for struct types. Objective-C 700 classes are considered complete unless they were only forward declared via 701 ``@class ClassName`` in the type's `SBTarget`/`SBModule`. Otherwise 702 returns true. 703 " 704 ) lldb::SBType::IsTypeComplete; 705 706 %feature("docstring", 707 "Returns the `TypeFlags` values for this type. 708 709 See the respective `TypeFlags` values for what values can be set. Returns an 710 integer in which each `TypeFlags` value is represented by a bit. Specific 711 flags can be checked via Python's bitwise operators. For example, the 712 `eTypeIsInteger` flag can be checked like this: 713 714 ``(an_sb_type.GetTypeFlags() & lldb.eTypeIsInteger) != 0`` 715 716 If this type is invalid this returns ``0``. 717 718 See the different values for `TypeFlags` for the language-specific meanings 719 of each `TypeFlags` value. 720 " 721 ) lldb::SBType::GetTypeFlags; 722 723 %feature("docstring", 724 "Represents a list of :py:class:`SBType` s. 725 726 The FindTypes() method of :py:class:`SBTarget`/:py:class:`SBModule` returns a SBTypeList. 727 728 SBTypeList supports :py:class:`SBType` iteration. For example, 729 730 .. code-block:: cpp 731 732 // main.cpp: 733 734 class Task { 735 public: 736 int id; 737 Task *next; 738 Task(int i, Task *n): 739 id(i), 740 next(n) 741 {} 742 }; 743 744 .. code-block:: python 745 746 # find_type.py: 747 748 # Get the type 'Task'. 749 type_list = target.FindTypes('Task') 750 self.assertTrue(len(type_list) == 1) 751 # To illustrate the SBType iteration. 752 for type in type_list: 753 # do something with type 754 755 ") lldb::SBTypeList; 756