| ►C_build_ext | |
| Cpybind11.setup_helpers.build_ext | |
| Cpybind11.setup_helpers.build_ext | |
| ►C_Extension | |
| Cpybind11.setup_helpers.Pybind11Extension | |
| Cpybind11.setup_helpers.Pybind11Extension | |
| Cuhal::_Type< T > | |
| ►Cuhal::_ValHeader_ | A helper struct wrapping an IPbus header and a valid flag |
| Cuhal::_ValVector_< T > | A Template helper struct wrapping a block of IPbus header, a register for storing a block of data and a valid flag |
| Cuhal::_ValWord_< T > | 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 |
| CA | |
| ►CA_Repeat | |
| ►CB_Repeat | |
| ►CC_Repeat | |
| ►CD_Repeat | |
| CPyD_Repeat | |
| CPyD_Repeat | |
| CD_Repeat | |
| CPyC_Repeat | |
| CPyC_Repeat | |
| CC_Repeat | |
| CPyB_Repeat | |
| CPyB_Repeat | |
| CB_Repeat | |
| CPyA_Repeat | |
| CPyA_Repeat | |
| ►CA_Tpl | |
| ►CB_Tpl | |
| CPyA_Tpl< B_Tpl > | |
| CPyA_Tpl< B_Tpl > | |
| ►CC_Tpl | |
| CD_Tpl | |
| CD_Tpl | |
| CC_Tpl | |
| CB_Tpl | |
| ►CPyA_Tpl< Base > | |
| CPyB_Tpl< Base > | |
| CPyB_Tpl< Base > | |
| CPyA_Tpl< Base > | |
| ►Cuhal::tests::AbstractFixture | |
| Cuhal::tests::DummyAddressFileFixture | Fixture for tests based on 'dummy' address files |
| ►Cuhal::tests::MinimalFixture< type > | |
| Cuhal::tests::DummyHardwareFixture< type > | |
| Cuhal::tests::MinimalFixture< IPBUS_2_0_PCIE > | |
| ►CAdderBase | |
| CAdder | |
| CAdder | |
| Cuhal::tests::AddressTableOverlapFixture | |
| Calias_constructor< Args > | |
| ►Call_of | |
| Cis_copy_assignable< std::pair< T1, T2 > > | |
| Cis_copy_assignable< std::pair< T1, T2 > > | |
| Cis_copy_constructible< std::pair< T1, T2 > > | |
| Cis_copy_constructible< std::pair< T1, T2 > > | |
| Calways_construct_holder< T, Value > | |
| ►CAnimal | |
| ►CCat | |
| CPanther | |
| CPanther | |
| CCat | |
| ►CDog | |
| CChihuahua | |
| CChihuahua | |
| CLabrador | |
| CLabrador | |
| CDog | |
| Cany_container< T > | |
| ►Cdetail::any_of | |
| Cclass_< type_, options >::is_valid_class_option< T > | |
| Cclass_< type_, options >::is_valid_class_option< T > | |
| ►Carg | Annotation for arguments |
| Carg_v | Annotation for arguments with values |
| Carg_v | Annotation for arguments with values |
| CArgAlwaysConverts | |
| CArgInspector1 | |
| CArgInspector2 | |
| Cargument_loader< Args > | 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_caster< ArrayType, Value, Resizable, Size > | |
| ►Carray_caster< std::array< Type, Size >, Type, false, Size > | |
| Ctype_caster< std::array< Type, Size > > | |
| Ctype_caster< std::array< Type, Size > > | |
| ►Carray_caster< std::valarray< Type >, Type, true > | |
| Ctype_caster< std::valarray< Type > > | |
| Ctype_caster< std::valarray< Type > > | |
| ►Carray_info< std::array< T, N > > | |
| Carray_info< T[N]> | |
| Carray_info< T[N]> | |
| ►Carray_info_scalar< T > | |
| Carray_info< T > | |
| Carray_info< T > | |
| ►Carray_info_scalar< char[N]> | |
| Carray_info< char[N]> | |
| Carray_info< char[N]> | |
| ►Carray_info_scalar< std::array< char, N > > | |
| Carray_info< std::array< char, N > > | |
| Carray_info< std::array< char, N > > | |
| CArrayStruct | |
| Carrow_proxy< T > | Quick proxy class needed to implement operator-> for iterators which can't return pointers |
| Cauto_deleter< T > | |
| Caxis_to_type< N > | |
| CB | |
| ►CBase | |
| CDispatchIssue | |
| CDispatchIssue | |
| Cbase< T > | Annotation indicating that a class derives from another given type |
| ►Cuhal::BaseFunctionObject< R > | Abstract base class for wrapping function pointers, function objects and bound functions as objects |
| Cuhal::FunctionObject< R, T > | Class for wrapping bound functions and function objects as an object |
| Cuhal::FunctionObject< R, T * > | Class for wrapping function pointer as an object |
| Cuhal::BaseLogLevel< T > | |
| ►Cuhal::BaseLogLevel< DebugLevel > | |
| Cuhal::DebugLevel | Helper struct representing the Debug log level to allow us to specialize functions according to their log level |
| ►Cuhal::BaseLogLevel< ErrorLevel > | |
| Cuhal::ErrorLevel | Helper struct representing the Error log level to allow us to specialize functions according to their log level |
| ►Cuhal::BaseLogLevel< FatalLevel > | |
| Cuhal::FatalLevel | Helper struct representing the Fatal log level to allow us to specialize functions according to their log level |
| ►Cuhal::BaseLogLevel< InfoLevel > | |
| Cuhal::InfoLevel | Helper struct representing the Info log level to allow us to specialize functions according to their log level |
| ►Cuhal::BaseLogLevel< NoticeLevel > | |
| Cuhal::NoticeLevel | Helper struct representing the Notice log level to allow us to specialize functions according to their log level |
| ►Cuhal::BaseLogLevel< WarningLevel > | |
| Cuhal::WarningLevel | Helper struct representing the Warning log level to allow us to specialize functions according to their log level |
| Cxpath_parser::binary_op_t | |
| ►Cbool_constant | |
| Cnegation< T > | |
| Cnegation< T > | |
| Cbools<... > | Compile-time all/any/none of that check the boolean value of all template types |
| Cobject::borrowed_t | |
| ►CBreaksBase< N > | |
| CBreaksTramp< N > | |
| CBreaksTramp< N > | |
| Cbuffer_info | Information record describing a Python buffer object |
| Cbuffer_protocol | Annotation which enables the buffer protocol for a type |
| Cuhal::Buffers | A class wrapping the send and recieve buffers that are to be filled and transported and the validated memories associated with them |
| ►Cpybind11::builtin_exception | |
| Cshared_exception | |
| Cshared_exception | |
| Ctest_exc_sp::C | |
| CC1 | |
| CC2 | |
| Ccall_guard< Ts > | \rst A call policy which places one or more guard variables (Ts...) around the function call |
| Ccall_guard< T > | |
| Ccall_guard< T, Ts... > | |
| Ccall_guard< Ts... > | |
| Ccall_guard<> | |
| Cuhal::ClientFactory | 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! |
| Cuhal::ClientFactory::ClientInfo | |
| ►Cuhal::ClientInterface | An abstract base class for defining the interface to the various IPbus clients as well as providing the generalized packing functionality |
| ►Cuhal::IPbusCore | A class providing the core IPbus packing functionality |
| Cuhal::IPbus< 1, IPbus_minor > | A class which provides the version-specific functionality for IPbus |
| Cuhal::IPbus< 2, IPbus_minor > | A class which provides the version-specific functionality for IPbus |
| Cuhal::tests::DummyClient | Empty client class, written to test registration |
| Ccommon_iterator | |
| Ccompare_buffer_info< T, SFINAE > | |
| 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 | |
| Cuhal::ConnectionManager::ConnectionDescriptor | A struct to hold the fields of each entry in the XML connections file |
| Cuhal::ConnectionManager | A class to open and manage XML connection files and wrap up the interfaces to the NodeTreeBuilder and the ClientFactory |
| CConstRefCasted | |
| Cconstructor< Args > | |
| CConstructorStats | |
| Ccontainer_traits< T > | |
| CCopyOnlyInt | |
| ►Cuhal::ClientFactory::CreatorInterface | An abstract base class for defining the interface to the creators |
| Cuhal::ClientFactory::Creator< T > | Templated concrete implementation with a CreatorInterface interface |
| ►Cuhal::DerivedNodeFactory::CreatorInterface | An abstract base class for defining the interface to the creators |
| Cuhal::DerivedNodeFactory::Creator< T > | Templated concrete implementation with a CreatorInterface interface |
| Ccustom_type_setup | Specifies a custom callback with signature void (PyHeapTypeObject*) that may be used to customize the Python type |
| Ctest_pytypes.CustomContains | |
| CCustomGuard | |
| CCustomOperatorNew | |
| CAdderBase::Data | |
| Cdeferred_type< T,... > | Defer the evaluation of type T until types Us are instantiated |
| CDependentGuard | |
| Cuhal::DerivedNodeFactory | 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! |
| Cdescr< N, Ts > | |
| CDestructionTester | |
| Cdict_readonly | Python's dictionary protocol permits this to be a forward iterator |
| Cdifferent_resolutions | |
| Cdoc | Annotation for documentation |
| Cdocument_order_comparator | |
| CDtypeCheck | |
| CDtypeSizeCheck | |
| ►Cuhal::tests::DummyHardwareInterface | Common abstract base class for IPbus 1.3 and 2.0 dummy hardware |
| ►Cuhal::tests::DummyHardware< 2, 0 > | |
| Cuhal::tests::PCIeDummyHardware | |
| ►Cuhal::tests::DummyHardware< IPbus_major, IPbus_minor > | Abstract base class to emulate IPbus hardware |
| Cuhal::tests::TCPDummyHardware< IPbus_major, IPbus_minor > | Concrete implementation of emulator of hardware using TCP |
| Cuhal::tests::UDPDummyHardware< IPbus_major, IPbus_minor > | Concrete implementation of emulator of hardware using UDP |
| Cuhal::tests::DummyHardwareOptions | Struct to store the dummy hardware command line options |
| Cuhal::tests::DummyHardwareRunner | |
| Cduration_caster< type > | |
| ►Cduration_caster< std::chrono::duration< Rep, Period > > | |
| Ctype_caster< std::chrono::duration< Rep, Period > > | |
| Ctype_caster< std::chrono::duration< Rep, Period > > | |
| ►Cduration_caster< std::chrono::time_point< Clock, Duration > > | |
| Ctype_caster< std::chrono::time_point< Clock, Duration > > | |
| Ctype_caster< std::chrono::time_point< Clock, Duration > > | |
| 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< Type > | |
| Ceigen_extract_stride< Eigen::Map< PlainObjectType, MapOptions, StrideType > > | |
| Ceigen_extract_stride< Eigen::Ref< PlainObjectType, Options, StrideType > > | |
| Ceigen_map_caster< MapType > | |
| ►Ceigen_map_caster< Eigen::Ref< PlainObjectType, 0, StrideType > > | |
| Ctype_caster< Eigen::Ref< PlainObjectType, 0, StrideType >, enable_if_t< is_eigen_dense_map< Eigen::Ref< PlainObjectType, 0, StrideType > >::value > > | |
| Ctype_caster< Eigen::Ref< PlainObjectType, 0, StrideType >, enable_if_t< is_eigen_dense_map< Eigen::Ref< PlainObjectType, 0, StrideType > >::value > > | |
| ►Ceigen_map_caster< Type > | |
| Ctype_caster< Type, enable_if_t< is_eigen_dense_map< Type >::value > > | |
| Ctype_caster< Type, enable_if_t< is_eigen_dense_map< Type >::value > > | |
| Ceigen_tensor_helper< T > | |
| Ceigen_tensor_helper< Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType > > | |
| Ceigen_tensor_helper< Eigen::TensorFixedSize< Scalar_, Eigen::Sizes< Indices... >, Options_, IndexType > > | |
| CEigenConformable< EigenRowMajor > | |
| CEigenProps< Type_ > | |
| CEl | |
| Cembedded_module | Python 2.7/3.x compatible version of PyImport_AppendInittab and error checks |
| Cempty< derived > | |
| ►Cempty< lacking_copy_ctor > | |
| Clacking_copy_ctor | |
| Clacking_copy_ctor | |
| ►Cempty< lacking_move_ctor > | |
| Clacking_move_ctor | |
| Clacking_move_ctor | |
| Cenum_base | |
| Cequal_to | |
| Cequivalent_integer< is_signed, length > | |
| 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_fetch_and_normalize | |
| Cerror_scope | RAII wrapper that temporarily clears any Python error state |
| Cexactly_one< Predicate, Default, Ts > | Return the one and only type which matches the predicate, or Default if none match |
| Cexactly_one< P, Default > | |
| CExampleMandA | |
| ►CExampleVirt | |
| CPyExampleVirt | |
| CPyExampleVirt | |
| ►CException | |
| Ctest_exceptions.FlakyException | |
| ►Cstd::exception | |
| CLocalException | |
| CLocalException | |
| CLocalSimpleException | |
| CLocalSimpleException | |
| CMyException | |
| CMyException | |
| CMyException2 | |
| CMyException2 | |
| CMyException4 | |
| CMyException4 | |
| CMyException6 | |
| CMyException6 | |
| Cerror_already_set | Fetch and hold an error which was already set in Python |
| Cpugi::xpath_exception | |
| Cuhal::exception::exception | An abstract base exception class, including an interface to throw as the derived type (for passing exceptions between threads) |
| Cfactory< CFunc, AFunc, typename, typename > | |
| Cfactory< CFunc, AFunc, CReturn(CArgs...), AReturn(AArgs...)> | |
| Cfactory< Func, void_type(*)(), Return(Args...)> | |
| ►Cstd::false_type | |
| Chas_operator_delete< T, SFINAE > | |
| Chas_operator_delete< T, SFINAE > | |
| Chas_operator_delete_size< T, SFINAE > | |
| Chas_operator_delete_size< T, SFINAE > | |
| Cis_comparable< T, SFINAE > | |
| Cis_comparable< T, SFINAE > | |
| Cis_complex< T > | |
| Cis_complex< T > | |
| Cis_input_iterator< T, typename > | Check if T looks like an input iterator |
| Cis_input_iterator< T, typename > | Check if T looks like an input iterator |
| Cis_instantiation< Class, T > | Check if T is an instantiation of the template Class |
| Cis_instantiation< Class, T > | Check if T is an instantiation of the template Class |
| Cis_std_array< T > | |
| Cis_std_array< T > | |
| Cmove_always< T, SFINAE > | |
| Cmove_always< T, SFINAE > | |
| Cmove_if_unreferenced< T, SFINAE > | |
| Cmove_if_unreferenced< T, SFINAE > | |
| Cvector_has_data_and_format< Vector, typename > | |
| Cvector_has_data_and_format< Vector, typename > | |
| Cfield_descriptor | |
| Cuhal::Mmap::File | |
| Cuhal::PCIe::File | |
| Cformat_descriptor< T, SFINAE > | |
| 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 > > | |
| 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 | |
| ►Cdetail::generic_type | |
| ►Cclass_< Type > | |
| Cenum_< Type > | Binds C++ enumerations and enumeration classes to Python |
| Cenum_< Type > | Binds C++ enumerations and enumeration classes to Python |
| Cclass_< Type > | |
| Cclass_< type_, options > | |
| Cclass_< type_, options > | |
| Cget_storage_pointer_type< T, typename > | |
| Cget_storage_pointer_type< MapType, void_t< typename MapType::PointerArgType > > | |
| Cget_storage_pointer_type< MapType, void_t< typename MapType::StoragePointerType > > | |
| Cget_tensor_descriptor< Type, ShowDetails, NeedsWriteable > | |
| Cgil_scoped_acquire | |
| Cgil_scoped_release | |
| ►Cboost::spirit::qi::grammar | |
| Cuhal::grammars::NodeTreeParametersGrammar | A struct wrapping a set of rules as a grammar that can parse a NodeTreeParametersGrammar of the form "name1=val1;name2=val2;name3=val3" |
| Cuhal::grammars::SemicolonDelimitedUriListGrammar | The BOOST::SPIRIT grammar for parsing the Semicolon delimited URI list into a vector of protocol-URI pairs |
| Chandle_type_name< T > | |
| 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 > | |
| Cstd::hash< HashMe > | |
| Cstd::hash< TplCtorClass > | |
| Cstd::hash< Vector2 > | |
| CHashMe | |
| Ceigen_tensor_helper< Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType > >::helper< T > | |
| Ceigen_tensor_helper< Eigen::Tensor< Scalar_, NumIndices_, Options_, IndexType > >::helper< index_sequence< Is... > > | |
| Cuhal::Mmap::HexTo< T > | |
| Cholder_helper< T > | Helper class which abstracts away certain actions |
| Cpybind11::detail::holder_helper< ref< T > > | |
| CPYBIND11_NAMESPACE::detail::holder_helper< ref< T > > | |
| ►Cuhal::HostToTargetInspector< IPbus_major, IPbus_minor > | Helper class to decode IPbus packets as passed from the Client to the Target |
| Cuhal::tests::DummyHardware< 2, 0 > | |
| Cuhal::tests::DummyHardware< IPbus_major, IPbus_minor > | Abstract base class to emulate IPbus hardware |
| Cuhal::HttpResponseType | Struct to store an http response received from a server when parsed by boost spirit |
| Cuhal::HwInterface | A class which bundles a node tree and an IPbus client interface together providing everything you need to navigate and perform hardware access |
| Cindex_sequence<... > | Index sequences |
| Ccpp_function::InitializingFunctionRecordDeleter | |
| ►CInnerProtocol | |
| Cuhal::ControlHub< InnerProtocol > | Transport protocol to transfer an IPbus buffer via ControlHub |
| Cuhal::TCP< InnerProtocol, nr_buffers_per_send > | Transport protocol to transfer an IPbus buffer via TCP |
| Cuhal::UDP< InnerProtocol > | Transport protocol to transfer an IPbus buffer via UDP |
| Cinstance | The 'instance' type which needs to be standard layout (need to be able to use 'offsetof') |
| Cint_to_str< Rem, Digits > | |
| Cint_to_str< 0, Digits... > | |
| Cinternals | Internal data structure used to track registered instances and types |
| CIntFloat | A simple union for basic testing |
| Cuhal::IntFmt< BASE, FORMAT, WIDTH > | Empty struct which acts as a dummy variable for passing the formatting information around |
| Cintrinsic_type< T > | 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]> | |
| Cuhal::IPbus< IPbus_major, IPbus_minor > | A class which provides the version-specific functionality for IPbus |
| ►Cuhal::IPbus< 2, 0 > | |
| Cuhal::Mmap | Transport protocol to transfer an IPbus buffer via device file, using mmap |
| Cuhal::PCIe | Transport protocol to transfer an IPbus buffer via PCIe |
| ►Cstd::is_base_of | |
| Cis_holder_type< base, holder > | |
| Cis_holder_type< base, holder > | |
| Cis_comparable< T, enable_if_t< container_traits< T >::is_pair > > | |
| Cis_comparable< T, enable_if_t< container_traits< T >::is_vector > > | |
| ►Cstd::is_copy_assignable | |
| ►Cis_copy_assignable< Container::value_type > | |
| 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< 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< Container::value_type > | |
| Cis_copy_assignable< T, SFINAE > | |
| Cis_copy_assignable< T, SFINAE > | |
| ►Cstd::is_copy_constructible | |
| ►Cis_copy_constructible< Container::value_type > | |
| 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< 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< Container::value_type > | |
| Cis_copy_constructible< T, SFINAE > | |
| Cis_copy_constructible< T, SFINAE > | |
| Cis_final | Annotation for classes that cannot be subclassed |
| Cis_fmt_numeric< T, SFINAE > | |
| 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_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_template_base_of_impl< Base > | |
| Citems_view< Map > | |
| ►CItemsView | |
| CItemsViewImpl< Map, ItemsView > | |
| ►Cstd::iterator | |
| Cuhal::Node::const_iterator | |
| Cvalues_and_holders::iterator | |
| Citerator_access< Iterator, SFINAE > | |
| Citerator_key_access< Iterator, SFINAE > | |
| Citerator_state< Access, Policy, Iterator, Sentinel, ValueType, Extra > | |
| Citerator_value_access< Iterator, SFINAE > | |
| Ckeep_alive< Nurse, Patient > | Keep patient alive while nurse lives |
| Ckeys_view< Map > | |
| ►CKeysView | |
| CKeysViewImpl< Map, KeysView > | |
| Ckw_only | Annotation indicating that all following arguments are keyword-only; the is the equivalent of an unnamed '*' argument (in Python 3) |
| Clatin1_decoder | |
| Clatin1_writer | |
| Cless | |
| Cless_equal | |
| Clist_caster< Type, Value > | |
| ►Clist_caster< std::deque< Type, Alloc >, Type > | |
| Ctype_caster< std::deque< Type, Alloc > > | |
| Ctype_caster< std::deque< Type, Alloc > > | |
| ►Clist_caster< std::list< Type, Alloc >, Type > | |
| Ctype_caster< std::list< Type, Alloc > > | |
| Ctype_caster< std::list< Type, Alloc > > | |
| ►Clist_caster< std::vector< Type, Alloc >, Type > | |
| Ctype_caster< std::vector< Type, Alloc > > | |
| Ctype_caster< std::vector< Type, Alloc > > | |
| Clist_item | |
| Cloader_life_support | A life support system for temporary objects created by type_caster::load() |
| Clocal_internals | |
| CLocalBase< int > | Simple class used to test py::local: |
| Cuhal::Location | A class to wrap the function name, filename and line-number location of its construction for the purpose of debugging and tracking unwinding exceptions |
| Cuhal::log_configuration | Class to restrict access to the log configuration parameters |
| ►Cstd::logic_error | |
| ►CMyException5 | |
| CMyException5_1 | |
| CMyException5_1 | |
| CMyException5 | |
| Cmake_index_sequence_impl< N, S > | |
| Cmake_index_sequence_impl< 0, S... > | |
| Cmap_caster< Type, Key, Value > | |
| ►Cmap_caster< std::map< Key, Value, Compare, Alloc >, Key, Value > | |
| Ctype_caster< std::map< Key, Value, Compare, Alloc > > | |
| Ctype_caster< std::map< Key, Value, Compare, Alloc > > | |
| ►Cmap_caster< std::unordered_map< Key, Value, Hash, Equal, Alloc >, Key, Value > | |
| Ctype_caster< std::unordered_map< Key, Value, Hash, Equal, Alloc > > | |
| Ctype_caster< std::unordered_map< Key, Value, Hash, Equal, Alloc > > | |
| Cmetaclass | Annotation which requests that a special metaclass is created for a type |
| CMixGL | |
| CMixGL2 | |
| Cmodule_::module_def | |
| Cmodule_local | Annotation that marks a class as local to the module: |
| CMovable | |
| Cmove_only_holder_caster< type, holder_type, SFINAE > | Type caster for holder types like std::unique_ptr |
| ►Cmove_only_holder_caster< type, std::unique_ptr< type, deleter > > | |
| Ctype_caster< std::unique_ptr< type, deleter > > | |
| Ctype_caster< std::unique_ptr< type, deleter > > | |
| CMoveOnlyInt | |
| CMoveOrCopyInt | |
| Cmulti_array_iterator< N > | |
| Cmultiple_inheritance | Annotation indicating that a class is involved in a multiple inheritance relationship |
| ►Cother_lib::my_caster | |
| CPYBIND11_NAMESPACE::detail::type_caster< other_lib::MyType > | |
| Cpybind11::detail::type_caster< other_lib::MyType > | |
| CMyException3 | |
| Cother_lib::MyType | |
| Cname | Annotation for function names |
| Cname_null_sentry | |
| Cnamespace_uri_predicate | |
| ►CNCVirt | |
| CNCVirtTrampoline | |
| CNCVirtTrampoline | |
| CNoBraceInitialization | |
| ►Cuhal::Node | A heirarchical node for navigating heirarchical firmwares |
| ►Cuhal::tests::DummyParentNode | |
| Cuhal::tests::DummyChildNode | Class further derived from Level1 |
| Cnodelete | Dummy destructor wrapper that can be used to expose classes with a private destructor |
| Cuhal::tests::NodeProperties | |
| Cuhal::NodeTreeBuilder | A class to build a node tree from an address table file |
| Cuhal::NodeTreeClassAttribute | 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 |
| Cuhal::NodeTreeFirmwareInfoAttribute | 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 |
| CNonCopyable | |
| CNonCopyableInt | |
| CNoneCastTester | |
| CNoneTester | |
| CNonRefIterator< T > | |
| Cnonsimple_values_and_holders | |
| CNonZeroIterator< T > | |
| CNonZeroSentinel | |
| Cnot_equal_to | |
| Cnpy_api | |
| Cnpy_format_descriptor< T, SFINAE > | |
| 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< std::is_enum< T >::value > > | |
| ►Cnpy_format_descriptor_name< T, typename > | |
| Cnpy_format_descriptor< T, enable_if_t< satisfies_any_of< T, std::is_arithmetic, is_complex >::value > > | |
| Cnpy_format_descriptor< T, enable_if_t< satisfies_any_of< T, std::is_arithmetic, is_complex >::value > > | |
| 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 |
| ►Cpybind11::object | |
| Cexternal::float_ | |
| Cpybind11.setup_helpers.ParallelCompile | |
| ►Cdetail::object_api | |
| ►Chandle | \rst Holds a reference to a Python object (no reference counting) |
| Cargs_proxy | |
| Cargs_proxy | |
| Ckwargs_proxy | |
| Ckwargs_proxy | |
| ►Cobject | \rst Holds a reference to a Python object (with reference counting) |
| ►Canyset | |
| Cfrozenset | |
| Cset | |
| Cbool_ | |
| Cbool_ | |
| ►Cbuffer | |
| ►Carray | |
| Carray_t< Scalar, array::forcecast|((props::row_major ? props::inner_stride :props::outer_stride)==1 ? array::c_style :(props::row_major ? props::outer_stride :props::inner_stride)==1 ? array::f_style :0)> | |
| Carray_t< Scalar, array::forcecast|((props::row_major ? props::inner_stride :props::outer_stride)==1 ? array::c_style :(props::row_major ? props::outer_stride :props::inner_stride)==1 ? array::f_style :0)> | |
| Carray_t< T, ExtraFlags > | |
| Carray_t< T, ExtraFlags > | |
| Carray | |
| Cbuffer | |
| Cbytearray | |
| Cbytearray | |
| Cbytes | |
| Cbytes | |
| Ccapsule | |
| Ccapsule | |
| Cconftest.Capture | |
| ►Cconftest.Output | |
| Cconftest.Unordered | |
| Cconftest.Unordered | |
| Cconftest.SanitizedString | |
| ►Cdict | |
| Ckwargs | |
| Ckwargs | |
| Cdict | |
| Cdtype | |
| Cdtype | |
| Cellipsis | |
| Cellipsis | |
| Cexception< type > | Wrapper to generate a new Python exception type |
| Cexception< type > | Wrapper to generate a new Python exception type |
| Cfloat_ | |
| Cfloat_ | |
| ►Cfunction | |
| Ccpp_function | Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object |
| Ccpp_function | Wraps an arbitrary C++ function/method/lambda function/.. into a callable Python object |
| Cfunction | |
| Cgeneric_type | Generic support for creating new Python heap types |
| Cgeneric_type | Generic support for creating new Python heap types |
| Cint_ | |
| Cint_ | |
| Citerable | |
| Citerable | |
| Citerator | \rst Wraps a Python iterator so that it can also be used as a C++ input iterator |
| Citerator | \rst Wraps a Python iterator so that it can also be used as a C++ input iterator |
| Clist | |
| Clist | |
| Cmemoryview | |
| Cmemoryview | |
| Cmodule_ | Wrapper for Python extension modules |
| Cmodule_ | Wrapper for Python extension modules |
| Cnone | |
| Cnone | |
| Csequence | |
| Csequence | |
| Cset | |
| Cslice | |
| Cslice | |
| Cstaticmethod | |
| Cstaticmethod | |
| Cstr | |
| Cstr | |
| ►Ctuple | |
| Cargs | |
| Cargs | |
| Ctuple | |
| Ctype | |
| Ctype | |
| Cweakref | |
| Cweakref | |
| Cobject | \rst Holds a reference to a Python object (with reference counting) |
| Chandle | \rst Holds a reference to a Python object (no reference counting) |
| Cop_< id, ot, L, R > | Operator implementation generator |
| Cop_impl< op_id, op_type, B, L, R > | Base template of operator implementations |
| Chandle_from_move_only_type_with_operator_PyObject::operator_const | |
| Chandle_from_move_only_type_with_operator_PyObject::operator_ncnst | |
| Copt_false | |
| Copt_true | |
| Coptional_caster< Type, Value > | |
| ►Coptional_caster< ReferenceSensitiveOptional< T > > | |
| CPYBIND11_NAMESPACE::detail::type_caster< ReferenceSensitiveOptional< T > > | |
| Cpybind11::detail::type_caster< ReferenceSensitiveOptional< T > > | |
| COptionalHolder< OptionalImpl, T > | |
| COptionalProperties< OptionalImpl > | |
| Coptions | |
| COstreamRedirect | |
| Coverload_cast< Args > | |
| Coverload_cast_impl< Args > | |
| Coverride_hash | |
| Coverride_unused | |
| Cpack_element< N, T, Ts > | Return the Nth element from the parameter pack |
| Cpack_element< 0, T, Ts... > | |
| Cuhal::detail::PacketFmt | Class used to display IPbus packet contents in human-readable format (e.g. in log messages) |
| Cuhal::Parser< R > | Forward declaration of the Parser so we can declare it friend |
| Cuhal::Parser< uhal::Node * > | |
| CPartialNestedStruct | |
| CPartialStruct | |
| CPerfTester | Generate custom IPbus/uHAL tests from the command line |
| Cuhal::tests::PerfTester | |
| Cpets::Pet | |
| Cpickle_factory< Get, Set, typename, typename > | Implementation for py::pickle(GetState, SetState) |
| Cpickle_factory< Get, Set, RetState(Self), NewInstance(ArgState)> | |
| ►CPolicy | |
| Cgeneric_iterator< Policy > | STL iterator template used for tuple, list, sequence and dict |
| Cgeneric_iterator< Policy > | STL iterator template used for tuple, list, sequence and dict |
| Cpybind11::polymorphic_type_hook< itype, detail::enable_if_t< std::is_base_of< Animal, itype >::value > > | |
| CPYBIND11_NAMESPACE::polymorphic_type_hook< itype, detail::enable_if_t< std::is_base_of< Animal, itype >::value > > | |
| ►Cpolymorphic_type_hook_base< itype, SFINAE > | |
| Cpolymorphic_type_hook< itype, SFINAE > | |
| Cpolymorphic_type_hook< itype, SFINAE > | |
| 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 |
| Carray_t< T, ExtraFlags >::private_ctor | |
| Cbuffer_info::private_ctr_tag | |
| Cprocess_attribute< T, SFINAE > | Partial template specializations to process custom attributes provided to cpp_function_ and class_ |
| Cprocess_attribute< custom_type_setup > | |
| Cprocess_attribute_default< T > | |
| ►Cprocess_attribute_default< arg > | |
| Cprocess_attribute< arg > | Process a keyword argument attribute (without a default value) |
| Cprocess_attribute< arg > | Process a keyword argument attribute (without a default value) |
| ►Cprocess_attribute_default< arg_v > | |
| Cprocess_attribute< arg_v > | Process a keyword argument attribute (with a default value) |
| Cprocess_attribute< arg_v > | Process a keyword argument attribute (with a default value) |
| ►Cprocess_attribute_default< arithmetic > | |
| Cprocess_attribute< arithmetic > | Process an 'arithmetic' attribute for enums (does nothing here) |
| Cprocess_attribute< arithmetic > | Process an 'arithmetic' attribute for enums (does nothing here) |
| ►Cprocess_attribute_default< base< T > > | |
| Cprocess_attribute< base< T > > | Process a parent class attribute (deprecated, does not support multiple inheritance) |
| Cprocess_attribute< base< T > > | Process a parent class attribute (deprecated, does not support multiple inheritance) |
| ►Cprocess_attribute_default< buffer_protocol > | |
| Cprocess_attribute< buffer_protocol > | |
| Cprocess_attribute< buffer_protocol > | |
| ►Cprocess_attribute_default< call_guard< Ts... > > | |
| Cprocess_attribute< call_guard< Ts... > > | |
| Cprocess_attribute< call_guard< Ts... > > | |
| ►Cprocess_attribute_default< const char * > | |
| ►Cprocess_attribute< const char * > | Process an attribute specifying the function's docstring (provided as a C-style string) |
| Cprocess_attribute< char * > | |
| Cprocess_attribute< char * > | |
| Cprocess_attribute< const char * > | Process an attribute specifying the function's docstring (provided as a C-style string) |
| ►Cprocess_attribute_default< doc > | |
| Cprocess_attribute< doc > | Process an attribute specifying the function's docstring |
| Cprocess_attribute< doc > | Process an attribute specifying the function's docstring |
| ►Cprocess_attribute_default< dynamic_attr > | |
| Cprocess_attribute< dynamic_attr > | |
| Cprocess_attribute< dynamic_attr > | |
| ►Cprocess_attribute_default< handle > | |
| Cprocess_attribute< T, enable_if_t< is_pyobject< T >::value > > | Process a parent class attribute |
| Cprocess_attribute< T, enable_if_t< is_pyobject< T >::value > > | Process a parent class attribute |
| ►Cprocess_attribute_default< is_final > | |
| Cprocess_attribute< is_final > | |
| Cprocess_attribute< is_final > | |
| ►Cprocess_attribute_default< is_method > | |
| Cprocess_attribute< is_method > | Process an attribute which indicates that this function is a method |
| Cprocess_attribute< is_method > | Process an attribute which indicates that this function is a method |
| ►Cprocess_attribute_default< is_new_style_constructor > | |
| Cprocess_attribute< is_new_style_constructor > | |
| Cprocess_attribute< is_new_style_constructor > | |
| ►Cprocess_attribute_default< is_operator > | |
| Cprocess_attribute< is_operator > | Process an attribute which indicates that this function is an operator |
| Cprocess_attribute< is_operator > | Process an attribute which indicates that this function is an operator |
| ►Cprocess_attribute_default< keep_alive< Nurse, Patient > > | |
| 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< 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_default< kw_only > | |
| Cprocess_attribute< kw_only > | Process a keyword-only-arguments-follow pseudo argument |
| Cprocess_attribute< kw_only > | Process a keyword-only-arguments-follow pseudo argument |
| ►Cprocess_attribute_default< metaclass > | |
| Cprocess_attribute< metaclass > | |
| Cprocess_attribute< metaclass > | |
| ►Cprocess_attribute_default< module_local > | |
| Cprocess_attribute< module_local > | |
| Cprocess_attribute< module_local > | |
| ►Cprocess_attribute_default< multiple_inheritance > | |
| Cprocess_attribute< multiple_inheritance > | Process a multiple inheritance attribute |
| Cprocess_attribute< multiple_inheritance > | Process a multiple inheritance attribute |
| ►Cprocess_attribute_default< name > | |
| Cprocess_attribute< name > | Process an attribute specifying the function's name |
| Cprocess_attribute< name > | Process an attribute specifying the function's name |
| ►Cprocess_attribute_default< pos_only > | |
| Cprocess_attribute< pos_only > | Process a positional-only-argument maker |
| Cprocess_attribute< pos_only > | Process a positional-only-argument maker |
| ►Cprocess_attribute_default< prepend > | |
| Cprocess_attribute< prepend > | Process a 'prepend' attribute, putting this at the beginning of the overload chain |
| Cprocess_attribute< prepend > | Process a 'prepend' attribute, putting this at the beginning of the overload chain |
| ►Cprocess_attribute_default< return_value_policy > | |
| Cprocess_attribute< return_value_policy > | Process an attribute indicating the function's return value policy |
| Cprocess_attribute< return_value_policy > | Process an attribute indicating the function's return value policy |
| ►Cprocess_attribute_default< scope > | |
| Cprocess_attribute< scope > | Process an attribute which indicates the parent scope of a method |
| Cprocess_attribute< scope > | Process an attribute which indicates the parent scope of a method |
| ►Cprocess_attribute_default< sibling > | |
| Cprocess_attribute< sibling > | Process an attribute which indicates that this is an overloaded function associated with a given sibling |
| Cprocess_attribute< sibling > | Process an attribute which indicates that this is an overloaded function associated with a given sibling |
| Cprocess_attributes< Args > | Recursively iterate over variadic template arguments |
| Cnpy_api::PyArray_Dims | |
| CPyArray_Proxy | |
| CPyArrayDescr_Proxy | |
| Cpyobject_caster< type > | |
| Cpyobject_caster< array_t< T, ExtraFlags > > | |
| ►Cpyobject_caster< T > | |
| Ctype_caster< T, enable_if_t< is_pyobject< T >::value > > | |
| Ctype_caster< T, enable_if_t< is_pyobject< T >::value > > | |
| ►Cpyobject_tag | Tag and check to identify a class which implements the Python object API |
| ►Cobject_api< accessor< Policy > > | |
| Caccessor< Policy > | |
| Caccessor< Policy > | |
| Cobject_api< accessor< Policy > > | |
| Cobject_api< Derived > | \rst A mixin class which adds common functions to handle, object and various accessors |
| Cobject_api< Derived > | \rst A mixin class which adds common functions to handle, object and various accessors |
| CPythonAlreadySetInDestructor | |
| CPythonCallInDestructor | |
| CPyVoidScalarObject_Proxy | |
| ►Cuhal::tests::PerfTester::QueuedTransaction | |
| Cuhal::tests::PerfTester::QueuedBlockRead | |
| Cuhal::tests::PerfTester::QueuedBlockWrite | |
| Cuhal::tests::PerfTester::QueuedRmwBits | |
| Cuhal::tests::PerfTester::QueuedRmwSum | |
| Cref< T > | Reference counting helper |
| Cref_tag | |
| CReferenceSensitiveOptional< T > | |
| CRefQualified | |
| ►Cuhal::RefWrapper< T > | |
| Cuhal::_Integer< T, FORMAT > | Forward declare an ultra-lightweight wrapper which does formatting of numbers only on demand |
| Cuhal::_Integer< T, IntFmt< bin, fixed, WIDTH > > | |
| Cuhal::_Integer< T, IntFmt< bin, variable, WIDTH > > | |
| Cuhal::_Integer< T, IntFmt< dec, fixed, WIDTH > > | |
| Cuhal::_Integer< T, IntFmt< dec, variable, WIDTH > > | |
| Cuhal::_Integer< T, IntFmt< hex, fixed, WIDTH > > | |
| Cuhal::_Integer< T, IntFmt< hex, variable, WIDTH > > | |
| Cuhal::_Quote< T > | |
| ►Cuhal::RefWrapper< const char * > | |
| Cuhal::_Quote< const char * > | |
| Cuhal::RefWrapper< T * > | |
| ►Cuhal::RefWrapper< timeval > | |
| Cuhal::_Time< FORMAT > | Forward declaration |
| Cuhal::ClientFactory::RegistrationHelper< T > | |
| Cuhal::RegistrationHelper< T > | 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 |
| Cremove_class< T > | Strip the class from a method type |
| Cremove_class< R(C::*)(A...) const > | |
| Cremove_class< R(C::*)(A...)> | |
| Cremove_cvref< T > | |
| Creturn_value_policy_override< Return, SFINAE > | |
| Creturn_value_policy_override< Return, detail::enable_if_t< std::is_base_of< type_caster_generic, make_caster< Return > >::value, void > > | |
| Cuhal::detail::RobustSessionMutex | Exception class to handle errors from pthread mutex-related functions |
| Cuhal::Rule< R > | Rule for matching XML attributes |
| ►Cstd::runtime_error | |
| Cbuiltin_exception | C++ bindings of builtin Python exceptions |
| Cbuiltin_exception | C++ bindings of builtin Python exceptions |
| Cerror_already_set | Fetch and hold an error which was already set in Python |
| CRValueCaster | Custom cast-only type that casts to a string "rvalue" or "lvalue" depending on the cast context |
| CRValueRefParam | |
| Csame_size< T > | |
| Cscope | Annotation for parent scope |
| Cscope_exit | |
| Cscoped_interpreter | \rst Scope guard version of initialize_interpreter and finalize_interpreter |
| ►Cscoped_ostream_redirect | \rst This a move-only guard that redirects output |
| Cscoped_estream_redirect | \rst Like scoped_ostream_redirect, but redirects cerr by default |
| Cscoped_estream_redirect | \rst Like scoped_ostream_redirect, but redirects cerr by default |
| ►Csetuptools.command.sdist.sdist | |
| Csetup.SDist | |
| Csetup.SDist | |
| Cselect_indices_impl< ISeq, size_t,... > | Make an index sequence of the indices of true arguments |
| ►Cselect_indices_impl< conditional_t< B, index_sequence< IPrev..., I >, index_sequence< IPrev... > >, I+1, Bs... > | |
| Cselect_indices_impl< index_sequence< IPrev... >, I, B, Bs... > | |
| Cselect_indices_impl< index_sequence< IPrev... >, I, B, Bs... > | |
| Cself_t | |
| 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_caster< Type, Key > | |
| ►Cset_caster< std::set< Key, Compare, Alloc >, Key > | |
| Ctype_caster< std::set< Key, Compare, Alloc > > | |
| Ctype_caster< std::set< Key, Compare, Alloc > > | |
| ►Cset_caster< std::unordered_set< Key, Hash, Equal, Alloc >, Key > | |
| Ctype_caster< std::unordered_set< Key, Hash, Equal, Alloc > > | |
| Ctype_caster< std::unordered_set< Key, Hash, Equal, Alloc > > | |
| Cuhal::detail::SharedObject< T > | Wrapper for C++ object that's placed in shared memory |
| Cuhal::detail::SharedObject< uhal::detail::RobustSessionMutex > | |
| Csibling | Annotation indicating that a function is an overload associated with a given "sibling" |
| Cuhal::SigBusGuard | |
| Csimple_collector< policy > | Helper class which collects only positional arguments for a Python function call |
| Cuhal::tests::SimpleAddressTableFixture | |
| ►Cexercise_trampoline::SimpleBase | |
| Cexercise_trampoline::SimpleBaseTrampoline | |
| Cexercise_trampoline::SimpleBaseTrampoline | |
| Cexercise_trampoline::SimpleCppDerived | |
| Cexercise_trampoline::SimpleCppDerived | |
| ►Cm.SimpleBase | |
| Ctest_pickling.SimplePyDerived | |
| Ctest_pickling.SimplePyDerived | |
| CSimpleStruct | |
| CSimpleStructReordered | |
| Ctest_class::pr4220_tripped_over_this::SoEmpty< int > | |
| Coptions::state | |
| Cobject::stolen_t | |
| Cstr_attr | |
| Cstrconv_attribute_impl< opt_escape > | |
| Cstrconv_pcdata_impl< opt_trim, opt_eol, opt_escape > | |
| Ccpp_function::strdup_guard | |
| ►Cstd::streambuf | |
| Cpythonbuf | |
| Cpythonbuf | |
| Cstring_caster< StringType, IsView > | |
| ►Cstring_caster< std::basic_string< CharT, Traits, Allocator > > | |
| Ctype_caster< std::basic_string< CharT, Traits, Allocator >, enable_if_t< is_std_char_type< CharT >::value > > | |
| Ctype_caster< std::basic_string< CharT, Traits, Allocator >, enable_if_t< is_std_char_type< CharT >::value > > | |
| CStringStruct | |
| Cstrip_function_object< F > | |
| CStrIssue | |
| ►Cboost::spirit::qi::symbols | |
| Cuhal::NodeTreeBuilder::mode_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 |
| Cuhal::NodeTreeBuilder::permissions_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 |
| Cuhal::TargetToHostInspector< IPbus_major, IPbus_minor > | Helper class to decode IPbus packets as passed from the Target to the Client |
| Ctest_initializer | |
| ►Ctest_override_cache_helper | |
| Ctest_override_cache_helper_trampoline | |
| Ctest_override_cache_helper_trampoline | |
| Ctest_override_cache_helper_trampoline | |
| Ctest_override_cache_helper_trampoline | |
| CTestFactory1 | |
| CTestFactory2 | |
| ►CTestFactory3 | |
| CTestFactory4 | |
| CTestFactory4 | |
| CTestFactory5 | |
| CTestFactory5 | |
| ►CTestFactory6 | |
| CPyTF6 | |
| CPyTF6 | |
| ►CTestFactory7 | |
| CPyTF7 | |
| CPyTF7 | |
| CTestFactoryHelper | |
| ►CTestProperties | |
| CTestPropertiesOverride | |
| CTestPropertiesOverride | |
| CTestPropRVP | |
| CTestStruct< T > | |
| CTestThread | |
| Cuhal::ThisThreadID | |
| ►Cthreading.Thread | |
| Ctest_thread.Thread | |
| Ctest_thread.Thread | |
| Cuhal::TimeFmt< T0, D0, T1, D1, T2, D2, T3, D3, T4, D4, T5, D5, T6 > | A struct whose template parameters represent a time format |
| Cuhal::TimeIntervalStats | |
| Cuhal::tests::Timer | A very simple timer |
| CTplCtorClass | Issue #528: templated constructor |
| Cuhal::ControlHub< InnerProtocol >::tpreamble | A struct representing the preamble which will be prepended to an IPbus buffer for the benefit of the Control Hub |
| ►CTransactionLevelError | |
| Cuhal::exception::IPbusCoreResponseCodeSet | Exception class to handle the case where the IPbus header could not be parsed |
| Cuhal::TranslatedFmt< T > | |
| ►Cstd::true_type | |
| Chas_operator_delete< T, void_t< decltype(static_cast< void(*)(void *)>(T::operator delete))> > | |
| Chas_operator_delete< T, void_t< decltype(static_cast< void(*)(void *)>(T::operator delete))> > | |
| Chas_operator_delete_size< T, void_t< decltype(static_cast< void(*)(void *, size_t)>(T::operator delete))> > | |
| Chas_operator_delete_size< T, void_t< decltype(static_cast< void(*)(void *, size_t)>(T::operator delete))> > | |
| 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_element &&container_traits< T >::is_comparable > > | |
| Cis_complex< std::complex< T > > | |
| Cis_complex< std::complex< T > > | |
| Cis_holder_type< base, std::unique_ptr< base, deleter > > | |
| Cis_holder_type< base, std::unique_ptr< base, deleter > > | |
| Cis_input_iterator< T, void_t< decltype(*std::declval< T & >()), decltype(++std::declval< T & >())> > | |
| Cis_input_iterator< T, void_t< decltype(*std::declval< T & >()), decltype(++std::declval< T & >())> > | |
| Cis_instantiation< Class, Class< Us... > > | |
| Cis_instantiation< Class, Class< Us... > > | |
| Cis_std_array< std::array< T, N > > | |
| Cis_std_array< std::array< T, N > > | |
| 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_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< 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_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 > > | |
| 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 > > | |
| 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 > > | |
| Ctuple_caster< Tuple, Ts > | |
| ►Ctuple_caster< std::pair, T1, T2 > | |
| Ctype_caster< std::pair< T1, T2 > > | |
| Ctype_caster< std::pair< T1, T2 > > | |
| ►Ctuple_caster< std::tuple, Ts... > | |
| Ctype_caster< std::tuple< Ts... > > | |
| Ctype_caster< std::tuple< Ts... > > | |
| Ctuple_item | |
| Ccall_guard< T, Ts... >::type | |
| Cpybind11::detail::type_caster< ArgAlwaysConverts > | |
| CPYBIND11_NAMESPACE::detail::type_caster< ArgAlwaysConverts > | |
| Cpybind11::detail::type_caster< ArgInspector1 > | |
| CPYBIND11_NAMESPACE::detail::type_caster< ArgInspector1 > | |
| Cpybind11::detail::type_caster< ArgInspector2 > | |
| CPYBIND11_NAMESPACE::detail::type_caster< ArgInspector2 > | |
| Ctype_caster< bool > | |
| Ctype_caster< CharT, enable_if_t< is_std_char_type< CharT >::value > > | |
| Ctype_caster< ConstRefCasted > | |
| Ctype_caster< CopyOnlyInt > | |
| Cpybind11::detail::type_caster< DestructionTester > | |
| CPYBIND11_NAMESPACE::detail::type_caster< DestructionTester > | |
| 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::chrono::time_point< std::chrono::system_clock, Duration > > | |
| Ctype_caster< std::complex< T > > | |
| Ctype_caster< std::function< Return(Args...)> > | |
| Ctype_caster< std::reference_wrapper< type > > | |
| 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_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_reference< T, Dim > > | |
| Ctype_caster< unchecked_mutable_reference< T, Dim > > | |
| Ctype_caster< unchecked_mutable_reference< T, Dim > > | |
| Ctype_caster< value_and_holder > | |
| ►Ctype_caster_generic | |
| Ctype_caster_base< T > | |
| Ctype_caster_base< StringType > | |
| Ctype_caster_base< T > | |
| Ctype_caster_base< StringType > | |
| ►Ctype_caster_base< type > | Generic type caster for objects stored on the heap |
| ►Ccopyable_holder_caster< T, std::shared_ptr< T > > | |
| Ctype_caster< std::shared_ptr< T > > | Specialize for the common std::shared_ptr, so users don't need to |
| Ctype_caster< std::shared_ptr< T > > | Specialize for the common std::shared_ptr, so users don't need to |
| Ccopyable_holder_caster< T, std::shared_ptr< T > > | |
| Ctype_caster< StringType > | |
| Ctype_caster< StringType > | |
| Ccopyable_holder_caster< type, holder_type, SFINAE > | Type caster for holder types like std::shared_ptr, etc |
| Ccopyable_holder_caster< type, holder_type, SFINAE > | Type caster for holder types like std::shared_ptr, etc |
| Ctype_caster< type, SFINAE > | |
| Ctype_caster< type, SFINAE > | |
| Ctype_caster_base< type > | Generic type caster for objects stored on the heap |
| 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_reference< T, Dims > | Proxy class providing unsafe, unchecked const access to array data |
| Cunchecked_mutable_reference< T, Dims > | |
| Cunchecked_mutable_reference< T, Dims > | |
| Cundefined_t | Type for an unused type slot |
| Cunpacking_collector< policy > | Helper class which collects positional, keyword, * and ** arguments for a Python function call |
| ►CUnregisteredBase | |
| CRegisteredDerived | |
| CRegisteredDerived | |
| CUnregisteredType | Dummy type which is not exported anywhere – something to trigger a conversion error |
| Cuhal::URI | Struct to store a URI when parsed by boost spirit |
| ►CUserType | A user-defined type which is exported and can be used by any test |
| CIncType | Like UserType, but increments value on copy for quick reference vs. copy tests |
| CIncType | Like UserType, but increments value on copy for quick reference vs. copy tests |
| Cutf16_counter | |
| Cutf16_decoder< opt_swap > | |
| Cutf16_writer | |
| Cutf32_counter | |
| Cutf32_decoder< opt_swap > | |
| Cutf32_writer | |
| Cutf8_counter | |
| Cutf8_decoder | |
| Cutf8_writer | |
| Cuhal::ValHeader | A class which wraps a single word of data and marks whether or not it is valid |
| Cvalue_and_holder | |
| Cvalues_and_holders | |
| Cvalues_view< Map > | |
| ►CValuesView | |
| CValuesViewImpl< Map, ValuesView > | |
| Cuhal::ValVector< T > | A class which wraps a block of data and marks whether or not it is valid |
| Cuhal::ValVector< uint32_t > | |
| Cpycohal::ValVectorIndexingSuite< T > | Struct containing wrapper functions for list-like indexing of ValVector<uint32_t> in python |
| Cuhal::ValWord< T > | A class which wraps a single word of data and marks whether or not it is valid |
| Cuhal::ValWord< uint32_t > | |
| Cvariant_caster< Variant > | Generic variant caster |
| Cvariant_caster< V< Ts... > > | |
| Cvariant_caster_visitor | Visit a variant and cast any found type to Python |
| CVector2 | |
| Cvectorize_arg< T > | |
| Cvectorize_helper< Func, Return, Args > | |
| Cvectorize_returned_array< Func, Return, Args > | |
| Cvectorize_returned_array< Func, void, Args... > | |
| ►Cm.VirtClass | |
| Ctest_gil_scoped.ExtendedVirtClass | |
| ►CVirtClass | |
| CPyVirtClass | |
| CPyVirtClass | |
| Cvisit_helper< Variant > | Helper class which abstracts away variant's visit function |
| Cvoid_caster< T > | |
| ►Cvoid_caster< std::nullptr_t > | |
| Ctype_caster< std::nullptr_t > | |
| Ctype_caster< std::nullptr_t > | |
| ►Cvoid_caster< void_type > | |
| ►Ctype_caster< void_type > | |
| Ctype_caster< void > | |
| Ctype_caster< void > | |
| Ctype_caster< void_type > | |
| Cvoid_t_impl<... > | |
| Cvoid_type | Helper type to replace 'void' in some expressions |
| Cwchar_decoder | |
| Cwchar_selector< size > | |
| Cwchar_selector< 2 > | |
| Cwchar_selector< 4 > | |
| Cwide_char_arg_deleter | |
| ►CWidget | |
| CPyWidget | |
| CPyWidget | |
| ►Cxml_allocator | |
| Cxml_document_struct | |
| Cpugi::xml_attribute | |
| Cpugi::xml_attribute_iterator | |
| Cpugi::xml_attribute_struct | |
| Cxml_buffered_writer | |
| Cxml_extra_buffer | |
| Cxml_memory_management_function_storage< T > | |
| Cxml_memory_page | |
| Cxml_memory_string_header | |
| Cpugi::xml_named_node_iterator | |
| ►Cpugi::xml_node | |
| Cpugi::xml_document | |
| Cpugi::xml_node_iterator | |
| Cpugi::xml_node_struct | |
| ►Cxml_node_struct | |
| Cxml_document_struct | |
| Cpugi::xml_object_range< It > | |
| Cpugi::xml_parse_result | |
| Cxml_parser | |
| Cxml_stream_chunk< T > | |
| Cpugi::xml_text | |
| Cpugi::xml_tree_walker | |
| ►Cpugi::xml_writer | |
| Cpugi::xml_writer_file | |
| Cpugi::xml_writer_stream | |
| Cxpath_allocator | |
| Cxpath_allocator_capture | |
| Cxpath_ast_node | |
| Cxpath_context | |
| Cxpath_lexer | |
| Cxpath_lexer_string | |
| Cxpath_memory_block | |
| Cpugi::xpath_node | |
| Cpugi::xpath_node_set | |
| Cxpath_node_set_raw | |
| Cpugi::xpath_parse_result | |
| Cxpath_parser | |
| Cpugi::xpath_query | |
| Cxpath_query_impl | |
| Cxpath_stack | |
| Cxpath_stack_data | |
| Cxpath_string | |
| Cpugi::xpath_variable | |
| ►Cxpath_variable | |
| Cxpath_variable_boolean | |
| Cxpath_variable_node_set | |
| Cxpath_variable_number | |
| Cxpath_variable_string | |
| Cpugi::xpath_variable_set | |
| ►CWidget | |
| Ctest_interpreter.DerivedWidget | |
| Ctest_interpreter.DerivedWidget | |
1.9.5
