| ►Nalerts | |
| CSource | Alert source instance which is used to fire alerts via metrics for a specified amount of time |
| ►Nbaggage | |
| CBaggage | Baggage header. Contains entries (key, value, optional<properties>) |
| CBaggageEntry | Baggage Entry. Has required key and value, optional list of properties. Keys shouldn't contain '=' and ','. Values shouldn't contains ',' and ';' |
| CBaggageEntryProperty | Property of entry. Has required key and optional value. Keys shouldn't contain '=', ';' and ','. Values shouldn't contains ',' and ';' |
| CBaggageException | Baggage base exception |
| CBaggageManager | |
| CBaggageManagerComponent | Component for relationship with header baggage |
| ►Ncache | Utilities for caching |
| CCacheUpdateTrait | Base class for periodically updated caches |
| CConfig | |
| CConfigError | |
| CConfigPatch | |
| CDataError | |
| CDataProvider | Interface for providing cached data of type T |
| CDataProviderMock | Mock implementation of DataProvider for testing purposes |
| CEmptyCacheError | |
| CEmptyDataError | |
| CExpirableLruCache | Class for expirable LRU cache |
| CLruCacheComponent | Base class for LRU-cache components |
| CLruCacheConfig | |
| CLruCacheConfigStatic | |
| CLruCacheWrapper | Wrapper around ExpirableLruCache that binds an update function for convenience |
| CLruMap | |
| CLruSet | |
| CNWayLRU | N-way LRU cache with per-way mutexes and optional dump support |
| CUpdateStatisticsScope | Allows a specific cache to fill cache statistics during an Update |
| CUpdateStatisticsScopeMock | Allows to test helper functions of CacheUpdateTrait::Update that use UpdateStatisticsScope |
| ►Nclients | |
| ►Ndns | DNS client |
| CComponent | Caching DNS resolver component |
| CInvalidConfigException | Configuration error |
| CNotResolvedException | Host resolution error |
| ►CResolver | Caching DNS resolver implementation |
| CLookupSourceCounters | |
| CResolverException | Generic resolver error |
| CUnsupportedDomainException | Unsupported domain error |
| ►Nhttp | HTTP client helpers |
| ►Nmiddlewares | |
| ►Nheaders_propagator | |
| CComponent | |
| ►Nretry_budget | |
| CComponent | |
| ►Nyandex_tracing | |
| CComponent | |
| CComponentBase | |
| CAuthFailedException | |
| CBadArgumentException | |
| CBaseCodeException | Exception with string and error_code |
| CBaseException | Exception with string |
| CCancelException | |
| CClient | HTTP client interface that returns a HTTP request builder from CreateRequest() |
| CClientCore | HTTP client that returns a HTTP request builder from CreateRequest() |
| CClientSettings | |
| CClientWithMiddlewares | HTTP client that returns a HTTP request builder from CreateRequest() with applied middlewares |
| CConnectTo | CURLOPT_CONNECT_TO argument for curl's connect_to() |
| CDeadlinePropagationConfig | |
| CDNSProblemException | |
| CForm | |
| CHttpClientException | |
| CHttpException | Base class for HttpClientException and HttpServerException |
| CHttpServerException | |
| CLocalStats | Represents all the local timings and statistics |
| CMiddlewareBase | Base class for HTTP Client middlewares |
| CMiddlewarePipelineComponent | Component that provides list of common middlewares names for all components::HttpClient instances |
| CMiddlewareRequest | Auxiliary entity that allows editing request to a client from middlewares |
| CNetworkProblemException | |
| CRequest | Class for creating and performing new http requests, usually retrieved from clients::http::Client |
| CResponse | Class that will be returned for successful request |
| CResponseFuture | Allows to perform a request concurrently with other work without creating an extra coroutine for waiting |
| CSSLException | |
| CStandaloneConfig | |
| CStreamedResponse | HTTP response for streamed API |
| CTechnicalError | |
| CTimeoutException | |
| CTooManyRedirectsException | |
| CWebSocketResponse | HTTP response for WebSocket upgrade |
| ►Ncompiler | Compiler and C++ language related tweaks |
| CSelectValue | Selects the proper value for the current compiler and standard library |
| CThreadLocal | Creates a unique thread-local variable that can be used in a coroutine-safe manner |
| CThreadLocalScope | The scope that grants access to a thread-local variable |
| ►Ncomponents | Contains functions and types to start a userver based service/tool |
| CAuthCheckerSettings | Component that loads auth configuration settings from a components::Secdist component if the latter was registered in components::ComponentList |
| CCachingComponentBase | Base class for caching components |
| CClickHouse | ClickHouse client component |
| CComponentBase | Base class for all application components, it depends on components::Logger and components::Tracer |
| CComponentConfig | Represents the config of a component that is being constructed; see Component system for introduction into components |
| CComponentContext | Class to retrieve other components |
| CComponentList | A list to keep a unique list of components to start with components::Run(), utils::DaemonMain() or components::RunOnce() |
| CComponentsLoadCancelledException | Exception that is thrown from components::ComponentContext::FindComponent() if a component load failed |
| CContainer | A simple Component that creates, hold, and distributes an object of user type T. The component has a name equal to the constexpr std::string_view result of user-defined ContainerName(Of<T>{}) |
| CDefaultSecdistProvider | Component that stores security related data (keys, passwords, ...) |
| CDumpConfigurator | Helper component that manages common configuration for userver dumps |
| ►CDynamicConfig | Component that stores the dynamic config |
| CNoblockSubscriber | Allows to subscribe to DynamicConfig updates without waiting for the first update to complete. Primarily intended for internal use |
| CDynamicConfigClient | Component that starts a clients::dynamic_config::Client client |
| CDynamicConfigClientUpdater | Component that does a periodic update of runtime configs |
| CDynamicConfigUpdatesSinkBase | Base class for components acting as dynamic config updates sinks |
| CDynamicRedis | Valkey and Redis dynamic client component, that does not require secdist |
| CFsCache | Component for storing files in memory |
| CHttpClient | Component that manages clients::http::ClientWithMiddlewares |
| CHttpClientCore | Component that manages clients::http::ClientCore |
| CInMemoryConfig | |
| CLogging | Logging component |
| CLoggingConfigurator | Helper component to configure logging |
| CManagerControllerComponent | Component that prepares the engine internals and starts all the other components |
| CMongo | MongoDB client component |
| CMongoCache | Base class for all caches polling mongo collection |
| CMultiMongo | Dynamically configurable MongoDB client component |
| COf | |
| CPostgreCache | Caching component for PostgreSQL. See Caching Component for PostgreSQL |
| CPostgres | PosgreSQL client component |
| CProcessStarter | Component for getting the engine::subprocess::ProcessStarter |
| CRabbitMQ | RabbitMQ (AMQP 0.9.1) client component |
| CRawComponentBase | The base class for all components. Don't use it for application components, use ComponentBase instead |
| CRedis | Valkey and Redis client component |
| CSecdist | Component that stores security related data (keys, passwords, ...) |
| CServer | Component that listens for incoming requests, manages incoming connections and passes the requests to the appropriate handler |
| CSingleThreadedTaskProcessors | Component that starts multiple single threaded task processors |
| CSQLite | SQLite client component |
| CState | |
| CStatisticsStorage | Component that keeps a utils::statistics::Storage storage for metrics |
| CSystemStatisticsCollector | Component for system resource usage statistics collection |
| CTcpAcceptorBase | Component for accepting incoming TCP connections |
| CTestsuiteSupport | Testsuite support component |
| CWithType | |
| ►Ncompression | |
| CDecompressionError | Base class for decompression errors |
| CErrWithCode | |
| CTooBigError | Decompressed data size exceeds the limit |
| ►Nconcurrent | Locking stuff |
| CAsyncEventChannel | |
| CAsyncEventSource | The read-only side of an event channel. Events are delivered to listeners in a strict FIFO order, i.e. only after the event was processed a new event may appear for processing, same listener is never called concurrently |
| CAsyncEventSubscriberScope | Manages the subscription to events from an AsyncEventSource |
| CBackgroundTaskStorage | |
| CBackgroundTaskStorageCore | |
| CConflatedEventChannel | A non-blocking version of 'AsyncEventChannel' |
| CConsumer | Consumer side of concurrent queues |
| CDefaultQueuePolicy | The default queue policy for GenericQueue. Custom queue policies must inherit from it |
| ►CFunctionId | |
| CHash | |
| ►CGenericQueue | Queue with single and multi producer/consumer options |
| CMultiConsumerSide | |
| CMultiProducerSide | |
| CNoMaxSizeProducerSide | |
| CSingleConsumerSide | |
| CSingleProducerSide | |
| CItemMutex | |
| CLazyValue | Lazy value computation with multiple users |
| CLockedPtr | Proxy class for locked access to data protected with locking::SharedLock<T> |
| CMpscQueue | |
| CMutexSet | A dynamic set of mutexes |
| CProducer | Producer side of concurrent queues |
| CStripedCounter | A contention-free sharded atomic counter, with memory consumption and read performance traded for write performance. Intended to be used for write-heavy counters, mostly in metrics |
| CVariable | |
| ►Ncongestion_control | Congestion Control |
| ►Nv2 | |
| CConfig | |
| ►CController | |
| CConfig | |
| CLimitWithDetails | |
| CLinearController | |
| ►CSensor | |
| CData | |
| CSingleObjectData | |
| CStats | |
| CComponent | Component to limit too active requests, also known as CC |
| CController | |
| CControllerInfo | |
| CLimit | |
| CLimiter | |
| CPolicyState | |
| ►CSensor | |
| CData | |
| CStats | |
| ►Ncrypto | Cryptography support |
| ►Nalgorithm | Miscellaneous cryptographic routines |
| CStringsEqualConstTimeComparator | Performs constant-time string comparison comparator |
| CCertificate | |
| CCmsSigner | |
| CCmsVerifier | |
| CCryptoException | Base exception |
| CDsaSigner | Generic signer for asymmetric cryptography |
| CDsaVerifier | Generic verifier for asymmetric cryptography |
| CHmacShaSigner | HMAC-SHA signer |
| CHmacShaVerifier | HMAC-SHA verifier |
| CKeyParseError | Signing key parse error |
| CNamedAlgo | Base class for a crypto algorithm implementation |
| COpenssl | Class to initialize OpenSSL with mutexes |
| CPrivateKey | |
| CPublicKey | |
| CSerializationError | Serialization error |
| CSigner | Base signer class |
| CSignerNone | "none" algorithm signer |
| CSignError | Signature generation error |
| CSslCtx | |
| CVerificationError | Signature verification error |
| CVerifier | Base verifier class |
| CVerifierNone | "none" algorithm verifier |
| ►Ndecimal64 | Fixed-point decimal data type and related functions |
| CCeilingRoundPolicy | Round towards +infinity |
| CDecimal | Fixed-point decimal data type for use in deterministic calculations, oftentimes involving money |
| CDecimalError | The base class for Decimal-related exceptions |
| CDefRoundPolicy | Default rounding. Fast, rounds to nearest |
| CDivisionByZeroError | Thrown on division by zero in Decimal arithmetic |
| CFloorRoundPolicy | Round towards -infinity |
| CFormatOptions | Parameters for flexible decimal formatting |
| CHalfDownRoundPolicy | Round to nearest, 0.5 towards zero |
| CHalfEvenRoundPolicy | Round to nearest, 0.5 towards number with even last digit |
| CHalfUpRoundPolicy | Round to nearest, 0.5 away from zero |
| COutOfBoundsError | Thrown on overflow in Decimal arithmetic |
| CParseError | Thrown on all errors related to parsing Decimal from string |
| CRoundDownRoundPolicy | Round towards zero. The fastest rounding |
| CRoundUpRoundPolicy | Round away from zero |
| ►Ndist_lock | Distributed locking |
| CDistLockedTask | A task that tries to acquire a distributed lock and runs user callback once while the lock is held |
| CDistLockedWorker | |
| CDistLockSettings | Distributed lock settings |
| CDistLockStrategyBase | Interface for distributed lock strategies |
| CLockIsAcquiredByAnotherHostException | Indicates that lock cannot be acquired because it's busy |
| CStatistics | |
| ►Ndrivers | Top namespace for drivers building blocks |
| CSubscribableFutureWrapper | An adaptor for working with certain external futures |
| ►Ndump | Dumping of cache-like components |
| CConfig | |
| CDumpableEntity | |
| CDumper | Manages dumps of a cache-like component |
| CDynamicConfig | |
| CEncryptedOperationsFactory | |
| CEncryptedReader | |
| CEncryptedWriter | |
| CError | |
| CFileOperationsFactory | |
| CFileReader | A handle to a dump file. File operations block the thread |
| CFileWriter | A handle to a dump file. File operations block the thread |
| CIsDumpedAggregate | |
| CMockReader | A Reader that reads from a string buffer (used in tests) |
| CMockWriter | A Writer that appends to a string buffer (used in tests) |
| COperationsFactory | An abstract Reader/Writer factory |
| CReader | A general interface for binary data input |
| CTo | A marker type used in ADL-found Read |
| CWriter | A general interface for binary data output |
| ►Ndynamic_config | |
| CAdditionalKeysToken | Defines the scope where DynamicConfigClientUpdater requests additional configs |
| ►CClient | Client for the dynamic configs service |
| CJsonReply | |
| CReply | |
| CClientConfig | |
| CConfigDefault | A config name-value pair for usage in dynamic_config::Key constructors |
| CConfigParseError | |
| CConstantConfig | A tag type for usage in dynamic_config::Key constructors |
| CDefaultAsJsonString | A strong typedef for usage in dynamic_config::Key constructors |
| CDiff | Helper class for subscribing to dynamic-config updates with a custom callback |
| CDocsMap | |
| CError | |
| CKey | A config key is a unique identifier for a config variable |
| CKeyValue | A type-erased config key-value pair |
| CSnapshot | The shared snapshot of dynamic configs. Cheap to copy, even cheaper to move. Thread safe, not updated with new dynamic config values in background (it's a snapshot!) |
| CSource | A client for easy dynamic config fetching in components |
| CStorageMock | Backing storage for dynamic_config::Source in tests and benchmarks |
| CVariableSnapshotPtr | |
| ►Neasy | Top namespace for easy library |
| CDependencies | |
| CDependenciesComponent | Factory component for the dependencies from easy library |
| CHttpBase | Easy::HttpWith like class with erased dependencies information that should be used only in dependency registration functions; use easy::HttpWith if not making a new dependency class |
| CHttpDep | Dependency class that provides a Http client |
| ►CHttpWith | Class for describing the service functionality in simple declarative way that generates static configs, applies schemas |
| CCallback | |
| CPgDep | Dependency class that provides a PostgreSQL cluster client |
| ►Nengine | Asynchronous engine primitives |
| ►Nio | Low-level asynchronous I/O interfaces |
| ►Nsys_linux | |
| CEvent | Notification event |
| CInotify | File descriptor that allows one to monitor filesystem events, such as file creation, modification, etc |
| CAddrException | Socket address-related exceptions |
| CBufferedReader | Wrapper for buffered input |
| CFdPoller | Low-level poller that can wait for read, write, and read/write operations on a file descriptor. It does not provide read/write operations |
| CIoCancelled | |
| CIoData | IoData for vector send |
| CIoException | Generic I/O error |
| CIoInterrupted | I/O interruption |
| CIoSystemError | Operating system I/O error |
| CIoTimeout | I/O timeout |
| CIpMreq | |
| CIpMulticastRequestException | Multicast request related exceptions |
| CPipe | Unidirectional pipe representation |
| CPipeReader | Reading end of an unidirectional pipe |
| CPipeWriter | Writing end of an unidirectional pipe |
| ►CPoller | I/O event monitor |
| CEvent | I/O event |
| CReadableBase | |
| CReadAwaiter | |
| CRwBase | |
| CSockaddr | Native socket address wrapper |
| ►CSocket | Socket representation |
| CRecvFromResult | |
| CTerminatorNotFoundException | |
| CTlsException | TLS I/O error |
| CTlsWrapper | |
| CWritableBase | |
| CWriteAwaiter | |
| ►Nsubprocess | |
| CChildProcess | Class that allows controlling child process; usually retrieved from engine::subprocess::ProcessStarter |
| CChildProcessStatus | Status of finished subprocess |
| CChildProcessStatusException | |
| CEnvironmentVariables | Environment variables representation |
| CEnvironmentVariablesScope | RAII idiom guard of environment variables |
| CEnvironmentVariablesUpdate | Iterable environment variables wrapper to update values |
| CExecOptions | Structure of settings for executing commands in the OS |
| CProcessStarter | Creates a new OS subprocess and executes a command in it |
| CCancellableSemaphore | Class that allows up to max_simultaneous_locks concurrent accesses to the critical section. It honours task cancellation, unlike Semaphore |
| CConditionVariable | Std::condition_variable replacement for asynchronous tasks |
| CDeadline | Internal representation of a deadline time point |
| CFuture | Std::future replacement for asynchronous tasks that works in pair with engine::Promise |
| CMutex | Std::mutex replacement for asynchronous tasks |
| CPromise | Std::promise replacement for asynchronous tasks that works in pair with engine::Future |
| CPromise< void > | |
| CSemaphore | Class that allows up to max_simultaneous_locks concurrent accesses to the critical section. It ignores task cancellation, unlike CancellableSemaphore |
| CSemaphoreLock | A replacement for std::shared_lock that accepts Deadline arguments |
| CSemaphoreLockCancelledError | Thrown by engine::CancellableSemaphore on current task cancellation |
| CSharedMutex | Std::shared_mutex replacement for asynchronous tasks |
| CSharedTask | Asynchronous task that has a shared ownership of the payload |
| CSharedTaskWithResult | Asynchronous task with result that has a shared ownership of payload |
| ►CSingleConsumerEvent | A multiple-producers, single-consumer event |
| CNoAutoReset | |
| CSingleThreadedTaskProcessorsPool | |
| CSingleUseEvent | A single-producer, single-consumer event |
| CSingleWaitingTaskMutex | Lighter version of Mutex with not more than 1 waiting task |
| CTask | Asynchronous task that has a unique ownership of the payload |
| CTaskBase | Base class for all the asynchronous tasks (engine::Task, engine::SharedTask, engine::SharedTaskWithResult, engine::TaskWithResult, dist_lock::DistLockedTask, ...) |
| CTaskCancellationBlocker | |
| CTaskCancellationToken | Cancellation token to given task object |
| CTaskCancelledException | Thrown if a TaskWithResult, for which we were waiting, got cancelled |
| CTaskInheritedVariable | TaskInheritedVariable is a per-coroutine variable of arbitrary type |
| CTaskLocalVariable | TaskLocalVariable is a per-coroutine variable of arbitrary type |
| CTaskProcessorPoolsConfig | A lightweight TaskProcessor config for engine::RunStandalone |
| CTaskProcessorsLoadMonitor | Component to monitor CPU usage for every TaskProcessor present in the service, and dump per-thread stats into metrics |
| CTaskWithResult | |
| CUnreachableSemaphoreLockError | |
| CWaitAnyContext | Stores a set of awaitables and allows waiting for completion of any of the stored awaitables |
| CWaitInterruptedException | |
| ►Nerror_injection | Artificial errors injection framework |
| CHook | |
| CSettings | Artificial error injection settings |
| ►Nfmt | |
| Cformatter< boost::uuids::uuid > | |
| Cformatter< T, Char, std::enable_if_t<::utils::IsStrongTypedef< T >{}> > | |
| Cformatter< T, typename std::enable_if_t< std::is_base_of_v< google::protobuf::Message, std::decay_t< T > >, char > > | fmt::format support for protobuf messages |
| Cformatter<::decimal64::Decimal< Prec, RoundPolicy >, Char > | Fmt support |
| Cformatter<::engine::io::Sockaddr > | Socket address fmt formatter |
| Cformatter<::formats::bson::Document > | Uses formats::bson::ToRelaxedJsonString representation by default |
| Cformatter<::formats::bson::JsonString > | |
| Cformatter<::formats::bson::Oid > | |
| Cformatter<::formats::json::Value > | |
| Cformatter<::http::headers::PredefinedHeader > | |
| Cformatter<::http::StatusCode > | |
| Cformatter<::protobuf::json::ParseErrorCode > | |
| Cformatter<::protobuf::json::ParseOptions > | |
| Cformatter<::protobuf::json::PrintErrorCode > | |
| Cformatter<::protobuf::json::PrintOptions > | |
| Cformatter<::server::http::HttpMethod > | |
| Cformatter<::utils::datetime::TimeOfDay< Duration > > | |
| Cformatter<::utils::SmallString< N > > | |
| Cformatter<::utils::statistics::HistogramView > | |
| Cformatter<::utils::statistics::Label > | |
| Cformatter<::utils::statistics::LabelsSpan > | |
| Cformatter<::utils::statistics::LabelView > | |
| Cformatter<::utils::statistics::MetricValue > | |
| Cformatter<::utils::statistics::Rate > | |
| Cformatter<::utils::StringLiteral, char > | |
| Cformatter<::utils::zstring_view, char > | |
| ►Nformats | Value formats representation, parsing and serialization |
| ►Nbson | BSON support |
| CBinary | BSON Binary |
| CBsonException | Generic BSON-related exception |
| CBsonString | |
| CConversionException | Conversion error |
| CDecimal128 | BSON Decimal128 |
| CDocument | BSON document |
| CExceptionWithPath | |
| CIterator | Iterator for BSON values |
| CJsonString | |
| CMaxKey | BSON MaxKey |
| CMemberMissingException | BSON nonexisting member access error |
| CMinKey | BSON MinKey |
| COid | BSON ObjectId |
| COutOfBoundsException | BSON array indexing error |
| CParseException | BSON parsing error |
| CPath | |
| CTimestamp | BSON Timestamp |
| CTypeMismatchException | BSON types mismatch error |
| ►CValue | Non-mutable BSON value representation |
| CDefaultConstructed | |
| CValueBuilder | Builder for BSON |
| ►Ncommon | Common utilities for all the formats |
| CConversionStack | Used in the implementation of functions that convert between different formats, e.g. formats::yaml::Value to formats::json::Value, etc |
| ►CItemsWrapper | Wrapper for handy python-like iteration over a map |
| CIterator | |
| CItemsWrapperValue | |
| CPath | |
| CTransferTag | This tag class is used to move a ValueBuilder object without copying |
| ►Njson | JSON support |
| ►Nparser | SAX parser tools |
| CArrayParser | |
| CBaseError | |
| CBaseParser | Base class for SAX parser |
| CBaseValidator | |
| CBoolParser | |
| CDummyParser | |
| CEmptyValidator | |
| CIntegralParser | |
| CInternalParseError | |
| CJsonValueParser | SAX-parser for formats::json::Value |
| CMapParser | |
| CNumberParser | |
| CParseError | |
| CParserHandler | |
| CParserState | |
| CStringParser | |
| CSubscriber | |
| CSubscriberSink | |
| CSubscriberSinkOptional | |
| CTypedParser | Main base class for SAX parsers |
| CValidator | |
| CArray | Non-mutable JSON array representation |
| CBadStreamException | |
| CConversionException | Conversion error |
| CException | |
| CExceptionWithPath | |
| CIterator | Iterator for formats::json::Value |
| CMemberMissingException | |
| CObject | Non-mutable JSON object representation |
| COutOfBoundsException | |
| CParseException | |
| CPrettyFormat | |
| ►CSchema | Contains a prepared JSON schema |
| CValidationError | |
| CValidationResult | Contains error details (if any) from Schema::Validate |
| CSchemaValidationException | |
| ►CStringBuilder | SAX like builder of JSON string. Use with extreme caution and only in performance critical part of your code |
| CArrayGuard | |
| CObjectGuard | |
| CTypeMismatchException | |
| CUnknownDiscriminatorException | |
| ►CValue | Non-mutable JSON value representation |
| CDefaultConstructed | |
| CIterTraits | |
| ►CValueBuilder | Builder for JSON |
| CIterTraits | |
| ►Nparse | Generic parsers and converters |
| CTo | |
| ►Nserialize | Common serializers |
| CSaxStream | |
| CTo | |
| ►Nyaml | YAML support |
| CBadStreamException | |
| CException | |
| CExceptionWithPath | |
| CIterator | Iterator for formats::yaml::Value |
| CMemberMissingException | |
| COutOfBoundsException | |
| CParseException | |
| CPath | |
| CPathPrefixException | |
| CTypeMismatchException | |
| ►CValue | Non-mutable YAML value representation |
| CDefaultConstructed | |
| CIterTraits | |
| ►CValueBuilder | Builder for YAML |
| CIterTraits | |
| ►Nfs | Filesystem support |
| ►Nblocking | Blocking function and classes to work with filesystem |
| CCFile | A std::FILE* wrapper |
| CFileDescriptor | A file descriptor wrapper |
| CTempDirectory | A unique directory for temporary files. The directory is deleted when the TempDirectory is destroyed |
| CTempFile | A unique temporary file. The file is deleted when the TempFile object is destroyed |
| CFileInfoWithData | Struct file with load data |
| CFsCacheClient | Class client for storing files in memory Usually retrieved from components::FsCache |
| CTempFile | A unique temporary file. The file is deleted when the TempFile object is destroyed |
| ►Ngoogle | |
| ►Nprotobuf | |
| CRepeatedField | |
| CRepeatedPtrField | |
| ►Ngrpc | |
| CTimePoint<::engine::Deadline > | |
| ►Ngrpc_proto_structs | |
| ►Nclient | |
| CReader | Proto-struct based Reader adapter |
| CReaderWriter | Proto-struct based ReaderWriter adapter |
| CResponseFuture | Proto-struct response future |
| CStreamReadFuture | Proto-struct stream response future |
| CWriter | Proto-struct based Writer adapter |
| ►Nserver | |
| CReader | Proto-struct based Reader adapter |
| CReaderWriter | Proto-struct based ReaderWriter adapter |
| CWriter | Proto-struct based Writer adapter |
| ►Ngrpc_protovalidate | |
| ►Nclient | |
| CBaseError | Base grpc_protovalidate error |
| CMessageError | Base grpc_protovalidate error with buf::validate::ValidationResult |
| CMiddleware | |
| CRequestError | RPC failed due to violations in the request protovalidate constraints |
| CResponseError | RPC failed due to violations in the response protovalidate constraints |
| CSettings | |
| CValidationSettings | |
| CValidatorComponent | Component for gRPC client response validation |
| CValidatorError | RPC failed due to validator internal errors. In most cases the reason this exception is thrown is protovalidate CEL expression errors in the proto file |
| ►Nserver | Top namespace for the server part of the grpc-protovalidate library |
| CMiddleware | |
| CSettings | |
| CValidationSettings | |
| CValidatorComponent | Component for gRPC server request validation |
| CValidationError | |
| CValidationParams | |
| CValidationResult | |
| ►Ngrpc_reflection | Top namespace for grpc-reflection library |
| CProtoServerReflection | |
| CReflectionServiceComponent | |
| ►Nhttp | HTTP helpers |
| ►Nheaders | Common HTTP headers |
| ►Nheader_map | |
| CMapEntry | |
| ►CHeaderMap | Container that maps case-insensitive header name into header value |
| CConstIterator | |
| CIterator | |
| CTooManyHeadersException | The exception being thrown in case of capacity overflow |
| CPredefinedHeader | A struct to represent compile-time known header name |
| CContentType | Content-Type representation |
| CContentTypeHash | |
| CDecomposedUrlView | |
| CMalformedContentType | Content-Type parsing error |
| ►Nkafka | |
| ►Nutest | |
| CKafkaCluster | Helper for Kafka unit testing |
| CMessage | Message owning data wrapper for unit tests |
| CConsumerComponent | Apache Kafka Consumer client component |
| CConsumerScope | RAII class that used as interface for Apache Kafka Consumer interaction and proper lifetime management |
| CDeliveryTimeoutException | |
| CGetMetadataException | Exception thrown when fetching metadata |
| CGetMetadataTimeoutException | |
| CHeadersIterator | Header views iterator |
| CHeadersReader | Class to read all message's headers |
| CHeaderView | Wrapper for Kafka header. Header name must be valid null-terminated string. Header value is treated as a binary data by Kafka |
| CMessage | Wrapper for polled message data access |
| CMessageTooLargeException | |
| COffsetRange | Represents the range of offsets for certain topic |
| COffsetRangeException | Exception thrown when there is an error retrieving the offset range |
| COffsetRangeTimeoutException | |
| COwningHeader | Owning wrapper for Kafka header |
| CParseHeadersException | Exception thrown when parsing consumed messages headers. Message::GetHeaders |
| CProducer | Apache Kafka Producer Client |
| CProducerComponent | Apache Kafka Producer client component |
| CQueueFullException | |
| CSeekException | Exception thrown when Seek* process failed. ConsumerScope::Seek ConsumerScope::SeekToBeginning ConsumerScope::SeekToEnd |
| CSeekInvalidArgumentException | Exception thrown when Seek* arguments are invalid. ConsumerScope::Seek ConsumerScope::SeekToBeginning ConsumerScope::SeekToEnd |
| CSendException | Base exception thrown by Producer::Send and Producer::SendAsync on send or delivery errors |
| CTopicNotFoundException | |
| CTopicPartitionView | Represents the topic's partition for certain topic |
| CUnknownPartitionException | |
| CUnknownTopicException | |
| ►Nlogging | Logging macro and utilities |
| ►Nstacktrace_cache | Contains functions that cache stacktrace results |
| CStacktraceGuard | |
| CDefaultLoggerGuard | Atomically replaces the default logger |
| CDefaultLoggerLevelScope | Allows to override global log level for the whole service within a scope. Primarily for use in tests |
| CHex | Formats value in a hex mode with the fixed length representation |
| CHexShort | |
| CJsonString | |
| CLogExtra | Extra tskv fields storage |
| CLogHelper | |
| CQuoted | Formats a string as quoted, escaping the '\' and '"' symbols |
| ►Nmeta | |
| CNotDetected | |
| ►Nmiddlewares | |
| ►Ngroups | |
| CAuth | The Group for authentication middlewares. Is located after Logging |
| CCore | The core group of middlewares. Is located after Auth |
| CLogging | The Group to work with logging. Is located after PreCore |
| CPostCore | The group is located after Core |
| CPreCore | The first group in the pipeline |
| CUser | The group for user middlewares - the last group in pipeline. It group used by default |
| CMiddlewareDependencyBuilder | Specifies a middleware's order with respect to other middlewares |
| CMiddlewareFactoryComponentBase | Base class for middleware factory component |
| CRunnerComponentBase | Base class for a component that runs middlewares |
| ►Nmoodycamel | |
| CConcurrentQueue | |
| ►Nmulti_index_lru | |
| CContainer | MultiIndex LRU container |
| CExpirableContainer | MultiIndex LRU expirable container |
| ►Nos_signals | Components and functions to work with OS signals |
| CProcessor | A client that allows to subscribe to OS signals SIGUSR1 and SIGUSR2 |
| CProcessorComponent | A component for os_signals::Processor |
| CProcessorMock | Provides Processor for use in tests |
| ►Notlp | |
| CLoggerComponent | Component to configure logging via OTLP collector |
| ►Nproto_structs | Top namespace for the proto-structs library |
| ►Nio | Namespace for conversion utilities and predefined proto-structs conversion hooks for well-known std/userver types |
| CContext | Read/write operation context |
| CContextWithErrors | Read/write operation context with error information |
| CReadContext | Read operation context passed to user-defined ReadProtoStruct global functions |
| CTo | An ADL helper which allows compiler to find functions to read proto structs from protobuf messages |
| CWriteContext | Write operation context passed to user-defined WriteProtoStruct global functions |
| ►Ntraits | Namespace contains types for obtaining meta information (traits, concepts, etc.) |
| CCompatibleMessageTrait | Trait that marks struct/class type as compatible to some protobuf message |
| CCompatibleMessageTrait< decimal64::Decimal< Prec, TRoundPolicy > > | |
| CCompatibleMessageTrait< formats::json::Array > | |
| CCompatibleMessageTrait< formats::json::Object > | |
| CCompatibleMessageTrait< formats::json::Value > | |
| CCompatibleMessageTrait< std::chrono::duration< TRep, TPeriod > > | |
| CCompatibleMessageTrait< std::chrono::hh_mm_ss< TDuration > > | |
| CCompatibleMessageTrait< std::chrono::time_point< std::chrono::system_clock > > | |
| CCompatibleMessageTrait< std::chrono::year_month_day > | |
| CCompatibleMessageTrait< T > | |
| CCompatibleMessageTrait< utils::Box< T > > | |
| CCompatibleMessageTrait< utils::datetime::TimeOfDay< TDuration > > | |
| CCompatibleMessageTrait<::structs::ConversionFailure > | |
| CCompatibleMessageTrait<::structs::Simple > | |
| CAny | Wrapper for google.protobuf.Any which provides interface to access stored message as compatible struct |
| CAnyPackError | Error packing protobuf message to proto_structs::Any underlying storage |
| CAnyUnpackError | Error unpacking protobuf message from proto_structs::Any underlying storage |
| CConversionError | Conversion error base class |
| CDate | Type to represent google.type.Date in proto structs |
| CDuration | Type to represent google.protobuf.Duration in proto structs |
| CError | Library basic exception type. All other proto-structs exceptions are derived from this type |
| COneof | Wrapper for oneof protobuf message fields |
| COneofAccessError | Invalid attempt to access unset proto_structs::Oneof field |
| CReadError | Error reading proto struct from protobuf message or binary data |
| CTimeOfDay | Type to represent google.type.TimeOfDay in proto structs |
| CTimestamp | Type to represent google.protobuf.Timestamp in proto structs |
| CUnbreakableDependencyCycle | A type that is generated for a field that participates in an unbreakable dependency cycle |
| CValueError | Incorrect value error |
| CWriteError | Error writing proto struct to protobuf message or binary data |
| ►Nprotobuf | Top namespace for the userver protobuf library |
| ►Njson | Top namespace for the protobuf JSON utilities |
| ►Ntests | |
| CAnyMessageData | |
| CBoolMessageData | |
| CBoolValue | |
| CBytesMessageData | |
| CBytesValue | |
| CDoubleMessageData | |
| CDoubleNegativeInfinity | |
| CDoublePositiveInfinity | |
| CDoubleQuietNan | |
| CDoubleSignalingNan | |
| CDoubleValue | |
| CDurationMessageData | |
| CEnumMessageData | |
| CFieldMaskMessageData | |
| CFloatMessageData | |
| CFloatNegativeInfinity | |
| CFloatPositiveInfinity | |
| CFloatQuietNan | |
| CFloatSignalingNan | |
| CFloatValue | |
| CInt32MessageData | |
| CInt32Value | |
| CInt64MessageData | |
| CInt64Value | |
| CMapMessageData | |
| CNestedMessageData | |
| CNullValueMessageData | |
| COneofMessageData | |
| CPresenceMessageData | |
| CProtoNullValue | |
| CRawAnyData | |
| CRepeatedMessageData | |
| CSampleError | |
| CStringMessageData | |
| CStringValue | |
| CTimestampMessageData | |
| CUInt32MessageData | |
| CUInt32Value | |
| CUInt64MessageData | |
| CUInt64Value | |
| CUnknownFieldMessageData | |
| CValueMessageData | |
| CWrapperMessageData | |
| CConversionError | JSON/protobuf conversion error |
| CConversionErrorBase | Base exception type for JSON/protobuf conversion errors |
| CConversionErrorInfo | JSON/protobuf conversion error information |
| CJsonError | Base exception type for JSON utilities |
| CParseOptions | Options which affect how JSON Value is converted to a protobuf message |
| CPrintOptions | Options which affect how protobuf message is converted to a JSON ValueBuilder/Value |
| CError | Library base exception type |
| ►Npytest_userver | Python module pytest_userver provides testsuite support for userver services |
| ►Nchaos | Python module that provides testsuite support for chaos tests; see Chaos Testing for an introduction |
| CBaseError | |
| CBaseGate | This base class maintain endpoints of two types: |
| CConnectionClosedError | |
| CGateRoute | Class that describes the route for TcpGate or UdpGate |
| CTcpGate | Implements TCP chaos-proxy logic such as accepting incoming tcp client connections |
| CUdpGate | Implements UDP chaos-proxy logic such as demuxing incoming datagrams from different clients |
| ►Nclient | Python module that provides clients for functional tests with testsuite; see Functional service tests (testsuite) for an introduction |
| C_State | Reflects the (supposed) current service state |
| C_StateManager | Used for computing the requests that we need to automatically align the service state with the test fixtures state |
| CBaseError | Base class for exceptions of this module |
| CClient | Asyncio userver client, typically retrieved from plugins.service_client.service_client fixture |
| CClientMonitor | Asyncio userver client for monitor listeners, typically retrieved from plugins.service_client.monitor_client fixture |
| CClientWrapper | Base asyncio userver client that implements HTTP requests to service |
| CConfigurationError | |
| CMetricsDiffer | A helper class for computing metric differences |
| CPeriodicTaskFailed | |
| CPeriodicTasksState | |
| CTestsuiteActionFailed | |
| CTestsuiteClientConfig | |
| CTestsuiteTaskConflict | |
| CTestsuiteTaskError | |
| CTestsuiteTaskFailed | |
| CTestsuiteTaskNotFound | |
| ►Ndynconf | Python module that provides classes and constants that may be useful when working with the dynamic config in testsuite |
| C_Changelog | |
| C_ChangelogEntry | |
| C_ConfigEntry | |
| C_Missing | |
| C_RemoveKey | |
| C_Updates | |
| CBaseError | Base class for exceptions from this module |
| CDynamicConfig | Simple dynamic config backend |
| CDynamicConfigNotFoundError | Config parameter was not found and no default was provided |
| CDynamicConfigUninitialized | Calling dynamic_config.get before defaults are fetched from the service |
| CInvalidDefaultsError | Dynamic config defaults action returned invalid response |
| CUnknownConfigError | Invalid dynamic config name in @pytest.mark.config |
| CUseStaticDefault | |
| ►Ngrpc | Mocks for the gRPC servers, a.k.a |
| ►N_client | |
| CPreCallClientInterceptor | A simple generic interceptor that allows to insert some code before each RPC is initiated |
| ►N_mocked_errors | |
| CMockedError | Base class for mocked exceptions |
| CNetworkError | When thrown from a mocked handler, leads to ugrpc.client.RpcInterruptedError |
| CTimeoutError | When thrown from a mocked handler, leads to ugrpc.client.RpcInterruptedError |
| ►N_reflection | |
| C_FakeChannel | |
| C_RawMethodInfo | |
| ►N_servicer_mock | |
| C_PatchedAbort | |
| C_PatchedServicerContext | grpc.aio.ServicerContext.abort immediately sends the response status, before AsyncCallQueue has a chance to update its call log |
| C_ServiceMock | |
| C_ServiceMockState | |
| CMockserver | Allows to install mocks that are reset between tests, see grpc_mockserver |
| CMockserverSession | Allows to install mocks that are kept active between tests, see grpc_mockserver_session |
| ►Nmetrics | Python module that provides helpers for functional testing of metrics with testsuite; see Functional service tests (testsuite) for an introduction |
| C_MetricsJSONEncoder | |
| CHistogram | Represents the value of a HIST_RATE (a.k.a |
| CMetric | Metric type that contains the labels: dict[str, str] and value: int |
| CMetricsSnapshot | Snapshot of captured metrics that mimics the dict interface |
| ►Nplugins | |
| ►Ncaches | Fixtures for controlling userver caches |
| CCacheControl | |
| CCacheControlAction | |
| CCacheControlRequest | |
| CInvalidationState | |
| CUserverCachePlugin | |
| ►Ncoverage | Helpers for coverage plugins |
| CUncoveredError | |
| ►Ndynamic_config | Supply dynamic configs for the service in testsuite |
| C_ConfigDefaults | |
| ►Npostgresql | Plugin that imports the required fixtures to start the database and adjusts the PostgreSQL "dbconnection" static config value |
| CRegisteredNtrx | |
| CRegisteredNtrxFailureType | |
| ►Nservice_runner | Helpers to make the make start-* commands work |
| ►CServiceRunnerModule | |
| CFakeModule | |
| CUserviceRunner | |
| ►Nsql_coverage | Plugin that imports the required fixtures for checking SQL/YQL coverage |
| CCoverage | Contains data about the current coverage of statements |
| ►Ntestpoint | Testpoints support for the server |
| CBaseError | |
| CTestpointControl | |
| CUnregisteredTestpointError | |
| ►Nydb | Pytest plugin that provides YDB fixtures for functional tests with testsuite; see YDB for an introduction |
| ►Nclient | |
| CYdbClient | YDB Client implementation |
| ►Nservice | |
| CServiceSettings | |
| ►Ns3api | |
| C_S3BucketUploadStorage | |
| C_S3ClientError | |
| C_S3EntityTooSmallError | |
| C_S3InvalidPartError | |
| C_S3InvalidPartOrderError | |
| C_S3NoSuchUploadError | |
| C_S3Upload | |
| C_S3UploadPart | |
| CS3HandleMock | |
| CS3MockBucketStorage | |
| CS3Object | |
| ►Nsql | |
| CRegisteredTrx | RegisteredTrx maintains transaction fault injection state to test transaction failure code path |
| ►Nutils | |
| ►Ncolorize | |
| CColorArg | |
| CColorizer | |
| CColors | |
| ►Nnet | |
| CHealthChecks | Class that holds all the info for health checks |
| CHostPort | Class that holds a host and port |
| ►Nsync | |
| CNotReady | |
| ►Nrcu | Read-Copy-Update |
| CAsyncDeleter | Destroys retired objects asynchronously in the same TaskProcessor |
| CBlockingRcuTraits | Rcu traits for using outside of coroutines |
| CDefaultRcuMapTraits | |
| CDefaultRcuTraits | Default RCU traits. Deletes garbage asynchronously. Designed for storing data of multi-megabyte or multi-gigabyte caches |
| CExclusiveRcuTraits | Rcu traits that only allow a single writer. Detects race conditions when multiple writers call Assign concurrently |
| CMissingKeyException | Thrown on missing element access |
| ►CRcuMap | Map-like structure allowing RCU keyset updates |
| CInsertReturnTypeImpl | |
| CRcuMapIterator | Forward iterator for the rcu::RcuMap |
| CReadablePtr | |
| CSnapshotHandle | A handle to the retired object version, which an RCU deleter should clean up |
| CSyncDeleter | Destroys retired objects synchronously |
| CSyncRcuTraits | Deletes garbage synchronously. Designed for storing small amounts of data with relatively fast destructors |
| CVariable | Read-Copy-Update variable |
| CWritablePtr | |
| ►Ns3api | Top namespace for S3 library |
| ►Nauthenticators | |
| CAccessKey | |
| CAuthenticator | Base class for all authenticators - classes that sign the request with auth data |
| ►Nmultipart_upload | |
| CAbortMultipartUploadRequest | |
| ►CCompleteMultipartUploadRequest | |
| CCompletedPart | |
| CCompleteMultipartUploadResult | |
| CCreateMultipartUploadRequest | |
| CInitiateMultipartUploadResult | |
| CListMultipartUploadsRequest | |
| ►CListMultipartUploadsResult | |
| CMultipartUpload | |
| CListPartsRequest | |
| ►CListPartsResult | |
| CPart | |
| CUploadPartRequest | |
| CUploadPartResult | |
| CAuthHeaderConflictError | |
| ►CClient | |
| CHeaderDataRequest | |
| CHeadersDataResponse | |
| CTag | |
| CClientImpl | Implementation of S3 client |
| CConnectionCfg | Connection settings - retries, timeouts, and so on |
| CGMockClient | |
| CListBucketError | |
| CMultipartUploadError | |
| CNoBucketError | |
| CObjectMeta | |
| CRequest | |
| CResponseParsingError | |
| CS3Connection | |
| ►Nserver | |
| ►Nauth | |
| CUserAuthInfo | |
| CUserScope | |
| ►Ncongestion_control | |
| CLimitee | |
| CLimiter | |
| CRequestsSource | |
| CSensor | |
| ►Nhandlers | Most common userver HTTP handlers |
| ►Nauth | |
| ►Ndigest | |
| CAuthCheckerBase | Base class for digest authentication checkers. Implements a digest-authentication logic |
| CAuthCheckerSettings | Struct of directives for digest authentication server settings per RFC 2617 |
| CAuthCheckerSettingsComponent | Component that loads digest auth configuration settings from a static_config.yaml |
| CAuthStandaloneCheckerBase | Class for digest authentication checker. Implements a stand-alone digest-authentication logic |
| CContextFromClient | |
| CContextFromServer | |
| CHasher | Used for data hashing and "nonce" generating |
| CNonceCacheSettings | |
| CNonceCacheSettingsComponent | Component that loads nonce cache settings from a static_config.yaml |
| CNonceInfo | |
| CParser | Class for parsing Authorization header directives from client request |
| CUserData | Contains information about the user |
| CAuthCheckerBase | |
| CAuthCheckerFactoryBase | Base class for all the authorization factory checkers |
| CAuthCheckerSettings | |
| CAuthCheckResult | |
| CDuplicateDirectiveException | |
| CException | |
| CHandlerAuthConfig | |
| CMissingDirectivesException | |
| CParseException | |
| CClientError | |
| CConflictError | |
| CCustomHandlerException | The generic base class for handler exceptions. Thrown exceptions should typically derive from ExceptionWithCode instead |
| CDnsClientControl | Handlers that controls the DNS client |
| CDumpCoroutines | Handler that returns detailed alive coroutines information |
| CDynamicDebugLog | Handler for forcing specific lines logging. Feature also known as dynamic debug logging |
| CExceptionWithCode | Base class for handler exceptions. For common HandlerErrorCode values you can use more specific exception classes below. For less common HandlerErrorCode values, this class can be used directly |
| CExternalBody | |
| CExtraHeaders | |
| CFormattedErrorData | |
| CHandlerBase | Base class for the request handlers |
| CHandlerConfig | |
| CHandlerErrorCodeHash | Hasher class for HandlerErrorCode |
| CHttpHandlerBase | Base class for all the Userver HTTP Handlers |
| CHttpHandlerFlatbufBase | Convenient base for handlers that accept requests with body in Flatbuffer format and respond with body in Flatbuffer format |
| CHttpHandlerJsonBase | Convenient base for handlers that accept requests with body in JSON format and respond with body in JSON format |
| CHttpHandlerStatic | Handler that returns HTTP 200 if file exist and returns file data with mapped content/type |
| CImplicitOptions | A "magical" handler that will respond to OPTIONS HTTP method for any other handler that cannot handle OPTIONS itself |
| CInspectRequests | Handler that returns information about all in-flight requests |
| CInternalMessage | |
| CInternalServerError | |
| CJemalloc | Handler that controls the jemalloc allocator |
| CJsonErrorBuilder | |
| CLegacyJsonErrorBuilder | |
| CLogLevel | Handler that controls logging levels of all the loggers |
| COnLogRotate | Handler that controls logging levels of all the loggers |
| CPing | Ping handler implementation with warmup |
| CPingBase | Base class for handlers that returns HTTP 200 if the service is OK and able to process requests |
| CRequestParseError | |
| CResourceNotFound | |
| CRestart | Handler that stops the service. It is expected that an external system (e.g. systemd or supervisord) restarts the service afterwards |
| CServerMonitor | Handler that returns statistics data |
| CServiceErrorCode | |
| CTestsControl | Handler that allows to control the behavior of server from tests, and functional tests with testsuite in particular |
| CUnauthorized | |
| CWebsocketHandlerBase | Base class for WebSocket handler |
| ►Nhttp | Server parts of the HTTP protocol implementation |
| CCookie | HTTP response cookie |
| CCustomHandlerException | An extension of server::handlers::CustomHandlerException that allows to specify a custom HttpStatus |
| CFormDataArg | Argument of a multipart/form-data request |
| CHttpRequest | HTTP Request data |
| CHttpRequestBuilder | HTTP Request Builder |
| CHttpResponse | HTTP Response data |
| CResponseBodyStream | |
| ►Nmiddlewares | HTTP server middlewares |
| ►CCors | CORS (Cross-Origin Resource Sharing) middleware |
| CConfig | |
| CCorsFactory | Factory for server::middlewares::Cors |
| CHandlerPipelineBuilder | Base class to build a per-handler middleware pipeline. One may inherit from it and implement any custom logic, if desired. By default the behavior is to use the server-wide pipeline |
| CHeadersPropagator | |
| CHeadersPropagatorFactory | |
| CHttpMiddlewareBase | Base class for a http middleware |
| CHttpMiddlewareFactoryBase | Base class for a http middleware-factory |
| CPipelineBuilder | Base class to build a server-wide middleware pipeline. One may inherit from it and implement any custom logic, if desired |
| CSimpleHttpMiddlewareFactory | A short-cut for defining a middleware-factory |
| ►Nrequest | Server request related types and functions |
| CDeadlinePropagationBlocker | Stops deadline propagation within its scope |
| CDeadlineSignal | Signals when an operation has detected deadline expiration |
| CHeader | |
| CHttpRequestConfig | |
| CRequestContext | Stores request-specific data during request processing |
| CResponseBase | Base class for all the server responses |
| CResponseDataAccounter | |
| CTaskInheritedData | Per-request data that should be available inside handlers |
| CServer | |
| ►Nstd | STL namespace |
| Chash<::decimal64::Decimal< Prec, RoundPolicy > > | Std::hash support |
| Chash<::formats::bson::Binary > | |
| Chash<::formats::bson::Oid > | |
| Chash<::formats::bson::Timestamp > | |
| Chash<::server::auth::UserScope > | |
| Chash<::storages::postgres::DBTypeName > | |
| Chash<::storages::postgres::io::PredefinedOids > | |
| Chash<::storages::postgres::SqlState > | Specialization of std::hash template for SqlState |
| Chash<::storages::postgres::TimePointTz > | std::hash support for storages::postgres::TimePointTz |
| Chash<::storages::postgres::TimePointWithoutTz > | std::hash support for storages::postgres::TimePointWithoutTz |
| Chash<::utils::CachedHash< T > > | |
| Chash<::utils::NotNull< T > > | |
| Chash<::utils::SmallString< N > > | |
| Chash<::utils::StrongTypedef< Tag, T, Ops > > | |
| ►Nstorages | Components, clients and helpers for different databases and storages |
| ►Nclickhouse | Top namespace for uClickHouse driver |
| ►Nio | UClickHouse input-output |
| ►Ncolumns | UClickHouse columns |
| ►CArrayColumn | Represents ClickHouse Array(T) column, where T is a ClickhouseColumn as well |
| CArrayDataHolder | |
| CArrayColumnMeta | |
| CClickhouseColumn | Base class for every typed ClickHouse column. To add new columns one should derive from this class, define types aliases: |
| CColumnIterator | Forward-iterator for iterating over column of type ColumnType |
| CDateTime64Column | Helper class for instantiating DateTime64 columns |
| ►CDateTime64Column< Precision, Duration< Rep, Period > > | |
| CTag | |
| CDateTimeColumn | Represents ClickHouse DateTime column |
| CFloat32Column | Represents Clickhouse Float32 column |
| CFloat64Column | Represents Clickhouse Float64 column |
| CInt32Column | Represents Clickhouse Int32 column |
| CInt64Column | Represents ClickHouse Int64 column |
| CInt8Column | Represents ClickHouse UInt8 Column |
| CMismatchedEndiannessUuidColumn | Legacy broken ClickHouse UUID column representation |
| ►CNullableColumn | Represents ClickHouse Nullable(T) column, where T is a ClickhouseColumn as well |
| CNullableDataHolder | |
| CNullableColumnMeta | |
| CStringColumn | Represents ClickHouse String column |
| CUInt16Column | Represents Clickhouse UInt16 column |
| CUInt32Column | Represents ClickHouse UInt32 column |
| CUInt64Column | Represents ClickHouse UInt64 column |
| CUInt8Column | Represents ClickHouse UInt8 Column |
| CUuidColumn | |
| CUuidRfc4122Column | Represents ClickHouse UUID column |
| CColumnsMapper | |
| CCppToClickhouse | |
| CFloatingWithPrecision | Class that can be escaped for clickhouse queries instead of [double] and [float]. [double] and [float] are escaped as FloatingWithPrecision<double, 12> and FloatingWithPrecision<float, 6> respectively. These constants were derived from the accuracity the numbers from ranges [0.0-100000.0] (doubles) and [0.0-100.0] (floats) can be represented by these type. Clickhouse also supports inf, -inf and nan, see clickhouse docs |
| ►CRowsMapper | |
| CIterator | |
| ►CCluster | Interface for executing queries on a cluster of ClickHouse servers |
| CNoAvailablePoolError | Exception that is thrown if all specified endpoints are unavailable |
| CCommandControl | |
| CExecutionResult | |
| CParameterStore | Class for dynamic ClickHouse parameter list construction |
| ►CQuery | Holds a query, its name and logging mode; used by all the SQL databases of userver |
| CNameLiteral | Compile time literal with query name |
| ►Nmongo | MongoDB client |
| ►Nbulk_ops | Bulk sub-operations |
| CDelete | Deletes documents as part of bulk operation |
| CInsertOne | Inserts a single document as part of bulk operation |
| CReplaceOne | Replaces a single document as part of bulk operation |
| CUpdate | Updates documents as part of bulk operation |
| ►Noperations | Collection operations |
| CAggregate | Runs an aggregation pipeline |
| CBulk | Efficiently executes a number of operations over a single collection |
| CCount | Counts documents matching the filter |
| CCountApprox | Returns approximate number of documents in a collection |
| CDelete | Deletes documents |
| CDistinct | Retrieves distinct values for a specified field |
| CDrop | |
| CFind | Retrieves documents matching the filter |
| CFindAndModify | Atomically updates a document and returns either previous or new version |
| CFindAndRemove | Atomically removes a document and returns it |
| CInsertMany | Inserts multiple documents |
| CInsertOne | Inserts a single document |
| CReplaceOne | Replaces a single document |
| CUpdate | Updates documents |
| ►Noptions | Collection operation options |
| CAllowPartialResults | Suppresses errors on querying a sharded collection with unavailable shards |
| CArrayFilters | Specifies an array of filter documents that determine which array elements to modify for an update operation on an array field |
| CCollation | Specifies collation options for text comparison |
| CComment | Sets a comment for the operation, which would be visible in profile data |
| CHint | Specifies an index to use for the query |
| CLimit | Specifies the number of documents to request from the server |
| CMaxServerTime | Specifies the server-side time limit for the operation |
| CProjection | Selects fields to be returned |
| CReadPreference | Read preference |
| CRetryDuplicateKey | Enables automatic one-time retry of duplicate key errors |
| CReturnNew | Specifies that FindAndModify should return the new version of an object |
| CSkip | Specifies the number of documents to skip |
| CSort | Sorts the results |
| CSuppressServerExceptions | Disables exception throw on server errors, should be checked manually in WriteResult |
| CTailable | Enables tailable cursor, which block at the end of capped collections |
| CUnordered | Disables ordering on bulk operations causing them to continue after an error |
| CUpsert | Enables insertion of a new document when update selector matches nothing |
| CWriteConcern | Write concern |
| ►Nutest | |
| CMongoLocal | Mongo local class |
| CMongoTest | Provides access to storages::mongo::Pool by means storages::mongo::utest::MongoLocal class |
| CAuthenticationException | Authentication error |
| ►CCancelledException | The current task has been cancelled, e.g. by deadline propagation |
| CByDeadlinePropagation | |
| CClusterUnavailableException | No server available to satisfy request constraints |
| CCollection | MongoDB collection handle, the main way to operate with MongoDB |
| ►CCursor | Interface for MongoDB query cursors |
| ►CIterator | |
| CDocHolder | |
| CDistLockComponentBase | Base class for mongo-based distlock worker components |
| CDistLockStrategy | Strategy for mongodb-based distributed locking |
| CDuplicateKeyException | Duplicate key error |
| CIncompatibleServerException | Incompatible server version |
| CInvalidConfigException | Config validation error |
| CInvalidQueryArgumentException | Query argument validation error |
| CMongoError | MongoDB error |
| CMongoException | Generic mongo-related exception |
| ►CMultiMongo | |
| CPoolSet | Database set builder |
| CNetworkException | Network (connectivity) error |
| CPool | MongoDB client pool |
| CPoolConfig | MongoDB connection pool configuration |
| CPoolNotFoundException | Nonexistent pool requested from the set |
| CPoolOverloadException | Pool refused to satisfy connection request due to high load |
| CPoolSettings | Mongo connection pool options |
| CQueryException | Generic query error |
| CServerException | Server-side error |
| CTransaction | MongoDB transaction handle that provides ACID guarantees |
| CTransactionException | Transaction-related exception |
| CWriteConcernException | Write concern error |
| CWriteResult | MongoDB write operation result |
| ►Nmysql | Top namespace for uMySQL driver |
| ►Nconvert | Namespace containing helper classes and functions for on-the-flight remapping DbType<->UserType |
| CTo | |
| ►Ntests | |
| CClusterWrapper | |
| CTmpTable | |
| CCluster | Client interface for a cluster of MySQL servers. Usually retrieved from components::MySQL |
| CCommandControl | |
| CCommandResultSet | A wrapper for command result set |
| CComponent | MySQL/MariaDB client component |
| CCursorResultSet | A wrapper for read-only cursor |
| CDate | Class that represent MySQL DATE type |
| CDateTime | Class that represents MySQL DATETIME type |
| CExecutionResult | Metadata for an execution of a statement that doesn't expect a result set (INSERT, UPDATE, DELETE) |
| CFieldTag | Used for extracting statement results as a single field |
| CMappedStatementResultSet | An interface for on-the-flight mapping statement result set from DbType into whatever type you provide without additional allocations |
| CMySQLCommandException | Command exception - something went wrong with the command |
| CMySQLException | Base class for all uMySQL driver exceptions |
| CMySQLIOException | IO exception (read/write timeout/cancelled) |
| CMySQLStatementException | Statement exception - something went wrong with the statement |
| CMySQLTransactionException | Transaction exception - something went wrong with the transaction |
| CMySQLValidationException | |
| ►CQuery | Holds a query, its name and logging mode; used by all the SQL databases of userver |
| CNameLiteral | Compile time literal with query name |
| CRowTag | Used for extracting statement results as rows |
| CStatementResultSet | A wrapper for statement execution result |
| CTransaction | RAII transaction wrapper, auto-ROLLBACKs on destruction if no prior Commit/Rollback call was made |
| ►Npostgres | Top namespace for uPg driver |
| ►Nio | UPg input-output |
| ►Ntraits | UPg input-output traits |
| CAddTupleConstRef | |
| CAddTupleConstRef< std::tuple< T... > > | |
| CBitContainerTraits | |
| CBitContainerTraits< BitContainer, std::enable_if_t< std::is_integral_v< BitContainer > > > | |
| CBitContainerTraits< std::array< bool, N > > | |
| CBitContainerTraits< std::bitset< N > > | |
| CCanClear | |
| CCanClear< T, ::utils::void_t< decltype(std::declval< T >().clear())> > | |
| CCanReserve | |
| CCanReserve< T, ::utils::void_t< decltype(std::declval< T >().reserve(std::declval< std::size_t >()))> > | |
| CCanResize | |
| CCanResize< T, ::utils::void_t< decltype(std::declval< T >().resize(std::declval< std::size_t >()))> > | |
| CCanUseEnumAsStrongTypedef | |
| CContainerFinalElement | Detect type of multidimensional C++ container |
| CDimensionCount | Calculate number of dimensions in C++ container |
| CDimensionCount< T, std::enable_if_t< kIsCompatibleContainer< T > > > | |
| CDimensionSize | |
| CDimensionSize< std::array< T, N > > | |
| CExtractionTag | |
| CExtractionTag< T, std::enable_if_t< kIsRowType< T > > > | |
| CFixedDimensions | |
| CGetSetNull | |
| CGetSetNull< boost::optional< T > > | |
| CGetSetNull< Null< T > > | |
| CGetSetNull< std::optional< T > > | |
| CGetSetNull<::utils::OptionalRef< T > > | |
| CGetSetNull<::utils::StrongTypedef< Tag, T, Ops, Enable > > | |
| CHasFixedDimensions | |
| CHasFormatter | Metafunction to detect if a type has a formatter |
| CHasIntrospection | |
| CHasParser | Metafunction to detect if a type has a parser |
| CInput | Customisation point for parsers |
| CInput< BoundedRange< T >, std::enable_if_t< kHasParser< T > > > | |
| CInput< formats::json::Value > | |
| CInput< Range< T >, std::enable_if_t< kHasParser< T > > > | |
| CInput< std::chrono::duration< Rep, Period > > | Binary parser for std::chrono::duration |
| CInput< T, EnableIfCanUseEnumAsStrongTypedef< T > > | |
| CIO | A default deducer of parsers/formatters for a type/data format. Can be specialised for a type/format pair providing custom parsers/formatters |
| CIsBitStringCompatible | |
| CIsBitStringCompatible< std::array< bool, N > > | |
| CIsBitStringCompatible< std::bitset< N > > | |
| CIsBitStringCompatible<::utils::Flags< Enum > > | |
| CIsByteaCompatible | |
| CIsByteaCompatible< std::string > | |
| CIsByteaCompatible< std::string_view > | |
| CIsByteaCompatible< std::vector< char, VectorArgs... > > | |
| CIsByteaCompatible< std::vector< unsigned char, VectorArgs... > > | |
| CIsCompatibleContainer | Mark C++ container type as supported by the driver |
| CIsCompatibleContainer< std::array< T, Size > > | |
| CIsCompatibleContainer< std::set< T... > > | |
| CIsCompatibleContainer< std::unordered_set< T... > > | |
| CIsCompatibleContainer< std::vector< T... > > | |
| CIsMappedToArray | Detect if the C++ type is mapped to a Postgres array type |
| CIsMappedToPg | Detect if the C++ type is mapped to a Postgres type |
| CIsMappedToPg< boost::optional< T > > | |
| CIsMappedToPg< Null< T > > | |
| CIsMappedToPg< std::optional< T > > | |
| CIsMappedToPg< T, EnableIfCanUseEnumAsStrongTypedef< T > > | |
| CIsMappedToPg<::utils::OptionalRef< T > > | |
| CIsMappedToPg<::utils::StrongTypedef< Tag, T, Ops, Enable > > | |
| CIsMappedToSystemType | Detect if the C++ type is mapped to a Postgres system type |
| CIsMappedToUserType | Detect if the C++ type is mapped to a Postgres user type |
| CIsNullable | Metafunction to detect nullability of a type |
| CIsNullable< boost::optional< T > > | Nullability traits for boost::optional |
| CIsNullable< Null< T > > | |
| CIsNullable< std::optional< T > > | Nullability traits for std::optional |
| CIsNullable<::utils::OptionalRef< T > > | Nullability traits for USERVER_NAMESPACE::utils::OptionalRef |
| CIsNullable<::utils::StrongTypedef< Tag, T, Ops, Enable > > | |
| CIsSpecialMapping | Mark C++ mapping a special case for disambiguation |
| CIsSpecialMapping< boost::optional< T > > | |
| CIsSpecialMapping< Null< T > > | |
| CIsSpecialMapping< std::optional< T > > | |
| CIsSpecialMapping< T, EnableIfCanUseEnumAsStrongTypedef< T > > | |
| CIsSpecialMapping<::utils::OptionalRef< T > > | |
| CIsSpecialMapping<::utils::StrongTypedef< Tag, T, Ops, Enable > > | |
| CIsSuitableRowType | |
| CIsSuitableRowType<::utils::StrongTypedef< Tag, T, Ops, Enable > > | |
| CIsTuple | |
| CIsTuple< std::tuple< T... > > | |
| CIsTupleOfRefs | |
| CIsTupleOfRefs< std::tuple< T &... > > | |
| COutput | Customisation point for formatters |
| COutput< BoundedRange< T >, std::enable_if_t< kHasFormatter< T > > > | |
| COutput< formats::json::Value > | |
| COutput< PlainJson > | |
| COutput< Range< T >, std::enable_if_t< kHasFormatter< T > > > | |
| COutput< std::chrono::duration< Rep, Period > > | Binary formatter for std::chrono::duration |
| COutput< T, EnableIfCanUseEnumAsStrongTypedef< T > > | |
| CParserBufferCategory | Buffer category for parser |
| CParserBufferCategory< BufferParser< boost::optional< T > > > | |
| CParserBufferCategory< BufferParser< std::optional< T > > > | |
| CParserBufferCategory< BufferParser<::utils::StrongTypedef< Tag, T, Ops, Enable > > > | |
| CRemoveTupleReferences | |
| CRemoveTupleReferences< std::tuple< T... > > | |
| CRowCategory | |
| CRowCategory<::utils::StrongTypedef< Tag, T, Ops, Enable > > | |
| CTupleHasFormatters | |
| CTupleHasFormatters< std::tuple< T... > > | |
| CTupleHasParsers | |
| CTupleHasParsers< std::tuple< T... > > | |
| CTypeBufferCategory | |
| CArrayType | |
| CArrayType< PredefinedOids::kBit > | |
| CArrayType< PredefinedOids::kBoolean > | |
| CArrayType< PredefinedOids::kBox > | |
| CArrayType< PredefinedOids::kBpchar > | |
| CArrayType< PredefinedOids::kBytea > | |
| CArrayType< PredefinedOids::kChar > | |
| CArrayType< PredefinedOids::kCid > | |
| CArrayType< PredefinedOids::kCidr > | |
| CArrayType< PredefinedOids::kCircle > | |
| CArrayType< PredefinedOids::kDate > | |
| CArrayType< PredefinedOids::kDateRange > | |
| CArrayType< PredefinedOids::kFloat4 > | |
| CArrayType< PredefinedOids::kFloat8 > | |
| CArrayType< PredefinedOids::kInet > | |
| CArrayType< PredefinedOids::kInt2 > | |
| CArrayType< PredefinedOids::kInt4 > | |
| CArrayType< PredefinedOids::kInt4Range > | |
| CArrayType< PredefinedOids::kInt8 > | |
| CArrayType< PredefinedOids::kInt8Range > | |
| CArrayType< PredefinedOids::kInterval > | |
| CArrayType< PredefinedOids::kJson > | |
| CArrayType< PredefinedOids::kJsonb > | |
| CArrayType< PredefinedOids::kLine > | |
| CArrayType< PredefinedOids::kLseg > | |
| CArrayType< PredefinedOids::kLsn > | |
| CArrayType< PredefinedOids::kMacaddr > | |
| CArrayType< PredefinedOids::kMacaddr8 > | |
| CArrayType< PredefinedOids::kName > | |
| CArrayType< PredefinedOids::kNumeric > | |
| CArrayType< PredefinedOids::kNumRange > | |
| CArrayType< PredefinedOids::kOid > | |
| CArrayType< PredefinedOids::kPath > | |
| CArrayType< PredefinedOids::kPoint > | |
| CArrayType< PredefinedOids::kPolygon > | |
| CArrayType< PredefinedOids::kRecord > | |
| CArrayType< PredefinedOids::kText > | |
| CArrayType< PredefinedOids::kTid > | |
| CArrayType< PredefinedOids::kTime > | |
| CArrayType< PredefinedOids::kTimestamp > | |
| CArrayType< PredefinedOids::kTimestampRange > | |
| CArrayType< PredefinedOids::kTimestamptz > | |
| CArrayType< PredefinedOids::kTimestamptzRange > | |
| CArrayType< PredefinedOids::kUuid > | |
| CArrayType< PredefinedOids::kVarbit > | |
| CArrayType< PredefinedOids::kVarchar > | |
| CArrayType< PredefinedOids::kXid > | |
| CBufferCategoryHash | |
| CBufferFormatter | Primary template for Postgre buffer formatter Specialisations should provide call operators that write to a buffer |
| CBufferFormatter< AddressV4 > | Binary formatter for utils::ip::AddressV4 |
| CBufferFormatter< AddressV6 > | Binary formatter for utils::ip::AddressV6 |
| CBufferFormatter< Bigint > | |
| CBufferFormatter< bool > | |
| CBufferFormatter< boost::optional< T >, std::enable_if_t< traits::kHasFormatter< T > > > | Formatter specialization for boost::optional |
| CBufferFormatter< boost::uuids::uuid > | |
| CBufferFormatter< char > | |
| CBufferFormatter< char[N]> | |
| CBufferFormatter< Date > | Binary formatter for utils::datetime::Date |
| CBufferFormatter< decimal64::Decimal< Prec, RoundPolicy > > | |
| CBufferFormatter< double > | |
| CBufferFormatter< float > | |
| CBufferFormatter< InetNetwork > | Binary formatter for utils::ip::InetNetwork |
| CBufferFormatter< Integer > | |
| CBufferFormatter< Macaddr > | Binary formatter for utils::macaddr:Macaddr |
| CBufferFormatter< Macaddr8 > | Binary formatter for utils::macaddr:Macaddr8 |
| CBufferFormatter< MultiPrecision< Precision > > | |
| CBufferFormatter< NetworkV4 > | Binary formatter for utils::ip::NetworkV4 |
| CBufferFormatter< NetworkV6 > | Binary formatter for utils::ip::NetworkV6 |
| CBufferFormatter< Null< T > > | |
| CBufferFormatter< postgres::BitStringWrapper< BitContainer, kBitStringType > > | |
| CBufferFormatter< postgres::ByteaWrapper< ByteContainer >, traits::EnableIfByteaCompatible< std::decay_t< ByteContainer > > > | |
| CBufferFormatter< Smallint > | |
| CBufferFormatter< std::bitset< N > > | |
| CBufferFormatter< std::optional< T >, std::enable_if_t< traits::kHasFormatter< T > > > | Formatter specialization for std::optional |
| CBufferFormatter< std::string > | |
| CBufferFormatter< std::string_view > | |
| CBufferFormatter< TimePointTz > | Binary formatter for TimePointTz |
| CBufferFormatter< TimePointWithoutTz > | Binary formatter for TimePointWithoutTz |
| CBufferFormatter<::utils::datetime::TimeOfDay< Duration > > | Binary formatter for utils::datetime::TimeOfDay mapped to postgres time This datatype is time-zone agnostic, it should't be mixed with timetz type or sudden TZ adjustments will be applied |
| CBufferFormatter<::utils::OptionalRef< T >, std::enable_if_t< traits::kHasFormatter< T > > > | Formatter specialization for utils::OptionalRef |
| CBufferFormatter<::utils::StrongTypedef< Tag, T, Ops, Enable > > | |
| CBufferParser | Primary template for Postgre buffer parser. Specialisations should provide call operators that parse FieldBuffer |
| CBufferParser< AddressV4 > | Binary parser for utils::ip::AddressV4 |
| CBufferParser< AddressV6 > | Binary parser for utils::ip::AddressV6 |
| CBufferParser< Bigint > | |
| CBufferParser< bool > | |
| CBufferParser< boost::optional< T >, std::enable_if_t< traits::kHasParser< T > > > | Parser specialization for boost::optional |
| CBufferParser< boost::uuids::uuid > | |
| CBufferParser< char > | |
| CBufferParser< Date > | Binary parser for utils::datetime::Date |
| CBufferParser< decimal64::Decimal< Prec, RoundPolicy > > | |
| CBufferParser< double > | |
| CBufferParser< float > | |
| CBufferParser< InetNetwork > | Binary parser for utils::ip::InetNetwork |
| CBufferParser< Integer > | |
| CBufferParser< Macaddr > | Binary parser for utils::macaddr::Macaddr |
| CBufferParser< Macaddr8 > | Binary parser for utils::macaddr::Macaddr8 |
| CBufferParser< MultiPrecision< Precision > > | |
| CBufferParser< NetworkV4 > | Binary parser for utils::ip::NetworkV4 |
| CBufferParser< NetworkV6 > | Binary parser for utils::ip::NetworkV6 |
| CBufferParser< postgres::BitStringWrapper< BitContainer, kBitStringType > > | |
| CBufferParser< postgres::ByteaWrapper< ByteContainer >, traits::EnableIfByteaCompatible< std::decay_t< ByteContainer > > > | |
| CBufferParser< Smallint > | |
| CBufferParser< std::bitset< N > > | |
| CBufferParser< std::optional< T >, std::enable_if_t< traits::kHasParser< T > > > | Parser specialization for std::optional |
| CBufferParser< std::string > | |
| CBufferParser< std::string_view > | |
| CBufferParser< TimePoint > | Binary parser for TimePoint. Implicitly converts TimePoint to TimePointWithoutTz |
| CBufferParser< TimePointTz > | Binary parser for TimePointTz |
| CBufferParser< TimePointWithoutTz > | Binary parser for TimePointWithoutTz |
| CBufferParser<::utils::datetime::TimeOfDay< Duration > > | Binary parser for utils::datetime::TimeOfDay mapped to postgres time |
| CBufferParser<::utils::StrongTypedef< Tag, T, Ops, Enable > > | |
| CCodegen | |
| CCppToPg | Detect mapping of a C++ type to Postgres type |
| CCppToPg< ::utils::StrongTypedef< Tag, T, Ops, Enable >, std::enable_if_t<!traits::kIsStrongTypedefDirectlyMapped< Tag, T, Ops, Enable > &&traits::kIsMappedToPg< T > > > | |
| CCppToPg< boost::optional< T >, std::enable_if_t< traits::kIsMappedToPg< T > > > | Pg mapping specialization for boost::optional |
| CCppToPg< Null< T > > | |
| CCppToPg< std::optional< T >, std::enable_if_t< traits::kIsMappedToPg< T > > > | Pg mapping specialization for std::optional |
| CCppToPg< T, std::enable_if_t<!traits::kIsSpecialMapping< T > &&traits::kIsMappedToPg< T > &&!traits::kIsMappedToArray< T > > > | |
| CCppToPg< T, traits::EnableIfCanUseEnumAsStrongTypedef< T > > | |
| CCppToPg<::utils::OptionalRef< T >, std::enable_if_t< traits::kIsMappedToPg< T > > > | Pg mapping specialization for USERVER_NAMESPACE::utils::OptionalRef |
| CCppToSystemPg | Primary template for declaring mapping to a PostgreSQL system type |
| CCppToSystemPg< AddressV4 > | |
| CCppToSystemPg< AddressV6 > | |
| CCppToSystemPg< Bigint > | |
| CCppToSystemPg< BigintRange > | |
| CCppToSystemPg< bool > | |
| CCppToSystemPg< boost::uuids::uuid > | |
| CCppToSystemPg< BoundedBigintRange > | |
| CCppToSystemPg< BoundedIntegerRange > | |
| CCppToSystemPg< char > | |
| CCppToSystemPg< char[N]> | |
| CCppToSystemPg< const char * > | |
| CCppToSystemPg< Date > | |
| CCppToSystemPg< decimal64::Decimal< Prec, RoundPolicy > > | |
| CCppToSystemPg< double > | |
| CCppToSystemPg< float > | |
| CCppToSystemPg< formats::json::Value > | |
| CCppToSystemPg< InetNetwork > | |
| CCppToSystemPg< Integer > | |
| CCppToSystemPg< IntegerRange > | |
| CCppToSystemPg< Macaddr > | |
| CCppToSystemPg< Macaddr8 > | |
| CCppToSystemPg< MultiPrecision< Precision > > | |
| CCppToSystemPg< NetworkV4 > | |
| CCppToSystemPg< NetworkV6 > | |
| CCppToSystemPg< PlainJson > | |
| CCppToSystemPg< postgres::BitStringWrapper< BitContainer, postgres::BitStringType::kBit > > | |
| CCppToSystemPg< postgres::BitStringWrapper< BitContainer, postgres::BitStringType::kBitVarying > > | |
| CCppToSystemPg< postgres::ByteaWrapper< ByteContainer > > | |
| CCppToSystemPg< Smallint > | |
| CCppToSystemPg< std::bitset< N > > | |
| CCppToSystemPg< std::chrono::duration< Rep, Period > > | |
| CCppToSystemPg< std::chrono::time_point< ClockType, Duration > > | |
| CCppToSystemPg< std::string > | |
| CCppToSystemPg< std::string_view > | |
| CCppToSystemPg< TimePointTz > | |
| CCppToSystemPg< TimePointWithoutTz > | |
| CCppToSystemPg<::utils::datetime::TimeOfDay< Duration > > | |
| CCppToUserPg | Primary template for declaring mapping to a PostgreSQL user type |
| CEnumMappingBase | |
| CFieldBuffer | |
| CPgToCpp | |
| CRowType | |
| CTransformFormatter | |
| CTransformParser | |
| CAccessRuleViolation | |
| CAdminShutdown | |
| CAlreadyInTransaction | |
| CArrayError | Base error when working with array types |
| CBitStringError | Base error when working with bit string types |
| CBitStringOverflow | Value in PostgreSQL binary buffer cannot be represented by a given C++ type |
| CBitStringWrapper | |
| CBoundedRange | |
| CBoundedRangeError | PostgreSQL range type has at least one end unbound |
| CByteaWrapper | Wrapper for binary data container |
| CCannotConnectNow | |
| CCardinalityViolation | |
| CCheckViolation | |
| CCluster | Interface for executing queries on a cluster of PostgreSQL servers |
| CClusterError | |
| CClusterHostTypeHash | |
| CClusterSettings | Settings for storages::postgres::Cluster |
| CClusterStatistics | Cluster statistics storage |
| CClusterUnavailable | |
| CCommandControl | |
| CCommandError | Error when invoking a libpq function |
| CCompositeFieldDef | Description of a field in a user-defined composite type, for type checking |
| CCompositeMemberTypeMismatch | PostgreSQL composite type has different member type that the C++ mapping suggests |
| CCompositeSizeMismatch | PostgreSQL composite type has different count of members from the C++ counterpart |
| CCompositeTypeDescription | PostgreSQL composite type description |
| CConfigurationFileError | |
| CConnectionBusy | An attempt to make a query to server was made while there is another query in flight |
| CConnectionError | |
| CConnectionFailed | Exception is thrown when a single connection fails to connect |
| CConnectionInterrupted | A network operation was interrupted by task cancellation |
| CConnectionSettings | |
| CConnectionSettingsDynamic | |
| CConnectionStatistics | Template connection statistics storage |
| CConnectionTimeoutError | A network operation on a connection has timed out |
| CConstFieldIterator | Iterator over fields in a result set's row |
| CConstRowIterator | |
| CCrashShutdown | |
| CDatabase | Object for accessing PostgreSQL database instance (sharded or not) |
| CDatabaseDropped | |
| CDataException | Base class for data exceptions Doc: https://www.postgresql.org/docs/12/static/errcodes-appendix.html |
| ►CDBTypeDescription | Description of a PostgreSQL type. The structure is selected from the pg_catalog.pg_type table (not all, only appropriate fields). See https://www.postgresql.org/docs/12/catalog-pg-type.html |
| CNameHash | |
| CNamesEqual | |
| CTypeCategoryHash | |
| CDBTypeName | Identity for a PostgreSQL type name |
| CDependentPrivilegeDescriptorsStillExist | |
| CDiagnosticsException | |
| CDimensionMismatch | Array received from postgres has different dimensions from those of C++ container |
| CDistLockComponentBase | Base class for postgres-based distlock worker components |
| CDistLockStrategy | Postgres distributed locking strategy |
| CDsnOptions | |
| CDuplicatePreparedStatement | |
| CEnumerationError | |
| CError | Base class for all exceptions that may be thrown by the driver |
| CExclusionViolation | |
| CExternalRoutineException | |
| CExternalRoutineInvocationException | |
| CFdwError | |
| CFeatureNotSupported | |
| CField | Accessor to a single field in a result set's row |
| CFieldDescription | |
| CFieldIndexOutOfBounds | Result set has less columns that the requested index |
| CFieldNameDoesntExist | Result set doesn't have field with the requested name |
| CFieldTag | Tag type to disambiguate reading the first value of a row to a user's composite type (PostgreSQL composite type in the row initializes user's type) |
| CFieldTupleMismatch | A row was requested to be parsed based on field names/indexed, the count of names/indexes doesn't match the tuple size |
| CFieldValueIsNull | Data extraction from a null field value to a non-nullable type requested |
| CFieldView | |
| CForeignKeyViolation | |
| CInstanceStatisticsNonatomic | |
| CInstanceStatisticsTemplate | Template instance statistics storage |
| CInstanceStatsDescriptor | Instance statistics with description |
| CInstanceTopologyStatistics | Template instance topology statistics storage |
| CInsufficientResources | |
| CIntegrityConstraintViolation | Base class for integrity constraint violation errors. Doc: https://www.postgresql.org/docs/12/static/errcodes-appendix.html |
| CInternalServerError | |
| CInvalidAuthorizationSpecification | |
| CInvalidBinaryBuffer | Binary buffer contains invalid data. Can occur when parsing binary buffers containing multiple fields |
| CInvalidBitStringRepresentation | Value in PostgreSQL binary buffer cannot be represented as bit string type |
| CInvalidConfig | |
| CInvalidCursorState | |
| CInvalidDimensions | |
| CInvalidDSN | |
| CInvalidEnumerationLiteral | |
| CInvalidEnumerationValue | |
| CInvalidGrantor | |
| CInvalidInputBufferSize | Buffer size is invalid for a fixed-size type. Can occur when a wrong field type is requested for reply |
| CInvalidInputFormat | Invalid format for input data |
| CInvalidObjectName | Exception class for several Invalid * Name classes. Class 34 - Invalid Cursor Name Class 3D - Invalid Catalogue Name Class 3F - Invalid Schema Name TODO Add documentation (links) on the error classes TODO Split exception classes if needed based on documentation |
| CInvalidParserCategory | Field buffer contains different category of data than expected by data parser |
| CInvalidRepresentation | Integral representation for a numeric contains invalid data |
| CInvalidRoleSpecification | |
| CInvalidSqlStatementName | This exception is thrown in case a prepared statement doesn't exist |
| CInvalidTransactionState | |
| CInvalidTransactionTermination | |
| CInvalidTupleSizeRequested | A tuple was requested to be parsed out of a row that doesn't have enough fields |
| CIpAddressError | |
| CIpAddressInvalidFormat | |
| CLocatorException | |
| CLogicError | Base Postgres logic error. Reports errors that are consequences of erroneous driver usage, such as invalid query syntax, absence of appropriate parsers, out of range errors etc. These can be avoided by fixing code |
| CMessage | |
| CNarrowingOverflow | A binary buffer contains a numeric value that does not fit into a given C++ value type |
| CNoBinaryParser | A field in a result set doesn't have a binary parser |
| CNonSingleColumnResultSet | A row or result set requested to be treated as a single column, but contains more than one column |
| CNonSingleRowResultSet | A result set containing a single row was expected |
| CNotification | |
| CNotifyScope | RAII scope for receiving notifications |
| CNotImplemented | |
| CNotInTransaction | |
| CNotNullViolation | |
| CNull | Type to represent a null value |
| CNumericError | |
| CNumericOverflow | Value in PostgreSQL binary buffer cannot be represented by a given C++ type |
| CObjectNotInPrerequisiteState | |
| COperatorIntervention | |
| CParameterStore | Class for dynamic PostgreSQL parameter list construction |
| CPlPgSqlError | |
| CPoolError | Indicates errors during pool operation |
| CPoolSettings | PostgreSQL connection pool options |
| CPoolSettingsDynamic | |
| CPortal | |
| CProgramLimitExceeded | |
| CQueryCancelled | |
| CQueryQueue | A container to enqueue queries in FIFO order and execute them all within a single network round-trip |
| CRange | |
| CRestrictViolation | |
| CResultSet | PostgreSQL result set |
| CResultSetError | |
| CReverseConstFieldIterator | Reverse iterator over fields in a result set's row |
| CReverseConstRowIterator | |
| CRow | |
| CRowDescription | A wrapper for PGresult to access field descriptions |
| CRowIndexOutOfBounds | Result set has less rows than the requested row index |
| CRowTag | Tag type to disambiguate reading the row to a user's row type (values of the row initialize user's type data members) |
| CRuntimeError | Base Postgres runtime error. Reports errors that are consequences of erroneous data, misconfiguration, network errors etc |
| CSavepointException | |
| CServerConnectionError | Connection error reported by PostgreSQL server. Doc: https://www.postgresql.org/docs/12/static/errcodes-appendix.html Class 08 - Connection exception |
| CServerError | Error that was reported by PosgtreSQL server Contains the message sent by the server. Templated class because the errors can be both runtime and logic |
| CSnapshotFailure | |
| CSqlRoutineException | |
| CSqlStatementNotYetComplete | |
| CStatementMetricsSettings | PostgreSQL statements metrics options |
| CStatementStatistics | |
| CSyntaxError | |
| CSystemError | |
| CTimePointTz | Corresponds to TIMESTAMP WITH TIME ZONE database type |
| CTimePointWithoutTz | Corresponds to TIMESTAMP WITHOUT TIME ZONE database type |
| CTopologySettings | PostgreSQL topology options |
| CTransaction | PostgreSQL transaction |
| CTransactionError | |
| CTransactionForceRollback | |
| CTransactionOptions | PostgreSQL transaction options |
| CTransactionRollback | |
| CTransactionStatistics | Template transaction statistics storage |
| CTriggeredActionException | |
| CTriggeredDataChangeViolation | Class 27 - Triggered Data Change Violation |
| CTypeCannotBeNull | A value of a non-nullable type requested to be set null. Can occur if io::traits::IsNullable for the type is specialised as true_type, but io::traits::GetSetNull is not specialized appropriately |
| CTypedResultSet | |
| CUnboundedType | |
| CUniqueViolation | |
| CUnknownBufferCategory | While checking result set types, failed to determine the buffer category for a type oid. The context string is formed by the ResultSet and will have the form of 'result set field foo type my_schema.bar field baz array element' |
| CUnsupportedInterval | |
| CUserTypeError | Base error when working with mapped types |
| CUserTypes | Container for connection-specific user data types |
| CValueIsNaN | |
| CWithCheckOptionViolation | Class 44 - WITH CHECK OPTION Violation |
| ►Nredis | Valkey and Redis client and helpers |
| ►Nutest | |
| CRedisLocal | Valkey or Redis local class |
| CRedisTest | Valkey or Redis fixture |
| CClient | Valkey or Redis client |
| CClientNotConnectedException | Cannot connect to some redis server shard |
| CCommandControl | Redis command execution options |
| CCommandsBufferingSettings | |
| CConfig | Main config for the Valkey/Redis |
| CConnectionInfo | |
| CCount | A hint for Scan, Hscan, Scan and Zscan commands |
| CDynamicRedis | Manages dynamically created Redis clients |
| ►CDynamicSettings | Dynamic configuration settings for Redis clients |
| CHostPort | |
| CEmptyTransactionException | |
| CEvalShaResult | Value, returned by storages::redis::RequestEvalSha |
| CException | Generic redis-related exception |
| CExpireOptions | |
| CExpireReply | |
| CGeoaddArg | |
| CGeoPoint | |
| CGeoradiusOptions | |
| CGeosearchOptions | |
| CInvalidArgumentException | Invalid redis command argument |
| CKeyHasNoExpirationException | Trying to get expiration from a nonexistent or a persistent key |
| CMatch | A command option to use in Scan, Hscan, Scan and Zscan commands |
| CMemberScore | Data type that holds member and score |
| ►CMetricsSettings | |
| CDynamicSettings | |
| CNotStartedTransactionException | |
| CParseConfigException | Invalid config format |
| CParseReplyException | Invalid reply data format |
| CPoint | |
| CPublishSettings | |
| CPubsubMetricsSettings | |
| CRangeOptions | |
| CRangeScoreOptions | |
| CRedisWaitConnected | Connection wait options for the Redis; mostly used by storages::redis::Client::WaitConnectedOnce |
| CReplicationMonitoringSettings | |
| CReply | |
| ►CReplyData | |
| ►CMovableKeyValues | |
| CIterator | |
| CView | |
| CRequest | Valkey or Redis future for a non-scan and non-eval responses |
| CRequestCancelledException | Request was cancelled |
| CRequestDataBase | |
| CRequestEval | Redis future for EVAL responses |
| CRequestEvalSha | Redis future for EVALSHA responses |
| CRequestFailedException | Request execution failed |
| CRequestGeneric | Redis future for generic command responses. Can be used to request custom modules commands or unsupported yet commands |
| CRequestScanData | |
| CRequestScanDataBase | |
| CRetryNilFromMaster | |
| CScanOptionsGeneric | A command option to use in Scan, Hscan, Scan and Zscan commands that combines Match and Count options |
| CScanReplyElem | |
| CScanReplyElem< ScanTag::kHscan > | |
| CScanReplyElem< ScanTag::kScan > | |
| CScanReplyElem< ScanTag::kSscan > | |
| CScanReplyElem< ScanTag::kZscan > | |
| ►CScanRequest | Redis future for a SCAN-like responses |
| CGetAfterEofException | |
| ►CIterator | |
| CReplyElemHolder | |
| CScoreOptions | |
| CServerId | Opaque Id of Redis server instance / any server instance |
| CServerIdHasher | |
| CSetOptions | |
| CStat | |
| CSubscribeClient | Client that allows subscribing to Redis channel messages |
| CSubscriptionToken | RAII subscription guard, that is usually retrieved from storages::redis::SubscribeClient |
| CTo | |
| CTransaction | Atomic sequence of Redis commands (https://redis.io/topics/transactions), that is usually retrieved from storages::redis::Client::Multi() |
| CTtlReply | |
| CZaddOptions | |
| ►Nsecdist | Credentials storage |
| ►CDefaultLoader | |
| CSettings | |
| CInvalidSecdistJson | |
| CSecdist | Client to retrieve credentials from the components::Secdist and to subscribe to their updates |
| ►CSecdistConfig | Client to retrieve credentials from the components::Secdist |
| CSettings | |
| CSecdistError | |
| CSecdistProvider | |
| CUnknownMongoDbAlias | |
| CUnknownPostgresDbAlias | |
| CUnknownRedisClientName | |
| ►Nsqlite | |
| ►Ninfra | |
| ►Nstatistics | |
| CAggregatedInstanceStatistics | |
| CPoolConnectionStatistics | |
| CPoolQueriesStatistics | |
| CPoolStatistics | |
| CPoolTransactionsStatistics | |
| CPoolTransactionsStatisticsAggregated | |
| CQueryStatCounter | |
| CTransactionStatCounter | |
| ►Nstrategy | |
| CExclusiveReadWriteStrategy | |
| CPoolStrategyBase | |
| CReadOnlyStrategy | |
| CReadWriteStrategy | |
| CConnectionPtr | |
| CPool | |
| ►Nsettings | |
| CConnectionSettings | SQLite connection settings |
| CPoolSettings | SQLite connection pool settings |
| CSQLiteSettings | Comprehensive SQLite settings |
| CTransactionOptions | SQLite transaction options |
| CClient | Interface for executing queries on SQLite connection. Usually retrieved from components::SQLite |
| CCursorResultSet | A wrapper for read-only cursor |
| CExecutionResult | Metadata for an execution of a statement that doesn't expect a result set (INSERT, UPDATE, DELETE) |
| CFieldTag | Used for extracting statement results as a single field |
| CIsTuple | |
| CIsTuple< std::tuple< Args... > > | |
| ►CQuery | Holds a query, its name and logging mode; used by all the SQL databases of userver |
| CNameLiteral | Compile time literal with query name |
| CResultSet | A proxy for statement execution result |
| CRowTag | Used for extracting statement results as rows |
| CSavepoint | RAII savepoint wrapper, auto-ROLLBACKs on destruction if no prior Release/Rollback call was made |
| CSQLiteException | Base class for all uSQLite driver exceptions |
| CTransaction | RAII transaction wrapper, auto-ROLLBACKs on destruction if no prior Commit/Rollback call was made |
| ►CQuery | Holds a query, its name and logging mode; used by all the SQL databases of userver |
| CNameLiteral | Compile time literal with query name |
| ►Nstructs | |
| CConversionFailure | |
| CEmpty | |
| CErroneous | |
| CIndirect | |
| CMap | |
| COneof | |
| COptional | |
| CRepeated | |
| CScalar | |
| CSimple | |
| ►CStrong | |
| CTag | |
| CWellKnownJson | |
| CWellKnownStd | |
| CWellKnownUsrv | |
| ►Ntestsuite | Testsuite integration |
| CCacheControl | Testsuite interface for caches and cache-like components |
| CCacheResetRegistration | RAII helper for testsuite registration. Must be kept alive to keep supporting cache resetting |
| CDumpControl | Dumper control interface for testsuite |
| CDumperRegistrationHolder | RAII helper for testsuite registration |
| CExceptionsHandlingMiddleware | |
| CGrpcControl | |
| CHttpAllowedUrlsExtra | |
| CPeriodicTaskControl | Periodic task control interface for testsuite |
| CPeriodicTaskRegistrationHolder | RAII helper for testsuite registration |
| CPostgresControl | |
| CRedisControl | |
| CTaskAlreadyRunning | |
| CTaskNotFound | |
| CTestpointClientBase | Base testpoint client. Used to report TESTPOINT executions to testsuite |
| CTestpointControl | Testpoint control interface for testsuite |
| CTestsuiteTasks | Testsuite tasks support |
| ►Ntracing | Tracing support via tracing::Span |
| ►Nopentelemetry | |
| CTraceParentDataView | |
| CAnyValue | |
| CDefaultTracingManagerLocator | Component that provides access to the actual TracingManager that is used in handlers and clients |
| CGenericTracingManager | Generic tracing manager that knows about popular tracing headers and allows customising input and output headers |
| ►CInPlaceSpan | Avoids an extra allocation by storing tracing::Span data in-place |
| CDetachedTag | |
| CScopeTime | Type to measure execution time of a scope |
| CSpan | Measures the execution time of the current code block, links it with the parent tracing::Spans and stores that info in the log |
| CSpanBuilder | Provides interface for editing Span, before final building |
| CSpanEvent | Span event – time-stamped annotation of the span with user-provided text description |
| CTagScope | RAII object that calls Span::AddTag / Span::AddTagFrozen function in constructor and reverts these actions in destructor |
| CTracingManagerBase | Base class for propagating trace context information in headers |
| CTracingManagerComponentBase | Base component for implementing TracingManager component |
| ►Nugrpc | Asynchronous gRPC driver |
| ►Nclient | Client-side utilities |
| ►Nmiddlewares | |
| ►Nbaggage | |
| CMiddleware | Middleware for gRPC client baggage |
| ►Ndeadline_propagation | |
| CMiddleware | Middleware for RPC handler logging settings |
| ►Nheaders_propagator | |
| CComponent | GRPC client middleware for sending headers stored by the respective HTTP and gRPC server middlewares |
| ►Nlog | |
| CComponent | Component for gRPC client logging |
| ►Norigin | |
| CComponent | GRPC client middleware that sets x-origin metadata. gRPC server will then copy that to useragent tag in server request log |
| ►Ntestsuite | |
| CComponent | Component for gRPC client testsuite support |
| CMiddleware | Middleware for gRPC client testsuite |
| CAbortedError | |
| CAlreadyExistsError | |
| CBaseError | Base exception for all the client errors |
| CCallContext | GRPC call context |
| CCallOptions | Options passed to interface calls |
| CCancelledError | Concrete errors for all the error codes |
| CClientFactory | Creates gRPC clients |
| CClientFactoryComponent | Provides a ClientFactory in the component system |
| CClientFactorySettings | Settings relating to the ClientFactory |
| CClientInfo | Client meta info for a middleware construction |
| CClientQos | |
| CClientSettings | Settings relating to creation of a code-generated client |
| CCommonComponent | Contains common machinery that's required for all ugrpc clients |
| CDataLossError | |
| CDeadlineExceededError | |
| CErrorWithStatus | Error with grpc::Status details |
| CFailedPreconditionError | |
| CGenericClient | Allows to talk to gRPC services (generic and normal) using dynamic method names |
| CGenericOptions | |
| CGlobalQos | |
| CInternalError | |
| CInvalidArgumentError | |
| CMiddlewareBase | Base class for client gRPC middleware |
| CMiddlewareCallContext | Context for middleware-specific data during gRPC call |
| CMiddlewarePipelineComponent | Component to create middlewares pipeline |
| CNotFoundError | |
| COutOfRangeError | |
| CPermissionDeniedError | |
| CProxySettings | |
| CQos | Per-RPC quality-of-service config. Taken from ugrpc::client::ClientQos. Can also be passed to ugrpc client methods manually |
| CReader | Client-side interface for server-streaming |
| CReaderWriter | Client-side interface for bi-directional streaming |
| CResourceExhaustedError | |
| CResponseFuture | Controls a single request -> single response RPC |
| CRetryConfig | Retry configuration for outgoing RPCs |
| CRetryLimiter | Interface for controlling retry behavior based on request outcomes |
| CRetryLimiterFactory | Abstract factory for creating RetryLimiter instances |
| CRetryLimiterSettings | Settings for a RetryLimiter instance |
| CRpcCancelledError | RPC failed due to task cancellation |
| CRpcError | Error during an RPC |
| CRpcInterruptedError | RPC failed without a status. This means that either the call got cancelled using TryCancel or the channel is broken. Note: Deadline expiration throws ugrpc::client::DeadlineExceededError |
| CSimpleClientComponent | Template class for a simple gRPC client |
| CStreamReadFuture | StreamReadFuture for waiting a single read response from stream |
| CUnauthenticatedError | |
| CUnavailableError | |
| CUnimplementedError | |
| CUnknownError | |
| CWriter | Client-side interface for client-streaming |
| ►Nserver | Server-side utilities |
| ►Nmiddlewares | |
| ►Naccess_log | |
| CComponent | GRPC server access log middleware component. Writes one TSKV log line per handled RPC in a static format. This log is intended to be collected, parsed and stored for audit or extended statistics purposes |
| ►Nbaggage | |
| CMiddleware | |
| ►Ncongestion_control | |
| CComponent | Component for gRPC server logging |
| ►Ndeadline_propagation | |
| CMiddleware | |
| ►Ngraceful_shutdown_headers | |
| CComponent | Component for gRPC server graceful_shutdown_headers |
| ►Nheaders_propagator | |
| CComponent | Component for gRPC server headers_propagator |
| ►Nlog | |
| CComponent | Component for gRPC server logging |
| CBaseError | Base exception for all the server errors |
| CCallContext | GRPC call context |
| CCallContextBase | |
| CErrorWithStatus | Users can throw ErrorWithStatus in their RPC's implementation to return provided status code as a result |
| CGenericCallContext | Generic gRPC call context |
| CGenericServiceBase | Allows to handle RPCs with dynamic method names |
| CMiddlewareBase | Base class for server gRPC middleware |
| CMiddlewareCallContext | Context for middleware-specific data during gRPC call |
| CMiddlewarePipelineComponent | Component to create middlewares pipeline |
| CReader | Interface to read client's requests |
| CReaderWriter | Interface to both read and write messages |
| CResult | Result type for service handlers (non server-streaming) |
| CRpcError | Error during an RPC |
| CRpcInterruptedError | RPC failed without a status. This means that either the call got cancelled using TryCancel, the deadline has expired, or the client disconnected |
| CServer | Manages the gRPC server |
| CServerComponent | Component that configures and manages the gRPC server |
| CServerConfig | Settings relating to the whole gRPC server |
| CServiceBase | The type-erased base class for all gRPC service implementations |
| CServiceComponentBase | Base class for all the gRPC service components |
| CServiceConfig | Per-service settings |
| CServiceInfo | Service meta info for a middleware construction |
| CStorageContext | AnyStorage tag for gRPC call context |
| CStreamingResult | Special result type for server-streaming service handlers |
| CTlsConfig | |
| CWriter | Interface to write server's responses |
| ►Ntests | Userver gRPC testing facilities |
| CService | Sets up a mini gRPC server using a single service implementation |
| CServiceBase | Sets up a mini gRPC server using the provided service implementations |
| CServiceFixture | |
| CServiceFixtureBase | |
| CServiceWithClientFixture | Sets up a mini gRPC server and construct a client for it |
| CStandaloneClientFactory | Sets up a mini gRPC client that is not directly associated with any userver gRPC server |
| CBadRequest | Describes violations in a client request. This error type focuses on the syntactic aspects of the request |
| CBaseVisitor | Base class for FieldsVisitor and MessagesVisitor. Provides the interface and contains common code to use the data collected in the VisitorCompiler |
| CDateConversionError | Exception thrown when date conversion functions receive/produce invalid google::type::Date according to IsValid or otherwise lead to undefined behavior due to integer overflow |
| CDebugInfo | Provides debugging information such as stack traces |
| CDurationConversionError | Exception thrown when duration conversion functions receive/produce invalid google::protobuf::Duration according to IsValid or otherwise lead to undefined behavior due to integer overflow |
| CErrorInfo | Provides structured error information about the cause of an error |
| CFieldsVisitor | Collects knowledge of the structure of the protobuf messages allowing for efficient loops over fields to apply a callback to the ones selected by the 'selector' function |
| CFieldViolation | Describes a single field validation error |
| CHelp | Provides links to documentation and help resources |
| CHelpLink | Describes a single help link |
| CLocalizedMessage | Provides a localized error message that is safe to return to the user |
| CMessagesVisitor | Collects knowledge of the structure of the protobuf messages allowing for efficient loops over nested messages to apply a callback to the ones selected by the 'selector' function |
| CPreconditionFailure | Describes preconditions that failed during request processing |
| CPreconditionViolation | Describes a single precondition violation |
| CQuotaFailure | Describes quota violations that caused the request to fail |
| CQuotaViolation | Describes a single quota violation |
| CRequestInfo | Contains metadata about the request for debugging and logging |
| CResourceInfo | Provides information about a resource that is related to the error |
| CRetryInfo | Describes when the client can retry a failed request |
| CRichStatus | A wrapper around google::rpc::Status that provides a convenient API for creating and managing gRPC status responses with rich error details |
| CTimestampConversionError | Exception thrown when timestamp conversion functions receive/produce invalid google::protobuf::Timestamp according to IsValid or otherwise lead to undefined behavior due to integer overflow |
| CVisitorCompiler | Base class for BaseVisitor. Constructs and manages the descriptor graph to collect the data about the messages and enable the visitors to find all selected structures |
| ►Nurabbitmq | |
| CAdminChannel | Administrative interface for the broker. You may use this class to setup your exchanges/queues/bindings. You may as well use Client itself instead |
| CAuthSettings | |
| CChannel | Publisher interface for the broker. You may use this class to publish your messages |
| CClient | Interface for communicating with a RabbitMQ cluster |
| CClientCertSettings | |
| CClientSettings | |
| ►CConsumedMessage | Structure holding an AMQP message body along with some of its metadata fields. This struct is used to pass messages to the end user, hiding the actual AMQP message object implementation |
| CMetadata | |
| CConsumerBase | Base class for your consumers. You should derive from it and override Process method, which gets called when a new message arrives from the broker |
| CConsumerComponentBase | Base component for your consumers. Basically a ConsumerBase but in a nice component-ish way |
| CConsumerSettings | Consumer settings struct |
| CEndpointInfo | |
| CEnvelope | Structure holding an AMQP message body along with some of its metadata fields. This struct is used to pass messages from the end user, hiding the actual AMQP message object implementation |
| CExchange | StrongTypedef alias for an exchange name |
| CIAdminInterface | Administrative interface for the broker. This class is merely an interface for convenience and you are not expected to use it directly (use Client/AdminChannel instead) |
| CIChannelInterface | Publisher interface for the broker. This class is merely an interface for convenience and you are not expected to use it directly (use Client/Channel instead) |
| CIReliableChannelInterface | Reliable publisher interface for the broker. This class is merely an interface for convenience and you are not expected to use it directly (use Client/ReliableChannel instead) |
| CPoolSettings | |
| CQueue | StrongTypedef alias for a queue name |
| CRabbitEndpoints | |
| CRabbitEndpointsMulti | |
| CReliableChannel | Reliable publisher interface for the broker. You may use this class to reliably publish your messages (publisher-confirms) |
| CTlsSettings | |
| ►Nutest | Mocks and test helpers |
| CDefaultLoggerFixture | Fixture that allows to set the default logger and manages its lifetime |
| ►CDnsServerMock | |
| CDnsAnswer | |
| CDnsQuery | |
| CNoAnswer | |
| ►CHttpServerMock | Toy HTTP server for testing; for raw TCP or TLS testing use utest::SimpleServer |
| CHttpRequest | Structure with HTTP request that is passed to the HttpHandler callback |
| CHttpResponse | Structure with HTTP response to return from the HttpHandler callback |
| CLogCaptureFixture | Fixture that allows to capture and extract log written into the default logger |
| CLogCaptureLogger | A mocked logger that stores the log records in memory |
| CLogRecord | Represents single log record, typically written via LOG_* macros |
| CNotSingleLogError | Thrown by GetSingleLog |
| CPrintTestName | Test name printer for parameterized tests written in gtest |
| ►CSimpleServer | Toy server for simple network testing; for testing HTTP prefer using utest::HttpServerMock |
| CResponse | Response to return from the OnRequest callback |
| ►CStressLoop | Helper for stress tests for watching for "OK, we have been running for enough time, let's stop" event |
| ►CIterator | |
| CValue | |
| ►Nutils | Utilities |
| ►Ndatetime | Date and time utilities |
| CDate | Date in format YYYY-MM-DD, std::chrono::year_month_day like type |
| CDateParseError | Date/time parsing error |
| CSteadyClock | |
| CSteadyCoarseClock | Steady clock with up to a few millisecond resolution that is slightly faster than the std::chrono::steady_clock |
| CTimeOfDay | A simple implementation of a "time since midnight" datatype |
| CTimeOfDay< std::chrono::duration< Rep, Period > > | |
| CTimePointTz | Timepoint with timezone parsed in kRfc3339Format |
| CTimePointTzBase | |
| CTimePointTzFraction | Timepoint with timezone parsed in kFractionFormat |
| CTimePointTzIsoBasic | Timepoint with timezone parsed in kDefaultFormat |
| CTimezoneLookupError | Timezone information lookup error |
| CWallCoarseClock | System clock with up to a few millisecond resolution that is slightly faster than the std::chrono::system_clock |
| ►Nencoding | |
| CTskvParser | A streaming parser for the TSKV variant that userver emits |
| ►Nhedging | |
| CHedgedRequestBulkFuture | Future of hedged bulk request |
| CHedgedRequestFuture | Future of hedged request |
| CHedgingSettings | Class define hedging settings |
| CRequestTraits | |
| ►Nip | IP address and utilities |
| CAddressBase | Base class for IPv4/IPv6 addresses |
| CAddressSystemError | Invalid network or address |
| CInetNetwork | INET IPv4/IPv4 network |
| CNetworkBase | Base class for IPv4/IPv6 network |
| ►Nstatistics | |
| CBaseFormatBuilder | |
| CBusyMarker | A RAII-style guard to account code block execution time in utils::statistics::BusyStorage. Aware of recursive invocations in the same thread |
| CBusyStorage | |
| CEntry | Statistics registration holder, used to unregister a metric source before it is destroyed |
| CHistogram | A histogram with a dynamically-allocated array of buckets |
| CHistogramAggregator | Used to aggregate multiple utils::statistics::Histogram metrics |
| CHistogramView | The non-owning reader API for "histogram" metrics |
| CLabel | Label name+value storage |
| CLabelsSpan | View over a continuous range of LabelView |
| CLabelView | Non owning label name+value storage |
| CMetricQueryError | Thrown by statistics::Snapshot queries on unexpected metrics states |
| CMetricsStorage | Storage of metrics registered with MetricTag<Metric> |
| CMetricTag | Metric description and registration in a declarative way |
| CMetricValue | The value of a metric |
| ►CMinMaxAvg | Class for concurrent safe calculation of minimum, maximum and average over series of values |
| CCurrent | |
| CPercentile | Class allows easy calculation of percentiles |
| CRate | Rate metrics (or "counter" metrics) are metrics that only monotonically increase or are reset to zero on restart. Some monitoring systems give them special treatment with regard to maintaining proper non-negative derivative |
| CRateCounter | Atomic counter of type Rate with relaxed memory ordering |
| CRecentPeriod | Class maintains circular buffer of Counters |
| CRelaxedCounter | Atomic counter of type T with relaxed memory ordering |
| CRequest | Class describing the request for metrics data |
| CSnapshot | A snapshot of metrics from utils::statistics::Storage |
| CStatisticsRequest | Used in legacy statistics extenders |
| CStorage | |
| CStripedRateCounter | Atomic counter of type Rate with relaxed memory ordering, increased memory consumption and decreased contention |
| CWarning | |
| CWriter | Class for writing metrics that is provided by utils::statistics::Storage |
| ►Ntrx_tracker | Tracking for heavy operations while having active transactions |
| CCheckDisabler | Disable check for active transactions |
| CTransactionLock | Class for incrementing and decrementing transaction counter |
| CTransactionTrackerStatistics | Statistics for transaction tracker |
| ►CAnyMovable | Replacement for std::any that is not copyable. It allows to store non-copyable and even non-movable types |
| CHolderBase | |
| CAnyStorage | Map-like heterogeneous data storage |
| CAnyStorageDataTag | |
| CAtomicFlags | Wrapper to extend enum with atomic flags interface |
| Cbad_expected_access | |
| CBadAnyMovableCast | The exception that is thrown when AnyCast fails |
| CBox | Remote storage for a single item. Implemented as a unique pointer that is never null, except when moved from |
| CCachedHash | Holds the key and its hash for faster comparisons and hashing |
| CCachedHashKeyEqual | Compares utils::CachedHash only by keys |
| CCachedHashKeyEqual< Equal, std::false_type > | |
| CCheckedPtr | Utility template for returning a pointer to an object that is owned by someone else; throws std::runtime_error if nullptr is stored |
| CCheckedPtr< T & > | |
| CCpuRelax | |
| CCurrentThreadNameGuard | RAII helper to run some code with a temporary current thread name |
| CDefaultDict | Dictionary that for missing keys falls back to a default value stored by key utils::kDefaultDictDefaultName |
| Cexpected | For holding a value or an error |
| Cexpected< void, E > | |
| CFastPimpl | Implements pimpl idiom without dynamic memory allocation |
| CFastScopeGuard | Helper class to perform actions on scope exit |
| CFilterBloom | Space-efficient probabilistic data structure |
| CFixedArray | A fixed-size array with the size determined at runtime |
| CFlags | Wrapper to extend enum with flags interface |
| CFromStringException | Function utils::FromString exception type |
| CHashSeed | The seed structure used by underlying hashing implementation |
| CInvariantError | Exception that is thrown on UINVARIANT violation |
| CLazyPrvalue | Can be used with various emplace functions to allow in-place constructing a non-movable value using a callable |
| CLazySharedPtr | A lazy wrapper around utils::SharedReadablePtr that fetches the data on first access |
| CMacaddrBase | Base class for Macaddr/Macaddr8 |
| Cmatch_results | A drop-in replacement for std::match_results without huge includes and with better performance characteristics. Represents capturing groups of a single match result |
| CNotNull | Restricts a pointer or smart pointer to only hold non-null values |
| COptionalRef | Class that behaves as a nullable reference. Main difference from the pointer - value comparison of pointed values |
| COverloaded | Utility to define std::variant visitors in a simple way |
| ►CPeriodicTask | Task that periodically runs a user callback. Callback is started after the previous callback execution is finished every period + A - B, where: |
| CSettings | Configuration parameters for PeriodicTask |
| CRandomBase | Virtualized standard UniformRandomBitGenerator concept, for use with random number distributions |
| CRe2Replacement | Replacement string with substitution support |
| Cregex | A drop-in replacement for std::regex without huge includes and with better performance characteristics |
| CRegexError | Thrown from constructors of utils::regex with an invalid pattern |
| CResourceScopeStorage | Smart collection of ScopePtr. It is a helper class used in component system or in a component-less unit tests |
| CResultStore | |
| CResultStore< void > | |
| CRetryBudget | |
| CRetryBudgetSettings | |
| CScopeGuard | Helper class to perform actions on scope exit |
| CScopeTimePause | Utility to easily pause ScopeTime, e.g. when yielding |
| CSharedReadablePtr | std::shared_ptr<const T> wrapper that makes sure that the pointer is stored before dereferencing. Protects from dangling references |
| CSlidingInterval | Sliding interval of values that provides functions to compute average, min and max values from the last window_size values of interval |
| CSmallString | An alternative to std::string with a custom SSO (small string optimization) container size. Unlike std::string, SmallString is not null-terminated thus it has no c_str(), data() returns a not null-terminated buffer |
| Cspan | A polyfill for std::span from C++20 |
| CStrCaseHash | Case sensitive ASCII hashing functor |
| CStreamingCpuRelax | |
| CStrIcaseCompareThreeWay | Case insensitive ASCII 3-way comparison functor |
| CStrIcaseEqual | Case insensitive ASCII equality comparison functor |
| CStrIcaseHash | Case insensitive ASCII hashing functor |
| CStrIcaseLess | Case insensitive ASCII less comparison functor |
| CStringLiteral | Non-empty string view to a compile time known null terminated char array that lives for the lifetime of program, as per [lex.string]; a drop-in replacement for static const std::string kVar = "value" and constexpr std::string_view kVar = "value" |
| CStrongTypedef | Strong typedef for a type T |
| CSwappingSmart | |
| CTaskBuilder | Builder class for engine::Task and engine::TaskWithResult |
| ►CTokenBucket | |
| CRefillPolicy | Token bucket refill policy |
| CTracefulException | Exception that remembers the backtrace at the point of its construction |
| CTracefulExceptionBase | Base class implementing backtrace storage and message builder, published only for documentation purposes, please inherit from utils::TracefulException instead |
| ►CTrivialBiMap | Bidirectional unordered map for trivial types, including string literals; could be efficiently used as a unordered non-bidirectional map |
| CIterator | |
| CValueType | |
| CTrivialSet | Unordered set for trivial types, including string literals |
| Cunexpected | |
| Czstring_view | Non-empty string view type that guarantees null-termination and has a c_str() member function |
| ►Nwebsocket | |
| CConfig | |
| CMessage | WebSocket message |
| CStatistics | |
| CWebSocketConnection | Main class for Websocket connection |
| ►Nyaml_config | Utilities to work with static YAML config |
| CIterator | |
| CSchema | JSON Schema-like type definition |
| CSchemaPtr | |
| ►CYamlConfig | Datatype that represents YAML with substituted variables |
| CDefaultConstructed | |
| CIterTraits | |
| ►Nydb | |
| CBaseError | |
| CBoolTrait | |
| CColumnParseError | |
| CCoordinationClient | YDB Coordination Client |
| CCoordinationSession | Coordination Session |
| CCredentialsProviderComponent | Credentials provider component for creating custom credentials provider factory |
| CCursor | |
| CCursorIterator | |
| CCustomMemberName | |
| CDeadlineExceededError | |
| CDistLockComponentBase | Base class for YDB-based distlock worker components |
| CDistLockedWorker | |
| CDistLockSettings | A set of tweak-able settings for ydb::DistLockWorker |
| CDoubleTrait | |
| CEmptyResponseError | |
| CExecuteResponse | |
| CFederatedTopicClient | YDB Federated Topic Client |
| CFederatedTopicReadSession | |
| CIgnoreResultsError | |
| CInsertColumn | |
| CInt32Trait | |
| CInt64Trait | |
| CInvalidTransactionError | |
| CJsonDocumentTag | |
| CJsonDocumentTrait | |
| CJsonTrait | |
| COperationCancelledError | |
| COperationSettings | |
| COptionalPrimitiveTraits | |
| CParseContext | Used for error reporting in ydb::ValueTraits::Parse |
| CParseError | |
| ►CPreparedArgsBuilder | |
| CPreparedArgsWithKey | |
| CPrimitiveTraits | |
| CQuerySettings | |
| CReadTableResults | |
| CResponseTruncatedError | |
| CRow | |
| CScanQueryResults | |
| CStringTrait | |
| CStructMemberNames | Specifies C++ to YDB struct member names mapping. It's enough to only specify the names that are different between C++ and YDB |
| CTableClient | |
| CTimestampTrait | |
| CTopicClient | YDB Topic Client |
| CTopicReadSession | |
| CTransaction | YDB Transaction |
| CTransactionForceRollback | |
| CTypeMismatchError | |
| CUint32Trait | |
| CUint64Trait | |
| CUndefinedDatabaseError | |
| CUtf8Tag | |
| CUtf8Trait | |
| CUuidTrait | |
| CValueTraits | |
| CValueTraits< BoolTrait::Type > | |
| CValueTraits< DoubleTrait::Type > | |
| CValueTraits< formats::json::Value > | |
| CValueTraits< InsertRow > | |
| CValueTraits< Int32Trait::Type > | |
| CValueTraits< Int64Trait::Type > | |
| CValueTraits< JsonDocument > | |
| CValueTraits< std::optional< BoolTrait::Type > > | |
| CValueTraits< std::optional< DoubleTrait::Type > > | |
| CValueTraits< std::optional< Int32Trait::Type > > | |
| CValueTraits< std::optional< Int64Trait::Type > > | |
| CValueTraits< std::optional< JsonDocumentTrait::Type > > | |
| CValueTraits< std::optional< JsonTrait::Type > > | |
| CValueTraits< std::optional< StringTrait::Type > > | |
| CValueTraits< std::optional< T >, std::enable_if_t< meta::kIsRange< T > &&!meta::kIsMap< T > > > | |
| CValueTraits< std::optional< TimestampTrait::Type > > | |
| CValueTraits< std::optional< Uint32Trait::Type > > | |
| CValueTraits< std::optional< Uint64Trait::Type > > | |
| CValueTraits< std::optional< Utf8Trait::Type > > | |
| CValueTraits< std::optional< UuidTrait::Type > > | |
| CValueTraits< StringTrait::Type > | |
| CValueTraits< T, std::enable_if_t< meta::kIsRange< T > &&!meta::kIsMap< T > > > | |
| CValueTraits< TimestampTrait::Type > | |
| CValueTraits< Uint32Trait::Type > | |
| CValueTraits< Uint64Trait::Type > | |
| CValueTraits< Utf8Trait::Type > | |
| CValueTraits< UuidTrait::Type > | |
| CYdbComponent | YDB client component |
| CYdbResponseError | |
