| ►Nconftest | |
| CCapture | |
| COutput | |
| CSanitizedString | |
| CUnordered | |
| ►Nexercise_trampoline | |
| CSimpleBase | |
| CSimpleBaseTrampoline | |
| CSimpleCppDerived | |
| ►Nexternal | |
| Cfloat_ | |
| ►Nhandle_from_move_only_type_with_operator_PyObject | |
| Coperator_const | |
| Coperator_ncnst | |
| ►Nother_lib | |
| Cmy_caster | |
| CMyType | |
| ►Npets | |
| CPet | |
| ►Npugi | |
| Cxml_attribute | |
| Cxml_attribute_iterator | |
| Cxml_attribute_struct | |
| Cxml_document | |
| Cxml_named_node_iterator | |
| Cxml_node | |
| Cxml_node_iterator | |
| Cxml_node_struct | |
| Cxml_object_range | |
| Cxml_parse_result | |
| Cxml_text | |
| Cxml_tree_walker | |
| Cxml_writer | |
| Cxml_writer_file | |
| Cxml_writer_stream | |
| Cxpath_exception | |
| Cxpath_node | |
| Cxpath_node_set | |
| Cxpath_parse_result | |
| Cxpath_query | |
| Cxpath_variable | |
| Cxpath_variable_set | |
| ►Npybind11 | |
| ►Ndetail | |
| Cholder_helper< ref< T > > | |
| Ctype_caster< ArgAlwaysConverts > | |
| Ctype_caster< ArgInspector1 > | |
| Ctype_caster< ArgInspector2 > | |
| Ctype_caster< DestructionTester > | |
| Ctype_caster< other_lib::MyType > | |
| Ctype_caster< ReferenceSensitiveOptional< T > > | |
| ►Nsetup_helpers | |
| Cbuild_ext | |
| CParallelCompile | |
| CPybind11Extension | |
| Cpolymorphic_type_hook< itype, detail::enable_if_t< std::is_base_of< Animal, itype >::value > > | |
| ►NPYBIND11_NAMESPACE | |
| ►Ndetail | |
| Cholder_helper< ref< T > > | |
| Ctype_caster< ArgAlwaysConverts > | |
| Ctype_caster< ArgInspector1 > | |
| Ctype_caster< ArgInspector2 > | |
| Ctype_caster< DestructionTester > | |
| Ctype_caster< other_lib::MyType > | |
| Ctype_caster< ReferenceSensitiveOptional< T > > | |
| Cpolymorphic_type_hook< itype, detail::enable_if_t< std::is_base_of< Animal, itype >::value > > | |
| ►Npycohal | |
| CValVectorIndexingSuite | Struct containing wrapper functions for list-like indexing of ValVector<uint32_t> in python |
| ►Nsetup | |
| CSDist | |
| ►Nstd | |
| Chash< HashMe > | |
| Chash< TplCtorClass > | |
| Chash< Vector2 > | |
| ►Ntest_class | |
| ►Npr4220_tripped_over_this | |
| CSoEmpty | |
| ►Ntest_exc_sp | |
| CC | |
| ►Ntest_exceptions | |
| CFlakyException | |
| ►Ntest_gil_scoped | |
| CExtendedVirtClass | |
| ►Ntest_interpreter | |
| CDerivedWidget | |
| ►Ntest_pickling | |
| CSimplePyDerived | |
| ►Ntest_pytypes | |
| CCustomContains | |
| ►Ntest_thread | |
| CThread | |
| ►Nuhal | |
| ►Ndetail | |
| CPacketFmt | Class used to display IPbus packet contents in human-readable format (e.g. in log messages) |
| CRobustSessionMutex | Exception class to handle errors from pthread mutex-related functions |
| CSharedObject | Wrapper for C++ object that's placed in shared memory |
| ►Nexception | A namespace for all exceptions to live in - this will hopefully make documentation a bit clearer |
| Cexception | An abstract base exception class, including an interface to throw as the derived type (for passing exceptions between threads) |
| CIPbusCoreResponseCodeSet | Exception class to handle the case where the IPbus header could not be parsed |
| ►Ngrammars | |
| CNodeTreeParametersGrammar | A struct wrapping a set of rules as a grammar that can parse a NodeTreeParametersGrammar of the form "name1=val1;name2=val2;name3=val3" |
| CSemicolonDelimitedUriListGrammar | The BOOST::SPIRIT grammar for parsing the Semicolon delimited URI list into a vector of protocol-URI pairs |
| ►Ntests | |
| CAbstractFixture | |
| CAddressTableOverlapFixture | |
| CDummyAddressFileFixture | Fixture for tests based on 'dummy' address files |
| CDummyChildNode | Class further derived from Level1 |
| CDummyClient | Empty client class, written to test registration |
| CDummyHardware | Abstract base class to emulate IPbus hardware |
| CDummyHardwareFixture | |
| CDummyHardwareInterface | Common abstract base class for IPbus 1.3 and 2.0 dummy hardware |
| CDummyHardwareOptions | Struct to store the dummy hardware command line options |
| CDummyHardwareRunner | |
| CDummyParentNode | |
| CMinimalFixture | |
| CMinimalFixture< IPBUS_2_0_PCIE > | |
| CNodeProperties | |
| CPCIeDummyHardware | |
| ►CPerfTester | |
| CQueuedBlockRead | |
| CQueuedBlockWrite | |
| CQueuedRmwBits | |
| CQueuedRmwSum | |
| CQueuedTransaction | |
| CSimpleAddressTableFixture | |
| CTCPDummyHardware | Concrete implementation of emulator of hardware using TCP |
| CTimer | A very simple timer |
| CUDPDummyHardware | Concrete implementation of emulator of hardware using UDP |
| C_Integer | Forward declare an ultra-lightweight wrapper which does formatting of numbers only on demand |
| C_Integer< T, IntFmt< bin, fixed, WIDTH > > | |
| C_Integer< T, IntFmt< bin, variable, WIDTH > > | |
| C_Integer< T, IntFmt< dec, fixed, WIDTH > > | |
| C_Integer< T, IntFmt< dec, variable, WIDTH > > | |
| C_Integer< T, IntFmt< hex, fixed, WIDTH > > | |
| C_Integer< T, IntFmt< hex, variable, WIDTH > > | |
| C_Quote | |
| C_Quote< const char * > | |
| C_Time | Forward declaration |
| C_Type | |
| C_ValHeader_ | A helper struct wrapping an IPbus header and a valid flag |
| C_ValVector_ | A Template helper struct wrapping a block of IPbus header, a register for storing a block of data and a valid flag |
| C_ValWord_ | A Template helper struct wrapping an IPbus header, a register for storing a single word of data, a valid flag and a mask for modifying returned values |
| CBaseFunctionObject | Abstract base class for wrapping function pointers, function objects and bound functions as objects |
| CBaseLogLevel | |
| CBuffers | A class wrapping the send and recieve buffers that are to be filled and transported and the validated memories associated with them |
| ►CClientFactory | A class to construct an IPbus client based on the protocol identifier specified NOTE! This is a factory method and must be Mutex protected if it is used in multithreaded environments! |
| CClientInfo | |
| CCreator | Templated concrete implementation with a CreatorInterface interface |
| CCreatorInterface | An abstract base class for defining the interface to the creators |
| CRegistrationHelper | |
| CClientInterface | An abstract base class for defining the interface to the various IPbus clients as well as providing the generalized packing functionality |
| ►CConnectionManager | A class to open and manage XML connection files and wrap up the interfaces to the NodeTreeBuilder and the ClientFactory |
| CConnectionDescriptor | A struct to hold the fields of each entry in the XML connections file |
| ►CControlHub | Transport protocol to transfer an IPbus buffer via ControlHub |
| Ctpreamble | A struct representing the preamble which will be prepended to an IPbus buffer for the benefit of the Control Hub |
| CDebugLevel | Helper struct representing the Debug log level to allow us to specialize functions according to their log level |
| ►CDerivedNodeFactory | A singleton class to register derived nodes, and create instances of them later NOTE! This is a factory method and must be Mutex protected if it is used in multithreaded environments! |
| CCreator | Templated concrete implementation with a CreatorInterface interface |
| CCreatorInterface | An abstract base class for defining the interface to the creators |
| CErrorLevel | Helper struct representing the Error log level to allow us to specialize functions according to their log level |
| CFatalLevel | Helper struct representing the Fatal log level to allow us to specialize functions according to their log level |
| CFunctionObject | Class for wrapping bound functions and function objects as an object |
| CFunctionObject< R, T * > | Class for wrapping function pointer as an object |
| CHostToTargetInspector | Helper class to decode IPbus packets as passed from the Client to the Target |
| CHttpResponseType | Struct to store an http response received from a server when parsed by boost spirit |
| CHwInterface | A class which bundles a node tree and an IPbus client interface together providing everything you need to navigate and perform hardware access |
| CInfoLevel | Helper struct representing the Info log level to allow us to specialize functions according to their log level |
| CIntFmt | Empty struct which acts as a dummy variable for passing the formatting information around |
| CIPbus | A class which provides the version-specific functionality for IPbus |
| CIPbus< 1, IPbus_minor > | A class which provides the version-specific functionality for IPbus |
| CIPbus< 2, IPbus_minor > | A class which provides the version-specific functionality for IPbus |
| CIPbusCore | A class providing the core IPbus packing functionality |
| CLocation | A class to wrap the function name, filename and line-number location of its construction for the purpose of debugging and tracking unwinding exceptions |
| Clog_configuration | Class to restrict access to the log configuration parameters |
| ►CMmap | Transport protocol to transfer an IPbus buffer via device file, using mmap |
| CFile | |
| CHexTo | |
| ►CNode | A heirarchical node for navigating heirarchical firmwares |
| Cconst_iterator | |
| ►CNodeTreeBuilder | A class to build a node tree from an address table file |
| Cmode_lut | A look-up table that the boost qi parser uses for associating strings ("single","block","port","incremental","non-incremental","inc","non-inc") with enumerated mode types |
| Cpermissions_lut | A look-up table that the boost qi parser uses for associating strings ("r","w","rw","wr","read","write","readwrite","writeread") with enumerated permissions types |
| CNodeTreeClassAttribute | Struct to store the name and member variables within a node class attribute when parsed by boost spirit The class attribute has the form "classname;name1=val1;name2=val2;name3=val3;" where the name-value pairs are optional, as is the trailing semicolon |
| CNodeTreeFirmwareInfoAttribute | Struct to store the name and member variables within a node endpoint attribute when parsed by boost spirit The endpoint attribute has the form "endpoint;name1=val1;name2=val2;name3=val3;" where the name-value pairs are optional, as is the trailing semicolon |
| CNoticeLevel | Helper struct representing the Notice log level to allow us to specialize functions according to their log level |
| CParser | Forward declaration of the Parser so we can declare it friend |
| ►CPCIe | Transport protocol to transfer an IPbus buffer via PCIe |
| CFile | |
| CRefWrapper | |
| CRefWrapper< T * > | |
| CRegistrationHelper | Experimental!! Helper struct for adding the DerivedNode to the Node Factory Declaring an instance of an object at global scope means that it is created before the main code is entered We can use this to our advantage by using the constructor of this object to add entries to the factory in a distributed fashion (for instance, in the file where the derived node is defined), rather than manually having to add entries in one file To make things even simpler, the REGISTER macro expands the template argument to a string and passes it to the constructor |
| CRule | Rule for matching XML attributes |
| CSigBusGuard | |
| CTargetToHostInspector | Helper class to decode IPbus packets as passed from the Target to the Client |
| CTCP | Transport protocol to transfer an IPbus buffer via TCP |
| CThisThreadID | |
| CTimeFmt | A struct whose template parameters represent a time format |
| CTimeIntervalStats | |
| CTranslatedFmt | |
| CUDP | Transport protocol to transfer an IPbus buffer via UDP |
| CURI | Struct to store a URI when parsed by boost spirit |
| CValHeader | A class which wraps a single word of data and marks whether or not it is valid |
| CValVector | A class which wraps a block of data and marks whether or not it is valid |
| CValWord | A class which wraps a single word of data and marks whether or not it is valid |
| CWarningLevel | Helper struct representing the Warning log level to allow us to specialize functions according to their log level |
| CA | |
| CA_Repeat | |
| CA_Tpl | |
| Caccessor | |
| CAdder | |
| ►CAdderBase | |
| CData | |
| Calias_constructor | |
| Calways_construct_holder | |
| CAnimal | |
| Cany_container | |
| Canyset | |
| Carg | Annotation for arguments |
| Carg_v | Annotation for arguments with values |
| CArgAlwaysConverts | |
| CArgInspector1 | |
| CArgInspector2 | |
| Cargs | |
| Cargs_proxy | |
| Cargument_loader | Helper class which loads arguments for C++ functions called from Python |
| Cargument_record | Internal data structure which holds metadata about a keyword argument |
| Carithmetic | Annotation to mark enums as an arithmetic type |
| Carray | |
| Carray_caster | |
| Carray_info | |
| Carray_info< char[N]> | |
| Carray_info< std::array< char, N > > | |
| Carray_info< std::array< T, N > > | |
| Carray_info< T[N]> | |
| Carray_info_scalar | |
| ►Carray_t | |
| Cprivate_ctor | |
| CArrayStruct | |
| Carrow_proxy | Quick proxy class needed to implement operator-> for iterators which can't return pointers |
| Cauto_deleter | |
| Caxis_to_type | |
| CB | |
| CB_Repeat | |
| CB_Tpl | |
| CBase | |
| Cbase | Annotation indicating that a class derives from another given type |
| Cbool_ | |
| Cbools | Compile-time all/any/none of that check the boolean value of all template types |
| CBreaksBase | |
| CBreaksTramp | |
| Cbuffer | |
| ►Cbuffer_info | Information record describing a Python buffer object |
| Cprivate_ctr_tag | |
| Cbuffer_protocol | Annotation which enables the buffer protocol for a type |
| Cbuiltin_exception | C++ bindings of builtin Python exceptions |
| Cbytearray | |
| Cbytes | |
| CC1 | |
| CC2 | |
| CC_Repeat | |
| CC_Tpl | |
| Ccall_guard | \rst A call policy which places one or more guard variables (Ts...) around the function call |
| Ccall_guard< T > | |
| ►Ccall_guard< T, Ts... > | |
| Ctype | |
| Ccall_guard<> | |
| Ccapsule | |
| CCat | |
| CChihuahua | |
| ►Cclass_ | |
| Cis_valid_class_option | |
| Ccommon_iterator | |
| Ccompare_buffer_info | |
| Ccompare_buffer_info< T, detail::enable_if_t< detail::is_pod_struct< T >::value > > | |
| Ccompare_buffer_info< T, detail::enable_if_t< std::is_integral< T >::value > > | |
| CComplexStruct | |
| CConstRefCasted | |
| Cconstructor | |
| CConstructorStats | |
| Ccontainer_traits | |
| Ccopyable_holder_caster | Type caster for holder types like std::shared_ptr, etc |
| CCopyOnlyInt | |
| ►Ccpp_function | Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object |
| CInitializingFunctionRecordDeleter | |
| Cstrdup_guard | |
| Ccustom_type_setup | Specifies a custom callback with signature void (PyHeapTypeObject*) that may be used to customize the Python type |
| CCustomGuard | |
| CCustomOperatorNew | |
| CD_Repeat | |
| CD_Tpl | |
| Cdeferred_type | Defer the evaluation of type T until types Us are instantiated |
| CDependentGuard | |
| Cdescr | |
| CDestructionTester | |
| Cdict | |
| Cdict_readonly | Python's dictionary protocol permits this to be a forward iterator |
| Cdifferent_resolutions | |
| CDispatchIssue | |
| Cdoc | Annotation for documentation |
| Cdocument_order_comparator | |
| CDog | |
| Cdtype | |
| CDtypeCheck | |
| CDtypeSizeCheck | |
| Cduration_caster | |
| Cdynamic_attr | Annotation which enables dynamic attributes, i.e. adds __dict__ to a class |
| CE_nc | Issue #487: binding std::vector<E> with E non-copyable |
| Ceigen_extract_stride | |
| Ceigen_extract_stride< Eigen::Map< PlainObjectType, MapOptions, StrideType > > | |
| Ceigen_extract_stride< Eigen::Ref< PlainObjectType, Options, StrideType > > | |
| Ceigen_map_caster | |
| Ceigen_tensor_helper | |
| ►Ceigen_tensor_helper< Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType > > | |
| Chelper | |
| Chelper< index_sequence< Is... > > | |
| Ceigen_tensor_helper< Eigen::TensorFixedSize< Scalar_, Eigen::Sizes< Indices... >, Options_, IndexType > > | |
| CEigenConformable | |
| CEigenProps | |
| CEl | |
| Cellipsis | |
| Cembedded_module | Python 2.7/3.x compatible version of PyImport_AppendInittab and error checks |
| Cempty | |
| Cenum_ | Binds C++ enumerations and enumeration classes to Python |
| Cenum_base | |
| Cequal_to | |
| Cequivalent_integer | |
| Cequivalent_integer< false, 1 > | |
| Cequivalent_integer< false, 2 > | |
| Cequivalent_integer< false, 4 > | |
| Cequivalent_integer< false, 8 > | |
| Cequivalent_integer< true, 1 > | |
| Cequivalent_integer< true, 2 > | |
| Cequivalent_integer< true, 4 > | |
| Cequivalent_integer< true, 8 > | |
| Cerror_already_set | Fetch and hold an error which was already set in Python |
| Cerror_fetch_and_normalize | |
| Cerror_scope | RAII wrapper that temporarily clears any Python error state |
| Cexactly_one | Return the one and only type which matches the predicate, or Default if none match |
| Cexactly_one< P, Default > | |
| CExampleMandA | |
| CExampleVirt | |
| Cexception | Wrapper to generate a new Python exception type |
| Cfactory | |
| Cfactory< CFunc, AFunc, CReturn(CArgs...), AReturn(AArgs...)> | |
| Cfactory< Func, void_type(*)(), Return(Args...)> | |
| Cfield_descriptor | |
| Cfloat_ | |
| Cformat_descriptor | |
| Cformat_descriptor< char[N]> | |
| Cformat_descriptor< std::array< char, N > > | |
| Cformat_descriptor< std::complex< T >, detail::enable_if_t< std::is_floating_point< T >::value > > | Glibc defines I as a macro which breaks things, e.g., boost template names |
| Cformat_descriptor< T, detail::enable_if_t< detail::array_info< T >::is_array > > | |
| Cformat_descriptor< T, detail::enable_if_t< detail::is_pod_struct< T >::value > > | |
| Cformat_descriptor< T, detail::enable_if_t< std::is_arithmetic< T >::value > > | |
| Cformat_descriptor< T, detail::enable_if_t< std::is_enum< T >::value > > | |
| Cfrozenset | |
| Cfunction | |
| Cfunction_call | Internal data associated with a single function call |
| Cfunction_record | Internal data structure which holds metadata about a bound function (signature, overloads, etc.) |
| Cgap | |
| Cgeneric_item | |
| Cgeneric_iterator | STL iterator template used for tuple, list, sequence and dict |
| Cgeneric_type | Generic support for creating new Python heap types |
| Cget_storage_pointer_type | |
| Cget_storage_pointer_type< MapType, void_t< typename MapType::PointerArgType > > | |
| Cget_storage_pointer_type< MapType, void_t< typename MapType::StoragePointerType > > | |
| Cget_tensor_descriptor | |
| Cgil_scoped_acquire | |
| Cgil_scoped_release | |
| Chandle | \rst Holds a reference to a Python object (no reference counting) |
| Chandle_type_name | |
| Chandle_type_name< args > | |
| Chandle_type_name< array > | |
| Chandle_type_name< array_t< T, Flags > > | |
| Chandle_type_name< bool_ > | |
| Chandle_type_name< bytes > | |
| Chandle_type_name< float_ > | |
| Chandle_type_name< int_ > | |
| Chandle_type_name< iterable > | |
| Chandle_type_name< iterator > | |
| Chandle_type_name< kwargs > | |
| Chandle_type_name< none > | |
| Chas_operator_delete | |
| Chas_operator_delete< T, void_t< decltype(static_cast< void(*)(void *)>(T::operator delete))> > | |
| Chas_operator_delete_size | |
| Chas_operator_delete_size< T, void_t< decltype(static_cast< void(*)(void *, size_t)>(T::operator delete))> > | |
| CHashMe | |
| Cholder_helper | Helper class which abstracts away certain actions |
| CIncType | Like UserType, but increments value on copy for quick reference vs. copy tests |
| Cindex_sequence | Index sequences |
| Cinstance | The 'instance' type which needs to be standard layout (need to be able to use 'offsetof') |
| Cint_ | |
| Cint_to_str | |
| Cint_to_str< 0, Digits... > | |
| Cinternals | Internal data structure used to track registered instances and types |
| CIntFloat | A simple union for basic testing |
| Cintrinsic_type | Helper template to strip away type modifiers |
| Cintrinsic_type< const T > | |
| Cintrinsic_type< const T[N]> | |
| Cintrinsic_type< T & > | |
| Cintrinsic_type< T && > | |
| Cintrinsic_type< T * > | |
| Cintrinsic_type< T[N]> | |
| Cis_comparable | |
| Cis_comparable< T, enable_if_t< container_traits< T >::is_element &&container_traits< T >::is_comparable > > | |
| Cis_comparable< T, enable_if_t< container_traits< T >::is_pair > > | |
| Cis_comparable< T, enable_if_t< container_traits< T >::is_vector > > | |
| Cis_complex | |
| Cis_complex< std::complex< T > > | |
| Cis_copy_assignable | |
| Cis_copy_assignable< Container, enable_if_t< all_of< std::is_copy_assignable< Container >, std::is_same< typename Container::value_type &, typename Container::reference > >::value > > | |
| Cis_copy_assignable< std::pair< T1, T2 > > | |
| Cis_copy_constructible | |
| Cis_copy_constructible< Container, enable_if_t< all_of< std::is_copy_constructible< Container >, std::is_same< typename Container::value_type &, typename Container::reference >, negation< std::is_same< Container, typename Container::value_type > > >::value > > | |
| Cis_copy_constructible< std::pair< T1, T2 > > | |
| Cis_final | Annotation for classes that cannot be subclassed |
| Cis_fmt_numeric | |
| Cis_fmt_numeric< std::complex< T >, detail::enable_if_t< std::is_floating_point< T >::value > > | |
| Cis_fmt_numeric< T, enable_if_t< std::is_arithmetic< T >::value > > | |
| Cis_holder_type | |
| Cis_holder_type< base, std::unique_ptr< base, deleter > > | |
| Cis_input_iterator | Check if T looks like an input iterator |
| Cis_input_iterator< T, void_t< decltype(*std::declval< T & >()), decltype(++std::declval< T & >())> > | |
| Cis_instantiation | Check if T is an instantiation of the template Class |
| Cis_instantiation< Class, Class< Us... > > | |
| Cis_method | Annotation for methods |
| Cis_new_style_constructor | Tag for a new-style __init__ defined in detail/init.h |
| Cis_operator | Annotation for operators |
| Cis_std_array | |
| Cis_std_array< std::array< T, N > > | |
| Cis_template_base_of_impl | |
| Citems_view | |
| CItemsViewImpl | |
| Citerable | |
| Citerator | \rst Wraps a Python iterator so that it can also be used as a C++ input iterator |
| Citerator_access | |
| Citerator_key_access | |
| Citerator_state | |
| Citerator_value_access | |
| Ckeep_alive | Keep patient alive while nurse lives |
| Ckeys_view | |
| CKeysViewImpl | |
| Ckw_only | Annotation indicating that all following arguments are keyword-only; the is the equivalent of an unnamed '*' argument (in Python 3) |
| Ckwargs | |
| Ckwargs_proxy | |
| CLabrador | |
| Clacking_copy_ctor | |
| Clacking_move_ctor | |
| Clatin1_decoder | |
| Clatin1_writer | |
| Cless | |
| Cless_equal | |
| Clist | |
| Clist_caster | |
| Clist_item | |
| Cloader_life_support | A life support system for temporary objects created by type_caster::load() |
| Clocal_internals | |
| CLocalBase | Simple class used to test py::local: |
| CLocalException | |
| CLocalSimpleException | |
| Cmake_index_sequence_impl | |
| Cmake_index_sequence_impl< 0, S... > | |
| Cmap_caster | |
| Cmemoryview | |
| Cmetaclass | Annotation which requests that a special metaclass is created for a type |
| CMixGL | |
| CMixGL2 | |
| ►Cmodule_ | Wrapper for Python extension modules |
| Cmodule_def | |
| Cmodule_local | Annotation that marks a class as local to the module: |
| CMovable | |
| Cmove_always | |
| Cmove_always< T, enable_if_t< all_of< move_is_plain_type< T >, negation< is_copy_constructible< T > >, std::is_move_constructible< T >, std::is_same< decltype(std::declval< make_caster< T > >().operator T&()), T & > >::value > > | |
| Cmove_if_unreferenced | |
| Cmove_if_unreferenced< T, enable_if_t< all_of< move_is_plain_type< T >, negation< move_always< T > >, std::is_move_constructible< T >, std::is_same< decltype(std::declval< make_caster< T > >().operator T&()), T & > >::value > > | |
| Cmove_only_holder_caster | Type caster for holder types like std::unique_ptr |
| CMoveOnlyInt | |
| CMoveOrCopyInt | |
| Cmulti_array_iterator | |
| Cmultiple_inheritance | Annotation indicating that a class is involved in a multiple inheritance relationship |
| CMyException | |
| CMyException2 | |
| CMyException3 | |
| CMyException4 | |
| CMyException5 | |
| CMyException5_1 | |
| CMyException6 | |
| Cname | Annotation for function names |
| Cname_null_sentry | |
| Cnamespace_uri_predicate | |
| CNCVirt | |
| CNCVirtTrampoline | |
| Cnegation | |
| CNoBraceInitialization | |
| Cnodelete | Dummy destructor wrapper that can be used to expose classes with a private destructor |
| CNonCopyable | |
| CNonCopyableInt | |
| Cnone | |
| CNoneCastTester | |
| CNoneTester | |
| CNonRefIterator | |
| Cnonsimple_values_and_holders | |
| CNonZeroIterator | |
| CNonZeroSentinel | |
| Cnot_equal_to | |
| ►Cnpy_api | |
| CPyArray_Dims | |
| Cnpy_format_descriptor | |
| Cnpy_format_descriptor< char[N]> | |
| Cnpy_format_descriptor< std::array< char, N > > | |
| Cnpy_format_descriptor< T, enable_if_t< array_info< T >::is_array > > | |
| Cnpy_format_descriptor< T, enable_if_t< satisfies_any_of< T, std::is_arithmetic, is_complex >::value > > | |
| Cnpy_format_descriptor< T, enable_if_t< std::is_enum< T >::value > > | |
| Cnpy_format_descriptor_name | |
| Cnpy_format_descriptor_name< T, enable_if_t< is_complex< T >::value > > | |
| Cnpy_format_descriptor_name< T, enable_if_t< std::is_floating_point< T >::value > > | |
| Cnpy_format_descriptor_name< T, enable_if_t< std::is_integral< T >::value > > | |
| Cnumpy_internals | |
| Cnumpy_type_info | |
| Cobj_attr | |
| CObject | Reference counted object base class |
| ►Cobject | \rst Holds a reference to a Python object (with reference counting) |
| Cborrowed_t | |
| Cstolen_t | |
| Cobject_api | \rst A mixin class which adds common functions to handle, object and various accessors |
| Cop_ | Operator implementation generator |
| Cop_impl | Base template of operator implementations |
| Copt_false | |
| Copt_true | |
| Coptional_caster | |
| COptionalHolder | |
| COptionalProperties | |
| ►Coptions | |
| Cstate | |
| COstreamRedirect | |
| Coverload_cast | |
| Coverload_cast_impl | |
| Coverride_hash | |
| Coverride_unused | |
| Cpack_element | Return the Nth element from the parameter pack |
| Cpack_element< 0, T, Ts... > | |
| CPanther | |
| CPartialNestedStruct | |
| CPartialStruct | |
| CPerfTester | Generate custom IPbus/uHAL tests from the command line |
| Cpickle_factory | Implementation for py::pickle(GetState, SetState) |
| Cpickle_factory< Get, Set, RetState(Self), NewInstance(ArgState)> | |
| Cpolymorphic_type_hook | |
| Cpolymorphic_type_hook_base | |
| Cpolymorphic_type_hook_base< itype, detail::enable_if_t< std::is_polymorphic< itype >::value > > | |
| Cpos_only | Annotation indicating that all previous arguments are positional-only; the is the equivalent of an unnamed '/' argument (in Python 3.8) |
| Cprepend | Mark a function for addition at the beginning of the existing overload chain instead of the end |
| Cprocess_attribute | Partial template specializations to process custom attributes provided to cpp_function_ and class_ |
| Cprocess_attribute< arg > | Process a keyword argument attribute (without a default value) |
| Cprocess_attribute< arg_v > | Process a keyword argument attribute (with a default value) |
| Cprocess_attribute< arithmetic > | Process an 'arithmetic' attribute for enums (does nothing here) |
| Cprocess_attribute< base< T > > | Process a parent class attribute (deprecated, does not support multiple inheritance) |
| Cprocess_attribute< buffer_protocol > | |
| Cprocess_attribute< call_guard< Ts... > > | |
| Cprocess_attribute< char * > | |
| Cprocess_attribute< const char * > | Process an attribute specifying the function's docstring (provided as a C-style string) |
| Cprocess_attribute< custom_type_setup > | |
| Cprocess_attribute< doc > | Process an attribute specifying the function's docstring |
| Cprocess_attribute< dynamic_attr > | |
| Cprocess_attribute< is_final > | |
| Cprocess_attribute< is_method > | Process an attribute which indicates that this function is a method |
| Cprocess_attribute< is_new_style_constructor > | |
| Cprocess_attribute< is_operator > | Process an attribute which indicates that this function is an operator |
| Cprocess_attribute< keep_alive< Nurse, Patient > > | Process a keep_alive call policy – invokes keep_alive_impl during the pre-call handler if both Nurse, Patient != 0 and use the post-call handler otherwise |
| Cprocess_attribute< kw_only > | Process a keyword-only-arguments-follow pseudo argument |
| Cprocess_attribute< metaclass > | |
| Cprocess_attribute< module_local > | |
| Cprocess_attribute< multiple_inheritance > | Process a multiple inheritance attribute |
| Cprocess_attribute< name > | Process an attribute specifying the function's name |
| Cprocess_attribute< pos_only > | Process a positional-only-argument maker |
| Cprocess_attribute< prepend > | Process a 'prepend' attribute, putting this at the beginning of the overload chain |
| Cprocess_attribute< return_value_policy > | Process an attribute indicating the function's return value policy |
| Cprocess_attribute< scope > | Process an attribute which indicates the parent scope of a method |
| Cprocess_attribute< sibling > | Process an attribute which indicates that this is an overloaded function associated with a given sibling |
| Cprocess_attribute< T, enable_if_t< is_pyobject< T >::value > > | Process a parent class attribute |
| Cprocess_attribute_default | |
| Cprocess_attributes | Recursively iterate over variadic template arguments |
| CPyA_Repeat | |
| CPyA_Tpl | |
| CPyArray_Proxy | |
| CPyArrayDescr_Proxy | |
| CPyB_Repeat | |
| CPyB_Tpl | |
| CPyC_Repeat | |
| CPyD_Repeat | |
| CPyExampleVirt | |
| Cpyobject_caster | |
| Cpyobject_caster< array_t< T, ExtraFlags > > | |
| Cpyobject_tag | Tag and check to identify a class which implements the Python object API |
| CPyTF6 | |
| CPyTF7 | |
| CPythonAlreadySetInDestructor | |
| Cpythonbuf | |
| CPythonCallInDestructor | |
| CPyVirtClass | |
| CPyVoidScalarObject_Proxy | |
| CPyWidget | |
| Cref | Reference counting helper |
| Cref_tag | |
| CReferenceSensitiveOptional | |
| CRefQualified | |
| CRegisteredDerived | |
| Cremove_class | Strip the class from a method type |
| Cremove_class< R(C::*)(A...) const > | |
| Cremove_class< R(C::*)(A...)> | |
| Cremove_cvref | |
| Creturn_value_policy_override | |
| Creturn_value_policy_override< Return, detail::enable_if_t< std::is_base_of< type_caster_generic, make_caster< Return > >::value, void > > | |
| CRValueCaster | Custom cast-only type that casts to a string "rvalue" or "lvalue" depending on the cast context |
| CRValueRefParam | |
| Csame_size | |
| Cscope | Annotation for parent scope |
| Cscope_exit | |
| Cscoped_estream_redirect | \rst Like scoped_ostream_redirect, but redirects cerr by default |
| Cscoped_interpreter | \rst Scope guard version of initialize_interpreter and finalize_interpreter |
| Cscoped_ostream_redirect | \rst This a move-only guard that redirects output |
| Cselect_indices_impl | Make an index sequence of the indices of true arguments |
| Cselect_indices_impl< index_sequence< IPrev... >, I, B, Bs... > | |
| Cself_t | |
| Csequence | |
| Csequence_fast_readonly | Lightweight iterator policy using just a simple pointer: see PySequence_Fast_ITEMS |
| Csequence_item | |
| Csequence_slow_readwrite | Full read and write access using the sequence protocol: see detail::sequence_accessor |
| Cset | |
| Cset_caster | |
| Cshared_exception | |
| Csibling | Annotation indicating that a function is an overload associated with a given "sibling" |
| Csimple_collector | Helper class which collects only positional arguments for a Python function call |
| CSimpleStruct | |
| CSimpleStructReordered | |
| Cslice | |
| Cstaticmethod | |
| Cstr | |
| Cstr_attr | |
| Cstrconv_attribute_impl | |
| Cstrconv_pcdata_impl | |
| Cstring_caster | |
| CStringStruct | |
| Cstrip_function_object | |
| CStrIssue | |
| Ctest_initializer | |
| Ctest_override_cache_helper | |
| Ctest_override_cache_helper_trampoline | |
| CTestFactory1 | |
| CTestFactory2 | |
| CTestFactory3 | |
| CTestFactory4 | |
| CTestFactory5 | |
| CTestFactory6 | |
| CTestFactory7 | |
| CTestFactoryHelper | |
| CTestProperties | |
| CTestPropertiesOverride | |
| CTestPropRVP | |
| CTestStruct | |
| CTestThread | |
| CTplCtorClass | Issue #528: templated constructor |
| Ctuple | |
| Ctuple_caster | |
| Ctuple_item | |
| Ctype | |
| Ctype_caster | |
| Ctype_caster< bool > | |
| Ctype_caster< CharT, enable_if_t< is_std_char_type< CharT >::value > > | |
| Ctype_caster< ConstRefCasted > | |
| Ctype_caster< CopyOnlyInt > | |
| Ctype_caster< Eigen::Ref< PlainObjectType, 0, StrideType >, enable_if_t< is_eigen_dense_map< Eigen::Ref< PlainObjectType, 0, StrideType > >::value > > | |
| Ctype_caster< Eigen::TensorMap< Type, Options >, typename eigen_tensor_helper< remove_cv_t< Type > >::ValidType > | |
| Ctype_caster< MoveOnlyInt > | |
| Ctype_caster< MoveOrCopyInt > | |
| Ctype_caster< RValueCaster > | |
| Ctype_caster< std::array< Type, Size > > | |
| Ctype_caster< std::basic_string< CharT, Traits, Allocator >, enable_if_t< is_std_char_type< CharT >::value > > | |
| Ctype_caster< std::chrono::duration< Rep, Period > > | |
| Ctype_caster< std::chrono::time_point< Clock, Duration > > | |
| Ctype_caster< std::chrono::time_point< std::chrono::system_clock, Duration > > | |
| Ctype_caster< std::complex< T > > | |
| Ctype_caster< std::deque< Type, Alloc > > | |
| Ctype_caster< std::function< Return(Args...)> > | |
| Ctype_caster< std::list< Type, Alloc > > | |
| Ctype_caster< std::map< Key, Value, Compare, Alloc > > | |
| Ctype_caster< std::nullptr_t > | |
| Ctype_caster< std::pair< T1, T2 > > | |
| Ctype_caster< std::reference_wrapper< type > > | |
| Ctype_caster< std::set< Key, Compare, Alloc > > | |
| Ctype_caster< std::shared_ptr< T > > | Specialize for the common std::shared_ptr, so users don't need to |
| Ctype_caster< std::tuple< Ts... > > | |
| Ctype_caster< std::unique_ptr< type, deleter > > | |
| Ctype_caster< std::unordered_map< Key, Value, Hash, Equal, Alloc > > | |
| Ctype_caster< std::unordered_set< Key, Hash, Equal, Alloc > > | |
| Ctype_caster< std::valarray< Type > > | |
| Ctype_caster< std::vector< Type, Alloc > > | |
| Ctype_caster< T, enable_if_t< is_pyobject< T >::value > > | |
| Ctype_caster< T, enable_if_t< std::is_arithmetic< T >::value &&!is_std_char_type< T >::value > > | |
| Ctype_caster< Type, enable_if_t< is_eigen_dense_map< Type >::value > > | |
| Ctype_caster< Type, enable_if_t< is_eigen_dense_plain< Type >::value > > | |
| Ctype_caster< Type, enable_if_t< is_eigen_other< Type >::value > > | |
| Ctype_caster< Type, enable_if_t< is_eigen_sparse< Type >::value > > | |
| Ctype_caster< Type, typename eigen_tensor_helper< Type >::ValidType > | |
| Ctype_caster< unchecked_mutable_reference< T, Dim > > | |
| Ctype_caster< unchecked_reference< T, Dim > > | |
| Ctype_caster< value_and_holder > | |
| Ctype_caster< void > | |
| Ctype_caster< void_type > | |
| Ctype_caster_base | Generic type caster for objects stored on the heap |
| Ctype_caster_generic | |
| Ctype_equal_to | |
| Ctype_hash | |
| Ctype_info | Additional type information which does not fit into the PyTypeObject |
| Ctype_list | Helper template which holds a list of types |
| Ctype_record | Special data structure which (temporarily) holds metadata about a bound class |
| CUnboundStruct | |
| Cunchecked_mutable_reference | |
| Cunchecked_reference | Proxy class providing unsafe, unchecked const access to array data |
| Cundefined_t | Type for an unused type slot |
| Cunpacking_collector | Helper class which collects positional, keyword, * and ** arguments for a Python function call |
| CUnregisteredBase | |
| CUnregisteredType | Dummy type which is not exported anywhere – something to trigger a conversion error |
| CUserType | A user-defined type which is exported and can be used by any test |
| Cutf16_counter | |
| Cutf16_decoder | |
| Cutf16_writer | |
| Cutf32_counter | |
| Cutf32_decoder | |
| Cutf32_writer | |
| Cutf8_counter | |
| Cutf8_decoder | |
| Cutf8_writer | |
| Cvalue_and_holder | |
| ►Cvalues_and_holders | |
| Citerator | |
| Cvalues_view | |
| CValuesViewImpl | |
| Cvariant_caster | Generic variant caster |
| Cvariant_caster< V< Ts... > > | |
| Cvariant_caster_visitor | Visit a variant and cast any found type to Python |
| CVector2 | |
| Cvector_has_data_and_format | |
| Cvector_has_data_and_format< Vector, enable_if_t< std::is_same< decltype(format_descriptor< typename Vector::value_type >::format(), std::declval< Vector >().data()), typename Vector::value_type * >::value > > | |
| Cvectorize_arg | |
| Cvectorize_helper | |
| Cvectorize_returned_array | |
| Cvectorize_returned_array< Func, void, Args... > | |
| CVirtClass | |
| Cvisit_helper | Helper class which abstracts away variant's visit function |
| Cvoid_caster | |
| Cvoid_t_impl | |
| Cvoid_type | Helper type to replace 'void' in some expressions |
| Cwchar_decoder | |
| Cwchar_selector | |
| Cwchar_selector< 2 > | |
| Cwchar_selector< 4 > | |
| Cweakref | |
| Cwide_char_arg_deleter | |
| CWidget | |
| Cxml_allocator | |
| Cxml_buffered_writer | |
| Cxml_document_struct | |
| Cxml_extra_buffer | |
| Cxml_memory_management_function_storage | |
| Cxml_memory_page | |
| Cxml_memory_string_header | |
| Cxml_parser | |
| Cxml_stream_chunk | |
| Cxpath_allocator | |
| Cxpath_allocator_capture | |
| Cxpath_ast_node | |
| Cxpath_context | |
| Cxpath_lexer | |
| Cxpath_lexer_string | |
| Cxpath_memory_block | |
| Cxpath_node_set_raw | |
| ►Cxpath_parser | |
| Cbinary_op_t | |
| Cxpath_query_impl | |
| Cxpath_stack | |
| Cxpath_stack_data | |
| Cxpath_string | |
| Cxpath_variable_boolean | |
| Cxpath_variable_node_set | |
| Cxpath_variable_number | |
| Cxpath_variable_string | |
1.9.5
