| ►C< > WrappedIteratorT & > > | |
| Cwpi::iterator_adaptor_base< pointer_iterator< WrappedIteratorT, decltype(&*std::declval< WrappedIteratorT >()) >, WrappedIteratorT, std::iterator_traits< WrappedIteratorT >::iterator_category, decltype(&*std::declval< WrappedIteratorT >()) > | |
| C_AFD_POLL_HANDLE_INFO | |
| C_AFD_POLL_INFO | |
| ►Cunits::detail::_base_unit_t | |
| Cunits::base_unit< Meter, Kilogram, Second, Radian, Ampere, Kelvin, Mole, Candela, Byte > | Class representing SI base unit types |
| ►Cunits::detail::_unit | |
| Cunits::unit< Conversion, BaseUnit, PiExponent, Translation > | Type representing an arbitrary unit |
| ►Cunits::detail::_unit_t | |
| Cunits::unit_t< kv_unit > | |
| Cunits::unit_t< ka_unit > | |
| Cunits::unit_t< units::compound_unit< units::volt, units::inverse< units::second > > > | |
| Cunits::unit_t< units::compound_unit< units::radians_per_second, units::inverse< units::volt > > > | |
| Cunits::unit_t< units::compound_unit< units::newton_meters, units::inverse< units::ampere > > > | |
| Cunits::unit_t< Input > | |
| Cunits::unit_t< units::inverse< units::seconds > > | |
| Cunits::unit_t< units::compound_unit< Acceleration, units::inverse< Input > > > | |
| Cunits::unit_t< Distance > | |
| Cunits::unit_t< Velocity > | |
| Cunits::unit_t< units::radian > | |
| Cunits::unit_t< b_unit > | |
| Cunits::unit_t< zeta_unit > | |
| Cunits::unit_t< Rate > | |
| Cunits::unit_t< Unit > | |
| Cunits::unit_t< units::compound_unit< units::radians, units::inverse< units::meters > > > | |
| Cunits::unit_t< Acceleration > | |
| Cunits::unit_t< Units, T, NonLinearScale > | Container for values which represent quantities of a given unit |
| ►Cunits::detail::_unit_value_t | |
| Cunits::unit_value_add< U1, U2 > | Adds two unit_value_t types at compile-time |
| Cunits::unit_value_divide< U1, U2 > | Divides two unit_value_t types at compile-time |
| Cunits::unit_value_multiply< U1, U2 > | Multiplies two unit_value_t types at compile-time |
| Cunits::unit_value_power< U1, power > | Raises unit_value_to a power at compile-time |
| Cunits::unit_value_sqrt< U1, Eps > | Calculates square root of unit_value_t at compile-time |
| Cunits::unit_value_subtract< U1, U2 > | Subtracts two unit_value_t types at compile-time |
| Cunits::unit_value_t< Units, Num, Denom > | Stores a rational unit value as a compile-time constant |
| C_uv_barrier | |
| C_wpi_proto_ProtobufArmFeedforward | |
| C_wpi_proto_ProtobufChassisSpeeds | |
| C_wpi_proto_ProtobufCubicHermiteSpline | |
| C_wpi_proto_ProtobufDCMotor | |
| C_wpi_proto_ProtobufDifferentialDriveFeedforward | |
| C_wpi_proto_ProtobufDifferentialDriveKinematics | |
| C_wpi_proto_ProtobufDifferentialDriveWheelPositions | |
| C_wpi_proto_ProtobufDifferentialDriveWheelSpeeds | |
| C_wpi_proto_ProtobufDifferentialDriveWheelVoltages | |
| C_wpi_proto_ProtobufElevatorFeedforward | |
| C_wpi_proto_ProtobufEllipse2d | |
| C_wpi_proto_ProtobufLinearSystem | |
| C_wpi_proto_ProtobufMatrix | |
| C_wpi_proto_ProtobufMecanumDriveKinematics | |
| C_wpi_proto_ProtobufMecanumDriveWheelPositions | |
| C_wpi_proto_ProtobufMecanumDriveWheelSpeeds | |
| C_wpi_proto_ProtobufPose2d | |
| C_wpi_proto_ProtobufPose3d | |
| C_wpi_proto_ProtobufQuaternion | |
| C_wpi_proto_ProtobufQuinticHermiteSpline | |
| C_wpi_proto_ProtobufRectangle2d | |
| C_wpi_proto_ProtobufRotation2d | |
| C_wpi_proto_ProtobufRotation3d | |
| C_wpi_proto_ProtobufSimpleMotorFeedforward | |
| C_wpi_proto_ProtobufSwerveDriveKinematics | |
| C_wpi_proto_ProtobufSwerveModulePosition | |
| C_wpi_proto_ProtobufSwerveModuleState | |
| C_wpi_proto_ProtobufTrajectory | |
| C_wpi_proto_ProtobufTrajectoryState | |
| C_wpi_proto_ProtobufTransform2d | |
| C_wpi_proto_ProtobufTransform3d | |
| C_wpi_proto_ProtobufTranslation2d | |
| C_wpi_proto_ProtobufTranslation3d | |
| C_wpi_proto_ProtobufTwist2d | |
| C_wpi_proto_ProtobufTwist3d | |
| C_wpi_proto_ProtobufVector | |
| CHAL_HMBData::Accumulator0 | |
| CHAL_HMBData::Accumulator1 | |
| Cdetail::actual_object_comparator< BasicJsonType > | |
| Cwpi::add_const_past_pointer< T, Enable > | If T is a pointer to X, return a pointer to const X |
| Cwpi::add_const_past_pointer< T, std::enable_if_t< std::is_pointer_v< T > > > | |
| Cwpi::add_lvalue_reference_if_not_pointer< T, Enable > | If T is a pointer, just return it. If it is not, return T& |
| Cwpi::add_lvalue_reference_if_not_pointer< T, std::enable_if_t< std::is_pointer_v< T > > > | |
| Cfrc::AddressableLED | A class for driving addressable LEDs, such as WS2812Bs and NeoPixels |
| Cfrc::sim::AddressableLEDSim | Class to control a simulated addressable LED |
| Cfrc::sim::ADIS16448_IMUSim | Class to control a simulated ADIS16448 IMU |
| Cfrc::sim::ADIS16470_IMUSim | Class to control a simulated ADIS16470 IMU |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::AdjustedParamTBase< T > | |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::AdjustedParamTBase< T & > | |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::AdjustedParamTBase< T && > | |
| Cadl_serializer< ValueType, typename > | Namespace for Niels Lohmann |
| Cfrc::sim::ADXL345Sim | Class to control a simulated ADXL345 |
| Cfrc::sim::ADXL362Sim | Class to control a simulated ADXL362 |
| Cfrc::sim::ADXRS450_GyroSim | Class to control a simulated ADXRS450 gyroscope |
| Cfrc::Alert | Persistent alert to be sent via NetworkTables |
| Cwpi::memory::aligned_allocator< RawAllocator > | A RawAllocator adapter that ensures a minimum alignment |
| Cwpi::AlignedCharArrayUnion< Ts > | A suitably aligned and sized character array member which can hold elements of any type |
| Cwpi::AlignedCharArrayUnion< wpi::detail::DenseMapPair< KeyT, unsigned >[InlineBuckets], LargeRep > | |
| Cwpi::AlignedCharArrayUnion< wpi::detail::DenseMapPair< KeyT, ValueT >[4], LargeRep > | |
| Cdetail::all< Container > | |
| Cfrc::ADXL345_I2C::AllAxes | Container type for accelerations from all axes |
| Cfrc::ADXL345_SPI::AllAxes | Container type for accelerations from all axes |
| Cfrc::ADXL362::AllAxes | Container type for accelerations from all axes |
| ►CAlloc | |
| Cwpi::detail::AllocatorHolder< Alloc > | |
| Cwpi::memory::allocator_deallocator< Type, RawAllocator > | A deleter class that deallocates the memory through a specified RawAllocator |
| Cwpi::memory::allocator_deallocator< Type[], RawAllocator > | Specialization of allocator_deallocator for array types |
| Cwpi::memory::allocator_deleter< Type, RawAllocator > | Similar to allocator_deallocator but calls the destructors of the object |
| Cwpi::memory::allocator_deleter< Type[], RawAllocator > | Specialization of allocator_deleter for array types |
| Cwpi::memory::allocator_info | Contains information about an allocator |
| Cwpi::memory::allocator_is_raw_allocator< Allocator > | Traits class that checks whether or not a standard Allocator can be used as RawAllocator |
| Cwpi::memory::allocator_polymorphic_deallocator< BaseType, RawAllocator > | A deleter class that deallocates the memory of a derived type through a specified RawAllocator |
| Cwpi::memory::allocator_polymorphic_deleter< BaseType, RawAllocator > | Similar to allocator_polymorphic_deallocator but calls the destructors of the object |
| Cwpi::memory::traits_detail::allocator_rebinder< Allocator, T > | |
| Cwpi::memory::traits_detail::allocator_rebinder< Alloc< U, Args... >, T > | |
| Cwpi::memory::allocator_storage< StoragePolicy, Mutex > | A RawAllocator that stores another allocator |
| ►Cwpi::memory::allocator_storage< direct_storage< RawAllocator >, Mutex > | |
| Cwpi::memory::thread_safe_allocator< RawAllocator, Mutex > | An alias template for allocator_storage using the direct_storage policy with a mutex |
| ►Cwpi::memory::allocator_storage< direct_storage< RawAllocator >, no_mutex > | |
| Cwpi::memory::allocator_adapter< RawAllocator > | An alias template for allocator_storage using the direct_storage policy without a mutex |
| ►Cwpi::memory::allocator_storage< reference_storage< RawAllocator >, no_mutex > | |
| Cwpi::memory::allocator_reference< RawAllocator > | An alias template for allocator_storage using the reference_storage policy |
| Cwpi::memory::allocator_traits< Allocator > | The default specialization of the allocator_traits for a RawAllocator |
| Cwpi::memory::allocator_traits< iteration_allocator< N, BlockAllocator > > | Specialization of the allocator_traits for iteration_allocator |
| Cwpi::memory::allocator_traits< memory_pool< PoolType, ImplRawAllocator > > | Specialization of the allocator_traits for memory_pool classes |
| Cwpi::memory::allocator_traits< memory_pool_collection< Pool, BucketDist, RawAllocator > > | Specialization of the allocator_traits for memory_pool_collection classes |
| Cwpi::memory::allocator_traits< memory_stack< BlockAllocator > > | Specialization of the allocator_traits for memory_stack classes |
| Cwpi::memory::allocator_traits< temporary_allocator > | Specialization of the allocator_traits for temporary_allocator classes |
| Cwpi::memory::traits_detail::allocator_type_impl< Allocator > | |
| Cwpi::AllocatorBase< DerivedT > | CRTP base class providing obvious overloads for the core Allocate() methods of LLVM-style allocators |
| ►Cwpi::AllocatorBase< MallocAllocator > | |
| Cwpi::MallocAllocator | |
| Cwpi::detail::AllocatorHolder< Alloc & > | |
| Cfrc::sim::AnalogEncoderSim | Class to control a simulated analog encoder |
| Cfrc::sim::AnalogGyroSim | Class to control a simulated analog gyro |
| CHAL_HMBData::AnalogInputs | |
| Cfrc::sim::AnalogInputSim | Class to control a simulated analog input |
| Cfrc::sim::AnalogOutputSim | Class to control a simulated analog output |
| CHAL_HMBData::AnalogTriggers | |
| Cfrc::sim::AnalogTriggerSim | Class to control a simulated analog trigger |
| Cdetail::ansi_color_escape< Char > | |
| Cwpi::memory::any_allocator | Tag type that enables type-erasure in reference_storage |
| Cfrc::AprilTag | Represents an AprilTag's metadata |
| Capriltag_detection | |
| Capriltag_detection_info_t | |
| Capriltag_detector | |
| Capriltag_family | |
| Capriltag_pose_t | This struct holds the transformation from the camera optical frame to the April tag frame |
| Capriltag_quad_thresh_params | |
| Cfrc::AprilTagDetection | A detection of an AprilTag tag |
| Cfrc::AprilTagDetector | An AprilTag detector engine |
| Cfrc::AprilTagFieldLayout | Class for representing a layout of AprilTags on a field and reading them from a JSON format |
| Cfrc::AprilTagPoseEstimate | A pair of AprilTag pose estimates |
| Cfrc::AprilTagPoseEstimator | Pose estimators for AprilTag tags |
| Cdetail::arg_converter< T, Context > | |
| ►Cdetail::arg_formatter< Char > | |
| Cdetail::printf_arg_formatter< Char > | |
| Cdetail::arg_pack< T > | |
| Cdetail::arg_ref< Char > | |
| Cdetail::arg_ref< char > | |
| Cwpi::Argument | |
| Cwpi::ArgumentParser | |
| Cfrc::ArmFeedforward | A helper class that computes feedforward outputs for a simple arm (modeled as a motor acting against the force of gravity on a beam suspended at an angle) |
| ►Cstd::array | |
| Cwpi::array< double, 3 > | |
| Cwpi::array< double, 4 > | |
| Cwpi::array< SwerveModulePosition, NumModules > | |
| Cwpi::array< double,(Degree+1)/2 > | |
| Cwpi::array< frc::Translation2d, NumModules > | |
| Cwpi::array< frc::Rotation2d, NumModules > | |
| Cwpi::array< T, N > | This class is a wrapper around std::array that does compile time size checking |
| Cwpi::memory::array_pool | Tag type defining a memory pool optimized for arrays |
| Cwpi::java::detail::ArrayHelper< T > | |
| Cwpi::uv::AsyncFunction< T > | |
| Cfrc::AsynchronousInterrupt | Class for handling asynchronous interrupts using a callback thread |
| CHAL_HMBData::AveragedAnalogInputs | |
| Cfrc::PS4Controller::Axis | Represents an axis on an PS4Controller |
| Cfrc::PS5Controller::Axis | Represents an axis on an PS5Controller |
| Cfrc::StadiaController::Axis | Represents an axis on an StadiaController |
| Cfrc::XboxController::Axis | Represents an axis on an XboxController |
| ►CB | |
| Cdetail::conjunction< B > | |
| Cwpi::detail_expected::conjunction< B > | |
| ►Cstd::bad_alloc | |
| ►Cwpi::memory::bad_allocation_size | The exception class thrown when an allocation size is bigger than the supported maximum |
| Cwpi::memory::bad_alignment | The exception class thrown when the alignment exceeds the supported maximum, i.e |
| Cwpi::memory::bad_array_size | The exception class thrown when the array size exceeds the supported maximum, i.e |
| Cwpi::memory::bad_node_size | The exception class thrown when the node size exceeds the supported maximum, i.e |
| ►Cwpi::memory::out_of_memory | The exception class thrown when a low level allocator runs out of memory |
| Cwpi::memory::out_of_fixed_memory | A special case of out_of_memory errors thrown when a low-level allocator with a fixed size runs out of memory |
| ►CBase | |
| ►Cfrc2::CommandHelper< Command, ConditionalCommand > | |
| Cfrc2::ConditionalCommand | A command composition that runs one of two commands, depending on the value of the given condition when this command is initialized |
| ►Cfrc2::CommandHelper< Command, DeferredCommand > | |
| Cfrc2::DeferredCommand | Defers Command construction to runtime |
| ►Cfrc2::CommandHelper< Command, FunctionalCommand > | |
| Cfrc2::FunctionalCommand | A command that allows the user to pass in functions for each of the basic command methods through the constructor |
| ►Cfrc2::CommandHelper< FunctionalCommand, InstantCommand > | |
| Cfrc2::InstantCommand | A Command that runs instantly; it will initialize, execute once, and end on the same iteration of the scheduler |
| ►Cfrc2::CommandHelper< Command, MecanumControllerCommand > | |
| Cfrc2::MecanumControllerCommand | A command that uses two PID controllers (PIDController) and a profiled PID controller (ProfiledPIDController) to follow a trajectory (Trajectory) with a mecanum drive |
| ►Cfrc2::CommandHelper< Command, NotifierCommand > | |
| Cfrc2::NotifierCommand | A command that starts a notifier to run the given runnable periodically in a separate thread |
| ►Cfrc2::CommandHelper< Command, PIDCommand > | |
| Cfrc2::PIDCommand | A command that controls an output with a PIDController |
| ►Cfrc2::CommandHelper< Command, ParallelCommandGroup > | |
| Cfrc2::ParallelCommandGroup | A command composition that runs a set of commands in parallel, ending when the last command ends |
| ►Cfrc2::CommandHelper< Command, ParallelDeadlineGroup > | |
| Cfrc2::ParallelDeadlineGroup | A command composition that runs a set of commands in parallel, ending only when a specific command (the "deadline") ends, interrupting all other commands that are still running at that point |
| ►Cfrc2::CommandHelper< Command, ParallelRaceGroup > | |
| Cfrc2::ParallelRaceGroup | A composition that runs a set of commands in parallel, ending when any one of the commands ends and interrupting all the others |
| ►Cfrc2::CommandHelper< InstantCommand, PrintCommand > | |
| Cfrc2::PrintCommand | A command that prints a string when initialized |
| ►Cfrc2::CommandHelper< Command, ProfiledPIDCommand< Distance > > | |
| Cfrc2::ProfiledPIDCommand< Distance > | A command that controls an output with a ProfiledPIDController |
| ►Cfrc2::CommandHelper< Command, ProxyCommand > | |
| Cfrc2::ProxyCommand | Schedules a given command when this command is initialized and ends when it ends, but does not directly run it |
| ►Cfrc2::CommandHelper< Command, RamseteCommand > | |
| Cfrc2::RamseteCommand | A command that uses a RAMSETE controller to follow a trajectory with a differential drive |
| ►Cfrc2::CommandHelper< Command, RepeatCommand > | |
| Cfrc2::RepeatCommand | A command that runs another command repeatedly, restarting it when it ends, until this command is interrupted |
| ►Cfrc2::CommandHelper< FunctionalCommand, RunCommand > | |
| Cfrc2::RunCommand | A command that runs a Runnable continuously |
| ►Cfrc2::CommandHelper< Command, ScheduleCommand > | |
| Cfrc2::ScheduleCommand | Schedules the given commands when this command is initialized |
| ►Cfrc2::CommandHelper< Command, SelectCommand< Key > > | |
| Cfrc2::SelectCommand< Key > | A command composition that runs one of a selection of commands using a selector and a key to command mapping |
| ►Cfrc2::CommandHelper< Command, SequentialCommandGroup > | |
| Cfrc2::SequentialCommandGroup | A command composition that runs a list of commands in sequence |
| ►Cfrc2::CommandHelper< FunctionalCommand, StartEndCommand > | |
| Cfrc2::StartEndCommand | A command that runs a given runnable when it is initialized, and another runnable when it ends |
| ►Cfrc2::CommandHelper< Command, SwerveControllerCommand< NumModules > > | |
| Cfrc2::SwerveControllerCommand< NumModules > | A command that uses two PID controllers (PIDController) and a profiled PID controller (ProfiledPIDController) to follow a trajectory (Trajectory) with a swerve drive |
| ►Cfrc2::CommandHelper< Command, TrapezoidProfileCommand< Distance > > | |
| Cfrc2::TrapezoidProfileCommand< Distance > | A command that runs a TrapezoidProfile |
| ►Cfrc2::CommandHelper< Command, WaitCommand > | |
| Cfrc2::WaitCommand | A command that does nothing but takes a specified amount of time to finish |
| ►Cfrc2::CommandHelper< Command, WaitUntilCommand > | |
| Cfrc2::WaitUntilCommand | A command that does nothing but ends after a specified match time or condition |
| ►Cfrc2::CommandHelper< Command, WrapperCommand > | |
| Cfrc2::WrapperCommand | A class used internally to wrap commands while overriding a specific method; all other methods will call through to the wrapped command |
| Cfrc2::CommandHelper< Base, CRTP > | CRTP implementation to allow polymorphic decorator functions in Command |
| Cbasic_appender< T > | |
| Cbasic_appender< Char > | |
| Cbasic_appender< char > | |
| Cbasic_cstring_view< Char > | A reference to a null-terminated string |
| Cbasic_format_arg< Context > | |
| Cbasic_format_arg< basic_printf_context > | |
| Cbasic_format_arg< context > | |
| Cbasic_format_arg< generic_context > | |
| Cbasic_format_args< Context > | A view of a collection of formatting arguments |
| Cbasic_format_args< basic_printf_context > | |
| Cbasic_format_args< context > | |
| Cbasic_format_args< generic_context > | |
| Cdetail::basic_fp< F > | |
| Cbasic_fstring< Char, T > | |
| Cbasic_printf_context< Char > | |
| ►Cbasic_specs | |
| ►Cformat_specs | |
| Cdetail::dynamic_format_specs< Char > | |
| Cdetail::dynamic_format_specs< Char > | |
| ►Cstd::basic_string | |
| Cwpi::memory::string< RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cbasic_string_view< Char > | An implementation of std::basic_string_view for pre-C++17 |
| Cbasic_string_view< char > | |
| Cbasic_string_view< char_type > | |
| Cfrc::sim::BatterySim | A utility class to simulate the robot battery |
| Cdetail::big_decimal_fp | |
| Cdetail::bigint | |
| Cdetail::binary_reader< BasicJsonType, InputAdapterType, SAX > | Deserialization of CBOR, MessagePack, and UBJSON values |
| Cwpi::memory::binary_segregator< Segregatable, RawAllocator > | A RawAllocator that either uses the Segregatable or the other RawAllocator |
| Cdetail::binary_writer< BasicJsonType, CharType > | Serialization to CBOR and MessagePack values |
| ►CBinaryType | |
| Cbyte_container_with_subtype< BinaryType > | Internal type for a backed binary type |
| Cdetail::bitint< N > | |
| ►Cbool_constant | |
| Cdetail::is_c_string< T > | |
| Cdetail::is_transparent< T > | |
| Cdetail::locking< T, Enable > | |
| ►Cfrc::BooleanEvent | This class provides an easy way to link actions to active high logic signals |
| Cfrc::NetworkBooleanEvent | A Button that uses a NetworkTable boolean field |
| Cdetail::dtoa_impl::boundaries | |
| Cwpi::log::DataLog::Buffer | |
| ►Cdetail::buffer< T > | A contiguous memory buffer with an optional growing ability |
| Cbasic_memory_buffer< T, SIZE, Allocator > | A dynamically growing memory buffer for trivially copyable/constructible types with the first SIZE elements stored in the object itself |
| Cdetail::iterator_buffer< OutputIt, T, Traits > | |
| Cdetail::iterator_buffer< T *, T > | |
| Cdetail::iterator_buffer< T *, T, fixed_buffer_traits > | |
| ►Cdetail::buffer< bigit > | |
| Cbasic_memory_buffer< bigit, bigits_capacity > | |
| Cdetail::buffer< Char > | |
| ►Cdetail::buffer< char > | |
| Cdetail::counting_buffer< T > | |
| Cdetail::file_print_buffer< F, Enable > | |
| Cdetail::file_print_buffer< F, enable_if_t< has_flockfile< F >::value > > | |
| Cdetail::buffer< char_type > | |
| ►Cdetail::buffer< Container::value_type > | |
| Cdetail::container_buffer< Container > | |
| ►Cdetail::buffer< OutputIt::container_type::value_type > | |
| ►Cdetail::container_buffer< OutputIt::container_type > | |
| Cdetail::iterator_buffer< OutputIt, enable_if_t< is_back_insert_iterator< OutputIt >::value &&is_contiguous< typename OutputIt::container_type >::value, typename OutputIt::container_type::value_type > > | |
| ►Cdetail::buffer< std::string::value_type > | |
| Cdetail::container_buffer< std::string > | |
| ►Cdetail::buffer< wchar_t > | |
| Cbasic_memory_buffer< wchar_t > | |
| ►Cdetail::buffer_traits | |
| Cdetail::iterator_buffer< OutputIt, T, Traits > | |
| Cbuffered_file | |
| Cfrc::sim::BuiltInAccelerometerSim | Class to control a simulated built-in accelerometer |
| Cfrc::PS4Controller::Button | Represents a digital button on an PS4Controller |
| Cfrc::PS5Controller::Button | Represents a digital button on an PS5Controller |
| Cfrc::StadiaController::Button | Represents a digital button on an StadiaController |
| Cfrc::XboxController::Button | Represents a digital button on an XboxController |
| Cbytes | |
| Cdetail::dragonbox::cache_accessor< T > | |
| Cdetail::dragonbox::cache_accessor< double > | |
| Cdetail::dragonbox::cache_accessor< float > | |
| Cdetail::dtoa_impl::cached_power | |
| Cwpi::CalculateSmallVectorDefaultInlinedElements< T > | Helper class for calculating the default number of inline elements for SmallVector<T> |
| Cwpi::SendableRegistry::CallbackData | Data passed to ForeachLiveWindow() callback function |
| Cwpi::CallbackListenerData< Callback > | |
| Cwpi::CallbackManager< Derived, Thread > | |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::CallbacksHolder< CallableT, CalledAs, Enable > | |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::CallbacksHolder< CallableT, CalledAs, EnableIfTrivial< CallableT > > | |
| Cfrc::sim::CallbackStore | Manages simulation callbacks; each object is associated with a callback |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::CalledAs< T > | |
| Cfrc::CameraServer | Singleton class for creating and keeping camera servers |
| Cfrc::CameraServerShared | |
| Cfrc::CAN | High level class for interfacing with CAN devices conforming to the standard CAN spec |
| Cwpi::details::can_invoke_to_string< T > | |
| Cfrc::CANData | |
| Cfrc::CANStatus | |
| Cwpi::cast_convert_val< To, From, SimpleFrom > | |
| Cwpi::cast_convert_val< To, FromTy *, FromTy * > | |
| Cwpi::cast_convert_val< To, FromTy, FromTy > | |
| Cwpi::cast_retty< To, From > | |
| Cwpi::cast_retty_impl< To, From > | |
| Cwpi::cast_retty_impl< To, const From * > | |
| Cwpi::cast_retty_impl< To, const From *const > | |
| Cwpi::cast_retty_impl< To, const From > | |
| Cwpi::cast_retty_impl< To, From * > | |
| Cwpi::cast_retty_impl< To, std::unique_ptr< From > > | |
| Cwpi::cast_retty_wrap< To, From, SimpleFrom > | |
| Cwpi::cast_retty_wrap< To, FromTy, FromTy > | |
| Cwpi::CastInfo< To, From, std::enable_if_t<!is_simple_type< From >::value > > | This struct provides an overload for CastInfo where From has simplify_type defined |
| Cwpi::CastInfoPointerUnionImpl< PTs > | We can't (at least, at this moment with C++14) declare CastInfo as a friend of PointerUnion like this: |
| ►Cwpi::CastIsPossible< To, From, Enable > | This struct provides a way to check if a given cast is possible |
| Cwpi::CastInfo< To, From, Enable > | This struct provides a method for customizing the way a cast is performed |
| ►Cwpi::OptionalValueCast< To, From, Derived > | This cast trait provides std::optional<T> casting |
| Cwpi::CastInfo< To, std::optional< From > > | Provide a CastInfo specialized for std::optional<From> |
| ►Cwpi::CastIsPossible< To, From * > | |
| ►Cwpi::UniquePtrCast< To, From, Derived > | This cast trait provides std::unique_ptr casting |
| Cwpi::CastInfo< To, std::unique_ptr< From > > | Provide a CastInfo specialized for std::unique_ptr |
| Cwpi::ValueFromPointerCast< To, From, Derived > | This cast trait provides casting for the specific case of casting to a value-typed object from a pointer-typed object |
| Cwpi::CastIsPossible< To, From, std::enable_if_t< std::is_base_of_v< To, From > > > | Upcasting (from derived to base) and casting from a type to itself should always be possible |
| Cwpi::CastIsPossible< To, std::optional< From > > | |
| Cdetail::char_converter< Context > | |
| ►Cstd::char_traits | |
| Cdetail::char_traits< T > | |
| Cdetail::char_traits< signed char > | |
| Cdetail::char_traits< unsigned char > | |
| Cfrc::ChassisSpeeds | Represents the speed of a robot chassis |
| Cwpi::memory::detail::check_standard_allocator< Allocator > | |
| Cdetail::chrono_formatter< FormatContext, OutputIt, Rep, Period > | |
| Cwpi::memory::detail::chunk_base | |
| Cwpi::circular_buffer< T > | This is a simple circular buffer so we don't need to "bucket brigade" copy old values |
| Cnt::meta::Client | Client (as published via $clients) |
| Cwpi::WebSocket::ClientOptions | Client connection options |
| Cnt::meta::ClientPublisher | Client publisher (as published via $clientpub$<client> or $serverpub) |
| Cnt::meta::ClientSubscriber | Client subscriber (as published via $clientsub$<client> or $serversub) |
| Cdetail::codecvt_result< CodeUnit > | |
| Cfrc::Color | Represents colors that can be used with Addressable LEDs |
| Cfrc::Color8Bit | Represents colors that can be used with Addressable LEDs |
| Cdetail::color_type | |
| Cdetail::color_type::color_union | |
| ►Cfrc2::CommandGenericHID | A version of frc::GenericHID with Trigger factories for command-based |
| Cfrc2::CommandJoystick | A version of frc::Joystick with Trigger factories for command-based |
| Cfrc2::CommandPS4Controller | A version of frc::PS4Controller with Trigger factories for command-based |
| Cfrc2::CommandPS5Controller | A version of frc::PS5Controller with Trigger factories for command-based |
| Cfrc2::CommandStadiaController | A version of frc::StadiaController with Trigger factories for command-based |
| Cfrc2::CommandXboxController | A version of frc::XboxController with Trigger factories for command-based |
| Cfrc2::CommandPtr | A wrapper around std::unique_ptr<Command> so commands have move-only semantics |
| Cdetail::compile_string | |
| Ccompiled_string | |
| Cwpi::memory::composable_allocator_traits< Allocator > | The default specialization of the composable_allocator_traits for a ComposableAllocator |
| Cwpi::memory::composable_allocator_traits< iteration_allocator< N, BlockAllocator > > | Specialization of the composable_allocator_traits for iteration_allocator classes |
| Cwpi::memory::composable_allocator_traits< memory_pool< PoolType, BlockOrRawAllocator > > | Specialization of the composable_allocator_traits for memory_pool classes |
| Cwpi::memory::composable_allocator_traits< memory_pool_collection< Pool, BucketDist, RawAllocator > > | Specialization of the composable_allocator_traits for memory_pool_collection classes |
| Cwpi::memory::composable_allocator_traits< memory_stack< BlockAllocator > > | Specialization of the composable_allocator_traits for memory_stack classes |
| Cdetail::dragonbox::cache_accessor< double >::compute_mul_parity_result | |
| Cdetail::dragonbox::cache_accessor< float >::compute_mul_parity_result | |
| Cdetail::dragonbox::cache_accessor< double >::compute_mul_result | |
| Cdetail::dragonbox::cache_accessor< float >::compute_mul_result | |
| ►Cstd::conditional | |
| Cstd::tuple_element< I, wpi::PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > > | |
| ►Cconditional_t | |
| Cconjunction< P1, Pn... > | |
| Crange_format_kind< T, Char, Enable > | |
| Cfrc2::sysid::Config | Hardware-independent configuration for a SysId test routine |
| Cfrc::AprilTagDetector::Config | Detector configuration |
| Cfrc::AprilTagPoseEstimator::Config | Configuration for the pose estimator |
| ►Cwpi::sig::Connection | A Connection object allows interaction with an ongoing slot connection |
| Cwpi::sig::ScopedConnection | ScopedConnection is a RAII version of Connection It disconnects the slot from the signal upon destruction |
| Cwpi::sig::ConnectionBlocker | ConnectionBlocker is a RAII object that blocks a connection until destruction |
| Cnt::ConnectionInfo | NetworkTables Connection Information |
| Csleipnir::VariableBlock< Mat >::const_iterator | |
| Csleipnir::VariableMatrix::const_iterator | |
| Cwpi::circular_buffer< T >::const_iterator | |
| Cwpi::static_circular_buffer< T, N >::const_iterator | |
| Cwpi::const_pointer_or_const_ref< T, Enable > | |
| Cwpi::const_pointer_or_const_ref< T, std::enable_if_t< std::is_pointer_v< T > > > | |
| Cfrc::ExponentialProfile< Distance, Input >::Constraints | Profile constraints |
| Cfrc::TrapezoidProfile< Distance >::Constraints | Profile constraints |
| Cwpi::ConstStrippingForwardingCast< To, From, ForwardTo > | Provides a cast trait that strips const from types to make it easier to implement a const-version of a non-const cast |
| ►Cwpi::ConstStrippingForwardingCast< To, const PointerUnion< PTs... >, CastInfo< To, PointerUnion< PTs... > > > | |
| Cwpi::CastInfo< To, const PointerUnion< PTs... > > | |
| Cwpi::details::ConsumeBinaryPrefixResult | |
| Cwpi::details::ConsumeHexPrefixResult | |
| Cdetail::container_input_adapter_factory_impl::container_input_adapter_factory< ContainerType, Enable > | |
| Cdetail::container_input_adapter_factory_impl::container_input_adapter_factory< ContainerType, void_t< decltype(begin(std::declval< ContainerType >()), end(std::declval< ContainerType >()))> > | |
| Cfrc::ControlAffinePlantInversionFeedforward< States, Inputs > | Constructs a control-affine plant inversion model-based feedforward from given model dynamics |
| Cfrc::Spline< Degree >::ControlVector | Represents a control vector for a spline |
| Cwpi::java::detail::ConvertIntArray< T > | |
| Cfrc::CoordinateAxis | A class representing a coordinate system axis within the NWU coordinate system |
| Cfrc::CoordinateSystem | A helper class that converts Pose3d objects between different standard coordinate frames |
| Cwpi::java::detail::copy_cv< CvSrc, Dest > | |
| Cdetail::count_fractional_digits< Num, Den, N, Enabled > | |
| Cdetail::count_fractional_digits< Num, Den, N, false > | |
| CHAL_HMBData::Counters::Counter | |
| ►Cfrc::CounterBase | Interface for counting the number of ticks on a digital input channel |
| Cfrc::Counter | Class for counting the number of ticks on a digital input channel |
| Cfrc::Encoder | Class to read quad encoders |
| CHAL_HMBData::Counters | |
| CHAL_HMBData::CounterTimers | |
| CCS_Event | Listener event |
| CCS_UsbCameraInfo | USB camera information |
| ►CCS_VideoMode | Video mode |
| Ccs::VideoMode | Video mode |
| Cfrc::ct_matrix< Scalar, Rows, Cols > | Compile-time wrapper for Eigen::Matrix |
| Cwpi::ct_string< Char, Traits, N > | Fixed length string (array of character) for compile time use |
| Cdetail::custom_tag | |
| Cdetail::custom_value< Context > | |
| Cdetail::custom_value< basic_printf_context > | |
| Cdetail::custom_value< context > | |
| Cdetail::custom_value< generic_context > | |
| ►Cwpi::log::DataLog | A data log for high-speed writing of data values |
| Cwpi::log::DataLogBackgroundWriter | A data log background writer that periodically flushes the data log on a background thread |
| Cwpi::log::DataLogWriter | A data log writer that flushes the data log to a file when Flush() is called |
| ►Cwpi::log::DataLogEntry | Log entry base class |
| ►Cwpi::log::DataLogValueEntryImpl< std::vector< int > > | |
| Cwpi::log::BooleanArrayLogEntry | Log array of boolean values |
| ►Cwpi::log::DataLogValueEntryImpl< bool > | |
| Cwpi::log::BooleanLogEntry | Log boolean values |
| ►Cwpi::log::DataLogValueEntryImpl< std::vector< double > > | |
| Cwpi::log::DoubleArrayLogEntry | Log array of double values |
| ►Cwpi::log::DataLogValueEntryImpl< double > | |
| Cwpi::log::DoubleLogEntry | Log double values |
| ►Cwpi::log::DataLogValueEntryImpl< std::vector< float > > | |
| Cwpi::log::FloatArrayLogEntry | Log array of float values |
| ►Cwpi::log::DataLogValueEntryImpl< float > | |
| Cwpi::log::FloatLogEntry | Log float values |
| ►Cwpi::log::DataLogValueEntryImpl< std::vector< int64_t > > | |
| Cwpi::log::IntegerArrayLogEntry | Log array of integer values |
| ►Cwpi::log::DataLogValueEntryImpl< int64_t > | |
| Cwpi::log::IntegerLogEntry | Log integer values |
| ►Cwpi::log::DataLogValueEntryImpl< std::vector< uint8_t > > | |
| Cwpi::log::RawLogEntry | Log arbitrary byte data |
| ►Cwpi::log::DataLogValueEntryImpl< std::vector< std::string > > | |
| Cwpi::log::StringArrayLogEntry | Log array of string values |
| ►Cwpi::log::DataLogValueEntryImpl< std::string > | |
| Cwpi::log::StringLogEntry | Log string values |
| Cwpi::log::DataLogValueEntryImpl< T > | |
| Cwpi::log::ProtobufLogEntry< T > | Log protobuf serializable objects |
| Cwpi::log::StructArrayLogEntry< T, I > | Log raw struct serializable array of objects |
| Cwpi::log::StructLogEntry< T, I > | Log raw struct serializable objects |
| Cwpi::log::DataLogIterator | DataLogReader iterator |
| Cfrc::DataLogManager | Centralized data log that provides automatic data log file management |
| Cwpi::log::DataLogReader | Data log reader (reads logs written by the DataLog class) |
| Cwpi::log::DataLogRecord | A record in the data log |
| Cday | |
| Cfrc::DCMotor | Holds the constants for a DC motor |
| Cfrc::Debouncer | A simple debounce filter for boolean streams |
| ►Cwpi::DebugEpochBase | A base class for data structure classes wishing to make iterators ("handles") pointing into themselves fail-fast |
| Cwpi::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, wpi::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, wpi::detail::DenseMapPair< KeyT, ValueT > > | |
| Cwpi::DenseMapBase< SmallDenseMap< KeyT, ValueT, 4, DenseMapInfo< KeyT >, wpi::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, wpi::detail::DenseMapPair< KeyT, ValueT > > | |
| Cwpi::DenseMapBase< SmallDenseMap< KeyT, unsigned, InlineBuckets, DenseMapInfo< KeyT >, wpi::detail::DenseMapPair< KeyT, unsigned > >, KeyT, unsigned, DenseMapInfo< KeyT >, wpi::detail::DenseMapPair< KeyT, unsigned > > | |
| Cwpi::DenseMapBase< DenseMap< KeyT, unsigned, DenseMapInfo< KeyT >, wpi::detail::DenseMapPair< KeyT, unsigned > >, KeyT, unsigned, DenseMapInfo< KeyT >, wpi::detail::DenseMapPair< KeyT, unsigned > > | |
| Cwpi::DenseMapBase< DenseMap< int, EntryInfo2, DenseMapInfo< int >, wpi::detail::DenseMapPair< int, EntryInfo2 > >, int, EntryInfo2, DenseMapInfo< int >, wpi::detail::DenseMapPair< int, EntryInfo2 > > | |
| ►Cwpi::DenseMapBase< DerivedT, KeyT, ValueT, KeyInfoT, BucketT > | |
| Cwpi::DenseMap< KeyT, unsigned > | |
| Cwpi::DenseMap< int, EntryInfo2 > | |
| Cwpi::SmallDenseMap< KeyT, unsigned, N > | |
| Cwpi::DenseMap< KeyT, ValueT, KeyInfoT, BucketT > | |
| Cwpi::SmallDenseMap< KeyT, ValueT, InlineBuckets, KeyInfoT, BucketT > | |
| ►Cwpi::SmallPtrSetImplBase | SmallPtrSetImplBase - This is the common code shared among all the SmallPtrSet<>'s, which is almost everything |
| ►Cwpi::SmallPtrSetImpl< PointeeType * > | |
| ►Cwpi::SmallPtrSet< PointeeType *, N > | |
| Cwpi::SmallSet< PointeeType *, N > | If this set is of pointer values, transparently switch over to using SmallPtrSet for performance |
| ►Cwpi::SmallPtrSetImpl< PtrType > | A templated base class for SmallPtrSet which provides the typesafe interface that is common across all small sizes |
| Cwpi::SmallPtrSet< PtrType, SmallSize > | SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements |
| Cunits::decibel_scale< T > | Unit_t scale for representing decibel values |
| Cdetail::dragonbox::decimal_fp< T > | |
| Cwpi::memory::detail::deeply_tracked_block_allocator< Tracker, BlockAllocator > | |
| Cdetail::default_arg_formatter< Char > | |
| Cwpi::detail_expected::default_constructor_tag | |
| Cwpi::DefaultDoCastIfPossible< To, From, Derived > | This cast trait just provides the default implementation of doCastIfPossible to make CastInfo specializations more declarative |
| ►Cwpi::DefaultDoCastIfPossible< std::optional< To >, From, detail::SelfType< void, OptionalValueCast< To, From > > > | |
| Cwpi::OptionalValueCast< To, From, Derived > | This cast trait provides std::optional<T> casting |
| ►Cwpi::DefaultDoCastIfPossible< To, From *, detail::SelfType< void, ValueFromPointerCast< To, From > > > | |
| Cwpi::ValueFromPointerCast< To, From, Derived > | This cast trait provides casting for the specific case of casting to a value-typed object from a pointer-typed object |
| ►Cwpi::DefaultDoCastIfPossible< To, PointerUnion< PTs... >, CastInfo< To, PointerUnion< PTs... > > > | |
| Cwpi::CastInfo< To, PointerUnion< PTs... > > | |
| Cwpi::memory::temporary_stack_initializer::defer_create_t | |
| Cwpi::DenseMapInfo< T, Enable > | An information struct used to provide DenseMap with the various necessary components for a given value type T |
| Cwpi::DenseMapInfo< char > | |
| Cwpi::DenseMapInfo< Enum, std::enable_if_t< std::is_enum_v< Enum > > > | |
| Cwpi::DenseMapInfo< hash_code, void > | |
| Cwpi::DenseMapInfo< int > | |
| Cwpi::DenseMapInfo< long > | |
| Cwpi::DenseMapInfo< long long > | |
| Cwpi::DenseMapInfo< PointerIntPair< PointerTy, IntBits, IntType >, void > | |
| Cwpi::DenseMapInfo< PointerUnion< PTs... > > | |
| Cwpi::DenseMapInfo< short > | |
| Cwpi::DenseMapInfo< std::pair< T, U > > | |
| Cwpi::DenseMapInfo< std::tuple< Ts... > > | |
| Cwpi::DenseMapInfo< std::variant< Ts... > > | |
| Cwpi::DenseMapInfo< T * > | |
| Cwpi::DenseMapInfo< unsigned > | |
| Cwpi::DenseMapInfo< unsigned char > | |
| Cwpi::DenseMapInfo< unsigned long > | |
| Cwpi::DenseMapInfo< unsigned long long > | |
| Cwpi::DenseMapInfo< unsigned short > | |
| ►Cstd::deque | |
| Cwpi::memory::deque< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::deque_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| Cdetail::detector< Default, AlwaysVoid, Op, Args > | |
| Cdetail::detector< Default, void_t< Op< Args... > >, Op, Args... > | |
| CHAL_HMBData::DI | |
| Cfrc::DifferentialDriveAccelerationLimiter | Filters the provided voltages to limit a differential drive's linear and angular acceleration |
| Cfrc::DifferentialDriveFeedforward | A helper class which computes the feedforward outputs for a differential drive drivetrain |
| Cfrc::sim::DifferentialDrivetrainSim | |
| Cfrc::DifferentialDriveWheelPositions | Represents the wheel positions for a differential drive drivetrain |
| Cfrc::DifferentialDriveWheelSpeeds | Represents the wheel speeds for a differential drive drivetrain |
| Cfrc::DifferentialDriveWheelVoltages | Motor voltages for a differential drive |
| Cdetail::digit_grouping< Char > | |
| Cfrc::sim::DigitalPWMSim | Class to control a simulated digital PWM output |
| ►Cfrc::DigitalSource | DigitalSource Interface |
| Cfrc::AnalogTriggerOutput | Class to represent a specific output from an analog trigger |
| Cfrc::DigitalInput | Class to read a digital input |
| Cfrc::DigitalOutput | Class to write to digital outputs |
| Chal::DIOSetProxy | Proxy class for directly manipulating the DIO pins |
| Cfrc::sim::DIOSim | Class to control a simulated digital input or output |
| Cwpi::memory::direct_storage< RawAllocator > | A StoragePolicy that stores the allocator directly |
| Cwpi::DirectUnpackCallback< T, U, N > | A callback method that will directly unpack elements into the specified vector like data structure |
| ►Cwpi::DirectUnpackCallback< T, std::vector< T >, 1 > | |
| Cwpi::StdVectorUnpackCallback< T, N > | A DirectUnpackCallback backed by a std::vector |
| ►Cwpi::DirectUnpackCallback< T, wpi::SmallVector< T, 1 >, 1 > | |
| Cwpi::UnpackCallback< T, N > | A DirectUnpackCallback backed by a SmallVector<T, N> |
| ►Cwpi::DirectUnpackCallback< T, WpiArrayEmplaceWrapper< T, N >, N > | |
| Cwpi::WpiArrayUnpackCallback< T, N > | A DirectUnpackCallback backed by a wpi::array<T, N> |
| Cdetail::dtoa_impl::diyfp | |
| Cfrc::DMA | Class for configuring Direct Memory Access (DMA) of FPGA inputs |
| Cfrc::sim::DoubleSolenoidSim | |
| Cfrc::DriverStation | Provide access to the network communication data to / from the Driver Station |
| Cfrc::internal::DriverStationModeThread | For internal use only |
| Cfrc::sim::DriverStationSim | Class to control a simulated driver station |
| Cfrc::DSControlWord | A wrapper around Driver Station control word |
| ►Cwpi::impl::DSOData | |
| Cwpi::DynamicStructObject | Dynamic (run-time) mutable access to a serialized raw struct, with internal data storage |
| Cwpi::detail_expected::expected_storage_base< void, E, false, true >::dummy | |
| CHAL_HMBData::DutyCycle | |
| Cfrc::sim::DutyCycleEncoderSim | Class to control a simulated duty cycle encoder |
| Cfrc::sim::DutyCycleSim | Class to control a simulated duty cycle digital input |
| Cdetail::dynamic_arg_list | |
| Cdynamic_format_arg_store< Context > | A dynamic list of formatting arguments with storage |
| Cdetail::dynamic_spec_getter | |
| Cdetail::dynamic_spec_handler< Char > | |
| ►Cwpi::DynamicStruct | Dynamic (run-time) read-only access to a serialized raw struct |
| ►Cwpi::MutableDynamicStruct | Dynamic (run-time) mutable access to a serialized raw struct |
| Cwpi::DynamicStructObject | Dynamic (run-time) mutable access to a serialized raw struct, with internal data storage |
| Cfrc::ElevatorFeedforward | A helper class that computes feedforward outputs for a simple elevator (modeled as a motor acting against the force of gravity) |
| Cfrc::Ellipse2d | Represents a 2d ellipse space containing translational, rotational, and scaling components |
| Cwpi::empty_array_t | |
| ►Cstd::enable_shared_from_this | |
| Cwpi::DsClient | |
| Cwpi::HttpWebSocketServerConnection< Derived > | A server-side HTTP connection that also accepts WebSocket upgrades |
| Cwpi::ParallelTcpConnector | Parallel TCP connector |
| Cwpi::WebSocket | RFC 6455 compliant WebSocket client and server implementation |
| Cwpi::WebSocketServer | Dedicated WebSocket server |
| ►Cwpi::uv::Handle | Handle |
| ►Cwpi::uv::HandleImpl< Async< T... >, uv_async_t > | |
| Cwpi::uv::Async< T > | Async handle |
| ►Cwpi::uv::HandleImpl< Async<>, uv_async_t > | |
| Cwpi::uv::Async<> | Async specialization for no data parameters |
| ►Cwpi::uv::HandleImpl< AsyncFunction< R(T...)>, uv_async_t > | |
| Cwpi::uv::AsyncFunction< R(T...)> | Function async handle |
| ►Cwpi::uv::HandleImpl< Check, uv_check_t > | |
| Cwpi::uv::Check | Check handle |
| ►Cwpi::uv::HandleImpl< FsEvent, uv_fs_event_t > | |
| Cwpi::uv::FsEvent | Filesystem Event handle |
| ►Cwpi::uv::HandleImpl< Idle, uv_idle_t > | |
| Cwpi::uv::Idle | Idle handle |
| ►Cwpi::uv::HandleImpl< Poll, uv_poll_t > | |
| Cwpi::uv::Poll | Poll handle |
| ►Cwpi::uv::HandleImpl< Prepare, uv_prepare_t > | |
| Cwpi::uv::Prepare | Prepare handle |
| ►Cwpi::uv::HandleImpl< Process, uv_process_t > | |
| Cwpi::uv::Process | Process handle |
| ►Cwpi::uv::HandleImpl< Signal, uv_signal_t > | |
| Cwpi::uv::Signal | Signal handle |
| ►Cwpi::uv::HandleImpl< Timer, uv_timer_t > | |
| Cwpi::uv::Timer | Timer handle |
| ►Cwpi::uv::HandleImpl< Udp, uv_udp_t > | |
| Cwpi::uv::Udp | UDP handle |
| Cwpi::uv::HandleImpl< T, U > | Handle |
| ►Cwpi::uv::Stream | Stream handle |
| ►Cwpi::uv::StreamImpl< Tty, uv_tty_t > | |
| Cwpi::uv::Tty | TTY handle |
| ►Cwpi::uv::NetworkStream | Network stream handle |
| ►Cwpi::uv::NetworkStreamImpl< Pipe, uv_pipe_t > | |
| Cwpi::uv::Pipe | Pipe handle |
| ►Cwpi::uv::NetworkStreamImpl< Tcp, uv_tcp_t > | |
| Cwpi::uv::Tcp | TCP handle |
| Cwpi::uv::NetworkStreamImpl< T, U > | |
| Cwpi::uv::StreamImpl< T, U > | |
| Cwpi::uv::Loop | Event loop |
| ►Cwpi::uv::Request | Request |
| ►Cwpi::uv::RequestImpl< ConnectReq, uv_connect_t > | |
| ►Cwpi::uv::ConnectReq | Connection request |
| Cwpi::uv::PipeConnectReq | Pipe connection request |
| Cwpi::uv::TcpConnectReq | TCP connection request |
| ►Cwpi::uv::RequestImpl< GetAddrInfoReq, uv_getaddrinfo_t > | |
| Cwpi::uv::GetAddrInfoReq | GetAddrInfo request |
| ►Cwpi::uv::RequestImpl< GetNameInfoReq, uv_getnameinfo_t > | |
| Cwpi::uv::GetNameInfoReq | GetNameInfo request |
| ►Cwpi::uv::RequestImpl< ShutdownReq, uv_shutdown_t > | |
| Cwpi::uv::ShutdownReq | Shutdown request |
| ►Cwpi::uv::RequestImpl< UdpSendReq, uv_udp_send_t > | |
| Cwpi::uv::UdpSendReq | UDP send request |
| ►Cwpi::uv::RequestImpl< WorkReq, uv_work_t > | |
| Cwpi::uv::WorkReq | Work request |
| ►Cwpi::uv::RequestImpl< WriteReq, uv_write_t > | |
| Cwpi::uv::WriteReq | Write request |
| Cwpi::uv::RequestImpl< T, U > | Request |
| CHAL_HMBData::Encoders::Encoder | |
| CHAL_HMBData::Encoders | |
| Cfrc::sim::EncoderSim | Class to control a simulated encoder |
| CHAL_HMBData::EncoderTimers | |
| Csleipnir::EqualityConstraints | A vector of equality constraints of the form câ‚‘(x) = 0 |
| Cwpi::uv::Error | Error code |
| ►Cwpi::memory::traits_detail::error | |
| ►Cwpi::memory::traits_detail::std_concept | |
| ►Cwpi::memory::traits_detail::min_concept | |
| Cwpi::memory::traits_detail::full_concept | |
| Cnt::Event | NetworkTables event |
| Cwpi::Event | An atomic signaling event for synchronization |
| Cnt::EventFlags | Event notification flags |
| Cfrc::EventLoop | A declarative way to bind a set of actions to a loop and execute them when the loop is polled |
| Cwpi::EventLoopRunner | Executes an event loop on a separate thread |
| Cwpi::EventVector | |
| ►Cstd::exception | |
| ►Cdetail::exception | General exception of the basic_json class |
| Cdetail::invalid_iterator | Exception indicating errors with iterators |
| Cdetail::other_error | Exception indicating other library errors |
| Cdetail::out_of_range | Exception indicating access out of the defined range |
| Cdetail::parse_error | Exception indicating a parse error |
| Cdetail::type_error | Exception indicating executing a member function with a wrong type |
| Cwpi::bad_expected_access< E > | |
| ►Cwpi::detail_expected::expected_default_ctor_base< T, E, Enable > | |
| Cwpi::expected< T, E > | An expected<T, E> object is an object that contains the storage for another object and manages the lifetime of this contained object T |
| Cwpi::detail_expected::expected_default_ctor_base< T, E, false > | |
| ►Cwpi::detail_expected::expected_delete_assign_base< T, E, EnableCopy, EnableMove > | |
| Cwpi::expected< T, E > | An expected<T, E> object is an object that contains the storage for another object and manages the lifetime of this contained object T |
| Cwpi::detail_expected::expected_delete_assign_base< T, E, false, false > | |
| Cwpi::detail_expected::expected_delete_assign_base< T, E, false, true > | |
| Cwpi::detail_expected::expected_delete_assign_base< T, E, true, false > | |
| ►Cwpi::detail_expected::expected_delete_ctor_base< T, E, EnableCopy, EnableMove > | |
| Cwpi::expected< T, E > | An expected<T, E> object is an object that contains the storage for another object and manages the lifetime of this contained object T |
| Cwpi::detail_expected::expected_delete_ctor_base< T, E, false, false > | |
| Cwpi::detail_expected::expected_delete_ctor_base< T, E, false, true > | |
| Cwpi::detail_expected::expected_delete_ctor_base< T, E, true, false > | |
| ►Cwpi::detail_expected::expected_storage_base< T, E, bool, bool > | |
| ►Cwpi::detail_expected::expected_operations_base< T, E > | |
| ►Cwpi::detail_expected::expected_copy_base< T, E, bool > | |
| ►Cwpi::detail_expected::expected_move_base< T, E, bool > | |
| ►Cwpi::detail_expected::expected_copy_assign_base< T, E, bool > | |
| ►Cwpi::detail_expected::expected_move_assign_base< T, E, bool > | |
| Cwpi::expected< T, E > | An expected<T, E> object is an object that contains the storage for another object and manages the lifetime of this contained object T |
| Cwpi::detail_expected::expected_move_assign_base< T, E, false > | |
| Cwpi::detail_expected::expected_copy_assign_base< T, E, false > | |
| Cwpi::detail_expected::expected_move_base< T, E, false > | |
| Cwpi::detail_expected::expected_copy_base< T, E, false > | |
| Cwpi::detail_expected::expected_storage_base< T, E, false, true > | |
| Cwpi::detail_expected::expected_storage_base< T, E, true, false > | |
| Cwpi::detail_expected::expected_storage_base< T, E, true, true > | |
| ►Cwpi::detail_expected::expected_storage_base< void, E > | |
| Cwpi::detail_expected::expected_operations_base< void, E > | |
| Cwpi::detail_expected::expected_storage_base< void, E, false, false > | |
| Cwpi::detail_expected::expected_storage_base< void, E, false, true > | |
| Cfrc::ExponentialProfile< Distance, Input > | A Exponential-shaped velocity profile |
| Csleipnir::detail::Expression | An autodiff expression node |
| Csleipnir::detail::ExpressionGraph | This class is an adaptor type that performs value updates of an expression's computational graph in a way that skips duplicates |
| Cdetail::utility_internal::Extend< Seq, SeqSize, Rem > | |
| Cdetail::utility_internal::Extend< integer_sequence< T, Ints... >, SeqSize, 0 > | |
| Cdetail::utility_internal::Extend< integer_sequence< T, Ints... >, SeqSize, 1 > | |
| Cfrc::ExtendedKalmanFilter< States, Inputs, Outputs > | A Kalman filter combines predictions from a model and measurements to give an estimate of the true system state |
| Cdetail::external_constructor< value_t > | |
| Cdetail::external_constructor< value_t::array > | |
| Cdetail::external_constructor< value_t::binary > | |
| Cdetail::external_constructor< value_t::boolean > | |
| Cdetail::external_constructor< value_t::number_float > | |
| Cdetail::external_constructor< value_t::number_integer > | |
| Cdetail::external_constructor< value_t::number_unsigned > | |
| Cdetail::external_constructor< value_t::object > | |
| Cdetail::external_constructor< value_t::string > | |
| ►CLocale::facet | |
| Cformat_facet< Locale > | |
| Cwpi::memory::fallback_allocator< Default, Fallback > | A RawAllocator with a fallback |
| Cdetail::fallback_digit_grouping< Char > | |
| Cwpi::memory::detail::fallback_type< Fallback > | |
| Cwpi::memory::detail::fallback_type< binary_segregator< Segregator, Fallback > > | |
| ►Cstd::false_type | |
| ►Cwpi::sig::trait::detail::is_weak_ptr< decltype(to_weak(std::declval< T >()))> | |
| Cwpi::sig::trait::detail::is_weak_ptr_compatible< T, void_t< decltype(to_weak(std::declval< T >()))> > | |
| Cdetail::has_back_insert_iterator_container_append< OutputIt, InputIt, typename > | |
| Cdetail::has_const_begin_end< T, Enable > | |
| Cdetail::has_flip< T, Enable > | |
| Cdetail::has_flockfile< F, Enable > | |
| Cdetail::has_from_json< BasicJsonType, T, typename > | |
| Cdetail::has_isfinite< T, Enable > | |
| Cdetail::has_member_data_tm_gmtoff< T, typename > | |
| Cdetail::has_member_data_tm_zone< T, typename > | |
| Cdetail::has_member_fn_begin_end_t< T, Enable > | |
| Cdetail::has_mutable_begin_end< T, Enable > | |
| Cdetail::has_non_default_from_json< BasicJsonType, T, typename > | |
| Cdetail::has_to_json< BasicJsonType, T, typename > | |
| Cdetail::has_to_string_view< T, Enable > | |
| Cdetail::is_back_insert_iterator< It, Enable > | |
| Cdetail::is_basic_json< typename > | |
| Cdetail::is_buffer_appender< It, Enable > | |
| Cdetail::is_comparable< Compare, A, B, typename > | |
| ►Cdetail::is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType, typename > | |
| Cdetail::is_compatible_array_type< BasicJsonType, CompatibleArrayType > | |
| ►Cdetail::is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, typename > | |
| Cdetail::is_compatible_integer_type< RealIntegerType, CompatibleNumberIntegerType > | |
| ►Cdetail::is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, typename > | |
| Cdetail::is_compatible_object_type< BasicJsonType, CompatibleObjectType > | |
| ►Cdetail::is_compatible_type_impl< BasicJsonType, CompatibleType, typename > | |
| Cdetail::is_compatible_type< BasicJsonType, CompatibleType > | |
| Cdetail::is_complete_type< T, typename > | |
| ►Cdetail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, typename > | |
| Cdetail::is_constructible_array_type< BasicJsonType, ConstructibleArrayType > | |
| ►Cdetail::is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType, typename > | |
| Cdetail::is_constructible_object_type< BasicJsonType, ConstructibleObjectType > | |
| Cdetail::is_constructible_tuple< T1, T2 > | |
| Cdetail::is_iterator_traits< T, typename > | |
| Cdetail::is_json_iterator_of< BasicJsonType, T > | |
| Cdetail::is_json_ref< typename > | |
| Cdetail::is_named_arg< T > | |
| Cdetail::is_output_iterator< It, T, Enable > | |
| Cdetail::is_range_< T, _ > | |
| Cdetail::is_reference_wrapper< T > | |
| Cdetail::is_specialization_of< Primary, T > | |
| Cdetail::is_static_named_arg< T > | |
| Cdetail::is_std_string_like< T, Enable > | |
| Cdetail::locking< T, void_t< typename formatter< remove_cvref_t< T > >::nonlocking > > | |
| Cdetail::use_format_as< T, Enable > | |
| Cdetail::use_format_as_member< T, Enable > | |
| Cis_contiguous< T > | |
| ►Cis_xchar< T > | Specifies if T is an extended character type. Can be specialized by users |
| Cis_char< T > | |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::IsSizeLessThanThresholdT< T, class > | |
| Cwpi::detail_expected::is_expected_impl< T > | |
| Cwpi::details::HasContainerTraits< T, typename > | |
| Cwpi::details::HasContainerTraits< std::string > | |
| Cwpi::details::HasContainerTraits< std::string_view > | |
| Cwpi::details::HasStreamableTraits< T, typename > | |
| Cwpi::explicitly_convertible< From, To, typename > | |
| Cwpi::memory::detail::is_instantiation_of< Template, T > | |
| Cwpi::memory::is_shared_allocator< RawAllocator > | Specifies whether or not a RawAllocator has shared semantics |
| Cwpi::sig::trait::detail::is_callable< typename, typename, typename, typename > | |
| Cwpi::sig::trait::detail::is_weak_ptr< T, typename > | |
| Cwpi::sig::trait::detail::is_weak_ptr_compatible< T, typename > | |
| Cwpi::FastQueue< T, MAX_BLOCK_SIZE > | |
| Cfrc::PneumaticHub::Faults | Faults for a REV PH |
| Cfrc::PowerDistribution::Faults | Faults for a PowerDistribution device |
| Cfrc::FieldObject2d | Game field object on a Field2d |
| Cdetail::file_access< Tag, BufType, FileMemberPtr > | |
| ►Cdetail::file_base< F > | |
| Cdetail::apple_file< F > | |
| Cdetail::fallback_file< F > | |
| Cdetail::glibc_file< F > | |
| Cdetail::file_input_adapter | |
| Cwpi::FileLogger | A class version of tail -f, otherwise known as tail -f at home |
| Cdetail::find_escape_result< Char > | |
| Cwpi::FirstIndexOfType< T, Us > | Find the first index where a type appears in a list of types |
| Cwpi::memory::fixed_block_allocator< RawAllocator > | A BlockAllocator that allows only one block allocation |
| ►Cdetail::fixed_buffer_traits | |
| Cdetail::iterator_buffer< T *, T, fixed_buffer_traits > | |
| Cwpi::memory::detail::fixed_memory_stack | |
| Cdetail::fixed_string< Char, N > | |
| Cdetail::float128 | |
| Cdetail::dragonbox::float_info< T, Enable > | |
| Cdetail::dragonbox::float_info< double > | |
| Cdetail::dragonbox::float_info< float > | |
| Cdetail::dragonbox::float_info< T, enable_if_t< is_double_double< T >::value > > | |
| Cdetail::dragonbox::float_info< T, enable_if_t< std::numeric_limits< T >::digits==64||std::numeric_limits< T >::digits==113||is_float128< T >::value > > | |
| Cdetail::format_arg_store< Context, NUM_ARGS, NUM_NAMED_ARGS, DESC > | |
| Cdetail::format_handler< Char > | |
| Cformat_int | A fast integer formatter |
| Cdetail::format_string_char< S, typename > | |
| Cdetail::format_string_char< S, enable_if_t< std::is_base_of< detail::compile_string, S >::value > > | |
| Cdetail::format_string_char< S, void_t< decltype(sizeof(detail::to_string_view(std::declval< S >())))> > | |
| Cdetail::format_string_checker< Char, NUM_ARGS, NUM_NAMED_ARGS, DYNAMIC_NAMES > | |
| Cformat_to_n_result< OutputIt > | |
| Cformat_to_result | |
| Cdetail::format_tuple_element< FormatContext > | |
| ►Cformatter< T, Char, Enable > | |
| Cformatter< group_digits_view< T > > | |
| ►Cformatter< basic_string_view< Char >, Char > | |
| ►Cbasic_ostream_formatter< Char > | |
| Cformatter< detail::streamed_view< T >, Char > | |
| Cformatter< std::thread::id, Char > | |
| Cformatter< Char[N], Char > | |
| Cformatter< std::basic_string< Char, Traits, Allocator >, Char > | |
| ►Cformatter< bool, Char > | |
| Cformatter< BitRef, Char, enable_if_t< detail::is_bit_reference_like< BitRef >::value > > | |
| Cformatter< bytes > | |
| Cformatter< Char, T > | |
| ►Cformatter< detail::all< T::container_type >, Char > | |
| Cformatter< T, Char, enable_if_t< conjunction< detail::is_container_adaptor_like< T >, bool_constant< range_format_kind< T, Char >::value==range_format::disabled > >::value > > | |
| Cformatter< detail::bigint > | |
| ►Cformatter< detail::format_as_result< T >, Char > | |
| Cformatter< T, Char, void_t< detail::format_as_result< T > > > | |
| Cformatter< join_view< It, Sentinel, Char >, Char > | |
| ►Cformatter< long long, Char > | |
| Cformatter< detail::bitint< N >, Char > | |
| Cformatter< nested_view< T, Char >, Char > | |
| Cformatter< R, Char, enable_if_t< conjunction< bool_constant< range_format_kind< R, Char >::value !=range_format::disabled &&range_format_kind< R, Char >::value !=range_format::map &&range_format_kind< R, Char >::value !=range_format::string &&range_format_kind< R, Char >::value !=range_format::debug_string >, detail::is_formattable_delayed< R, Char > >::value > > | |
| Cformatter< R, Char, enable_if_t< range_format_kind< R, Char >::value==range_format::map > > | |
| Cformatter< R, Char, enable_if_t< range_format_kind< R, Char >::value==range_format::string||range_format_kind< R, Char >::value==range_format::debug_string > > | |
| ►Cformatter< remove_cvref_t< T >, Char > | |
| Cformatter< std::reference_wrapper< T >, Char, enable_if_t< is_formattable< remove_cvref_t< T >, Char >::value > > | |
| Cformatter< remove_cvref_t< value_type >, Char > | |
| Cformatter< std::chrono::duration< Rep, Period >, Char > | |
| Cformatter< std::complex< T >, Char > | |
| Cformatter< std::error_code > | |
| ►Cformatter< std::tm, Char > | |
| Cformatter< day, Char > | |
| Cformatter< local_time< Duration >, Char > | |
| Cformatter< month, Char > | |
| ►Cformatter< sys_time< Duration >, Char > | |
| Cformatter< utc_time< Duration >, Char > | |
| Cformatter< weekday, Char > | |
| Cformatter< year, Char > | |
| Cformatter< year_month_day, Char > | |
| Cformatter< string_type, Char > | |
| Cformatter< string_view, char > | |
| ►Cformatter< T, Char > | |
| Cformatter< detail::styled_arg< T >, Char > | |
| Cformatter< std::atomic< T >, Char, enable_if_t< is_formattable< T, Char >::value > > | |
| Cformatter< T, char > | |
| Cformatter< T, Char, typename std::enable_if< std::is_base_of< std::exception, T >::value >::type > | |
| Cformatter< Tuple, Char, enable_if_t< fmt::is_tuple_like< Tuple >::value &&fmt::is_tuple_formattable< Tuple, Char >::value > > | |
| Cformatter< tuple_join_view< Char, Tuple >, Char, enable_if_t< is_tuple_like< Tuple >::value > > | |
| Cfmt::formatter< Unit, CharT, std::enable_if_t< units::traits::is_unit_t_v< Unit > > > | Formatter for unit types |
| ►Cformatter< unsigned long long, Char > | |
| Cformatter< detail::ubitint< N >, Char > | |
| ►Cstd::forward_list | |
| Cwpi::memory::forward_list< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::forward_list_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| Cwpi::ForwardToPointerCast< To, From, ForwardTo > | Provides a cast trait that uses a defined pointer to pointer cast as a base for reference-to-reference casts |
| Chal::fpga_clock | A std::chrono compatible wrapper around the FPGA Timer |
| Cwpi::WebSocket::Frame | Frame |
| Cwpi::memory::detail::free_list_array< FreeList, AccessPolicy > | |
| Cwpi::memory::detail::free_list_array< typename node_pool::type, typename identity_buckets::type > | |
| Cwpi::memory::detail::free_list_array< typename PoolType::type, typename BucketDistribution::type > | |
| Cwpi::memory::detail::free_memory_list | |
| Cdetail::from_json_fn | |
| Cfstring< T > | A compile-time format string |
| Csleipnir::function_ref< F > | An implementation of std::function_ref, a lightweight non-owning reference to a callable |
| Cwpi::function_ref< Fn > | An efficient, type-erasing, non-owning reference to a callable |
| Csleipnir::function_ref< R(Args...)> | |
| Cwpi::function_ref< Ret(Params...)> | |
| Csleipnir::function_ref< sleipnir::VariableMatrix(const sleipnir::Variable &t, const sleipnir::VariableMatrix &x, const sleipnir::VariableMatrix &u, const sleipnir::Variable &dt)> | |
| Cwpi::FunctionPointerLikeTypeTraits< Alignment, FunctionPointerT > | Provide suitable custom traits struct for function pointers |
| ►Cwpi::FunctionPointerLikeTypeTraits< 4, ReturnT(*)(ParamTs...)> | |
| Cwpi::PointerLikeTypeTraits< ReturnT(*)(ParamTs...)> | Provide a default specialization for function pointers that assumes 4-byte alignment |
| Cwpi::future< T > | A lightweight version of std::future |
| Cwpi::future< void > | Explicit specialization for future<void> |
| Cwpi::detail::FutureThen< To, From > | |
| Cwpi::detail::FutureThen< To, void > | |
| Cwpi::detail::FutureThen< void, From > | |
| Cwpi::detail::FutureThen< void, void > | |
| Cg2d_line_segment_t | |
| Cg2d_line_t | |
| Cdetail::utility_internal::Gen< T, N > | |
| Cdetail::utility_internal::Gen< T, 0 > | |
| Cgeneric_context< OutputIt, Char > | |
| ►Cfrc::GenericHID | Handle input from standard HID devices connected to the Driver Station |
| Cfrc::Joystick | Handle input from standard Joysticks connected to the Driver Station |
| Cfrc::PS4Controller | Handle input from PS4 controllers connected to the Driver Station |
| Cfrc::PS5Controller | Handle input from PS5 controllers connected to the Driver Station |
| Cfrc::StadiaController | Handle input from Stadia controllers connected to the Driver Station |
| Cfrc::XboxController | Handle input from Xbox controllers connected to the Driver Station |
| ►Cfrc::sim::GenericHIDSim | Class to control a simulated generic joystick |
| Cfrc::sim::JoystickSim | Class to control a simulated joystick |
| Cfrc::sim::PS4ControllerSim | Class to control a simulated PS4 controller |
| Cfrc::sim::PS5ControllerSim | Class to control a simulated PS5 controller |
| Cfrc::sim::StadiaControllerSim | Class to control a simulated Stadia controller |
| Cfrc::sim::XboxControllerSim | Class to control a simulated Xbox controller |
| Cdetail::get_cstring< Char > | |
| Cdetail::get_locale | |
| Cwpi::pointer_union_detail::GetFirstType< T,... > | Find the first type in a list of types |
| Cwpi::memory::detail::global_leak_checker_impl< Handler > | |
| Csleipnir::Gradient | This class calculates the gradient of a a variable with respect to a vector of variables |
| Cgroup_digits_view< T > | |
| Cwpi::memory::growing_block_allocator< RawAllocator, Num, Den > | A BlockAllocator that uses a given RawAllocator for allocating the blocks |
| ►CHAL_AddressableLEDData | Structure for holding one LED's color data |
| Cfrc::AddressableLED::LEDData | |
| CHAL_CANStreamMessage | Storage for CAN Stream Messages |
| CHAL_ControlWord | |
| ►CHAL_DMASample | Buffer for containing all DMA data for a specific sample |
| Cfrc::DMASample | DMA sample |
| CHAL_HMBData | |
| CHAL_JoystickAxes | |
| CHAL_JoystickButtons | |
| CHAL_JoystickDescriptor | |
| CHAL_JoystickPOVs | |
| CHAL_MatchInfo | |
| CHAL_PowerDistributionChannelData | |
| CHAL_PowerDistributionFaults | |
| CHAL_PowerDistributionStickyFaults | Storage for REV PDH Sticky Faults |
| CHAL_PowerDistributionVersion | Power distribution version |
| CHAL_REVPHCompressorConfig | Storage for compressor config |
| CHAL_REVPHFaults | Storage for REV PH Faults |
| CHAL_REVPHStickyFaults | Storage for REV PH Sticky Faults |
| CHAL_REVPHVersion | Storage for REV PH Version |
| CHAL_Value | HAL Entry Value |
| Chal::HalCallbackListener< CallbackFunction > | |
| CHALSIM_NotifierInfo | |
| Chal::Handle< CType, FreeFunction, CInvalid > | A move-only C++ wrapper around a HAL handle |
| Cbasic_format_arg< Context >::handle | |
| Chal::Handle< HAL_AddressableLEDHandle, HAL_FreeAddressableLED > | |
| Chal::Handle< HAL_AnalogInputHandle, HAL_FreeAnalogInputPort > | |
| Chal::Handle< HAL_AnalogOutputHandle, HAL_FreeAnalogOutputPort > | |
| Chal::Handle< HAL_AnalogTriggerHandle, HAL_CleanAnalogTrigger > | |
| Chal::Handle< HAL_CANHandle, HAL_CleanCAN > | |
| Chal::Handle< HAL_CounterHandle, HAL_FreeCounter > | |
| Chal::Handle< HAL_DigitalHandle, HAL_FreeDIOPort > | |
| Chal::Handle< HAL_DigitalHandle, HAL_FreePWMPort > | |
| Chal::Handle< HAL_DigitalPWMHandle > | |
| Chal::Handle< HAL_DMAHandle, HAL_FreeDMA > | |
| Chal::Handle< HAL_DutyCycleHandle, HAL_FreeDutyCycle > | |
| Chal::Handle< HAL_EncoderHandle, HAL_FreeEncoder > | |
| Chal::Handle< HAL_GyroHandle, HAL_FreeAnalogGyro > | |
| Chal::Handle< HAL_I2CPort, HAL_CloseI2C, HAL_I2C_kInvalid > | |
| Chal::Handle< HAL_InterruptHandle, HAL_CleanInterrupts > | |
| Chal::Handle< HAL_NotifierHandle, HAL_CleanNotifier > | |
| Chal::Handle< HAL_PowerDistributionHandle, HAL_CleanPowerDistribution > | |
| Chal::Handle< HAL_RelayHandle, HAL_FreeRelayPort > | |
| Chal::Handle< HAL_SerialPortHandle, HAL_CloseSerial > | |
| Chal::Handle< HAL_SPIPort, HAL_CloseSPI, HAL_SPI_kInvalid > | |
| ►Chal::HandleBase | Base for all HAL Handles |
| Chal::DigitalHandleResource< THandle, TStruct, size > | The DigitalHandleResource class is a way to track handles |
| Chal::IndexedClassedHandleResource< THandle, TStruct, size, enumValue > | The IndexedClassedHandleResource class is a way to track handles |
| Chal::IndexedHandleResource< THandle, TStruct, size, enumValue > | The IndexedHandleResource class is a way to track handles |
| Chal::LimitedClassedHandleResource< THandle, TStruct, size, enumValue > | The LimitedClassedHandleResource class is a way to track handles |
| Chal::LimitedHandleResource< THandle, TStruct, size, enumValue > | The LimitedHandleResource class is a way to track handles |
| Chal::UnlimitedHandleResource< THandle, TStruct, enumValue > | The UnlimitedHandleResource class is a way to track handles |
| ►Cwpi::DebugEpochBase::HandleBase | A base class for iterator classes ("handles") that wish to poll for iterator invalidating modifications in the underlying data structure |
| Cwpi::DenseMapIterator< KeyT, ValueT, KeyInfoT, Bucket, IsConst > | |
| Cwpi::SmallPtrSetIterator< PtrTy > | SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet |
| ►CHandler | |
| Cwpi::memory::detail::global_leak_checker_impl< Handler >::counter | |
| Cwpi::memory::detail::object_leak_checker< Handler > | |
| Cdetail::has_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > > | |
| Cdetail::has_non_default_from_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > > | |
| Cdetail::has_to_json< BasicJsonType, T, enable_if_t< !is_basic_json< T >::value > > | |
| Cstd::hash< wpi::hash_code > | |
| Cstd::hash< wpi::WPI_BASIC_JSON_TPL > | Hash value for JSON objects |
| Cwpi::hash_code | An opaque object representing a hash code |
| Cwpi::hashing::detail::hash_combine_recursive_helper | Helper class to manage the recursive combining of hash_combine arguments |
| Cwpi::hashing::detail::hash_state | The intermediate state used during hashing |
| Cwpi::HashBuilder< HasherT, Endianness > | |
| Cwpi::detail::HasPointerLikeTypeTraits< T, U > | |
| Cwpi::detail::HasPointerLikeTypeTraits< T, decltype((sizeof(PointerLikeTypeTraits< T >)+sizeof(T)), void())> | |
| Cwpi::memory::detail::heap_allocator_impl | |
| Csleipnir::Hessian | This class calculates the Hessian of a variable with respect to a vector of variables |
| Cfrc::HolonomicDriveController | This holonomic drive controller can be used to follow trajectories using a holonomic drivetrain (i.e |
| Cwpi::http_parser | |
| Cwpi::http_parser_settings | |
| Cwpi::http_parser_url | |
| Cwpi::HttpConnection | |
| Cwpi::HttpLocation | |
| Cwpi::HttpMultipartScanner | |
| Cwpi::HttpParser | HTTP protocol parser |
| Cwpi::HttpPath | Class for HTTP path matching |
| Cwpi::HttpPathRef | Proxy reference object for a portion of a HttpPath |
| Cwpi::HttpQueryMap | Map for looking up elements of the query portion of a URI |
| Cwpi::HttpRequest | |
| ►Cwpi::HttpServerConnection | |
| Cwpi::HttpWebSocketServerConnection< Derived > | A server-side HTTP connection that also accepts WebSocket upgrades |
| Cfrc::I2C | I2C bus interface class |
| Cwpi::memory::detail::identity_access_policy | |
| Cwpi::memory::identity_buckets | A BucketDistribution for memory_pool_collection defining that there is a bucket, i.e |
| Cdetail::identity_tag< T > | |
| Cimage_f32 | |
| Cimage_u32 | |
| Cimage_u8 | |
| Cimage_u8_lut | |
| Cimage_u8x3 | |
| Cimage_u8x4 | |
| Cfrc::ImplicitModelFollower< States, Inputs > | Contains the controller coefficients and logic for an implicit model follower |
| Cwpi::in_place_t | |
| Csleipnir::InequalityConstraints | A vector of inequality constraints of the form cᵢ(x) ≥ 0 |
| Cdetail::input_stream_adapter | |
| Cdetail::int_checker< IsSigned > | |
| Cdetail::int_checker< true > | |
| Cdetail::integer_sequence< T, Ints > | |
| ►Cdetail::integer_sequence< T, Ns... > | |
| Cdetail::make_integer_sequence< T, 0, Ns... > | |
| ►Cstd::integral_constant | |
| ►Cwpi::memory::shared_ptr_node_size< T, std_allocator< T, RawAllocator > > | |
| Cwpi::memory::allocate_shared_node_size< T, RawAllocator > | The node size required by allocate_shared |
| Cdetail::has_key_compare< T > | |
| Cdetail::is_basic_json_context< BasicJsonContext > | |
| Cdetail::is_range_< T, void > | |
| Cdetail::is_same_arithmetic_type< Rep1, Rep2 > | |
| Cdetail::negation< B > | |
| Cdetail::range_format_kind_< T > | |
| Cdetail::type_constant< T, Char > | |
| Cstd::tuple_size< wpi::PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > > | |
| Cstd::tuple_size< wpi::array< T, N > > | |
| Cstd::tuple_size<::wpi::detail::iteration_proxy_value< IteratorType > > | |
| Cunits::traits::has_decibel_scale< T > | Trait which tests whether a type is inherited from a decibel scale |
| Cunits::traits::has_linear_scale< T > | Trait which tests whether a type is inherited from a linear scale |
| Cunits::traits::is_convertible_unit_t< U1, U2 > | Trait which tests whether two container types derived from unit_t are convertible to each other |
| Cunits::traits::is_nonlinear_scale< T, Ret > | Trait which tests that class T meets the requirements for a non-linear scale |
| Cunits::traits::is_ratio< T > | Trait that tests whether a type represents a std::ratio |
| Cunits::traits::is_same_scale< T1, T2 > | Trait which tests whether two types has the same non-linear scale |
| Cunits::traits::is_unit_value_t< T, Units > | Trait which tests whether a type is a unit_value_t representing the given unit type |
| Cunits::traits::is_unit_value_t_category< Category, T > | Trait which tests whether type T is a unit_value_t with a unit type in the given category |
| Cwpi::FirstIndexOfType< T, T, Us... > | |
| Cwpi::FirstIndexOfType< T, U, Us... > | |
| Cwpi::TypesAreDistinct< Ts > | Determine if all types in Ts are distinct |
| Cwpi::detail::ConstantLog2< N > | A tiny meta function to compute the log2 of a compile time constant |
| Cwpi::detail::ConstantLog2< 1 > | |
| Cwpi::detail::TypesAreDistinct< T, Us > | |
| Cwpi::detail_expected::is_nothrow_swappable< T, U > | |
| Cwpi::detail_expected::is_swappable< T, U > | |
| Cwpi::detail_expected::is_swappable< T[N], T[N]> | |
| Cwpi::detail_expected::swap_adl_tests::is_adl_swap_noexcept< T, U > | |
| ►Cwpi::detail_expected::swap_adl_tests::is_std_swap_noexcept< T > | |
| Cwpi::detail_expected::swap_adl_tests::is_std_swap_noexcept< T[N]> | |
| Cwpi::hashing::detail::is_hashable_data< T > | Trait to indicate whether a type's bits can be hashed directly |
| Cwpi::hashing::detail::is_hashable_data< std::pair< T, U > > | |
| Cwpi::memory::detail::is_composable_allocator< T, std::integral_constant< bool, true > > | |
| Cwpi::memory::detail::is_raw_allocator< T, std::integral_constant< bool, true > > | |
| Cwpi::memory::forward_list_node_size< T > | Contains the node size of a node based STL container with a specific type |
| Cwpi::memory::is_thread_safe_allocator< RawAllocator > | Specifies whether or not a RawAllocator is thread safe as-is |
| Cwpi::memory::list_node_size< T > | Contains the node size of a node based STL container with a specific type. |
| Cwpi::memory::map_node_size< T > | Contains the node size of a node based STL container with a specific type |
| Cwpi::memory::multimap_node_size< T > | Contains the node size of a node based STL container with a specific type. |
| Cwpi::memory::multiset_node_size< T > | Contains the node size of a node based STL container with a specific type. |
| Cwpi::memory::set_node_size< T > | Contains the node size of a node based STL container with a specific type. |
| Cwpi::memory::shared_ptr_node_size< T, StdAllocator > | Contains the node size of a node based STL container with a specific type. |
| Cwpi::memory::unordered_map_node_size< T > | Contains the node size of a node based STL container with a specific type. |
| Cwpi::memory::unordered_multimap_node_size< T > | Contains the node size of a node based STL container with a specific type. |
| Cwpi::memory::unordered_multiset_node_size< T > | Contains the node size of a node based STL container with a specific type. |
| Cwpi::memory::unordered_set_node_size< T > | Contains the node size of a node based STL container with a specific type. |
| Cdetail::internal_iterator< BasicJsonType > | Iterator value |
| Cdetail::internal_iterator< typename std::remove_const< BasicJsonType >::type > | |
| Cwpi::interpolating_map< Key, Value > | Implements a table of key-value pairs with linear interpolation between values |
| Cwpi::interpolating_map< units::meters_per_second_t, Matrixd< 2, 3 > > | |
| Cwpi::interpolating_map< units::meters_per_second_t, Matrixd< 2, 5 > > | |
| CHAL_HMBData::Interrupts::Interrupt | |
| Chal::InterruptManager | |
| CHAL_HMBData::Interrupts | |
| Csleipnir::IntrusiveSharedPtr< T > | A custom intrusive shared pointer implementation without thread synchronization overhead |
| Csleipnir::IntrusiveSharedPtr< Expression > | |
| Cwpi::memory::traits_detail::invalid_allocator_concept< T > | |
| Cwpi::detail_expected::invoke_result_impl< F, class, Us > | |
| Cwpi::detail_expected::invoke_result_impl< F, decltype(detail_expected::invoke(std::declval< F >(), std::declval< Us >()...), void()), Us... > | |
| ►Cstd::is_base_of | |
| Cdetail::is_compiled_string< S > | |
| Cunits::traits::is_base_unit< T > | Trait which tests if a class is a base_unit type |
| Cdetail::is_bit_reference_like< T > | |
| Cwpi::memory::is_block_allocator< T > | Traits that check whether a type models concept BlockAllocator |
| Cdetail::is_compatible_array_type_impl< BasicJsonType, CompatibleArrayType, enable_if_t< is_detected< iterator_t, CompatibleArrayType >::value &&is_iterator_traits< iterator_traits< detected_t< iterator_t, CompatibleArrayType > > >::value &&!std::is_same< CompatibleArrayType, detected_t< range_value_t, CompatibleArrayType > >::value > > | |
| Cdetail::is_compatible_integer_type_impl< RealIntegerType, CompatibleNumberIntegerType, enable_if_t< std::is_integral< RealIntegerType >::value &&std::is_integral< CompatibleNumberIntegerType >::value &&!std::is_same< bool, CompatibleNumberIntegerType >::value > > | |
| Cdetail::is_compatible_object_type_impl< BasicJsonType, CompatibleObjectType, enable_if_t< is_detected< mapped_type_t, CompatibleObjectType >::value &&is_detected< key_type_t, CompatibleObjectType >::value > > | |
| Cdetail::is_compatible_string_type< BasicJsonType, CompatibleStringType > | |
| Cdetail::is_compatible_type_impl< BasicJsonType, CompatibleType, enable_if_t< is_complete_type< CompatibleType >::value > > | |
| ►Cstd::is_constructible | |
| Cdetail::is_constructible< T, Args > | |
| Cdetail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< !std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value &&!is_compatible_string_type< BasicJsonType, ConstructibleArrayType >::value &&is_default_constructible< ConstructibleArrayType >::value &&(std::is_move_assignable< ConstructibleArrayType >::value||std::is_copy_assignable< ConstructibleArrayType >::value)&&is_detected< iterator_t, ConstructibleArrayType >::value &&is_iterator_traits< iterator_traits< detected_t< iterator_t, ConstructibleArrayType > > >::value &&is_detected< range_value_t, ConstructibleArrayType >::value &&!std::is_same< ConstructibleArrayType, detected_t< range_value_t, ConstructibleArrayType > >::value &&is_complete_type< detected_t< range_value_t, ConstructibleArrayType > >::value > > | |
| Cdetail::is_constructible_object_type_impl< BasicJsonType, ConstructibleObjectType, enable_if_t< is_detected< mapped_type_t, ConstructibleObjectType >::value &&is_detected< key_type_t, ConstructibleObjectType >::value > > | |
| Cdetail::is_constructible_string_type< BasicJsonType, ConstructibleStringType > | |
| Cdetail::is_container_adaptor_like< T > | |
| ►Cstd::is_convertible | |
| Cdetail::is_std_string_like< T, void_t< decltype(std::declval< T >().find_first_of(typename T::value_type(), 0))> > | |
| ►Cstd::is_default_constructible | |
| Cdetail::is_default_constructible< T > | |
| ►Cis_detected | |
| Cdetail::is_detected_lazy< Op, Args > | |
| Cunits::traits::is_dimensionless_unit< T > | |
| ►Cis_formattable | |
| Cdetail::is_formattable_delayed< R, Char > | |
| Cdetail::is_getable< BasicJsonType, T > | |
| ►Cstd::is_integral | |
| Cdetail::is_integral< T > | |
| Cwpi::is_integral_or_enum< T > | Metafunction that determines whether the given type is either an integral type or an enumeration type, including enum classes |
| Cdetail::is_iterator_of_multibyte< T > | |
| Cdetail::is_iterator_traits< iterator_traits< T > > | |
| Cdetail::is_map< T > | |
| Cdetail::is_ordered_map< T > | |
| Cdetail::is_range< T > | |
| Cis_range< T, Char > | |
| ►Cstd::is_same | |
| Cunits::traits::is_convertible_unit< U1, U2 > | Trait which checks whether two units can be converted to each other |
| Cwpi::memory::detail::has_invalid_alloc_function< T > | |
| Cwpi::memory::detail::has_invalid_dealloc_function< T > | |
| Cwpi::memory::detail::has_invalid_try_alloc_function< T > | |
| Cwpi::memory::detail::has_invalid_try_dealloc_function< T > | |
| Cdetail::is_sax< SAX, BasicJsonType > | |
| Cdetail::is_sax_static_asserts< SAX, BasicJsonType > | |
| Cdetail::is_set< T > | |
| Cwpi::is_simple_type< X > | |
| Cwpi::memory::traits_detail::is_stateful_impl< Allocator, IsEmpty > | |
| Cwpi::memory::traits_detail::is_stateful_impl< Allocator, false > | |
| Cwpi::memory::traits_detail::is_stateful_impl< Allocator, true > | |
| Cis_tuple_formattable< T, C > | |
| Cdetail::is_tuple_formattable_< T, C, bool > | |
| Cdetail::is_tuple_formattable_< T, C, true > | |
| Cis_tuple_like< T > | |
| Cdetail::is_tuple_like_< T > | |
| Cdetail::is_zero_int | |
| Cwpi::isa_impl< To, From, Enabler > | |
| Cwpi::isa_impl< To, From, std::enable_if_t< std::is_base_of_v< To, From > > > | |
| Cwpi::isa_impl_cl< To, From > | |
| Cwpi::isa_impl_cl< To, const From * > | |
| Cwpi::isa_impl_cl< To, const From *const > | |
| Cwpi::isa_impl_cl< To, const From > | |
| Cwpi::isa_impl_cl< To, const std::unique_ptr< From > > | |
| Cwpi::isa_impl_cl< To, From * > | |
| Cwpi::isa_impl_cl< To, From *const > | |
| Cwpi::isa_impl_wrap< To, From, SimpleFrom > | |
| Cwpi::isa_impl_wrap< To, FromTy, FromTy > | |
| Cwpi::detail::IsaAndPresentCheckPredicate< Types > | |
| Cwpi::detail::IsaCheckPredicate< Types > | |
| Cwpi::details::IsChoiceTypeSupported< T > | |
| Cwpi::detail::IsPointerLike< T > | |
| Cwpi::detail::IsPointerLike< T * > | |
| Cdetail::iter_impl< BasicJsonType > | Template for a bidirectional iterator for the basic_json class This class implements a both iterators (iterator and const_iterator) for the basic_json class |
| Cwpi::memory::iteration_allocator< N, BlockOrRawAllocator > | A stateful RawAllocator that is designed for allocations in a loop |
| ►Cwpi::memory::iteration_allocator< 2, default_allocator > | |
| Cwpi::memory::double_frame_allocator< BlockOrRawAllocator > | An alias for iteration_allocator for two iterations |
| Cdetail::iteration_proxy< IteratorType > | Proxy class for the items() function |
| Cdetail::iteration_proxy_value< IteratorType > | |
| Csleipnir::VariableBlock< Mat >::iterator | |
| Csleipnir::VariableMatrix::iterator | |
| Cwpi::circular_buffer< T >::iterator | |
| Cwpi::rotated_span< T, Extent >::iterator | |
| Cwpi::static_circular_buffer< T, N >::iterator | |
| ►Cwpi::iterator_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT > | CRTP base class which implements the entire standard iterator facade in terms of a minimal subset of the interface |
| ►Cwpi::iterator_adaptor_base< DerivedT, WrappedIteratorT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT > | CRTP base class for adapting an iterator to a different type |
| Cwpi::pointee_iterator< WrappedIteratorT, T > | An iterator type that allows iterating over the pointees via some other iterator |
| Cwpi::pointer_iterator< WrappedIteratorT, T > | |
| Cwpi::iterator_facade_base< DerivedT, typename std::iterator_traits< WrappedIteratorT >::iterator_category, typename std::iterator_traits< WrappedIteratorT >::value_type, typename std::iterator_traits< WrappedIteratorT >::difference_type, std::conditional_t< std::is_same< typename std::iterator_traits< WrappedIteratorT >::value_type, typename std::iterator_traits< WrappedIteratorT >::value_type >::value, typename std::iterator_traits< WrappedIteratorT >::pointer, typename std::iterator_traits< WrappedIteratorT >::value_type * >, std::conditional_t< std::is_same< typename std::iterator_traits< WrappedIteratorT >::value_type, typename std::iterator_traits< WrappedIteratorT >::value_type >::value, typename std::iterator_traits< WrappedIteratorT >::reference, typename std::iterator_traits< WrappedIteratorT >::value_type & > > | |
| ►Citerator_facade_base< pointee_iterator | |
| Cwpi::iterator_adaptor_base< pointee_iterator< WrappedIteratorT, std::remove_reference_t< decltype(**std::declval< WrappedIteratorT >())> >, WrappedIteratorT, std::iterator_traits< WrappedIteratorT >::iterator_category, std::remove_reference_t< decltype(**std::declval< WrappedIteratorT >())> > | |
| ►Cwpi::iterator_facade_base< SmallSetIterator< T, N, C >, std::forward_iterator_tag, T > | |
| Cwpi::SmallSetIterator< T, N, C > | SmallSetIterator - This class implements a const_iterator for SmallSet by delegating to the underlying SmallVector or Set iterators |
| Cdetail::iterator_input_adapter< IteratorType > | |
| Cdetail::iterator_input_adapter_factory< IteratorType, Enable > | |
| Cdetail::iterator_input_adapter_factory< IteratorType, enable_if_t< is_iterator_of_multibyte< IteratorType >::value > > | |
| Cwpi::iterator_range< IteratorT > | A range adaptor for a pair of iterators |
| Cdetail::iterator_traits< T, typename > | |
| Cstd::iterator_traits< fmt::basic_appender< T > > | |
| Cdetail::iterator_traits< T *, enable_if_t< std::is_object< T >::value > > | |
| Cdetail::iterator_types< It, typename > | |
| Cdetail::iterator_types< It, void_t< typename It::difference_type, typename It::value_type, typename It::pointer, typename It::reference, typename It::iterator_category > > | |
| ►Cdetail::iterator_types< T > | |
| Cdetail::iterator_traits< T, enable_if_t< !std::is_pointer< T >::value > > | |
| Csleipnir::Jacobian | This class calculates the Jacobian of a vector of variables with respect to a vector of variables |
| ►Cwpi::java::JClass | Finds a class and keeps it as a global reference |
| Cwpi::java::JException | Finds an exception class and keep it as a global reference |
| Cwpi::java::JClassInit | |
| Cwpi::java::JExceptionInit | |
| Cwpi::java::JGlobal< T > | |
| Cwpi::java::JLocal< T > | Container class for cleaning up Java local references |
| Cwpi::memory::joint | Tag type that can't be created |
| Cwpi::memory::joint_allocator | A RawAllocator that uses the additional joint memory for its allocation |
| Cwpi::memory::joint_array< T > | A zero overhead dynamic array using joint memory |
| Cwpi::memory::joint_ptr< T, RawAllocator > | A pointer to an object where all allocations are joint |
| Cwpi::memory::joint_size | Tag type to make the joint size more explicit |
| Cwpi::memory::detail::joint_stack | |
| Cwpi::memory::joint_type< T > | CRTP base class for all objects that want to use joint memory |
| ►Cwpi::detail::json_base_class | |
| Cbasic_json< ObjectType, ArrayType, StringType, BooleanType, NumberIntegerType, NumberUnsignedType, NumberFloatType, AllocatorType, JSONSerializer, BinaryType, CustomBaseClass > | Namespace for Niels Lohmann |
| Cdetail::json_default_base | Default base class of the basic_json class |
| Cjson_pointer< RefStringType > | JSON Pointer defines a string syntax for identifying a specific value within a JSON document |
| Cdetail::json_ref< BasicJsonType > | |
| Cjson_sax< BasicJsonType > | SAX interface |
| Cdetail::json_sax_acceptor< BasicJsonType > | |
| Cdetail::json_sax_dom_callback_parser< BasicJsonType > | |
| Cdetail::json_sax_dom_parser< BasicJsonType > | SAX implementation to create a JSON value from SAX events |
| Cwpi::java::detail::JSpanBase< T, IsCritical, Size > | Helper class for working with JNI arrays |
| Cwpi::java::JStringRef | Java string (jstring) reference |
| Cfrc::KalmanFilter< States, Inputs, Outputs > | A Kalman filter combines predictions from a model and measurements to give an estimate of the true system state |
| Cfrc::KalmanFilterLatencyCompensator< States, Inputs, Outputs, KalmanFilterType > | This class incorporates time-delayed measurements into a Kalman filter's state estimate |
| Cfrc::Kinematics< WheelSpeeds, WheelPositions > | Helper class that converts a chassis velocity (dx, dy, and dtheta components) into individual wheel speeds |
| ►Cfrc::Kinematics< DifferentialDriveWheelSpeeds, DifferentialDriveWheelPositions > | |
| Cfrc::DifferentialDriveKinematics | Helper class that converts a chassis velocity (dx and dtheta components) to left and right wheel velocities for a differential drive |
| ►Cfrc::Kinematics< MecanumDriveWheelSpeeds, MecanumDriveWheelPositions > | |
| Cfrc::MecanumDriveKinematics | Helper class that converts a chassis velocity (dx, dy, and dtheta components) into individual wheel speeds |
| ►Cfrc::Kinematics< wpi::array< SwerveModuleState, NumModules >, wpi::array< SwerveModulePosition, NumModules > > | |
| Cfrc::SwerveDriveKinematics< NumModules > | Helper class that converts a chassis velocity (dx, dy, and dtheta components) into individual module states (speed and angle) |
| Cfrc::sim::DifferentialDrivetrainSim::KitbotGearing | Represents a gearing option of the Toughbox mini |
| Cfrc::sim::DifferentialDrivetrainSim::KitbotMotor | Represents common motor layouts of the kit drivetrain |
| Cfrc::sim::DifferentialDrivetrainSim::KitbotWheelSize | Represents common wheel sizes of the kit drivetrain |
| Cfrc::LayoutType | Represents the type of a layout in Shuffleboard |
| Cfrc::LEDPattern | |
| Cfrc::LEDPattern::LEDReader | A wrapper around a length and an arbitrary reader function that accepts an LED index and returns data for the LED at that index |
| Cstd::less< ::wpi::detail::value_t > | |
| Cwpi::structparser::Lexer | Raw struct schema lexer |
| ►Cdetail::lexer_base< BasicJsonType > | |
| Cdetail::lexer< BasicJsonType, InputAdapterType > | Lexical analysis |
| Cunits::linear_scale< T > | Unit_t scale which is linear |
| ►Cunits::linear_scale< UNIT_LIB_DEFAULT_TYPE > | |
| Cunits::unit_t< kv_unit > | |
| Cunits::unit_t< ka_unit > | |
| Cunits::unit_t< units::compound_unit< units::volt, units::inverse< units::second > > > | |
| Cunits::unit_t< units::compound_unit< units::radians_per_second, units::inverse< units::volt > > > | |
| Cunits::unit_t< units::compound_unit< units::newton_meters, units::inverse< units::ampere > > > | |
| Cunits::unit_t< Input > | |
| Cunits::unit_t< units::inverse< units::seconds > > | |
| Cunits::unit_t< units::compound_unit< Acceleration, units::inverse< Input > > > | |
| Cunits::unit_t< Distance > | |
| Cunits::unit_t< Velocity > | |
| Cunits::unit_t< units::radian > | |
| Cunits::unit_t< b_unit > | |
| Cunits::unit_t< zeta_unit > | |
| Cunits::unit_t< Rate > | |
| Cunits::unit_t< Unit > | |
| Cunits::unit_t< units::compound_unit< units::radians, units::inverse< units::meters > > > | |
| Cunits::unit_t< Acceleration > | |
| Cunits::unit_t< Units, T, NonLinearScale > | Container for values which represent quantities of a given unit |
| Cfrc::LinearFilter< T > | This class implements a linear, digital filter |
| Cfrc::LinearPlantInversionFeedforward< States, Inputs > | Constructs a plant inversion model-based feedforward from a LinearSystem |
| Cfrc::LinearQuadraticRegulator< States, Inputs > | Contains the controller coefficients and logic for a linear-quadratic regulator (LQR) |
| Cfrc::LinearSystem< States, Inputs, Outputs > | A plant defined using state-space notation |
| Cfrc::LinearSystem< 2, 2, 2 > | |
| Cfrc::LinearSystemId | Linear system ID utility functions |
| Cfrc::LinearSystemLoop< States, Inputs, Outputs > | Combines a controller, feedforward, and observer for controlling a mechanism with full state feedback |
| Cfrc::sim::LinearSystemSim< States, Inputs, Outputs > | This class helps simulate linear systems |
| ►Cfrc::sim::LinearSystemSim< 1, 1, 1 > | |
| Cfrc::sim::FlywheelSim | Represents a simulated flywheel mechanism |
| ►Cfrc::sim::LinearSystemSim< 2, 1, 2 > | |
| Cfrc::sim::DCMotorSim | Represents a simulated DC motor mechanism |
| Cfrc::sim::ElevatorSim | Represents a simulated elevator mechanism |
| Cfrc::sim::SingleJointedArmSim | Represents a simulated arm mechanism |
| ►Cstd::list | |
| Cwpi::memory::list< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::list_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| Cfrc::detail::ListenerExecutor | An executor for running listener tasks posted by Sendable listeners synchronously from the main application thread |
| Cfrc::LiveWindow | Public interface for putting sensors and actuators on the LiveWindow |
| Cloc_value | |
| Cdetail::loc_writer< Char > | |
| Cdetail::local_t | |
| Cdetail::locale | |
| ►Cdetail::locale_ref | |
| Ccontext | |
| Cwpi::memory::detail::locked_allocator< Alloc, Mutex > | |
| Cwpi::memory::detail::log2_access_policy | |
| Cwpi::memory::log2_buckets | A BucketDistribution for memory_pool_collection defining that there is a bucket, i.e |
| Cwpi::Logger | |
| Cnt::LogMessage | NetworkTables log message |
| Cwpi::memory::detail::lowlevel_allocator_leak_handler< Functor > | |
| Cfrc::LTVDifferentialDriveController | The linear time-varying differential drive controller has a similar form to the LQR, but the model used to compute the controller gain is the nonlinear differential drive model linearized around the drivetrain's current state |
| Cfrc::LTVUnicycleController | The linear time-varying unicycle controller has a similar form to the LQR, but the model used to compute the controller gain is the nonlinear unicycle model linearized around the drivetrain's current state |
| Cdetail::make_integer_sequence< T, N, Ns > | |
| Cwpi::memory::detail::make_segregator_t< Segregatables > | |
| Cwpi::memory::detail::make_segregator_t< Segregatable > | |
| Cwpi::memory::detail::make_segregator_t< Segregatable, RawAllocator > | |
| Cwpi::memory::detail::make_segregator_t< Segregatable, Tail... > | |
| ►Cstd::make_unsigned | |
| Cdetail::make_unsigned_or_bool< T > | |
| Cdetail::make_unsigned_or_bool< bool > | |
| Cdetail::make_unsigned_or_unchanged< T, INTEGRAL > | |
| Cdetail::make_unsigned_or_unchanged< T, true > | |
| Cdetail::make_void< Ts > | |
| Cwpi::memory::detail::malloc_allocator_impl | |
| ►Cstd::map | |
| Cwpi::memory::map< Key, Value, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::map_scoped_alloc< Key, Value, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| ►Cstd::map< std::string, EntryInfo, std::less<>, std::allocator< std::pair< const std::string, EntryInfo > > > | |
| Cwpi::StringMap< EntryInfo > | |
| ►Cstd::map< std::string, frc::MechanismRoot2d, std::less<>, std::allocator< std::pair< const std::string, frc::MechanismRoot2d > > > | |
| Cwpi::StringMap< frc::MechanismRoot2d > | |
| ►Cstd::map< std::string, frc::ShuffleboardLayout *, std::less<>, std::allocator< std::pair< const std::string, frc::ShuffleboardLayout * > > > | |
| Cwpi::StringMap< frc::ShuffleboardLayout * > | |
| ►Cstd::map< std::string, MotorEntries, std::less<>, std::allocator< std::pair< const std::string, MotorEntries > > > | |
| Cwpi::StringMap< MotorEntries > | |
| ►Cstd::map< std::string, nt::Value, std::less<>, std::allocator< std::pair< const std::string, nt::Value > > > | |
| Cwpi::StringMap< nt::Value > | |
| ►Cstd::map< std::string, NT_Entry, std::less<>, std::allocator< std::pair< const std::string, NT_Entry > > > | |
| Cwpi::StringMap< NT_Entry > | |
| ►Cstd::map< std::string, ProtoFile, std::less<>, std::allocator< std::pair< const std::string, ProtoFile > > > | |
| Cwpi::StringMap< ProtoFile > | |
| ►Cstd::map< std::string, size_t, std::less<>, std::allocator< std::pair< const std::string, size_t > > > | |
| Cwpi::StringMap< size_t > | |
| ►Cstd::map< std::string, std::chrono::nanoseconds, std::less<>, std::allocator< std::pair< const std::string, std::chrono::nanoseconds > > > | |
| Cwpi::StringMap< std::chrono::nanoseconds > | |
| ►Cstd::map< std::string, std::string_view, std::less<>, std::allocator< std::pair< const std::string, std::string_view > > > | |
| Cwpi::StringMap< std::string_view > | |
| ►Cstd::map< std::string, std::unique_ptr< frc::MechanismObject2d >, std::less<>, std::allocator< std::pair< const std::string, std::unique_ptr< frc::MechanismObject2d > > > > | |
| Cwpi::StringMap< std::unique_ptr< frc::MechanismObject2d > > | |
| ►Cstd::map< std::string, std::unique_ptr< google::protobuf::Message >, std::less<>, std::allocator< std::pair< const std::string, std::unique_ptr< google::protobuf::Message > > > > | |
| Cwpi::StringMap< std::unique_ptr< google::protobuf::Message > > | |
| ►Cstd::map< std::string, T, std::less<>, std::allocator< std::pair< const std::string, T > > > | |
| Cwpi::StringMap< T, Allocator > | StringMap is a sorted associative container that contains key-value pairs with unique string keys |
| ►Cstd::map< std::string, void *, std::less<>, std::allocator< std::pair< const std::string, void * > > > | |
| Cwpi::StringMap< void * > | |
| ►Cstd::map< std::string, wpi::StructDescriptor, std::less<>, std::allocator< std::pair< const std::string, wpi::StructDescriptor > > > | |
| Cwpi::StringMap< wpi::StructDescriptor > | |
| Cwpi::MappedFileRegion | |
| Cwpi::MapVector< KeyT, ValueT, MapType, VectorType > | This class implements a map that also provides access to all stored values in a deterministic order |
| ►Cwpi::MapVector< KeyT, ValueT, SmallDenseMap< KeyT, unsigned, N >, SmallVector< std::pair< KeyT, ValueT >, N > > | |
| Cwpi::SmallMapVector< KeyT, ValueT, N > | A MapVector that performs no allocations if smaller than a certain size |
| Cmatd_chol_t | Creates a double matrix with the Cholesky lower triangular matrix of A |
| Cmatd_plu_t | |
| Cmatd_svd_t | |
| Cmatd_t | Defines a matrix structure for holding double-precision values with data in row-major order (i.e |
| Cwpi::math::MathShared | |
| Cwpi::math::MathSharedStore | |
| Cfrc::MecanumDriveWheelPositions | Represents the wheel positions for a mecanum drive drivetrain |
| Cfrc::MecanumDriveWheelSpeeds | Represents the wheel speeds for a mecanum drive drivetrain |
| Cfrc2::sysid::Mechanism | |
| ►Cfrc::MechanismObject2d | Common base class for all Mechanism2d node types |
| Cfrc::MechanismLigament2d | Ligament node on a Mechanism2d |
| Cfrc::MechanismRoot2d | Root Mechanism2d node |
| Cfrc::MedianFilter< T > | A class that implements a moving-window median filter |
| Cwpi::memory::memory_arena< BlockAllocator, Cached > | A memory arena that manages huge memory blocks for a higher-level allocator |
| Cwpi::memory::memory_arena< allocator_type > | |
| Cwpi::memory::memory_arena< allocator_type, false > | |
| Cwpi::memory::detail::memory_arena_cache< Cached > | |
| Cwpi::memory::detail::memory_arena_cache< cached_arena > | |
| Cwpi::memory::detail::memory_arena_cache< uncached_arena > | |
| Cwpi::memory::memory_block | A memory block |
| Cwpi::memory::detail::memory_block_stack | |
| Cwpi::memory::memory_pool< PoolType, BlockOrRawAllocator > | A stateful RawAllocator that manages nodes of fixed size |
| Cwpi::memory::memory_pool_collection< PoolType, BucketDistribution, BlockOrRawAllocator > | A stateful RawAllocator that behaves as a collection of multiple memory_pool objects |
| ►Cwpi::memory::memory_pool_collection< node_pool, identity_buckets, default_allocator > | |
| Cwpi::memory::bucket_allocator< PoolType, ImplAllocator > | An alias for memory_pool_collection using the identity_buckets policy and a PoolType defaulting to node_pool |
| Cwpi::memory::detail::memory_pool_collection_leak_handler | |
| Cwpi::memory::detail::memory_pool_leak_handler | |
| ►Cfoonathan_memory_pmr::memory_resource | |
| ►Cwpi::memory::memory_resource | The memory_resource abstract base class used in the implementation |
| Cwpi::memory::memory_resource_adapter< RawAllocator > | Wraps a RawAllocator and makes it a memory_resource |
| Cwpi_memory_pmr::memory_resource | |
| Cwpi::memory::memory_resource_allocator | Wraps a memory_resource and makes it a RawAllocator |
| Cwpi::memory::memory_stack< BlockOrRawAllocator > | A stateful RawAllocator that provides stack-like (LIFO) allocations |
| Cwpi::memory::memory_stack< temporary_block_allocator > | |
| Cwpi::memory::detail::memory_stack_leak_handler | |
| Cwpi::memory::memory_stack_raii_unwind< Stack > | Simple utility that automatically unwinds a Stack to a previously saved location |
| Cwpi::memory::memory_stack_raii_unwind< wpi::memory::temporary_stack > | |
| ►Cwpi::MemoryBuffer | This interface provides simple read-only access to a block of memory, and provides simple methods for reading files and standard input into a memory buffer |
| Cwpi::SmallVectorMemoryBuffer | SmallVector-backed MemoryBuffer instance |
| Cwpi::WritableMemoryBuffer | This class is an extension of MemoryBuffer, which allows copy-on-write access to the underlying contents |
| Cwpi::WriteThroughMemoryBuffer | This class is an extension of MemoryBuffer, which allows write access to the underlying contents and committing those changes to the original source |
| Cwpi::MemoryBufferRef | |
| Cfrc::MerweScaledSigmaPoints< States > | Generates sigma points and weights according to Van der Merwe's 2004 dissertation[1] for the UnscentedKalmanFilter class |
| Cnanopb::MessageDescriptor< GenMessageT > | |
| Cwpi::log::MetadataRecordData | Data contained in a set metadata control record as created by DataLog::SetMetadata() |
| Cfrc::TrajectoryConstraint::MinMax | Represents a minimum and maximum acceleration |
| Cmonostate | |
| Cwpi::monostate | |
| Cmonth | |
| ►Cfrc::MotorController | Interface for motor controlling devices |
| Cfrc::MotorControllerGroup | Allows multiple MotorController objects to be linked together |
| Cfrc::NidecBrushless | Nidec Brushless Motor |
| ►Cfrc::PWMMotorController | Common base class for all PWM Motor Controllers |
| Cfrc::DMC60 | Digilent DMC 60 Motor Controller with PWM control |
| Cfrc::Jaguar | Luminary Micro / Vex Robotics Jaguar Motor Controller with PWM control |
| Cfrc::Koors40 | AndyMark Koors40 Motor Controller with PWM control |
| Cfrc::PWMSparkFlex | REV Robotics SPARK Flex Motor Controller with PWM control |
| Cfrc::PWMSparkMax | REV Robotics SPARK MAX Motor Controller with PWM control |
| Cfrc::PWMTalonFX | Cross the Road Electronics (CTRE) Talon FX Motor Controller with PWM control |
| Cfrc::PWMTalonSRX | Cross the Road Electronics (CTRE) Talon SRX Motor Controller with PWM control |
| Cfrc::PWMVenom | Playing with Fusion Venom Motor Controller with PWM control |
| Cfrc::PWMVictorSPX | Cross the Road Electronics (CTRE) Victor SPX Motor Controller with PWM control |
| Cfrc::RomiMotor | RomiMotor |
| Cfrc::SD540 | Mindsensors SD540 Motor Controller with PWM control |
| Cfrc::Spark | REV Robotics SPARK Motor Controller with PWM control |
| Cfrc::Talon | Cross the Road Electronics (CTRE) Talon Motor Controller with PWM control |
| Cfrc::Victor | Vex Robotics Victor 888 Motor Controller with PWM control |
| Cfrc::VictorSP | Vex Robotics Victor SP Motor Controller with PWM control |
| Cfrc::XRPMotor | XRPMotor |
| Cfrc::sysid::SysIdRoutineLog::MotorLog | Logs data from a single motor during a SysIdRoutine |
| ►Cfrc::MotorSafety | The Motor Safety feature acts as a watchdog timer for an individual motor |
| Cfrc::NidecBrushless | Nidec Brushless Motor |
| Cfrc::PWMMotorController | Common base class for all PWM Motor Controllers |
| Cfrc::Relay | Class for Spike style relay outputs |
| ►Cfrc::RobotDriveBase | Common base class for drive platforms |
| Cfrc::DifferentialDrive | A class for driving differential drive/skid-steer drive platforms such as the Kit of Parts drive base, "tank drive", or West Coast Drive |
| Cfrc::MecanumDrive | A class for driving Mecanum drive platforms |
| Cfrc::XRPMotor | XRPMotor |
| Cwpi::MulticastServiceAnnouncer | |
| Cwpi::MulticastServiceResolver | |
| ►Cstd::multimap | |
| Cwpi::memory::multimap< Key, Value, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::multimap_scoped_alloc< Key, Value, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| ►Cstd::multiset | |
| Cwpi::memory::multiset< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::multiset_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| Csleipnir::MultistartResult< DecisionVariables > | The result of a multistart solve |
| Cnt::MultiSubscriber | Subscribe to multiple topics based on one or more topic name prefixes |
| Cwpi::memory::detail::mutex_storage< Mutex > | |
| Cwpi::memory::detail::mutex_storage< no_mutex > | |
| Cwpi::ArgumentParser::MutuallyExclusiveGroup | |
| Cdetail::named_arg_info< Char > | |
| Cdetail::named_arg_info< char_type > | |
| Cdetail::named_arg_info< typename Context::char_type > | |
| Cdetail::named_arg_store< Context, NUM_ARGS, NUM_NAMED_ARGS, DESC > | |
| Cdetail::named_arg_value< Char > | |
| Cdetail::named_arg_value< char_type > | |
| Cdetail::native_formatter< T, Char, TYPE > | |
| ►Cdetail::native_formatter< detail::float128, Char, detail::type::float_type > | |
| Cformatter< detail::float128, Char > | |
| ►Cdetail::native_formatter< T, Char, detail::type_constant< T, Char >::value > | |
| Cformatter< T, Char, enable_if_t< detail::type_constant< T, Char >::value !=detail::type::custom_type > > | |
| Cnested_formatter< T, Char > | |
| ►Cnested_formatter< string_view > | |
| Cformatter< std::bitset< N >, Char > | |
| Cnested_view< T, Char > | |
| ►Cwpi::NetworkAcceptor | |
| Cwpi::TCPAcceptor | |
| ►Cwpi::NetworkStream | |
| Cwpi::TCPStream | |
| Cnt::NetworkTable | A network table that knows its subtable path |
| Cnt::NetworkTableEntry | NetworkTables Entry |
| Cnt::NetworkTableInstance | NetworkTables Instance |
| Cnt::NetworkTableListener | Event listener |
| Cnt::NetworkTableListenerPoller | Event polled listener |
| Cwpi::memory::detail::new_allocator_impl | |
| Cwpi::detail_expected::no_init_t | |
| ►Cwpi::memory::detail::no_leak_checker< Handler > | |
| Cwpi::memory::detail::lowlevel_allocator< Functor > | |
| Cwpi::memory::no_mutex | A dummy Mutex class that does not lock anything |
| Cdetail::node< typename > | |
| Cwpi::memory::node_pool | Tag type defining a memory pool optimized for nodes |
| Csleipnir::slicing::none_t | |
| Cdetail::nonesuch | |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::NonTrivialCallbacks | A struct we use to aggregate three callbacks when we need full set of operations |
| Cfrc::Notifier | Notifiers run a user-provided callback function on a separate thread |
| CNT_ConnectionInfo | NetworkTables Connection Information |
| CNT_Event | NetworkTables event |
| CNT_LogMessage | NetworkTables log message |
| CNT_Meta_Client | Client (as published via $clients) |
| CNT_Meta_ClientPublisher | Client publisher (as published via $clientpub$<client> or $serverpub) |
| CNT_Meta_ClientSubscriber | Client subscriber (as published via $clientsub$<client> or $serversub) |
| CNT_Meta_SubscriberOptions | Subscriber options |
| CNT_Meta_TopicPublisher | Topic publisher (as published via $pub$<topic>) |
| CNT_Meta_TopicSubscriber | Topic subscriber (as published via $sub$<topic>) |
| CNT_PubSubOptions | NetworkTables publish/subscribe options |
| CNT_TimestampedBoolean | Timestamped Boolean |
| CNT_TimestampedBooleanArray | Timestamped BooleanArray |
| CNT_TimestampedDouble | Timestamped Double |
| CNT_TimestampedDoubleArray | Timestamped DoubleArray |
| CNT_TimestampedFloat | Timestamped Float |
| CNT_TimestampedFloatArray | Timestamped FloatArray |
| CNT_TimestampedInteger | Timestamped Integer |
| CNT_TimestampedIntegerArray | Timestamped IntegerArray |
| CNT_TimestampedRaw | Timestamped Raw |
| CNT_TimestampedString | Timestamped String |
| CNT_TimestampedStringArray | Timestamped StringArray |
| CNT_TimeSyncEventData | NetworkTables time sync event data |
| CNT_TopicInfo | NetworkTables Topic Information |
| CNT_Value | NetworkTables Entry Value |
| CNT_ValueEventData | NetworkTables value event data |
| Cdetail::null< T > | |
| Cwpi::memory::null_allocator | A composable RawAllocator that will always fail |
| Cdetail::null_chrono_spec_handler< Derived > | |
| ►Cdetail::null_chrono_spec_handler< chrono_format_checker > | |
| Cdetail::chrono_format_checker | |
| ►Cdetail::null_chrono_spec_handler< tm_format_checker > | |
| Cdetail::tm_format_checker | |
| ►Cwpi::NullableValueCastFailed< To > | All of these cast traits are meant to be implementations for useful casts that users may want to use that are outside the standard behavior |
| Cwpi::ValueFromPointerCast< To, From, Derived > | This cast trait provides casting for the specific case of casting to a value-typed object from a pointer-typed object |
| Cwpi::NullDeleter< T > | |
| Cwpi::sig::detail::NullMutex | |
| Cdetail::numpunct< Char > | |
| ►CNumTraits | |
| CEigen::NumTraits< sleipnir::Variable > | NumTraits specialization that allows instantiating Eigen types with Variable |
| Cfrc::KalmanFilterLatencyCompensator< States, Inputs, Outputs, KalmanFilterType >::ObserverSnapshot | This class contains all the information about our observer at a given time |
| Cfrc::Odometry< WheelSpeeds, WheelPositions > | Class for odometry |
| Cfrc::Odometry3d< WheelSpeeds, WheelPositions > | Class for odometry |
| ►Cfrc::Odometry3d< DifferentialDriveWheelSpeeds, DifferentialDriveWheelPositions > | |
| Cfrc::DifferentialDriveOdometry3d | Class for differential drive odometry |
| ►Cfrc::Odometry3d< MecanumDriveWheelSpeeds, MecanumDriveWheelPositions > | |
| Cfrc::MecanumDriveOdometry3d | Class for mecanum drive odometry |
| ►Cfrc::Odometry3d< wpi::array< SwerveModuleState, NumModules >, wpi::array< SwerveModulePosition, NumModules > > | |
| Cfrc::SwerveDriveOdometry3d< NumModules > | Class for swerve drive odometry |
| ►Cfrc::Odometry< DifferentialDriveWheelSpeeds, DifferentialDriveWheelPositions > | |
| Cfrc::DifferentialDriveOdometry | Class for differential drive odometry |
| ►Cfrc::Odometry< MecanumDriveWheelSpeeds, MecanumDriveWheelPositions > | |
| Cfrc::MecanumDriveOdometry | Class for mecanum drive odometry |
| ►Cfrc::Odometry< wpi::array< SwerveModuleState, NumModules >, wpi::array< SwerveModulePosition, NumModules > > | |
| Cfrc::SwerveDriveOdometry< NumModules > | Class for swerve drive odometry |
| Cfrc::OnBoardIO | This class represents the onboard IO of the Romi reference robot |
| ►Csleipnir::OptimizationProblem | This class allows the user to pose a constrained nonlinear optimization problem in natural mathematical notation and solve it |
| Csleipnir::OCPSolver | This class allows the user to pose and solve a constrained optimal control problem (OCP) in a variety of ways |
| Cwpi::uv::Process::Option | Structure for Spawn() option temporaries |
| Cwpi::memory::detail::ordered_free_memory_list | |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::StorageUnionT::OutOfLineStorageT | |
| Cdetail::output_adapter< CharType, StringType > | |
| ►Cdetail::output_adapter_protocol< CharType > | Abstract output adapter interface |
| Cdetail::output_stream_adapter< CharType > | Output adapter for output streams |
| Cdetail::output_string_adapter< CharType, StringType > | Output adapter for basic_string |
| Cdetail::output_vector_adapter< CharType, AllocatorType > | Output adapter for byte vectors |
| Cdetail::raw_ostream_adapter< CharType > | |
| ►CP | |
| Cconjunction< P > | |
| Cwpi::PackCallback< T > | A callback method that will pack elements when called |
| Cwpi::support::detail::packed_endian_specific_integral< ValueType, Endian, Alignment, ALIGN > | |
| ►Cstd::pair | |
| Cwpi::detail::DenseMapPair< KeyT, unsigned > | |
| Cwpi::detail::DenseMapPair< int, EntryInfo2 > | |
| Cwpi::detail::DenseMapPair< KeyT, ValueT > | |
| Cpam | |
| Cparse_context< Char > | Parsing context consisting of a format string range being parsed and an argument counter for automatic indexing |
| ►Cparse_context< Char > | |
| Cdetail::compile_parse_context< Char > | |
| Cdetail::parse_dynamic_spec_result< Char > | |
| Cdetail::parse_empty_specs< Char > | |
| Cwpi::details::parse_number< T, Param > | |
| Cwpi::details::parse_number< T > | |
| Cwpi::details::parse_number< T, chars_format::binary > | |
| Cwpi::details::parse_number< T, chars_format::fixed > | |
| Cwpi::details::parse_number< T, chars_format::general > | |
| Cwpi::details::parse_number< T, chars_format::hex > | |
| Cwpi::details::parse_number< T, chars_format::scientific > | |
| Cwpi::details::parse_number< T, radix_16 > | |
| Cwpi::details::parse_number< T, radix_2 > | |
| Cwpi::structparser::ParsedDeclaration | Raw struct schema declaration |
| Cwpi::structparser::ParsedSchema | Raw struct schema |
| Cwpi::structparser::Parser | Raw struct schema parser |
| Cdetail::parser< BasicJsonType, InputAdapterType > | Syntax analysis |
| Cpb_bytes_array_s | |
| Cpb_callback_s | |
| Cpb_extension_s | |
| Cpb_extension_type_s | |
| Cpb_field_iter_s | |
| Cpb_filedesc_s | |
| Cpb_istream_s | |
| Cpb_msgdesc_s | |
| Cpb_ostream_s | |
| Cwpi::support::detail::PickAlignment< T, alignment > | value is either alignment, or alignof(T) if alignment is 0 |
| Cpjpeg | |
| Cpjpeg_component | |
| ►Cfrc::PneumaticsBase | Base class for pneumatics devices |
| Cfrc::PneumaticHub | Module class for controlling a REV Robotics Pneumatic Hub |
| Cfrc::PneumaticsControlModule | Module class for controlling a Cross The Road Electronics Pneumatics Control Module |
| ►Cfrc::sim::PneumaticsBaseSim | |
| Cfrc::sim::CTREPCMSim | Class to control a simulated Pneumatic Control Module (PCM) |
| Cfrc::sim::REVPHSim | Class to control a simulated Pneumatic Control Module (PCM) |
| Cpnm | |
| Cfrc::AprilTagDetection::Point | A point |
| Cwpi::PointerIntPair< PointerTy, IntBits, IntType, PtrTraits, Info > | PointerIntPair - This class implements a pair of a pointer and small integer |
| Cwpi::PointerIntPair< wpi::PointerUnion, 1, bool > | |
| Cwpi::PointerIntPairInfo< PointerT, IntBits, PtrTraits > | |
| Cwpi::PointerLikeTypeTraits< T > | A traits type that is used to handle pointer types and things that are just wrappers for pointers as a uniform entity |
| Cwpi::PointerLikeTypeTraits< const T * > | |
| Cwpi::PointerLikeTypeTraits< const T > | |
| Cwpi::PointerLikeTypeTraits< PointerIntPair< PointerTy, IntBits, IntType, PtrTraits > > | |
| Cwpi::PointerLikeTypeTraits< PointerUnion< PTs... > > | |
| Cwpi::PointerLikeTypeTraits< T * > | |
| Cwpi::PointerLikeTypeTraits< uintptr_t > | |
| Cwpi::PointerLikeTypeTraits< void * > | |
| Cwpi::iterator_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::PointerProxy | A proxy object for computing a pointer via indirecting a copy of a reference |
| Cwpi::pointer_union_detail::PointerUnionMembers< Derived, ValTy, I, Types > | |
| Cwpi::pointer_union_detail::PointerUnionMembers< Derived, ValTy, I > | |
| ►Cwpi::pointer_union_detail::PointerUnionMembers< Derived, ValTy, I+1, Types... > | |
| Cwpi::pointer_union_detail::PointerUnionMembers< Derived, ValTy, I, Type, Types... > | |
| ►Cwpi::pointer_union_detail::PointerUnionMembers< PointerUnion< PTs... >, PointerIntPair< void *, pointer_union_detail::bitsRequired(sizeof...(PTs)), int, pointer_union_detail::PointerUnionUIntTraits< PTs... > >, 0, PTs... > | |
| Cwpi::PointerUnion< PTs > | A discriminated union of two or more pointer types, with the discriminator in the low bit of the pointer |
| Cwpi::pointer_union_detail::PointerUnionUIntTraits< PTs > | Provide PointerLikeTypeTraits for void* that is used by PointerUnion for the template arguments |
| Cwpi::CallbackThread< Derived, TUserInfo, TListenerData, TNotifierData >::Poller | |
| Csleipnir::PoolAllocator< T > | This class is an allocator for the pool resource |
| Csleipnir::PoolResource | This class implements a pool memory resource |
| Cwpi::PortForwarder | Forward ports to another host |
| Cfrc::Pose2d | Represents a 2D pose containing translational and rotational elements |
| Cfrc::Pose3d | Represents a 3D pose containing translational and rotational elements |
| Cfrc::PoseEstimator< WheelSpeeds, WheelPositions > | This class wraps odometry to fuse latency-compensated vision measurements with encoder measurements |
| Cfrc::PoseEstimator3d< WheelSpeeds, WheelPositions > | This class wraps odometry to fuse latency-compensated vision measurements with encoder measurements |
| ►Cfrc::PoseEstimator3d< DifferentialDriveWheelSpeeds, DifferentialDriveWheelPositions > | |
| Cfrc::DifferentialDrivePoseEstimator3d | This class wraps Differential Drive Odometry to fuse latency-compensated vision measurements with differential drive encoder measurements |
| ►Cfrc::PoseEstimator3d< MecanumDriveWheelSpeeds, MecanumDriveWheelPositions > | |
| Cfrc::MecanumDrivePoseEstimator3d | This class wraps Mecanum Drive Odometry to fuse latency-compensated vision measurements with mecanum drive encoder velocity measurements |
| ►Cfrc::PoseEstimator3d< wpi::array< SwerveModuleState, NumModules >, wpi::array< SwerveModulePosition, NumModules > > | |
| Cfrc::SwerveDrivePoseEstimator3d< NumModules > | This class wraps Swerve Drive Odometry to fuse latency-compensated vision measurements with swerve drive encoder distance measurements |
| ►Cfrc::PoseEstimator< DifferentialDriveWheelSpeeds, DifferentialDriveWheelPositions > | |
| Cfrc::DifferentialDrivePoseEstimator | This class wraps Differential Drive Odometry to fuse latency-compensated vision measurements with differential drive encoder measurements |
| ►Cfrc::PoseEstimator< MecanumDriveWheelSpeeds, MecanumDriveWheelPositions > | |
| Cfrc::MecanumDrivePoseEstimator | This class wraps Mecanum Drive Odometry to fuse latency-compensated vision measurements with mecanum drive encoder velocity measurements |
| ►Cfrc::PoseEstimator< wpi::array< SwerveModuleState, NumModules >, wpi::array< SwerveModulePosition, NumModules > > | |
| Cfrc::SwerveDrivePoseEstimator< NumModules > | This class wraps Swerve Drive Odometry to fuse latency-compensated vision measurements with swerve drive encoder distance measurements |
| Cdetail::position_t | Struct to capture the start position of the current token |
| Cfrc::sim::PowerDistributionSim | Class to control a simulated Power Distribution Panel (PowerDistribution) |
| Cfrc::Preferences | The preferences class provides a relatively simple way to save important values to the roboRIO to access the next time the roboRIO is booted |
| Cdetail::primitive_iterator_t | |
| Cprintf_formatter< T > | |
| Cdetail::printf_precision_handler | |
| Cdetail::printf_width_handler | |
| ►Cstd::priority_queue | |
| Cwpi::memory::priority_queue< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::priority_queue_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| Cwpi::priority_queue< T, Sequence, Compare > | This class is the same as std::priority_queue with two changes: |
| Cwpi::priority_queue< Callback, std::vector< Callback >, std::greater< Callback > > | |
| Cdetail::priority_tag< N > | |
| Cdetail::priority_tag< 0 > | |
| Csleipnir::Profiler | Records the number of profiler measurements (start/stop pairs) and the average duration between each start and stop call |
| Cfrc::ExponentialProfile< Distance, Input >::ProfileTiming | Profile timing |
| Cwpi::promise< T > | A lightweight version of std::promise |
| Cwpi::promise< void > | Explicit specialization for promise<void> |
| ►Cwpi::detail::PromiseFactoryBase | |
| Cwpi::PromiseFactory< R > | |
| Cwpi::PromiseFactory< T > | A promise factory for lightweight futures |
| Cwpi::PromiseFactory< void > | Explicit specialization for PromiseFactory<void> |
| Cwpi::memory::propagation_traits< RawAllocator > | Controls the propagation of a std_allocator for a certain RawAllocator |
| Cwpi::memory::propagation_traits< joint_allocator > | Specialization of the propagation_traits for the joint_allocator |
| Cwpi::Protobuf< T > | Protobuf serialization template |
| Cwpi::Protobuf< frc::ArmFeedforward > | |
| Cwpi::Protobuf< frc::ChassisSpeeds > | |
| Cwpi::Protobuf< frc::CubicHermiteSpline > | |
| Cwpi::Protobuf< frc::DCMotor > | |
| Cwpi::Protobuf< frc::DifferentialDriveFeedforward > | |
| Cwpi::Protobuf< frc::DifferentialDriveKinematics > | |
| Cwpi::Protobuf< frc::DifferentialDriveWheelPositions > | |
| Cwpi::Protobuf< frc::DifferentialDriveWheelSpeeds > | |
| Cwpi::Protobuf< frc::DifferentialDriveWheelVoltages > | |
| Cwpi::Protobuf< frc::ElevatorFeedforward > | |
| Cwpi::Protobuf< frc::Ellipse2d > | |
| Cwpi::Protobuf< frc::LinearSystem< States, Inputs, Outputs > > | |
| Cwpi::Protobuf< frc::Matrixd< Rows, Cols, Options, MaxRows, MaxCols > > | |
| Cwpi::Protobuf< frc::Matrixd< Size, 1, Options, MaxRows, MaxCols > > | |
| Cwpi::Protobuf< frc::MecanumDriveKinematics > | |
| Cwpi::Protobuf< frc::MecanumDriveWheelPositions > | |
| Cwpi::Protobuf< frc::MecanumDriveWheelSpeeds > | |
| Cwpi::Protobuf< frc::Pose2d > | |
| Cwpi::Protobuf< frc::Pose3d > | |
| Cwpi::Protobuf< frc::Quaternion > | |
| Cwpi::Protobuf< frc::QuinticHermiteSpline > | |
| Cwpi::Protobuf< frc::Rectangle2d > | |
| Cwpi::Protobuf< frc::Rotation2d > | |
| Cwpi::Protobuf< frc::Rotation3d > | |
| Cwpi::Protobuf< frc::SimpleMotorFeedforward< Distance > > | |
| Cwpi::Protobuf< frc::SwerveDriveKinematics< NumModules > > | |
| Cwpi::Protobuf< frc::SwerveModulePosition > | |
| Cwpi::Protobuf< frc::SwerveModuleState > | |
| Cwpi::Protobuf< frc::Trajectory > | |
| Cwpi::Protobuf< frc::Trajectory::State > | |
| Cwpi::Protobuf< frc::Transform2d > | |
| Cwpi::Protobuf< frc::Transform3d > | |
| Cwpi::Protobuf< frc::Translation2d > | |
| Cwpi::Protobuf< frc::Translation3d > | |
| Cwpi::Protobuf< frc::Twist2d > | |
| Cwpi::Protobuf< frc::Twist3d > | |
| Cwpi::ProtobufMessage< T > | Ease of use wrapper to make nanopb streams more opaque to the user |
| Cwpi::ProtobufMessageDatabase | Database of protobuf dynamic messages |
| Cwpi::ProtoInputStream< T > | Class for wrapping a nanopb istream |
| Cwpi::ProtoOutputStream< T > | Class for wrapping a nanopb ostream |
| ►Cnt::Publisher | NetworkTables publisher |
| ►Cnt::StructArrayPublisher< T, I... > | |
| Cnt::StructArrayEntry< T, I > | NetworkTables struct-encoded value array entry |
| ►Cnt::StructPublisher< T, I... > | |
| Cnt::StructEntry< T, I > | NetworkTables struct-encoded value entry |
| ►Cnt::BooleanArrayPublisher | NetworkTables BooleanArray publisher |
| Cnt::BooleanArrayEntry | NetworkTables BooleanArray entry |
| ►Cnt::BooleanPublisher | NetworkTables Boolean publisher |
| Cnt::BooleanEntry | NetworkTables Boolean entry |
| ►Cnt::DoubleArrayPublisher | NetworkTables DoubleArray publisher |
| Cnt::DoubleArrayEntry | NetworkTables DoubleArray entry |
| ►Cnt::DoublePublisher | NetworkTables Double publisher |
| Cnt::DoubleEntry | NetworkTables Double entry |
| ►Cnt::FloatArrayPublisher | NetworkTables FloatArray publisher |
| Cnt::FloatArrayEntry | NetworkTables FloatArray entry |
| ►Cnt::FloatPublisher | NetworkTables Float publisher |
| Cnt::FloatEntry | NetworkTables Float entry |
| ►Cnt::GenericPublisher | NetworkTables generic publisher |
| Cnt::GenericEntry | NetworkTables generic entry |
| ►Cnt::IntegerArrayPublisher | NetworkTables IntegerArray publisher |
| Cnt::IntegerArrayEntry | NetworkTables IntegerArray entry |
| ►Cnt::IntegerPublisher | NetworkTables Integer publisher |
| Cnt::IntegerEntry | NetworkTables Integer entry |
| ►Cnt::ProtobufPublisher< T > | NetworkTables protobuf-encoded value publisher |
| Cnt::ProtobufEntry< T > | NetworkTables protobuf-encoded value entry |
| ►Cnt::RawPublisher | NetworkTables Raw publisher |
| Cnt::RawEntry | NetworkTables Raw entry |
| ►Cnt::StringArrayPublisher | NetworkTables StringArray publisher |
| Cnt::StringArrayEntry | NetworkTables StringArray entry |
| ►Cnt::StringPublisher | NetworkTables String publisher |
| Cnt::StringEntry | NetworkTables String entry |
| Cnt::StructArrayPublisher< T, I > | NetworkTables struct-encoded value array publisher |
| Cnt::StructPublisher< T, I > | NetworkTables struct-encoded value publisher |
| ►Cnt::UnitPublisher< T > | NetworkTables unit-typed publisher |
| Cnt::UnitEntry< T > | NetworkTables unit-typed entry |
| Cnt::PubSubOptions | NetworkTables publish/subscribe options |
| Cwpi::detail::PunnedPointer< Ptr > | |
| Cwpi::detail::PunnedPointer< PointerTy > | |
| Cwpi::detail::PunnedPointer< wpi::PointerUnion > | |
| CHAL_HMBData::PWM | |
| Cfrc::sim::PWMSim | Class to control a simulated PWM output |
| Cquad | |
| Cfrc::AprilTagDetector::QuadThresholdParameters | Quad threshold parameters |
| Cfrc::Quaternion | Represents a quaternion |
| ►Cstd::queue | |
| Cwpi::memory::queue< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::queue_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| Cfrc::RamseteController | Ramsete is a nonlinear time-varying feedback controller for unicycle models that drives the model to a desired pose along a two-dimensional trajectory |
| Crange_formatter< T, Char, Enable > | |
| Crange_formatter< detail::uncvref_type< range_type >, Char > | |
| Crange_formatter< T, Char, enable_if_t< conjunction< std::is_same< T, remove_cvref_t< T > >, is_formattable< T, Char > >::value > > | |
| ►Cwpi::raw_istream | |
| Cwpi::raw_fd_istream | |
| Cwpi::raw_mem_istream | |
| Cwpi::raw_socket_istream | |
| ►Cwpi::raw_ostream | This class implements an extremely fast bulk output stream that can only output to a stream |
| Cwpi::raw_os_ostream | Raw_os_ostream - A raw_ostream that writes to an std::ostream |
| ►Cwpi::raw_pwrite_stream | An abstract base class for streams implementations that also support a pwrite operation |
| ►Cwpi::raw_fd_ostream | A raw_ostream that writes to a file descriptor |
| Cwpi::raw_fd_stream | A raw_ostream of a file for reading/writing/seeking |
| Cwpi::raw_null_ostream | A raw_ostream that discards all output |
| ►Cwpi::raw_svector_ostream | A raw_ostream that writes to an SmallVector or SmallString |
| Cwpi::buffer_ostream | |
| Cwpi::buffer_unique_ostream | |
| Cwpi::raw_usvector_ostream | A raw_ostream that writes to an SmallVector or SmallString |
| Cwpi::raw_uvector_ostream | A raw_ostream that writes to a vector |
| Cwpi::raw_vector_ostream | A raw_ostream that writes to a vector |
| Cwpi::raw_socket_ostream | |
| Cwpi::raw_string_ostream | A raw_ostream that writes to an std::string |
| Cwpi::raw_uv_ostream | Raw_ostream style output to a SmallVector of uv::Buffer buffers |
| ►Ccs::RawEvent | Listener event |
| Ccs::VideoEvent | An event generated by the library and provided to event listeners |
| Cwpi::memory::std_allocator< T, RawAllocator >::rebind< U > | |
| Cwpi::memory::detail::rebind_block_allocator< RawAllocator, BlockAllocator > | |
| Cwpi::memory::detail::rebind_block_allocator< RawAllocator< Args... >, OtherBlockAllocator > | |
| Cfrc::detail::RecordingController | |
| Cfrc::Rectangle2d | Represents a 2d rectangular space containing translational, rotational, and scaling components |
| Cwpi::recursive_spinlock1 | A recursive spinlock mutex |
| Cwpi::recursive_spinlock2 | A recursive spinlock mutex |
| Cwpi::support::detail::packed_endian_specific_integral< ValueType, Endian, Alignment, ALIGN >::ref | |
| Cwpi::memory::detail::reference_shared | |
| Cwpi::memory::detail::reference_stateful | |
| Cwpi::memory::detail::reference_stateless | |
| Cwpi::memory::reference_storage< RawAllocator > | A StoragePolicy that stores a reference to an allocator |
| Cwpi::memory::reference_storage< any_allocator > | Specialization of the class template reference_storage that is type-erased |
| Cwpi::memory::detail::reference_storage_impl< RawAllocator, Tag > | |
| Cwpi::memory::detail::reference_storage_impl< allocator_traits< RawAllocator >::allocator_type, decltype(detail::reference_type(allocator_traits< RawAllocator >::is_stateful{}, is_shared_allocator< RawAllocator >{}))> | |
| Cwpi::memory::detail::reference_storage_impl< RawAllocator, reference_shared > | |
| Cwpi::memory::detail::reference_storage_impl< RawAllocator, reference_stateful > | |
| Cwpi::memory::detail::reference_storage_impl< RawAllocator, reference_stateless > | |
| Cwpi::iterator_facade_base< DerivedT, IteratorCategoryT, T, DifferenceTypeT, PointerT, ReferenceT >::ReferenceProxy | A proxy object for computing a reference via indirecting a copy of an iterator |
| CHAL_HMBData::RelayDOAO | |
| Cfrc::sim::RelaySim | Class to control a simulated relay |
| Cwpi::remove_cvref< T > | |
| Cfrc2::Requirements | Represents requirements for a command, which is a set of (pointers to) subsystems |
| Cfrc::Resource | Convenient way to track allocated resources |
| ►Cstd::reverse_iterator | |
| Cdetail::json_reverse_iterator< Base > | Template for a reverse iterator class |
| Crgb | |
| Cfrc::sim::RoboRioSim | A utility class to control a simulated RoboRIO |
| ►Cfrc::RobotBase | Implement a Robot Program framework |
| ►Cfrc::IterativeRobotBase | IterativeRobotBase implements a specific type of robot program framework, extending the RobotBase class |
| ►Cfrc::TimedRobot | TimedRobot implements the IterativeRobotBase robot program framework |
| Cfrc::TimesliceRobot | TimesliceRobot extends the TimedRobot robot program framework to provide timeslice scheduling of periodic functions |
| Cfrc::RobotController | |
| Cfrc2::RobotModeTriggers | A class containing static Trigger factories for running callbacks when robot mode changes |
| Cfrc::RobotState | Robot state utility functions |
| Cfrc::RomiGyro | Use a rate gyro to return the robots heading relative to a starting position |
| Cwpi::rotated_span< T, Extent > | This is a simple rotated span view |
| Cfrc::Rotation2d | A rotation in a 2D coordinate frame represented by a point on the unit circle (cosine and sine) |
| Cfrc::Rotation3d | A rotation in a 3D coordinate frame represented by a quaternion |
| ►Cstd::runtime_error | |
| Cfrc::RuntimeError | Runtime error exception |
| Cfrc::SplineParameterizer::MalformedSplineException | |
| Cruntime_format_string< Char > | |
| ►Cwpi::SafeThreadBase | Base class for SafeThreadOwner threads |
| ►Cwpi::SafeThread | |
| Cwpi::CallbackThread< Derived, TUserInfo, TListenerData, TNotifierData > | |
| Cwpi::detail::WorkerThreadThread< R, T > | |
| Cwpi::java::JCallbackThread< T > | Generic callback thread implementation |
| Cwpi::SafeThreadEvent | |
| ►Cwpi::detail::SafeThreadOwnerBase | Non-template owner base class for common owner code |
| ►Cwpi::SafeThreadOwner< JCallbackThread< T > > | |
| ►Cwpi::java::JCallbackManager< T > | |
| Cwpi::java::JSingletonCallbackManager< T > | |
| Cwpi::SafeThreadOwner< Thread > | |
| Cwpi::SafeThreadOwner< wpi::detail::WorkerThreadThread > | |
| Cwpi::SafeThreadOwner< T > | |
| ►Cwpi::detail::SafeThreadProxyBase | Non-template proxy base class for common proxy code |
| Cwpi::detail::SafeThreadProxy< T > | A proxy for SafeThread |
| Cwpi::SameType< T, T > | |
| Cwpi::scope_exit< F > | |
| Cwpi::ScopedFatalErrorHandler | ScopedFatalErrorHandler - This is a simple helper class which just calls install_fatal_error_handler in its constructor and remove_fatal_error_handler in its destructor |
| Cfrc::ScopedTracer | A class for keeping track of how much time it takes for different parts of code to execute |
| Cwpi::memory::detail::segregatable_type< I, Segregator > | |
| Cwpi::memory::detail::segregatable_type< 0, binary_segregator< Segregator, Fallback > > | |
| Cwpi::memory::detail::segregatable_type< I, binary_segregator< Segregator, Fallback > > | |
| Cwpi::memory::segregator_size< Segregator > | The number of Segregatable a segregator has |
| Cwpi::Semaphore | A semaphore for synchronization |
| ►Cwpi::Sendable | Interface for Sendable objects |
| Cfrc::ProfiledPIDController< units::radian > | |
| Cfrc2::Command | A state machine representing a complete action to be performed by the robot |
| Cfrc2::CommandScheduler | The scheduler responsible for running Commands |
| ►Cfrc2::SubsystemBase | A base for subsystems that handles registration in the constructor, and provides a more intuitive method for setting the default command |
| Cfrc2::PIDSubsystem | A subsystem that uses a PIDController to control an output |
| Cfrc2::ProfiledPIDSubsystem< Distance > | A subsystem that uses a ProfiledPIDController to control an output |
| Cfrc2::TrapezoidProfileSubsystem< Distance > | A subsystem that generates and runs trapezoidal motion profiles automatically |
| Cfrc::ADIS16448_IMU | Use DMA SPI to read rate, acceleration, and magnetometer data from the ADIS16448 IMU and return the robots heading relative to a starting position, AHRS, and instant measurements |
| Cfrc::ADIS16470_IMU | Use DMA SPI to read rate and acceleration data from the ADIS16470 IMU and return the robot's heading relative to a starting position and instant measurements |
| Cfrc::ADXRS450_Gyro | Use a rate gyro to return the robots heading relative to a starting position |
| Cfrc::AnalogAccelerometer | Handle operation of an analog accelerometer |
| Cfrc::AnalogEncoder | Class for supporting continuous analog encoders, such as the US Digital MA3 |
| Cfrc::AnalogGyro | Use a rate gyro to return the robots heading relative to a starting position |
| Cfrc::AnalogInput | Analog input class |
| Cfrc::AnalogOutput | MXP analog output class |
| Cfrc::AnalogPotentiometer | Class for reading analog potentiometers |
| Cfrc::AnalogTrigger | |
| Cfrc::AnalogTriggerOutput | Class to represent a specific output from an analog trigger |
| Cfrc::BangBangController | Implements a bang-bang controller, which outputs either 0 or 1 depending on whether the measurement is less than the setpoint |
| Cfrc::BuiltInAccelerometer | Built-in accelerometer |
| Cfrc::Compressor | Class for operating a compressor connected to a pneumatics module |
| Cfrc::Counter | Class for counting the number of ticks on a digital input channel |
| Cfrc::DifferentialDrive | A class for driving differential drive/skid-steer drive platforms such as the Kit of Parts drive base, "tank drive", or West Coast Drive |
| Cfrc::DigitalGlitchFilter | Class to enable glitch filtering on a set of digital inputs |
| Cfrc::DigitalInput | Class to read a digital input |
| Cfrc::DigitalOutput | Class to write to digital outputs |
| Cfrc::DoubleSolenoid | DoubleSolenoid class for running 2 channels of high voltage Digital Output on a pneumatics module |
| Cfrc::DutyCycle | Class to read a duty cycle PWM input |
| Cfrc::DutyCycleEncoder | Class for supporting duty cycle/PWM encoders, such as the US Digital MA3 with PWM Output, the CTRE Mag Encoder, the Rev Hex Encoder, and the AM Mag Encoder |
| Cfrc::Encoder | Class to read quad encoders |
| Cfrc::ExternalDirectionCounter | Counter using external direction |
| Cfrc::MecanumDrive | A class for driving Mecanum drive platforms |
| Cfrc::MotorControllerGroup | Allows multiple MotorController objects to be linked together |
| Cfrc::NidecBrushless | Nidec Brushless Motor |
| Cfrc::PIDController | Implements a PID control loop |
| Cfrc::PS4Controller | Handle input from PS4 controllers connected to the Driver Station |
| Cfrc::PS5Controller | Handle input from PS5 controllers connected to the Driver Station |
| ►Cfrc::PWM | Class implements the PWM generation in the FPGA |
| Cfrc::Servo | Standard hobby style servo |
| Cfrc::PWMMotorController | Common base class for all PWM Motor Controllers |
| Cfrc::PowerDistribution | Class for getting voltage, current, temperature, power and energy from the CTRE Power Distribution Panel (PDP) or REV Power Distribution Hub (PDH) |
| Cfrc::ProfiledPIDController< Distance > | Implements a PID control loop whose setpoint is constrained by a trapezoid profile |
| Cfrc::Relay | Class for Spike style relay outputs |
| Cfrc::SendableCameraWrapper | A wrapper to make video sources sendable and usable from Shuffleboard |
| ►Cfrc::SendableChooserBase | This class is a non-template base class for SendableChooser |
| Cfrc::SendableChooser< T > | The SendableChooser class is a useful tool for presenting a selection of options to the SmartDashboard |
| Cfrc::SharpIR | |
| Cfrc::Solenoid | Solenoid class for running high voltage Digital Output on a pneumatics module |
| Cfrc::StadiaController | Handle input from Stadia controllers connected to the Driver Station |
| Cfrc::Tachometer | Tachometer for getting rotational speed from a device |
| Cfrc::Ultrasonic | Ultrasonic rangefinder class |
| Cfrc::UpDownCounter | Up Down Counter |
| Cfrc::XboxController | Handle input from Xbox controllers connected to the Driver Station |
| ►Cnt::NTSendable | Interface for NetworkTable Sendable objects |
| Cfrc::ADXL345_I2C | ADXL345 Accelerometer on I2C |
| Cfrc::ADXL345_SPI | ADXL345 Accelerometer on SPI |
| Cfrc::ADXL362 | ADXL362 SPI Accelerometer |
| Cfrc::Field2d | 2D representation of game field for dashboards |
| Cfrc::Mechanism2d | Visual 2D representation of arms, elevators, and general mechanisms through a node-based API |
| ►Cwpi::SendableBuilder | Helper class for building Sendable dashboard representations |
| ►Cnt::NTSendableBuilder | Helper class for building Sendable dashboard representations for NetworkTables |
| Cfrc::SendableBuilderImpl | Implementation detail for SendableBuilder |
| Cfrc::sim::SendableChooserSim | Class that facilitates control of a SendableChooser's selected option in simulation |
| Cwpi::SendableHelper< Derived > | A helper class for use with objects that add themselves to SendableRegistry |
| ►Cwpi::SendableHelper< ADIS16448_IMU > | |
| Cfrc::ADIS16448_IMU | Use DMA SPI to read rate, acceleration, and magnetometer data from the ADIS16448 IMU and return the robots heading relative to a starting position, AHRS, and instant measurements |
| ►Cwpi::SendableHelper< ADIS16470_IMU > | |
| Cfrc::ADIS16470_IMU | Use DMA SPI to read rate and acceleration data from the ADIS16470 IMU and return the robot's heading relative to a starting position and instant measurements |
| ►Cwpi::SendableHelper< ADXL345_I2C > | |
| Cfrc::ADXL345_I2C | ADXL345 Accelerometer on I2C |
| ►Cwpi::SendableHelper< ADXL345_SPI > | |
| Cfrc::ADXL345_SPI | ADXL345 Accelerometer on SPI |
| ►Cwpi::SendableHelper< ADXL362 > | |
| Cfrc::ADXL362 | ADXL362 SPI Accelerometer |
| ►Cwpi::SendableHelper< ADXRS450_Gyro > | |
| Cfrc::ADXRS450_Gyro | Use a rate gyro to return the robots heading relative to a starting position |
| ►Cwpi::SendableHelper< AnalogAccelerometer > | |
| Cfrc::AnalogAccelerometer | Handle operation of an analog accelerometer |
| ►Cwpi::SendableHelper< AnalogEncoder > | |
| Cfrc::AnalogEncoder | Class for supporting continuous analog encoders, such as the US Digital MA3 |
| ►Cwpi::SendableHelper< AnalogGyro > | |
| Cfrc::AnalogGyro | Use a rate gyro to return the robots heading relative to a starting position |
| ►Cwpi::SendableHelper< AnalogInput > | |
| Cfrc::AnalogInput | Analog input class |
| ►Cwpi::SendableHelper< AnalogOutput > | |
| Cfrc::AnalogOutput | MXP analog output class |
| ►Cwpi::SendableHelper< AnalogPotentiometer > | |
| Cfrc::AnalogPotentiometer | Class for reading analog potentiometers |
| ►Cwpi::SendableHelper< AnalogTrigger > | |
| Cfrc::AnalogTrigger | |
| ►Cwpi::SendableHelper< AnalogTriggerOutput > | |
| Cfrc::AnalogTriggerOutput | Class to represent a specific output from an analog trigger |
| ►Cwpi::SendableHelper< BangBangController > | |
| Cfrc::BangBangController | Implements a bang-bang controller, which outputs either 0 or 1 depending on whether the measurement is less than the setpoint |
| ►Cwpi::SendableHelper< BuiltInAccelerometer > | |
| Cfrc::BuiltInAccelerometer | Built-in accelerometer |
| ►Cwpi::SendableHelper< Command > | |
| Cfrc2::Command | A state machine representing a complete action to be performed by the robot |
| ►Cwpi::SendableHelper< CommandScheduler > | |
| Cfrc2::CommandScheduler | The scheduler responsible for running Commands |
| ►Cwpi::SendableHelper< Compressor > | |
| Cfrc::Compressor | Class for operating a compressor connected to a pneumatics module |
| ►Cwpi::SendableHelper< Counter > | |
| Cfrc::Counter | Class for counting the number of ticks on a digital input channel |
| ►Cwpi::SendableHelper< DifferentialDrive > | |
| Cfrc::DifferentialDrive | A class for driving differential drive/skid-steer drive platforms such as the Kit of Parts drive base, "tank drive", or West Coast Drive |
| ►Cwpi::SendableHelper< DigitalGlitchFilter > | |
| Cfrc::DigitalGlitchFilter | Class to enable glitch filtering on a set of digital inputs |
| ►Cwpi::SendableHelper< DigitalInput > | |
| Cfrc::DigitalInput | Class to read a digital input |
| ►Cwpi::SendableHelper< DigitalOutput > | |
| Cfrc::DigitalOutput | Class to write to digital outputs |
| ►Cwpi::SendableHelper< DoubleSolenoid > | |
| Cfrc::DoubleSolenoid | DoubleSolenoid class for running 2 channels of high voltage Digital Output on a pneumatics module |
| ►Cwpi::SendableHelper< DutyCycle > | |
| Cfrc::DutyCycle | Class to read a duty cycle PWM input |
| ►Cwpi::SendableHelper< DutyCycleEncoder > | |
| Cfrc::DutyCycleEncoder | Class for supporting duty cycle/PWM encoders, such as the US Digital MA3 with PWM Output, the CTRE Mag Encoder, the Rev Hex Encoder, and the AM Mag Encoder |
| ►Cwpi::SendableHelper< Encoder > | |
| Cfrc::Encoder | Class to read quad encoders |
| ►Cwpi::SendableHelper< ExternalDirectionCounter > | |
| Cfrc::ExternalDirectionCounter | Counter using external direction |
| ►Cwpi::SendableHelper< Field2d > | |
| Cfrc::Field2d | 2D representation of game field for dashboards |
| ►Cwpi::SendableHelper< MecanumDrive > | |
| Cfrc::MecanumDrive | A class for driving Mecanum drive platforms |
| ►Cwpi::SendableHelper< Mechanism2d > | |
| Cfrc::Mechanism2d | Visual 2D representation of arms, elevators, and general mechanisms through a node-based API |
| ►Cwpi::SendableHelper< MotorControllerGroup > | |
| Cfrc::MotorControllerGroup | Allows multiple MotorController objects to be linked together |
| ►Cwpi::SendableHelper< NidecBrushless > | |
| Cfrc::NidecBrushless | Nidec Brushless Motor |
| ►Cwpi::SendableHelper< PIDController > | |
| Cfrc::PIDController | Implements a PID control loop |
| ►Cwpi::SendableHelper< PowerDistribution > | |
| Cfrc::PowerDistribution | Class for getting voltage, current, temperature, power and energy from the CTRE Power Distribution Panel (PDP) or REV Power Distribution Hub (PDH) |
| ►Cwpi::SendableHelper< ProfiledPIDController< Distance > > | |
| Cfrc::ProfiledPIDController< Distance > | Implements a PID control loop whose setpoint is constrained by a trapezoid profile |
| ►Cwpi::SendableHelper< ProfiledPIDController< units::radian > > | |
| Cfrc::ProfiledPIDController< units::radian > | |
| ►Cwpi::SendableHelper< PS4Controller > | |
| Cfrc::PS4Controller | Handle input from PS4 controllers connected to the Driver Station |
| ►Cwpi::SendableHelper< PS5Controller > | |
| Cfrc::PS5Controller | Handle input from PS5 controllers connected to the Driver Station |
| ►Cwpi::SendableHelper< PWM > | |
| Cfrc::PWM | Class implements the PWM generation in the FPGA |
| ►Cwpi::SendableHelper< PWMMotorController > | |
| Cfrc::PWMMotorController | Common base class for all PWM Motor Controllers |
| ►Cwpi::SendableHelper< Relay > | |
| Cfrc::Relay | Class for Spike style relay outputs |
| ►Cwpi::SendableHelper< SendableCameraWrapper > | |
| Cfrc::SendableCameraWrapper | A wrapper to make video sources sendable and usable from Shuffleboard |
| ►Cwpi::SendableHelper< SendableChooserBase > | |
| Cfrc::SendableChooserBase | This class is a non-template base class for SendableChooser |
| ►Cwpi::SendableHelper< SharpIR > | |
| Cfrc::SharpIR | |
| ►Cwpi::SendableHelper< Solenoid > | |
| Cfrc::Solenoid | Solenoid class for running high voltage Digital Output on a pneumatics module |
| ►Cwpi::SendableHelper< StadiaController > | |
| Cfrc::StadiaController | Handle input from Stadia controllers connected to the Driver Station |
| ►Cwpi::SendableHelper< SubsystemBase > | |
| Cfrc2::SubsystemBase | A base for subsystems that handles registration in the constructor, and provides a more intuitive method for setting the default command |
| ►Cwpi::SendableHelper< Tachometer > | |
| Cfrc::Tachometer | Tachometer for getting rotational speed from a device |
| ►Cwpi::SendableHelper< Ultrasonic > | |
| Cfrc::Ultrasonic | Ultrasonic rangefinder class |
| ►Cwpi::SendableHelper< UpDownCounter > | |
| Cfrc::UpDownCounter | Up Down Counter |
| ►Cwpi::SendableHelper< XboxController > | |
| Cfrc::XboxController | Handle input from Xbox controllers connected to the Driver Station |
| Cwpi::SendableRegistry | Public interface for registering sensors and actuators for use on dashboards and LiveWindow |
| Cfrc::SensorUtil | Stores most recent status information as well as containing utility functions for checking channels and error processing |
| Chal::SerialHelper | A class for deterministically getting information about Serial Ports |
| Cdetail::serializer< BasicJsonType > | |
| Cfrc::SerialPort | Driver for the RS-232 serial port on the roboRIO |
| Cwpi::WebSocketServer::ServerOptions | Server options |
| Cwpi::MulticastServiceResolver::ServiceData | |
| ►Cstd::set | |
| Cwpi::memory::set< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::set_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| Cwpi::SHA1 | |
| Cfrc::SharpIRSim | Simulation class for Sharp IR sensors |
| Cfrc::Shuffleboard | Mechanism with which data can be added and laid out in the Shuffleboard dashboard application from a robot program |
| ►Cfrc::ShuffleboardRoot | The root of the data placed in Shuffleboard |
| Cfrc::detail::ShuffleboardInstance | |
| ►Cfrc::ShuffleboardValue | |
| ►Cfrc::ShuffleboardComponentBase | A shim class to allow storing ShuffleboardComponents in arrays |
| ►Cfrc::ShuffleboardComponent< ComplexWidget > | |
| ►Cfrc::ShuffleboardWidget< ComplexWidget > | |
| Cfrc::ComplexWidget | A Shuffleboard widget that handles a Sendable object such as a motor controller or sensor |
| ►Cfrc::ShuffleboardComponent< ShuffleboardLayout > | |
| Cfrc::ShuffleboardLayout | A layout in a Shuffleboard tab |
| ►Cfrc::ShuffleboardComponent< SimpleWidget > | |
| ►Cfrc::ShuffleboardWidget< SimpleWidget > | |
| Cfrc::SimpleWidget | A Shuffleboard widget that handles a single data point such as a number or string |
| ►Cfrc::ShuffleboardComponent< SuppliedValueWidget< T > > | |
| ►Cfrc::ShuffleboardWidget< SuppliedValueWidget< T > > | |
| Cfrc::SuppliedValueWidget< T > | |
| ►Cfrc::ShuffleboardComponent< Derived > | A generic component in Shuffleboard |
| Cfrc::ShuffleboardWidget< Derived > | Abstract superclass for widgets |
| ►Cfrc::ShuffleboardContainer | Common interface for objects that can contain shuffleboard components |
| Cfrc::ShuffleboardLayout | A layout in a Shuffleboard tab |
| Cfrc::ShuffleboardTab | Represents a tab in the Shuffleboard dashboard |
| Cwpi::sig::SignalBase< Lockable, T > | SignalBase is an implementation of the observer pattern, through the use of an emitting object and slots that are connected to the signal and called with supplied arguments when a signal is emitted |
| Cwpi::sig::SignalBase< bool > | |
| Cwpi::sig::SignalBase< const addrinfo & > | |
| Cwpi::sig::SignalBase< const char *, const char * > | |
| Cwpi::sig::SignalBase< const char *, int > | |
| Cwpi::sig::SignalBase< int > | |
| Cwpi::sig::SignalBase< int64_t, int > | |
| Cwpi::sig::SignalBase< std::span< const uint8_t > > | |
| Cwpi::sig::SignalBase< std::span< const uint8_t >, bool > | |
| Cwpi::sig::SignalBase< std::string_view > | |
| Cwpi::sig::SignalBase< std::string_view, bool > | |
| Cwpi::sig::SignalBase< std::string_view, std::string_view > | |
| Cwpi::sig::SignalBase< std::string_view, wpi::WebSocket & > | |
| Cwpi::sig::SignalBase< T... > | |
| Cwpi::sig::SignalBase< uint16_t, std::string_view > | |
| Cwpi::sig::SignalBase< uint64_t > | |
| Cwpi::sig::SignalBase< wpi::uv::Buffer &, size_t > | |
| Cwpi::sig::SignalBase< wpi::uv::Buffer &, size_t, const sockaddr &, unsigned > | |
| Cwpi::sig::SignalBase< wpi::uv::Error > | |
| Cwpi::SignalObject< T > | RAII wrapper for signaling handles |
| ►Chal::impl::SimCallbackRegistryBase | |
| Chal::SimCallbackRegistry< CallbackFunction, GetName > | Simulation callback registry |
| ►Chal::impl::SimDataValueBase< T, MakeValue > | |
| Chal::SimDataValue< T, MakeValue, GetName, GetDefault > | Simulation data value wrapper |
| Chal::SimDevice | A move-only C++ wrapper around a HAL simulator device handle |
| Cfrc::sim::SimDeviceSim | Class to control the simulation side of a SimDevice |
| Cwpi::uv::SimpleBufferPool< DEPTH > | A simple pool allocator for Buffers |
| Cfrc::SimpleMotorFeedforward< Distance > | A helper class that computes feedforward voltages for a simple permanent-magnet DC motor |
| Cfrc::SimpleMotorFeedforward< units::meter > | |
| Cfrc::SimpleMotorFeedforward< units::meters > | |
| Cwpi::simplify_type< From > | Define a template that can be specialized by smart pointers to reflect the fact that they are automatically dereferenced, and are not involved with the template selection process... the default implementation is a noop |
| Cwpi::simplify_type< const From > | |
| Cfrc::SimulatedAnnealing< State > | An implementation of the Simulated Annealing stochastic nonlinear optimization method |
| ►Chal::SimValue | C++ wrapper around a HAL simulator value handle |
| Chal::SimBoolean | C++ wrapper around a HAL simulator boolean value handle |
| Chal::SimDouble | C++ wrapper around a HAL simulator double value handle |
| Chal::SimEnum | C++ wrapper around a HAL simulator enum value handle |
| Chal::SimInt | C++ wrapper around a HAL simulator int value handle |
| Chal::SimLong | C++ wrapper around a HAL simulator long value handle |
| Cdetail::singleton | |
| Cdetail::size_padding | |
| Cfrc::SlewRateLimiter< Unit > | A class that limits the rate of change of an input value |
| Csleipnir::Slice | |
| Cwpi::sig::detail::Slot< typename,... > | |
| Cwpi::sig::detail::SlotPmfTracked< typename, typename,... > | |
| ►Cwpi::sig::detail::SlotState | |
| ►Cwpi::sig::detail::SlotBase< Args... > | |
| Cwpi::sig::detail::Slot< Func, trait::typelist< Args... > > | |
| Cwpi::sig::detail::Slot< Func, trait::typelist< Connection &, Args... > > | |
| Cwpi::sig::detail::Slot< Pmf, Ptr, trait::typelist< Args... > > | |
| Cwpi::sig::detail::Slot< Pmf, Ptr, trait::typelist< Connection &, Args... > > | |
| Cwpi::sig::detail::SlotPmfTracked< Pmf, WeakPtr, trait::typelist< Args... > > | |
| Cwpi::sig::detail::SlotTracked< Func, WeakPtr, trait::typelist< Args... > > | |
| Cwpi::sig::detail::SlotBase< Args > | |
| Cwpi::sig::detail::SlotTracked< typename, typename,... > | |
| Cwpi::memory::detail::small_free_memory_list | |
| Cwpi::memory::small_node_pool | Tag type defining a memory pool optimized for small nodes |
| ►Cwpi::SmallPtrSetIteratorImpl | SmallPtrSetIteratorImpl - This is the common base class shared between all instances of SmallPtrSetIterator |
| Cwpi::SmallPtrSetIterator< PtrTy > | SmallPtrSetIterator - This implements a const_iterator for SmallPtrSet |
| Cwpi::SmallSet< T, N, C > | SmallSet - This maintains a set of unique values, optimizing for the case when the set is small (less than N) |
| Cwpi::SmallSet< frc2::Command *, 4 > | |
| Cwpi::SmallSet< frc2::Subsystem *, 4 > | |
| Cwpi::SmallSet< std::string, 32 > | |
| Cwpi::SmallVectorAlignmentAndSize< T, typename > | Figure out the offset of the first element |
| ►Cwpi::SmallVectorBase | This is all the stuff common to all SmallVectors |
| ►Cwpi::SmallVectorTemplateCommon< std::pair< KeyT, ValueT > > | |
| ►Cwpi::SmallVectorTemplateBase< std::pair< KeyT, ValueT > > | |
| ►Cwpi::SmallVectorImpl< std::pair< KeyT, ValueT > > | |
| Cwpi::SmallVector< std::pair< KeyT, ValueT >, N > | |
| Cwpi::SmallVector< std::pair< KeyT, ValueT >, 0 > | |
| ►Cwpi::SmallVectorTemplateCommon< char > | |
| ►Cwpi::SmallVectorTemplateBase< char > | |
| ►Cwpi::SmallVectorImpl< char > | |
| ►Cwpi::SmallVector< char, InternalLen > | |
| Cwpi::SmallString< 64 > | |
| Cwpi::SmallString< 128 > | |
| Cwpi::SmallString< 32 > | |
| Cwpi::SmallString< 16 > | |
| Cwpi::SmallString< InternalLen > | SmallString - A SmallString is just a SmallVector with methods and accessors that make it work better as a string (e.g |
| Cwpi::SmallVector< char, 0 > | |
| ►Cwpi::SmallVectorTemplateCommon< frc2::Subsystem * > | |
| ►Cwpi::SmallVectorTemplateBase< frc2::Subsystem * > | |
| ►Cwpi::SmallVectorImpl< frc2::Subsystem * > | |
| Cwpi::SmallVector< frc2::Subsystem *, N > | |
| ►Cwpi::SmallVectorTemplateCommon< frc2::Command * > | |
| ►Cwpi::SmallVectorTemplateBase< frc2::Command * > | |
| ►Cwpi::SmallVectorImpl< frc2::Command * > | |
| Cwpi::SmallVector< frc2::Command *, N > | |
| ►Cwpi::SmallVectorTemplateCommon< std::unique_ptr< frc2::Command > > | |
| ►Cwpi::SmallVectorTemplateBase< std::unique_ptr< frc2::Command > > | |
| ►Cwpi::SmallVectorImpl< std::unique_ptr< frc2::Command > > | |
| Cwpi::SmallVector< std::unique_ptr< frc2::Command >, 4 > | |
| ►Cwpi::SmallVectorTemplateCommon< frc::Pose2d > | |
| ►Cwpi::SmallVectorTemplateBase< frc::Pose2d > | |
| ►Cwpi::SmallVectorImpl< frc::Pose2d > | |
| Cwpi::SmallVector< frc::Pose2d, 1 > | |
| ►Cwpi::SmallVectorTemplateCommon< std::string > | |
| ►Cwpi::SmallVectorTemplateBase< std::string > | |
| ►Cwpi::SmallVectorImpl< std::string > | |
| Cwpi::SmallVector< std::string, N > | |
| Cwpi::SmallVector< std::string, 2 > | |
| ►Cwpi::SmallVectorTemplateCommon< wpi::SmallString< 16 > > | |
| ►Cwpi::SmallVectorTemplateBase< wpi::SmallString< 16 > > | |
| ►Cwpi::SmallVectorImpl< wpi::SmallString< 16 > > | |
| Cwpi::SmallVector< wpi::SmallString< 16 >, 4 > | |
| ►Cwpi::SmallVectorTemplateCommon< sleipnir::Variable > | |
| ►Cwpi::SmallVectorTemplateBase< sleipnir::Variable > | |
| ►Cwpi::SmallVectorImpl< sleipnir::Variable > | |
| Cwpi::SmallVector< sleipnir::Variable > | |
| ►Cwpi::SmallVectorTemplateCommon< sleipnir::detail::ExpressionGraph > | |
| ►Cwpi::SmallVectorTemplateBase< sleipnir::detail::ExpressionGraph > | |
| ►Cwpi::SmallVectorImpl< sleipnir::detail::ExpressionGraph > | |
| Cwpi::SmallVector< sleipnir::detail::ExpressionGraph > | |
| ►Cwpi::SmallVectorTemplateCommon< Eigen::Triplet< double > > | |
| ►Cwpi::SmallVectorTemplateBase< Eigen::Triplet< double > > | |
| ►Cwpi::SmallVectorImpl< Eigen::Triplet< double > > | |
| Cwpi::SmallVector< Eigen::Triplet< double > > | |
| ►Cwpi::SmallVectorTemplateCommon< int > | |
| ►Cwpi::SmallVectorTemplateBase< int > | |
| ►Cwpi::SmallVectorImpl< int > | |
| Cwpi::SmallVector< int > | |
| ►Cwpi::SmallVectorTemplateCommon< std::unique_ptr< std::byte[]> > | |
| ►Cwpi::SmallVectorTemplateBase< std::unique_ptr< std::byte[]> > | |
| ►Cwpi::SmallVectorImpl< std::unique_ptr< std::byte[]> > | |
| Cwpi::SmallVector< std::unique_ptr< std::byte[]> > | |
| ►Cwpi::SmallVectorTemplateCommon< void * > | |
| ►Cwpi::SmallVectorTemplateBase< void * > | |
| ►Cwpi::SmallVectorImpl< void * > | |
| Cwpi::SmallVector< void * > | |
| ►Cwpi::SmallVectorTemplateCommon< sleipnir::detail::Expression * > | |
| ►Cwpi::SmallVectorTemplateBase< sleipnir::detail::Expression * > | |
| ►Cwpi::SmallVectorImpl< sleipnir::detail::Expression * > | |
| Cwpi::SmallVector< sleipnir::detail::Expression * > | |
| ►Cwpi::SmallVectorTemplateCommon< WPI_EventHandle > | |
| ►Cwpi::SmallVectorTemplateBase< WPI_EventHandle > | |
| ►Cwpi::SmallVectorImpl< WPI_EventHandle > | |
| Cwpi::SmallVector< WPI_EventHandle, 4 > | |
| ►Cwpi::SmallVectorTemplateCommon< size_t > | |
| ►Cwpi::SmallVectorTemplateBase< size_t > | |
| ►Cwpi::SmallVectorImpl< size_t > | |
| Cwpi::SmallVector< size_t, 16 > | |
| ►Cwpi::SmallVectorTemplateCommon< uint8_t > | |
| ►Cwpi::SmallVectorTemplateBase< uint8_t > | |
| ►Cwpi::SmallVectorImpl< uint8_t > | |
| Cwpi::SmallVector< uint8_t, 0 > | |
| Cwpi::SmallVector< uint8_t, 14 > | |
| Cwpi::SmallVector< uint8_t, 1024 > | |
| Cwpi::SmallVector< uint8_t, 64 > | |
| ►Cwpi::SmallVectorTemplateCommon< wpi::uv::Buffer > | |
| ►Cwpi::SmallVectorTemplateBase< wpi::uv::Buffer > | |
| ►Cwpi::SmallVectorImpl< wpi::uv::Buffer > | |
| Cwpi::SmallVector< wpi::uv::Buffer, 4 > | |
| ►Cwpi::SmallVectorTemplateCommon< T, typename > | This is the part of SmallVectorTemplateBase which does not depend on whether the type T is a POD |
| ►Cwpi::SmallVectorTemplateBase< T, bool > | SmallVectorTemplateBase<TriviallyCopyable = false> - This is where we put method implementations that are designed to work with non-trivial T's |
| ►Cwpi::SmallVectorImpl< T > | This class consists of common code factored out of the SmallVector class to reduce code duplication based on the SmallVector 'N' template parameter |
| Cwpi::SmallVector< T, 1 > | |
| Cwpi::SmallVector< T, N > | |
| Cwpi::SmallVector< T, N > | This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small |
| Cwpi::SmallVectorTemplateBase< T, true > | SmallVectorTemplateBase<TriviallyCopyable = true> - This is where we put method implementations that are designed to work with trivially copyable T's |
| ►Cwpi::SmallVectorStorage< T, N > | Storage for the SmallVector elements |
| Cwpi::SmallVector< T, 1 > | |
| Cwpi::SmallVector< sleipnir::Variable > | |
| Cwpi::SmallVector< sleipnir::detail::ExpressionGraph > | |
| Cwpi::SmallVector< int > | |
| Cwpi::SmallVector< void * > | |
| Cwpi::SmallVector< sleipnir::detail::Expression * > | |
| Cwpi::SmallVector< T, N > | |
| Cwpi::SmallVector< T, N > | This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small |
| ►Cwpi::SmallVectorStorage< char, N > | |
| Cwpi::SmallVector< char, InternalLen > | |
| Cwpi::SmallVector< char, 0 > | |
| ►CSmallVectorStorage< Eigen::Triplet< double >, CalculateSmallVectorDefaultInlinedElements< Eigen::Triplet< double > >::value > | |
| Cwpi::SmallVector< Eigen::Triplet< double > > | |
| ►Cwpi::SmallVectorStorage< frc2::Command *, N > | |
| Cwpi::SmallVector< frc2::Command *, N > | |
| ►Cwpi::SmallVectorStorage< frc2::Subsystem *, N > | |
| Cwpi::SmallVector< frc2::Subsystem *, N > | |
| ►Cwpi::SmallVectorStorage< frc::Pose2d, N > | |
| Cwpi::SmallVector< frc::Pose2d, 1 > | |
| Cwpi::SmallVectorStorage< int, CalculateSmallVectorDefaultInlinedElements< int >::value > | |
| ►Cwpi::SmallVectorStorage< size_t, N > | |
| Cwpi::SmallVector< size_t, 16 > | |
| Cwpi::SmallVectorStorage< sleipnir::detail::Expression *, CalculateSmallVectorDefaultInlinedElements< sleipnir::detail::Expression * >::value > | |
| Cwpi::SmallVectorStorage< sleipnir::detail::ExpressionGraph, CalculateSmallVectorDefaultInlinedElements< sleipnir::detail::ExpressionGraph >::value > | |
| Cwpi::SmallVectorStorage< sleipnir::Variable, CalculateSmallVectorDefaultInlinedElements< sleipnir::Variable >::value > | |
| ►Cwpi::SmallVectorStorage< std::pair< KeyT, ValueT >, N > | |
| Cwpi::SmallVector< std::pair< KeyT, ValueT >, N > | |
| Cwpi::SmallVector< std::pair< KeyT, ValueT >, 0 > | |
| ►Cwpi::SmallVectorStorage< std::string, N > | |
| Cwpi::SmallVector< std::string, N > | |
| Cwpi::SmallVector< std::string, 2 > | |
| ►Cwpi::SmallVectorStorage< std::unique_ptr< frc2::Command >, N > | |
| Cwpi::SmallVector< std::unique_ptr< frc2::Command >, 4 > | |
| ►CSmallVectorStorage< std::unique_ptr< std::byte[]>, CalculateSmallVectorDefaultInlinedElements< std::unique_ptr< std::byte[]> >::value > | |
| Cwpi::SmallVector< std::unique_ptr< std::byte[]> > | |
| Cwpi::SmallVectorStorage< T, 0 > | We need the storage to be properly aligned even for small-size of 0 so that the pointer math in SmallVectorTemplateCommon::getFirstEl() is well-defined |
| Cwpi::SmallVectorStorage< T, CalculateSmallVectorDefaultInlinedElements< T >::value > | |
| ►Cwpi::SmallVectorStorage< uint8_t, N > | |
| Cwpi::SmallVector< uint8_t, 0 > | |
| Cwpi::SmallVector< uint8_t, 14 > | |
| Cwpi::SmallVector< uint8_t, 1024 > | |
| Cwpi::SmallVector< uint8_t, 64 > | |
| Cwpi::SmallVectorStorage< void *, CalculateSmallVectorDefaultInlinedElements< void * >::value > | |
| ►Cwpi::SmallVectorStorage< wpi::SmallString< 16 >, N > | |
| Cwpi::SmallVector< wpi::SmallString< 16 >, 4 > | |
| ►Cwpi::SmallVectorStorage< wpi::uv::Buffer, N > | |
| Cwpi::SmallVector< wpi::uv::Buffer, 4 > | |
| ►Cwpi::SmallVectorStorage< WPI_EventHandle, N > | |
| Cwpi::SmallVector< WPI_EventHandle, 4 > | |
| Cfrc::SmartDashboard | |
| Cfrc::sim::SolenoidSim | |
| Csleipnir::SolverConfig | Solver configuration |
| Csleipnir::SolverIterationInfo | Solver iteration information exposed to a user callback |
| Csleipnir::SolverStatus | Return value of OptimizationProblem::Solve() containing the cost function and constraint types and solver's exit condition |
| Cdetail::span< T > | |
| ►Cstd::span | |
| Cfrc::AprilTagDetector::Results | Array of detection results |
| Cdetail::span_input_adapter | |
| Cfrc::SPI | SPI bus interface class |
| Cfrc::sim::SPIAccelerometerSim | |
| Cwpi::spinlock | A spinlock mutex |
| Cfrc::Spline< Degree > | Represents a two-dimensional parametric spline that interpolates between two points |
| ►Cfrc::Spline< 3 > | |
| Cfrc::CubicHermiteSpline | Represents a hermite spline of degree 3 |
| ►Cfrc::Spline< 5 > | |
| Cfrc::QuinticHermiteSpline | Represents a hermite spline of degree 5 |
| Cfrc::SplineHelper | Helper class that is used to generate cubic and quintic splines from user provided waypoints |
| Cfrc::SplineParameterizer | Class used to parameterize a spline by its arc length |
| ►Cstd::stack | |
| Cwpi::memory::stack< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::stack_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| Cwpi::memory::detail::stack_marker | |
| Cwpi::log::StartRecordData | Data contained in a start control record as created by DataLog::Start() when writing the log |
| Cfrc::ExponentialProfile< Distance, Input >::State | Profile state |
| Cfrc::sim::DifferentialDrivetrainSim::State | |
| Cfrc::Trajectory::State | Represents one point on the trajectory |
| Cfrc::TrapezoidProfile< Distance >::State | Profile state |
| Cwpi::memory::static_allocator | A stateful RawAllocator that uses a fixed sized storage for the allocations |
| Cwpi::memory::static_allocator_storage< Size > | Storage for a static_allocator |
| Cwpi::memory::static_block_allocator | A BlockAllocator that allocates the blocks from a fixed size storage |
| Cwpi::static_circular_buffer< T, N > | This is a simple circular buffer so we don't need to "bucket brigade" copy old values |
| Cdetail::static_const< T > | |
| Cwpi::memory::std_allocator< T, RawAllocator > | Wraps a RawAllocator and makes it a "normal" Allocator |
| ►Cwpi::memory::std_allocator< T, any_allocator > | |
| Cwpi::memory::any_std_allocator< T > | An alias template for std_allocator using a type-erased RawAllocator |
| Cdetail::std_string_view< T > | |
| Cfrc::SteadyStateKalmanFilter< States, Inputs, Outputs > | A Kalman filter combines predictions from a model and measurements to give an estimate of the true system state |
| Cfrc::PneumaticHub::StickyFaults | Sticky faults for a REV PH |
| Cfrc::PowerDistribution::StickyFaults | Sticky faults for a PowerDistribution device |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::StorageUnionT | |
| ►CStreamBuf | |
| Cdetail::formatbuf< StreamBuf > | |
| Cdetail::streamed_view< T > | |
| Cstring_buffer | |
| Cstring_feeder | |
| Cdetail::string_literal< Char, C > | |
| Cdetail::string_value< Char > | |
| Cdetail::string_value< char_type > | |
| Cwpi::Struct< T, I > | Struct serialization template |
| Cwpi::Struct< bool > | Raw struct support for boolean values |
| Cwpi::Struct< double > | Raw struct support for double values |
| Cwpi::Struct< float > | Raw struct support for float values |
| Cwpi::Struct< frc::ArmFeedforward > | |
| Cwpi::Struct< frc::ChassisSpeeds > | |
| Cwpi::Struct< frc::CubicHermiteSpline > | |
| Cwpi::Struct< frc::DCMotor > | |
| Cwpi::Struct< frc::DifferentialDriveFeedforward > | |
| Cwpi::Struct< frc::DifferentialDriveKinematics > | |
| Cwpi::Struct< frc::DifferentialDriveWheelPositions > | |
| Cwpi::Struct< frc::DifferentialDriveWheelSpeeds > | |
| Cwpi::Struct< frc::DifferentialDriveWheelVoltages > | |
| Cwpi::Struct< frc::ElevatorFeedforward > | |
| Cwpi::Struct< frc::Ellipse2d > | |
| Cwpi::Struct< frc::LinearSystem< States, Inputs, Outputs > > | |
| Cwpi::Struct< frc::Matrixd< Rows, Cols, Options, MaxRows, MaxCols > > | |
| Cwpi::Struct< frc::Matrixd< Size, 1, Options, MaxRows, MaxCols > > | |
| Cwpi::Struct< frc::MecanumDriveKinematics > | |
| Cwpi::Struct< frc::MecanumDriveWheelPositions > | |
| Cwpi::Struct< frc::MecanumDriveWheelSpeeds > | |
| Cwpi::Struct< frc::Pose2d > | |
| Cwpi::Struct< frc::Pose3d > | |
| Cwpi::Struct< frc::Quaternion > | |
| Cwpi::Struct< frc::QuinticHermiteSpline > | |
| Cwpi::Struct< frc::Rectangle2d > | |
| Cwpi::Struct< frc::Rotation2d > | |
| Cwpi::Struct< frc::Rotation3d > | |
| Cwpi::Struct< frc::SimpleMotorFeedforward< Distance > > | |
| Cwpi::Struct< frc::SwerveDriveKinematics< NumModules > > | |
| Cwpi::Struct< frc::SwerveModulePosition > | |
| Cwpi::Struct< frc::SwerveModuleState > | |
| Cwpi::Struct< frc::Transform2d > | |
| Cwpi::Struct< frc::Transform3d > | |
| Cwpi::Struct< frc::Translation2d > | |
| Cwpi::Struct< frc::Translation3d > | |
| Cwpi::Struct< frc::Twist2d > | |
| Cwpi::Struct< frc::Twist3d > | |
| Cwpi::Struct< int16_t > | Raw struct support for int16_t values |
| Cwpi::Struct< int32_t > | Raw struct support for int32_t values |
| Cwpi::Struct< int64_t > | Raw struct support for int64_t values |
| Cwpi::Struct< int8_t > | Raw struct support for int8_t values |
| Cwpi::Struct< std::array< T, N >, I... > | Raw struct support for fixed-size arrays of other structs |
| Cwpi::Struct< uint16_t > | Raw struct support for uint16_t values |
| Cwpi::Struct< uint32_t > | Raw struct support for uint32_t values |
| Cwpi::Struct< uint64_t > | Raw struct support for uint64_t values |
| Cwpi::Struct< uint8_t > | Raw struct support for uint8_t values |
| Cwpi::StructArrayBuffer< T, I > | |
| Cwpi::StructArrayBuffer< T, I... > | |
| Cwpi::StructDescriptor | Raw struct dynamic struct descriptor |
| Cwpi::StructDescriptorDatabase | Database of raw struct dynamic descriptors |
| Cwpi::StructFieldDescriptor | Raw struct dynamic field descriptor |
| ►Cnt::Subscriber | NetworkTables subscriber |
| ►Cnt::StructArraySubscriber< T, I... > | |
| Cnt::StructArrayEntry< T, I > | NetworkTables struct-encoded value array entry |
| ►Cnt::StructSubscriber< T, I... > | |
| Cnt::StructEntry< T, I > | NetworkTables struct-encoded value entry |
| ►Cnt::BooleanArraySubscriber | NetworkTables BooleanArray subscriber |
| Cnt::BooleanArrayEntry | NetworkTables BooleanArray entry |
| ►Cnt::BooleanSubscriber | NetworkTables Boolean subscriber |
| Cnt::BooleanEntry | NetworkTables Boolean entry |
| ►Cnt::DoubleArraySubscriber | NetworkTables DoubleArray subscriber |
| Cnt::DoubleArrayEntry | NetworkTables DoubleArray entry |
| ►Cnt::DoubleSubscriber | NetworkTables Double subscriber |
| Cnt::DoubleEntry | NetworkTables Double entry |
| ►Cnt::FloatArraySubscriber | NetworkTables FloatArray subscriber |
| Cnt::FloatArrayEntry | NetworkTables FloatArray entry |
| ►Cnt::FloatSubscriber | NetworkTables Float subscriber |
| Cnt::FloatEntry | NetworkTables Float entry |
| ►Cnt::GenericSubscriber | NetworkTables generic subscriber |
| Cnt::GenericEntry | NetworkTables generic entry |
| ►Cnt::IntegerArraySubscriber | NetworkTables IntegerArray subscriber |
| Cnt::IntegerArrayEntry | NetworkTables IntegerArray entry |
| ►Cnt::IntegerSubscriber | NetworkTables Integer subscriber |
| Cnt::IntegerEntry | NetworkTables Integer entry |
| ►Cnt::ProtobufSubscriber< T > | NetworkTables protobuf-encoded value subscriber |
| Cnt::ProtobufEntry< T > | NetworkTables protobuf-encoded value entry |
| ►Cnt::RawSubscriber | NetworkTables Raw subscriber |
| Cnt::RawEntry | NetworkTables Raw entry |
| ►Cnt::StringArraySubscriber | NetworkTables StringArray subscriber |
| Cnt::StringArrayEntry | NetworkTables StringArray entry |
| ►Cnt::StringSubscriber | NetworkTables String subscriber |
| Cnt::StringEntry | NetworkTables String entry |
| Cnt::StructArraySubscriber< T, I > | NetworkTables struct-encoded value array subscriber |
| Cnt::StructSubscriber< T, I > | NetworkTables struct-encoded value subscriber |
| ►Cnt::UnitSubscriber< T > | NetworkTables unit-typed subscriber |
| Cnt::UnitEntry< T > | NetworkTables unit-typed entry |
| Cnt::meta::SubscriberOptions | Subscriber options |
| ►Cfrc2::Subsystem | A robot subsystem |
| Cfrc2::SubsystemBase | A base for subsystems that handles registration in the constructor, and provides a more intuitive method for setting the default command |
| Cfrc::SwerveModulePosition | Represents the position of one swerve module |
| Cfrc::SwerveModuleState | Represents the state of one swerve module |
| Cfrc::SynchronousInterrupt | Class for handling synchronous (blocking) interrupts |
| ►Cfrc::sysid::SysIdRoutineLog | Utility for logging data from a SysId test routine |
| Cfrc2::sysid::SysIdRoutine | A SysId characterization routine for a single mechanism |
| ►Cstd::chrono::system_clock | |
| Cwpi::sys::UtcClock | |
| Cwpi::detail_expected::swap_adl_tests::tag | |
| Cwpi::detail_expected::TC< class > | |
| Cwpi::TCPConnector | |
| Cwpi::memory::temporary_allocator | A stateful RawAllocator that handles temporary allocations |
| Cwpi::memory::detail::temporary_block_allocator | |
| Cwpi::memory::temporary_stack | A wrapper around the memory_stack that is used by the temporary_allocator |
| Cwpi::memory::temporary_stack_initializer | Manually takes care of the lifetime of the per-thread temporary_stack |
| Cwpi::memory::detail::temporary_stack_list_node | |
| Ctext_style | A text style consisting of foreground and background colors and emphasis |
| Cdetail::thousands_sep_result< Char > | |
| Cwpi::memory::threshold_segregatable< RawAllocator > | A Segregatable that allocates until a maximum size |
| Cfmt_detail::time_zone | |
| Cfrc::TimeInterpolatableBuffer< T > | The TimeInterpolatableBuffer provides an easy way to estimate past measurements |
| Cfrc::TimeInterpolatableBuffer< frc::Pose2d > | |
| Cfrc::TimeInterpolatableBuffer< frc::Pose3d > | |
| Ctimeprofile | |
| Ctimeprofile_entry | |
| Cfrc::Timer | A timer class |
| CHAL_HMBData::CounterTimers::Timer | |
| CHAL_HMBData::EncoderTimers::Timer | |
| CHAL_HMBData::Timestamp | |
| Cnt::Timestamped< T > | Timestamped value |
| Cnt::TimestampedUnit< T > | Timestamped unit |
| Cnt::TimeSyncEventData | NetworkTables time sync event data |
| Cdetail::tm_writer< OutputIt, Char, Duration > | |
| Cdetail::to_json_fn | |
| Cdetail::to_utf8< WChar, Buffer > | |
| Cwpi::structparser::Token | A lexed raw struct schema token |
| ►Cnt::Topic | NetworkTables Topic |
| Cnt::BooleanArrayTopic | NetworkTables BooleanArray topic |
| Cnt::BooleanTopic | NetworkTables Boolean topic |
| Cnt::DoubleArrayTopic | NetworkTables DoubleArray topic |
| Cnt::DoubleTopic | NetworkTables Double topic |
| Cnt::FloatArrayTopic | NetworkTables FloatArray topic |
| Cnt::FloatTopic | NetworkTables Float topic |
| Cnt::IntegerArrayTopic | NetworkTables IntegerArray topic |
| Cnt::IntegerTopic | NetworkTables Integer topic |
| Cnt::ProtobufTopic< T > | NetworkTables protobuf-encoded value topic |
| Cnt::RawTopic | NetworkTables Raw topic |
| Cnt::StringArrayTopic | NetworkTables StringArray topic |
| Cnt::StringTopic | NetworkTables String topic |
| Cnt::StructArrayTopic< T, I > | NetworkTables struct-encoded value array topic |
| Cnt::StructTopic< T, I > | NetworkTables struct-encoded value topic |
| Cnt::UnitTopic< T > | NetworkTables unit-typed topic |
| Cnt::TopicInfo | NetworkTables Topic Information |
| Cnt::meta::TopicPublisher | Topic publisher (as published via $pub$<topic>) |
| Cnt::meta::TopicSubscriber | Topic subscriber (as published via $sub$<topic>) |
| Cfrc::Tracer | A class for keeping track of how much time it takes for different parts of code to execute |
| Cwpi::memory::tracked_allocator< Tracker, RawAllocator > | A RawAllocator adapter that tracks another allocator using a tracker |
| ►Cwpi::memory::tracked_allocator< Tracker, detail::rebound_allocator< Tracker, RawAllocator > > | |
| Cwpi::memory::deeply_tracked_allocator< Tracker, RawAllocator > | A tracked_allocator that has rebound any BlockAllocator to the corresponding deeply_tracked_block_allocator |
| Cwpi::memory::tracked_block_allocator< Tracker, BlockOrRawAllocator > | A BlockAllocator adapter that tracks another allocator using a tracker |
| Cfrc::Trajectory | Represents a time-parameterized trajectory |
| Cfrc::TrajectoryConfig | Represents the configuration for generating a trajectory |
| ►Cfrc::TrajectoryConstraint | An interface for defining user-defined velocity and acceleration constraints while generating trajectories |
| Cfrc::CentripetalAccelerationConstraint | A constraint on the maximum absolute centripetal acceleration allowed when traversing a trajectory |
| Cfrc::DifferentialDriveKinematicsConstraint | A class that enforces constraints on the differential drive kinematics |
| Cfrc::DifferentialDriveVoltageConstraint | A class that enforces constraints on differential drive voltage expenditure based on the motor dynamics and the drive kinematics |
| Cfrc::EllipticalRegionConstraint< Constraint > | Enforces a particular constraint only within an elliptical region |
| Cfrc::MaxVelocityConstraint | Represents a constraint that enforces a max velocity |
| Cfrc::MecanumDriveKinematicsConstraint | A class that enforces constraints on the mecanum drive kinematics |
| Cfrc::RectangularRegionConstraint< Constraint > | Enforces a particular constraint only within a rectangular region |
| Cfrc::SwerveDriveKinematicsConstraint< NumModules > | A class that enforces constraints on the swerve drive kinematics |
| Cfrc::TrajectoryGenerator | Helper class used to generate trajectories with various constraints |
| Cfrc::TrajectoryParameterizer | Class used to parameterize a trajectory by time |
| Cfrc::TrajectoryUtil | Trajectory utilities |
| Cfrc::Transform2d | Represents a transformation for a Pose2d in the pose's frame |
| Cfrc::Transform3d | Represents a transformation for a Pose3d in the pose's frame |
| Cfrc::Translation2d | Represents a translation in 2D space |
| Cfrc::Translation3d | Represents a translation in 3D space |
| Cfrc::TrapezoidProfile< Distance > | A trapezoid-shaped velocity profile |
| Cfrc::TrapezoidProfile< units::radian > | |
| Cfrc::TravelingSalesman | Given a list of poses, this class finds the shortest possible route that visits each pose exactly once and returns to the origin pose |
| ►Cfrc2::Trigger | This class provides an easy way to link commands to conditions |
| Cfrc2::JoystickButton | A class used to bind command scheduling to joystick button presses |
| Cfrc2::NetworkButton | A Button that uses a NetworkTable boolean field |
| Cfrc2::POVButton | A class used to bind command scheduling to joystick POV presses |
| CHAL_HMBData::AnalogTriggers::Trigger | |
| Cwpi::detail::trivial_helper< T > | |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::TrivialCallback | A struct to hold a single trivial callback with sufficient alignment for our bitpacking |
| ►Cstd::true_type | |
| ►Cdetail::conjunction< is_constructible< T1, Args >... > | |
| Cdetail::is_constructible_tuple< T1, std::tuple< Args... > > | |
| ►Cdetail::conjunction< is_default_constructible< T1 >, is_default_constructible< T2 > > | |
| ►Cdetail::is_default_constructible< const std::pair< T1, T2 > > | |
| Cdetail::is_constructible< const std::pair< T1, T2 > > | |
| ►Cdetail::is_default_constructible< std::pair< T1, T2 > > | |
| Cdetail::is_constructible< std::pair< T1, T2 > > | |
| ►Cdetail::conjunction< is_default_constructible< Ts >... > | |
| ►Cdetail::is_default_constructible< const std::tuple< Ts... > > | |
| Cdetail::is_constructible< const std::tuple< Ts... > > | |
| ►Cdetail::is_default_constructible< std::tuple< Ts... > > | |
| Cdetail::is_constructible< std::tuple< Ts... > > | |
| ►Cwpi::memory::detail::is_block_or_raw_allocator_impl< T, memory::is_block_allocator< T >::value > | |
| Cwpi::memory::detail::is_block_or_raw_allocator< T > | |
| ►Cwpi::memory::detail::is_raw_allocator< T, decltype(detail::alloc_uses_default_traits(std::declval< T & >()))> | |
| ►Cwpi::memory::is_raw_allocator< T > | Traits that check whether a type models concept RawAllocator |
| ►Cwpi::memory::detail::is_composable_allocator< T, decltype(detail::composable_alloc_uses_default_traits(std::declval< T & >()))> | |
| Cwpi::memory::is_composable_allocator< T > | Traits that check whether a type models concept ComposableAllocator |
| Cwpi::memory::detail::is_block_or_raw_allocator_impl< T, false > | |
| Cwpi::memory::detail::is_composable_allocator< T, DefaultTraits > | |
| Cconjunction<... > | |
| Cdetail::conjunction<... > | |
| Cdetail::has_back_insert_iterator_container_append< OutputIt, InputIt, void_t< decltype(get_container(std::declval< OutputIt >()) .append(std::declval< InputIt >(), std::declval< InputIt >()))> > | |
| Cdetail::has_const_begin_end< T, void_t< decltype(*detail::range_begin(std::declval< const remove_cvref_t< T > & >())), decltype(detail::range_end(std::declval< const remove_cvref_t< T > & >()))> > | |
| Cdetail::has_flip< T, void_t< decltype(std::declval< T >().flip())> > | |
| Cdetail::has_flockfile< F, void_t< decltype(flockfile(&std::declval< F & >()))> > | |
| Cdetail::has_isfinite< T, enable_if_t< sizeof(std::isfinite(T())) !=0 > > | |
| Cdetail::has_member_data_tm_gmtoff< T, void_t< decltype(T::tm_gmtoff)> > | |
| Cdetail::has_member_data_tm_zone< T, void_t< decltype(T::tm_zone)> > | |
| Cdetail::has_member_fn_begin_end_t< T, void_t< decltype(*std::declval< T >().begin()), decltype(std::declval< T >().end())> > | |
| Cdetail::has_mutable_begin_end< T, void_t< decltype(*detail::range_begin(std::declval< T & >())), decltype(detail::range_end(std::declval< T & >())), int > > | |
| Cdetail::has_to_string_view< T, void_t< decltype(detail::to_string_view(std::declval< T >()))> > | |
| Cdetail::is_back_insert_iterator< It, bool_constant< std::is_same< decltype(adl::invoke_back_inserter< typename It::container_type >()), It >::value > > | |
| Cdetail::is_back_insert_iterator< basic_appender< T > > | |
| Cdetail::is_basic_json< WPI_BASIC_JSON_TPL > | |
| Cdetail::is_buffer_appender< It, bool_constant< is_back_insert_iterator< It >::value &&std::is_base_of< buffer< typename It::container_type::value_type >, typename It::container_type >::value > > | |
| Cdetail::is_comparable< Compare, A, B, void_t< decltype(std::declval< Compare >()(std::declval< A >(), std::declval< B >())), decltype(std::declval< Compare >()(std::declval< B >(), std::declval< A >()))> > | |
| Cdetail::is_complete_type< T, decltype(void(sizeof(T)))> | |
| Cdetail::is_constructible_array_type_impl< BasicJsonType, ConstructibleArrayType, enable_if_t< std::is_same< ConstructibleArrayType, typename BasicJsonType::value_type >::value > > | |
| Cdetail::is_integral< int128_opt > | |
| Cdetail::is_integral< uint128_t > | |
| Cdetail::is_json_iterator_of< BasicJsonType, typename BasicJsonType::const_iterator > | |
| Cdetail::is_json_iterator_of< BasicJsonType, typename BasicJsonType::iterator > | |
| Cdetail::is_json_ref< json_ref< T > > | |
| Cdetail::is_named_arg< named_arg< Char, T > > | |
| Cdetail::is_output_iterator< It, T, void_t< decltype(*std::declval< decay_t< It > & >()++=std::declval< T >())> > | |
| Cdetail::is_output_iterator< appender, char > | |
| Cdetail::is_reference_wrapper< std::reference_wrapper< T > > | |
| Cdetail::is_specialization_of< Primary, Primary< Args... > > | |
| Cdetail::use_format_as< T, bool_constant< std::is_arithmetic< format_as_result< T > >::value > > | |
| Cdetail::use_format_as_member< T, bool_constant< std::is_arithmetic< format_as_member_result< T > >::value > > | |
| Cis_char< char > | |
| Cis_char< char16_t > | |
| Cis_char< char32_t > | |
| Cis_char< wchar_t > | |
| Cis_contiguous< basic_memory_buffer< T, SIZE, Allocator > > | |
| Cis_contiguous< std::basic_string< Char, Traits, Allocator > > | |
| Cis_xchar< char16_t > | |
| Cis_xchar< char32_t > | |
| Cis_xchar< wchar_t > | |
| Cstd::is_error_code_enum< wpi::errc > | |
| Cwpi::TypesAreDistinct<> | |
| Cwpi::detail::TypesAreDistinct< T > | |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs >::enable_if_t< sizeof(T)<=2 *sizeof(void *)> > | |
| Cwpi::detail_expected::conjunction<... > | |
| Cwpi::detail_expected::is_expected_impl< expected< T, E > > | |
| Cwpi::details::HasContainerTraits< T, std::void_t< typename T::value_type, decltype(std::declval< T >().begin()), decltype(std::declval< T >().end()), decltype(std::declval< T >().size())> > | |
| Cwpi::details::HasStreamableTraits< T, std::void_t< decltype(std::declval< std::ostream & >()<< std::declval< T >())> > | |
| Cwpi::explicitly_convertible< From, To, std::void_t< decltype(static_cast< To >(std::declval< std::add_rvalue_reference_t< From > >()))> > | |
| Cwpi::memory::allocator_is_raw_allocator< std::allocator< T > > | Specialization of allocator_is_raw_allocator that allows std::allocator again |
| Cwpi::memory::detail::is_block_or_raw_allocator_impl< T, Block > | |
| Cwpi::memory::detail::is_instantiation_of< Template, Template< Args... > > | |
| Cwpi::memory::detail::is_raw_allocator< T, DefaultTraits > | |
| Cwpi::memory::is_shared_allocator< joint_allocator > | Specialization of is_shared_allocator to mark joint_allocator as shared |
| Cwpi::memory::is_shared_allocator< memory_resource_allocator > | Specialization of is_shared_allocator to mark memory_resource_allocator as shared |
| Cwpi::memory::is_thread_safe_allocator< joint_allocator > | Specialization of is_thread_safe_allocator to mark joint_allocator as thread safe |
| Cwpi::sig::trait::detail::is_callable< F, P, typelist< T... >, void_t< decltype(((*std::declval< P >()).*std::declval< F >())(std::declval< T >()...))> > | |
| Cwpi::sig::trait::detail::is_callable< F, typelist< T... >, void_t< decltype(std::declval< F >()(std::declval< T >()...))> > | |
| Cwpi::sig::trait::detail::is_weak_ptr< T, void_t< decltype(std::declval< T >().expired()), decltype(std::declval< T >().lock()), decltype(std::declval< T >().reset())> > | |
| Cstd::tuple_element< I, wpi::array< T, N > > | |
| Cstd::tuple_element< N, ::wpi::detail::iteration_proxy_value< IteratorType > > | |
| Cfrc::Twist2d | A change in distance along a 2D arc since the last pose update |
| Cfrc::Twist3d | A change in distance along a 3D arc since the last pose update |
| Cdetail::is_ordered_map< T >::two | |
| ►Cstd::conditional::type | |
| Cdetail::conjunction< B, Bn... > | |
| Cwpi::detail_expected::conjunction< B, Bs... > | |
| ►Cstd::is_base_of::type | |
| Cunits::traits::is_unit< T > | Traits which tests if a class is a unit |
| Cunits::traits::is_unit_t< T > | Traits which tests if a class is a unit |
| ►Ctypename detail::make_segregator_t::type | |
| Cwpi::memory::segregator< Allocators > | Creates multiple nested binary_segregator |
| Cdetail::type_is_unformattable_for< T, Char > | |
| Cdetail::type_mapper< Char > | |
| Cwpi::sig::trait::typelist<... > | Represent a list of types |
| Cdetail::ubitint< N > | |
| Cdetail::udl_arg< Char > | |
| Cwpi::UDPClient | |
| Cwpi::UidVector< T, reuse_threshold > | Vector which provides an integrated freelist for removal and reuse of individual elements |
| Cwpi::UidVector< ListenerData, 64 > | |
| Cwpi::UidVector< std::shared_ptr< wpi::CallbackThread::Poller >, 64 > | |
| Cwpi::impl::UidVectorIterator< It > | |
| Cdetail::uint128_fallback | |
| Cwpi::Uleb128Reader | Unsigned LEB128 streaming reader |
| Cfrc::sim::UltrasonicSim | Class to control a simulated Ultrasonic |
| Cwpi::unexpect_t | |
| Cwpi::unexpected< E > | |
| Cunionfind | |
| Cwpi::unique_function< FunctionT > | Unique_function is a type-erasing functor similar to std::function |
| Cwpi::unique_function< frc2::Command *()> | |
| Cwpi::unique_function< frc2::CommandPtr()> | |
| ►Cstd::unique_ptr | |
| Cwpi::memory::unique_base_ptr< BaseType, RawAllocator > | A std::unique_ptr that deletes using a RawAllocator and allows polymorphic types |
| Cwpi::memory::unique_ptr< T, RawAllocator > | A std::unique_ptr that deletes using a RawAllocator |
| Cwpi::detail::UniqueFunctionBase< ReturnT, ParamTs > | |
| ►Cwpi::detail::UniqueFunctionBase< R, P... > | |
| Cwpi::unique_function< R(P...) const > | |
| Cwpi::unique_function< R(P...)> | |
| ►Cunits::detail::unit_value_arithmetic | |
| Cunits::unit_value_add< U1, U2 > | Adds two unit_value_t types at compile-time |
| Cunits::unit_value_divide< U1, U2 > | Divides two unit_value_t types at compile-time |
| Cunits::unit_value_multiply< U1, U2 > | Multiplies two unit_value_t types at compile-time |
| Cunits::unit_value_power< U1, power > | Raises unit_value_to a power at compile-time |
| Cunits::unit_value_sqrt< U1, Eps > | Calculates square root of unit_value_t at compile-time |
| Cunits::unit_value_subtract< U1, U2 > | Subtracts two unit_value_t types at compile-time |
| ►Cstd::unordered_map | |
| Cwpi::memory::unordered_map< Key, Value, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::unordered_map_scoped_alloc< Key, Value, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| ►Cstd::unordered_multimap | |
| Cwpi::memory::unordered_multimap< Key, Value, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::unordered_multimap_scoped_alloc< Key, Value, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| ►Cstd::unordered_multiset | |
| Cwpi::memory::unordered_multiset< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::unordered_multiset_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| ►Cstd::unordered_set | |
| Cwpi::memory::unordered_set< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator. |
| Cwpi::memory::unordered_set_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers. |
| Cfrc::UnscentedKalmanFilter< States, Inputs, Outputs > | A Kalman filter combines predictions from a model and measurements to give an estimate of the true system state |
| Cwpi::UrlParser | Parses a URL into its constituent components |
| Ccs::UsbCameraInfo | USB camera information |
| Cdetail::utc_clock | |
| Cdetail::utf8_to_utf16 | |
| Cuv__dirent_s | |
| Cuv__io_s | |
| Cuv__queue | |
| Cuv__work | |
| Cuv_any_handle | |
| Cuv_any_req | |
| Cuv_async_s | |
| Cuv_barrier_t | |
| ►Cuv_buf_t | It should be possible to cast uv_buf_t[] to WSABUF[] see http://msdn.microsoft.com/en-us/library/ms741542(v=vs.85).aspx |
| Cwpi::uv::Buffer | Data buffer |
| Cuv_check_s | |
| Cuv_cond_t | |
| Cuv_connect_s | |
| Cuv_cpu_info_s | |
| Cuv_cpu_times_s | |
| Cuv_dir_s | |
| Cuv_dirent_s | |
| Cuv_env_item_s | |
| Cuv_fs_event_s | |
| Cuv_fs_poll_s | |
| Cuv_fs_s | |
| Cuv_getaddrinfo_s | |
| Cuv_getnameinfo_s | |
| Cuv_group_s | |
| Cuv_handle_s | |
| Cuv_idle_s | |
| Cuv_interface_address_s | |
| Cuv_key_t | |
| Cuv_lib_t | |
| Cuv_loop_s | |
| Cuv_metrics_s | |
| Cuv_once_s | |
| Cuv_passwd_s | |
| Cuv_pipe_s | |
| Cuv_poll_s | |
| Cuv_prepare_s | |
| Cuv_process_options_s | |
| Cuv_process_s | |
| Cuv_random_s | |
| Cuv_req_s | |
| Cuv_rusage_t | |
| Cuv_rwlock_t | |
| Cuv_shutdown_s | |
| Cuv_signal_s | |
| Cuv_stat_t | |
| Cuv_statfs_s | |
| Cuv_stdio_container_s | |
| Cuv_stream_s | |
| Cuv_tcp_s | |
| Cuv_thread_options_s | |
| Cuv_timer_s | |
| Cuv_timespec64_t | |
| Cuv_timespec_t | |
| Cuv_timeval64_t | |
| Cuv_timeval_t | |
| Cuv_tty_s | |
| Cuv_udp_s | |
| Cuv_udp_send_s | |
| Cuv_utsname_s | |
| Cuv_work_s | |
| Cuv_write_s | |
| Cnt::Value | A network table entry value |
| Cdetail::value< Context > | |
| Cdetail::value< basic_printf_context > | |
| Cdetail::value< context > | |
| Cdetail::value< generic_context > | |
| Cdetail::value_in_range_of_impl1< OfType, T, NeverOutOfRange, typename > | |
| Cdetail::value_in_range_of_impl1< OfType, T, false > | |
| Cdetail::value_in_range_of_impl1< OfType, T, true > | |
| Cdetail::value_in_range_of_impl2< OfType, T, OfTypeSigned, TSigned > | |
| Cdetail::value_in_range_of_impl2< OfType, T, false, false > | |
| Cdetail::value_in_range_of_impl2< OfType, T, false, true > | |
| Cdetail::value_in_range_of_impl2< OfType, T, true, false > | |
| Cdetail::value_in_range_of_impl2< OfType, T, true, true > | |
| Cnt::ValueEventData | NetworkTables Value Event Data |
| Cwpi::ValueIsPresent< T, Enable > | ValueIsPresent provides a way to check if a value is, well, present |
| Cwpi::ValueIsPresent< std::optional< T > > | |
| Cwpi::ValueIsPresent< T, std::enable_if_t< IsNullable< T > > > | |
| Csleipnir::Variable | An autodiff variable pointing to an expression node |
| Csleipnir::VariableBlock< Mat > | A submatrix of autodiff variables with reference semantics |
| Csleipnir::VariableMatrix | A matrix of autodiff variables |
| ►Cstd::vector | |
| Cwpi::memory::vector< T, RawAllocator > | Alias template for an STL container that uses a certain RawAllocator |
| Cwpi::memory::vector_scoped_alloc< T, RawAllocator > | Same as above but uses std::scoped_allocator_adaptor so the allocator is inherited by all nested containers |
| ►Cstd::vector< std::pair< const Key, T >, std::allocator< std::pair< const Key, T > > > | |
| Cordered_map< Key, T, IgnoredLess, Allocator > | Ordered_map: a minimal map-like container that preserves insertion order for use within wpi::basic_json<ordered_map> |
| Cfrc::PneumaticHub::Version | Version and device data received from a REV PH |
| Cfrc::PowerDistribution::Version | Version and device data received from a PowerDistribution device |
| Cwpi::VersionTuple | Represents a version number in the form major[.minor[.subminor[.build]]] |
| Cdetail::vformat_args< Char > | |
| Cdetail::vformat_args< char > | |
| Ccs::VideoListener | An event listener |
| Ccs::VideoProperty | A source or sink property |
| ►Ccs::VideoSink | A sink for video that accepts a sequence of frames |
| ►Ccs::ImageSink | A base class for single image reading sinks |
| Ccs::CvSink | A source for user code to accept video frames as OpenCV images |
| Ccs::RawSink | A sink for user code to accept video frames as raw bytes |
| Ccs::MjpegServer | A sink that acts as a MJPEG-over-HTTP network server |
| ►Ccs::VideoSource | A source for video that provides a sequence of frames |
| ►Ccs::ImageSource | A base class for single image providing sources |
| Ccs::CvSource | A source for user code to provide OpenCV images as video frames |
| Ccs::RawSource | A source for user code to provide video frames as raw bytes |
| ►Ccs::VideoCamera | A source that represents a video camera |
| ►Ccs::HttpCamera | A source that represents a MJPEG-over-HTTP (IP) camera |
| Ccs::AxisCamera | A source that represents an Axis IP camera |
| Ccs::UsbCamera | A source that represents a USB camera |
| ►Cdetail::view | |
| Cdetail::named_arg< Char, T > | |
| Cdetail::styled_arg< T > | |
| Cjoin_view< It, Sentinel, Char > | |
| Ctuple_join_view< Char, Tuple > | |
| Cwpi::memory::virtual_block_allocator | A BlockAllocator that reserves virtual memory and commits it part by part |
| Cwpi::memory::virtual_memory_allocator | A stateless RawAllocator that allocates memory using the virtual memory allocation functions |
| Cwpi::memory::detail::virtual_memory_allocator_leak_handler | |
| Cfrc::VisionPipeline | A vision pipeline is responsible for running a group of OpenCV algorithms to extract data from an image |
| ►Cfrc::VisionRunnerBase | Non-template base class for VisionRunner |
| Cfrc::VisionRunner< T > | A vision runner is a convenient wrapper object to make it easy to run vision pipelines from robot code |
| Cwpi::sig::trait::detail::voider<... > | |
| Cvprintf_args< Char > | |
| Cfrc::Watchdog | A class that's a wrapper around a watchdog timer |
| Cwpi::WebServer | A web server using the HTTP protocol |
| Cwpi::WebSocketServerHelper | WebSocket HTTP server helper |
| Cweekday | |
| Cfrc::DifferentialDrive::WheelSpeeds | Wheel speeds for a differential drive |
| Cfrc::MecanumDrive::WheelSpeeds | Wheel speeds for a mecanum drive |
| Cdetail::wide_string_input_adapter< BaseInputAdapter, WideCharType > | |
| Cdetail::wide_string_input_helper< BaseInputAdapter, T > | |
| Cdetail::wide_string_input_helper< BaseInputAdapter, 2 > | |
| Cdetail::wide_string_input_helper< BaseInputAdapter, 4 > | |
| Cfrc::WidgetType | Represents the type of a widget in Shuffleboard |
| Cwpi::WorkerThread< T > | |
| Cwpi::WorkerThread< R(T...)> | |
| Cwpi::detail::WorkerThreadAsync< R > | |
| Cwpi::detail::WorkerThreadAsync< void > | |
| Cwpi::detail::WorkerThreadRequest< R, T > | |
| ►CWPI_RawFrame | Raw Frame |
| Cwpi::RawFrame | |
| CWPI_ServiceData | |
| CWPI_String | A const UTF8 string |
| Cwpi::WpiArrayEmplaceWrapper< T, N > | A wrapper around a wpi::array that lets us treat it as a limited sized vector |
| Cdetail::write_int_arg< UInt > | |
| Cwriter | |
| Cfrc::XRPGyro | Use a rate gyro to return the robots heading relative to a starting position |
| Cfrc::XRPOnBoardIO | This class represents the onboard IO of the XRP reference robot |
| Cfrc::XRPRangefinder | This class represents the ultrasonic rangefinder on an XRP robot |
| Cfrc::XRPReflectanceSensor | This class represents the reflectance sensor pair on an XRP robot |
| Cfrc::XRPServo | XRPServo |
| Cwpi::XXH128_hash_t | The return value from 128-bit hashes |
| Cyear | |
| Cyear_month_day | |
| Czarray | |
| Czhash_iterator | |
| Czmaxheap_iterator | |
| ►CT | |
| Cwpi::memory::detail::ebo_storage< Tag, T > | |
1.12.0