Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►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