| ▼Group bal | Basic Application Library (bal) |
| ►Package balb | Basic Application Library Basis (balb) |
| balb_controlmanager | Provide a mechanism for mapping control messages to callbacks |
| balb_filecleanerconfiguration | Provide an attribute class for file cleaner configuration |
| balb_filecleanerutil | Provide a utility class for configuration-based file removal |
| balb_leakybucket | Provide a mechanism to monitor the consumption rate of a resource |
| balb_performancemonitor | Provide a mechanism to collect process performance measures |
| balb_pipecontrolchannel | Provide a mechanism for reading control messages from a named pipe |
| balb_pipetaskmanager | Provide a pipe-based mechanism to process task control messages |
| balb_ratelimiter | Provide a mechanism to limit peak and sustained consumption rates |
| balb_reservationguard | Provide a generic proctor for rate controlling objects |
| balb_testmessages | Provide value-semantic attribute classes |
| ►Package balber | Basic Application Library BER (balber) |
| balber_berconstants | Provide namespace for BER-related constants |
| balber_berdecoder | Provide a BER decoder class |
| balber_berdecoderoptions | Provide an attribute class for specifying BER decoding options |
| balber_berencoder | Provide a BER encoder class |
| balber_berencoderoptions | Provide value-semantic attribute classes |
| balber_beruniversaltagnumber | Enumerate the set of BER universal tag numbers |
| balber_berutil | Provide functions to encode and decode simple types in BER format |
| ►Package balcl | Basic Application Library Command Line (balcl) |
| balcl_commandline | Provide command line parsing, validation, and access |
| balcl_constraint | Define constraint function signatures for supported value types |
| balcl_occurrenceinfo | Provide a type describing requirement and default value of option |
| balcl_option | Provide an allocator-aware command-line-option descriptor class |
| balcl_optioninfo | Provide a POD command-line-option descriptor struct |
| balcl_optiontype | Enumerate the types supported for command-line-option values |
| balcl_optionvalue | Provide a variant type for command-line-option values |
| balcl_typeinfo | Provide a class describing an option's type and other attributes |
| ►Package baljsn | Basic Application Library JSoN (baljsn) |
| baljsn_datumdecoderoptions | Provide options for decoding JSON into a Datum object |
| baljsn_datumencoderoptions | Provide an attribute class for specifying Datum<->JSON options |
| baljsn_datumutil | Provide utilities converting between bdld::Datum and JSON data |
| baljsn_decoder | Provide a JSON decoder for bdeat compatible types |
| baljsn_decoderoptions | Provide an attribute class for specifying JSON decoding options |
| baljsn_decoderoptionsutil | Provide a utility for configuring baljsn::DecoderOptions |
| baljsn_encoder | Provide a JSON encoder for bdlat-compatible types |
| baljsn_encoder_testtypes | Provide value-semantic attribute classes |
| baljsn_encoderoptions | Provide an attribute class for specifying JSON encoding options |
| baljsn_encodingstyle | Provide value-semantic attribute classes |
| baljsn_formatter | Provide a formatter for encoding data in the JSON format |
| baljsn_parserutil | Provide a utility for decoding JSON data into simple types |
| baljsn_printutil | Provide a utility for encoding simple types in the JSON format |
| baljsn_simpleformatter | Provide a simple formatter for encoding data in the JSON format |
| baljsn_tokenizer | Provide a tokenizer for extracting JSON data from a streambuf |
| ►Package ball | Basic Application Library Logging (ball) |
| ball_administration | Provide a suite of utility functions for logging administration |
| ball_asyncfileobserver | Provide an asynchronous observer that logs to a file and stdout |
| ball_attribute | Provide a representation of (literal) name/value pairs |
| ball_attributecollectorregistry | Provide a registry for attribute collector functors |
| ball_attributecontainer | Provide a protocol for containers holding logging attributes |
| ball_attributecontainerlist | Provide a list of attribute container addresses |
| ball_attributecontext | Provide a container for storing attributes and caching results |
| ball_broadcastobserver | Provide a broadcast observer that forwards to other observers |
| ball_category | Provide a container for a name and associated thresholds |
| ball_categorymanager | Provide a manager of named categories each having "thresholds" |
| ball_context | Provide a container for the context of a transmitted log record |
| ball_countingallocator | Provide a concrete allocator that keeps count of allocated bytes |
| ball_defaultattributecontainer | Provide a default container for storing attribute name/value pairs |
| ball_fileobserver | Provide a thread-safe observer that logs to a file and to stdout |
| ball_fileobserver2 | Provide a thread-safe observer that emits log records to a file |
| ball_filteringobserver | Provide an observer that filters log records |
| ball_fixedsizerecordbuffer | Provide a thread-safe fixed-size buffer of record handles |
| ball_log | Provide macros and utility functions to facilitate logging |
| ball_logfilecleanerutil | Provide a utility class for removing log files |
| ball_loggercategoryutil | Provide a suite of utility functions for category management |
| ball_loggerfunctorpayloads | Provide a suite of logger manager singleton functor payloads |
| ball_loggermanager | Provide a manager of core logging functionality |
| ball_loggermanagerconfiguration | Provide a constrained-attribute class for the logger manager |
| ball_loggermanagerdefaults | Provide constrained default attributes for the logger manager |
| ball_logthrottle | Provide throttling equivalents of some of the ball_log macros |
| ball_managedattribute | Provide a wrapper for ball::Attribute with managed name storage |
| ball_managedattributeset | Provide a container for managed attributes |
| ball_multiplexobserver | Provide a multiplexing observer that forwards to other observers |
| ball_observer | Define a protocol for receiving and processing log records |
| ball_observeradapter | Provide a helper for implementing the ball::Observer protocol |
| ball_patternutil | Provide a utility class for string pattern matching |
| ball_predicate | Provide a predicate object that consists of a name/value pair |
| ball_predicateset | Provide a container for managed attributes |
| ball_record | Provide a container for the fields and attributes of a log record |
| ball_recordattributes | Provide a container for a fixed set of fields suitable for logging |
| ball_recordbuffer | Provide a protocol for managing log record handles |
| ball_recordjsonformatter | Provide a formatter for log records that renders output in JSON |
| ball_recordstringformatter | Provide a record formatter that uses a printf-style format spec |
| ball_rule | Provide an object having a pattern, thresholds, and attributes |
| ball_ruleset | Provide a set of unique rules |
| ball_scopedattribute | Provide a scoped guard for a single BALL attribute |
| ball_scopedattributes | Provide a class to add and remove attributes automatically |
| ball_severity | Enumerate a set of logging severity levels |
| ball_severityutil | Provide a suite of utility functions on ball::Severity levels |
| ball_streamobserver | Provide an observer that emits log records to a stream |
| ball_testobserver | Provide an instrumented observer for testing |
| ball_thresholdaggregate | Provide an aggregate of the four logging threshold levels |
| ball_transmission | Enumerate the set of states for log record transmission |
| ball_userfields | Provide a container of user supplied field values |
| ball_userfieldtype | Enumerate the set of data types for a user supplied attribute |
| ball_userfieldvalue | Provide a type for the value of a user supplied field |
| ►Package balm | Basic Application Library Metrics (balm) |
| balm_bdlmmetricsadapter | Provide a concrete instance of the bdlm metrics adapter |
| balm_category | Provide a representation of a metric category |
| balm_collector | Provide a container for collecting and aggregating metric values |
| balm_collectorrepository | Provide a repository for collectors |
| balm_configurationutil | Provide a namespace for metrics configuration utilities |
| balm_defaultmetricsmanager | Provide for a default instance of the metrics manager |
| balm_integercollector | Provide a container for collecting integral metric values |
| balm_integermetric | Provide helper classes for recording int metric values |
| balm_metric | Provide helper classes for recording metric values |
| balm_metricdescription | Provide a description for a metric |
| balm_metricformat | Provide a formatting specification for a metric |
| balm_metricid | Provide an identifier for a metric |
| balm_metricrecord | Provide an aggregated record of the value of a metric |
| balm_metricregistry | Provide a registry for metrics |
| balm_metrics | Provide a suite of operations for recording metric values |
| balm_metricsample | Provide a container for a sample of collected metric records |
| balm_metricsmanager | Provide a manager for recording and publishing metric data |
| balm_publicationscheduler | Provide a scheduler for publishing metrics |
| balm_publicationtype | Provide an enumeration of aggregate types used to publish metrics |
| balm_publisher | Provide a protocol to publish recorded metric values |
| balm_stopwatchscopedguard | Provide a scoped guard for recording elapsed time |
| balm_streampublisher | Provide a balm::Publisher implementation that writes to a stream |
| ►Package balscm | Basic Application Library Source Control Management (balscm) |
| balscm_version | Provide source control management (versioning) information |
| balscm_versiontag | Provide versioning information for the bal package group |
| ►Package balst | Basic Application Library Stack Trace utilities (balst) |
| balst_objectfileformat | Provide platform-dependent object file format trait definitions |
| balst_resolver_dwarfreader | Provide mechanism for reading DWARF information from object files |
| balst_resolver_filehelper | Provide platform-independent file input for stack trace resolvers |
| balst_resolverimpl_dladdr | Provide functions for resolving a stack trace using dladdr |
| balst_resolverimpl_elf | Provide a utility to resolve ELF symbols in a stack trace |
| balst_resolverimpl_windows | Provide resolution of symbols in stack trace for Windows objects |
| balst_resolverimpl_xcoff | Provide a mechanism to resolve xcoff symbols in a stack trace |
| balst_stacktrace | Provide a description of a function-call stack |
| balst_stacktraceconfigurationutil | Provide utility for global configuration of stack trace |
| balst_stacktraceframe | Provide an attribute class describing an execution stack frame |
| balst_stacktraceprinter | Provide an object for streaming the current stack trace |
| balst_stacktraceprintutil | Provide a single function to perform and print a stack trace |
| balst_stacktracetestallocator | Provide a test allocator that reports the call stack for leaks |
| balst_stacktraceutil | Provide low-level utilities for obtaining & printing a stack-trace |
| ►Package baltzo | Basic Application Library TimeZone (Olson) (baltzo) |
| baltzo_datafileloader | Provide a concrete baltzo::Loader for Zoneinfo binary files |
| baltzo_defaultzoneinfocache | Provide facilities to manage a default Zoneinfo cache object |
| baltzo_dstpolicy | Enumerate the set of daylight-saving time (DST) policy values |
| baltzo_errorcode | Enumerate the set of named errors for the baltzo package |
| baltzo_loader | Provide a protocol for obtaining information about a time zone |
| baltzo_localdatetime | Provide an attribute class for time-zone-aware datetime values |
| baltzo_localtimedescriptor | Provide an attribute class for characterizing local time values |
| baltzo_localtimeoffsetutil | Provide utilities for a bdlt_localtimeoffset local time callback |
| baltzo_localtimeperiod | Provide a type describing local time over a time period |
| baltzo_localtimevalidity | Enumerate the set of local time validity codes |
| baltzo_testloader | Provide a test implementation of the baltzo::Loader protocol |
| baltzo_timezoneutil | Provide utilities for converting times among different time zones |
| baltzo_timezoneutilimp | Implement utilities for converting times between time zones |
| baltzo_windowstimezoneutil | Provide utilities to map Zoneinfo identifiers to other systems |
| baltzo_zoneinfo | Provide a value type to represent a time zone |
| baltzo_zoneinfobinaryheader | Provide an attribute class for Zoneinfo binary-file header data |
| baltzo_zoneinfobinaryreader | Provide utilities for reading the Zoneinfo binary data format |
| baltzo_zoneinfocache | Provide a cache for time-zone information |
| baltzo_zoneinfoutil | Provide utility operations on baltzo::Zoneinfo objects |
| ►Package balxml | Basic Application Library XML (balxml) |
| balxml_base64parser | Provide push parser for Base64 types |
| balxml_configschema | Provide the service configuration schema |
| balxml_decoder | Provide a generic translation from XML into C++ objects |
| balxml_decoderoptions | Provide value-semantic attribute classes |
| balxml_elementattribute | Provide the properties of an attribute in an XML element tag |
| balxml_encoder | Provide an XML encoder utility |
| balxml_encoderoptions | Provide value-semantic attribute classes |
| balxml_encodingstyle | Provide value-semantic attribute classes |
| balxml_errorinfo | Provide common error information for XML components |
| balxml_formatter | Provide a simple interface for writing formatted XML |
| balxml_formatter_compactimpl | Provide a minimal-whitespace implementation for balxml_formatter |
| balxml_formatter_prettyimpl | Provide pretty-printing implementation for balxml_formatter |
| balxml_formatterwhitespacetype | Enumerate the set of whitespace options for balxml_formatter |
| balxml_hexparser | Provide push parser for hex types |
| balxml_listparser | Provide push parser for lists |
| balxml_minireader | Provide light-weight implementation of balxml::Reader protocol |
| balxml_namespaceregistry | Provide a unique integer ID for each XML namespace |
| balxml_prefixstack | Provide a unique integer ID for each XML namespace |
| balxml_reader | Provide common reader protocol for parsing XML documents |
| balxml_typesparserutil | Provide a utility for parsing types using XML formatting |
| balxml_typesprintutil | Provide a utility for printing types using XML formatting |
| balxml_utf8readerwrapper | Provide wrapper for Reader to check input UTF-8 validity |
| balxml_util | Provide a suite of common XML utilities |
| balxml_validatingreader | Provide a common reader protocol for parsing and validating XML |
| ▼Group bbl | Basic Business Library (bbl) |
| ►Package bblb | Basic Business Library Basic (bblb) |
| bblb_schedulegenerationutil | Provide functions for generating schedules of dates |
| ►Package bbldc | Basic Business Library Day-Count (bbldc) |
| bbldc_basicactual360 | Provide stateless functions for the Actual/360 convention |
| bbldc_basicactual36525 | Provide stateless functions for the Actual/365.25 convention |
| bbldc_basicactual365fixed | Provide stateless functions for the Actual/365 (fixed) convention |
| bbldc_basicbasicdaycountadapter | Provide a parameterized day-count convention implementation |
| bbldc_basicdaterangedaycountadapter | Provide a parameterized day-count convention implementation |
| bbldc_basicdaycount | Provide a protocol for basic day-count calculations |
| bbldc_basicdaycountutil | Support for day-count calculations of enum-specified conventions |
| bbldc_basicisdaactualactual | Provide stateless functions for the ISDA Actual/Actual convention |
| bbldc_basicisma30360 | Provide stateless functions for the ISMA 30/360 convention |
| bbldc_basicnl365 | Provide stateless functions for the NL/365 convention |
| bbldc_basicpsa30360eom | Provide stateless functions for PSA 30/360 end-of-month convention |
| bbldc_basicsia30360eom | Provide stateless functions for SIA 30/360 end-of-month convention |
| bbldc_basicsia30360neom | Provide stateless functions for the SIA-30/360-neom convention |
| bbldc_calendarbus252 | Provide stateless functions for calendar-based BUS-252 |
| bbldc_calendardaterangedaycountadapter | Provide a parameterized day-count convention implementation |
| bbldc_calendardaycountutil | Support for day-count calculations of enum-specified conventions |
| bbldc_daterangedaycount | Provide a protocol for date-range limited day-count calculations |
| bbldc_daycountconvention | Provide an enumeration of bbldc day-count conventions |
| bbldc_perioddaterangedaycountadapter | Provide a parameterized day-count convention implementation |
| bbldc_perioddaycountutil | Support for day-count calculations of enum-specified conventions |
| bbldc_periodicmaactualactual | Provide stateless functions for period-based ICMA Actual/Actual |
| bbldc_terminatedbasicdaycountadapter | Provide a parameterized day-count convention implementation |
| bbldc_terminateddaterangedaycountadapter | Provide a parameterized day-count convention implementation |
| bbldc_terminateddaycountutil | Support for day-count calculations of enum-specified conventions |
| bbldc_terminatedisda30360eom | Provide stateless functions for ISDA 30/360 eom convention |
| ►Package bblscm | Basic Business Library Source Control Management (bblscm) |
| bblscm_version | Provide source control management (versioning) information |
| bblscm_versiontag | Provide versioning information for the bbl package group |
| ▼Group bdl | Basic Development Library (bdl) |
| ►Package bdlat | Basic Development Library Attribute Types (bdlat) |
| bdlat_arrayfunctions | Provide a namespace defining "array" functions |
| bdlat_arrayiterators | Provide iterator support for bdlat_ArrayFunction-conformant types |
| bdlat_arrayutil | Provide utilities for operating on bdlat "array" types |
| bdlat_attributeinfo | Provide a container for attribute information |
| bdlat_bdeatoverrides | Provide macros to map bdeat names to bdlat names |
| bdlat_choicefunctions | Provide a namespace defining choice functions |
| bdlat_customizedtypefunctions | Provide a namespace defining customized type functions |
| bdlat_enumeratorinfo | Provide a container for enumerator information |
| bdlat_enumfunctions | Provide a namespace defining enumeration functions |
| bdlat_enumutil | Provide functions for decoding enumerations with fallback values |
| bdlat_formattingmode | Provide formatting mode constants |
| bdlat_nullablevaluefunctions | Provide a namespace defining nullable value functions |
| bdlat_nullablevalueutil | Provide utilities for operating on bdlat "nullable value" types |
| bdlat_selectioninfo | Provide a container for selection information |
| bdlat_sequencefunctions | Provide a namespace defining sequence functions |
| bdlat_symbolicconverter | Provide a utility for convert types with matching member symbols |
| bdlat_typecategory | Provide type category tags and a tag selection meta-function |
| bdlat_typename | Provide string representations for data type names |
| bdlat_typetraits | Provide compile-time traits for generated types |
| bdlat_valuetypefunctions | Provide a namespace for "value type" functions |
| ►Package bdlb | Basic Development Library Basis (bdlb) |
| bdlb_algorithmworkaroundutil | Provide a namespace for workarounds for faulty standard algorithms |
| bdlb_arrayutil | Provide utilities to determine properties of fixed-sized arrays |
| bdlb_bigendian | Provide big-endian integer types |
| bdlb_bitmaskutil | Provide simple mask values of uint32_t and uint64_t types |
| bdlb_bitstringimputil | Provide functional bit-manipulation of uint64_t values |
| bdlb_bitstringutil | Provide efficient operations on a multi-word sequence of bits |
| bdlb_bitutil | Provide efficient bit-manipulation of uint32_t/uint64_t values |
| bdlb_caselessstringviewequalto | Provide a case-insensitive equality predicate for string views |
| bdlb_caselessstringviewhash | Provide a case-insensitive hash functor for string views |
| bdlb_caselessstringviewless | Provide a case-insensitive less-than predicate for string views |
| bdlb_chartype | Supply locale-independent version of <ctype.h> functionality |
| bdlb_cstringequalto | Provide a standard compatible equality predicate for C-strings |
| bdlb_cstringhash | Provide a functor enabling C-strings as unordered-container keys |
| bdlb_cstringless | Provide a standard compatible less-than predicate for C-strings |
| bdlb_float | Provide floating-point classification types and functions |
| bdlb_functionoutputiterator | Provides an output iterator for a client-supplied functor |
| bdlb_guid | Provide a value-semantic type for Globally Unique Identifiers |
| bdlb_guidutil | Provide functions that produce Globally Unique Identifiers |
| bdlb_hashutil | Provide a utility of hash functions |
| bdlb_indexspan | Provide a value-semantic attribute type for position and length |
| bdlb_indexspanstringutil | Provide functions that operate on IndexSpan and string objects |
| bdlb_indexspanutil | Provide functions that operate on IndexSpan objects |
| bdlb_literalutil | Provide utility routines for programming language literals |
| bdlb_nullableallocatedvalue | Provide a template for nullable allocated (out-of-place) objects |
| bdlb_nullableallocatedvalue_cpp03 | Provide C++03 implementation for bdlb_nullableallocatedvalue.h |
| bdlb_nullableallocatedvalue_pointerbitspair | Provide a mechanism for using the unused bits of a pointer |
| bdlb_nullablevalue | Provide a template for nullable (in-place) objects |
| bdlb_nullablevalue_cpp03 | Provide C++03 implementation for bdlb_nullablevalue.h |
| bdlb_nullablevalueref | Tech preview for non-owning reference to nullable objects |
| bdlb_nullablevalueref_cpp03 | Provide C++03 implementation for bdlb_nullablevalueref.h |
| bdlb_nullopt | Provide a tag type and constant indicating an empty nullable value |
| bdlb_nulloutputiterator | Provide an output iterator type that discards output |
| bdlb_numericparseutil | Provide conversions from text into fundamental numeric types |
| bdlb_optionalprinter | Provide a suite of helper classes for printing bsl::optional |
| bdlb_pairutil | Provide a function that creates a pair of references |
| bdlb_pcgrandomgenerator | Provide a class to generate random numbers using the PCG algorithm |
| bdlb_print | Provide platform-independent stream utilities |
| bdlb_printadapter | Provide object for streaming objects using bdlb::PrintMethods |
| bdlb_printmethods | Provide methods for uniform printing of value-semantic types |
| bdlb_random | Provide a suite of procedures for random-number generation |
| bdlb_randomdevice | Provide a common interface to a system's random number generator |
| bdlb_scopeexit | Provide a general-purpose proctor object for scope-exit logic |
| bdlb_string | Provide utility functions on STL-style and C-style strings |
| bdlb_stringrefutil | Provide utility functions on bslstl::StringRef-erenced strings |
| bdlb_stringviewutil | Provide utility functions on bsl::string_view containers |
| bdlb_testinputiterator | Provide a pure input iterator for an empty range |
| bdlb_tokenizer | Provide access to user-described tokens via string references |
| bdlb_topologicalsortutil | Provide a utility to topologically sort a collection of inputs |
| bdlb_transformiterator | Provide a wrapping iterator that invokes a functor on dereference |
| bdlb_transparentequalto | Provide a transparent equality predicate |
| bdlb_transparenthash | Provide a transparent hash functor |
| bdlb_transparentless | Provide a transparent less-than predicate |
| bdlb_variant | Provide a variant (discriminated union-like) type |
| bdlb_variant_cpp03 | Provide C++03 implementation for bdlb_variant.h |
| ►Package bdlbb | Basic Development Library Blobs (bdlbb) |
| bdlbb_blob | Provide an indexed set of buffers from multiple sources |
| bdlbb_blobstreambuf | Provide blob implementing the streambuf interface |
| bdlbb_blobutil | Provide a suite of utilities for I/O operations on bdlbb::Blob |
| bdlbb_pooledblobbufferfactory | Provide a concrete implementation of bdlbb::BlobBufferFactory |
| bdlbb_simpleblobbufferfactory | Provide a simple implementation of bdlbb::BlobBufferFactory |
| ►Package bdlc | Basic Development Library Container (bdlc) |
| bdlc_bitarray | Provide a space-efficient, sequential container of boolean values |
| bdlc_compactedarray | Provide a compacted array of const user-defined objects |
| bdlc_flathashmap | Provide an open-addressed unordered map container |
| bdlc_flathashmap_cpp03 | Provide C++03 implementation for bdlc_flathashmap.h |
| bdlc_flathashset | Provide an open-addressed unordered set container |
| bdlc_flathashset_cpp03 | Provide C++03 implementation for bdlc_flathashset.h |
| bdlc_flathashtable | Provide an open-addressed hash table like Abseil flat_hash_map |
| bdlc_flathashtable_cpp03 | Provide C++03 implementation for bdlc_flathashtable.h |
| bdlc_flathashtable_groupcontrol | Provide inquiries to a flat hash table group of control values |
| bdlc_hashtable | Provide a double-hashed table with utility |
| bdlc_indexclerk | Provide a manager of reusable, non-negative integer indices |
| bdlc_packedintarray | Provide an extensible, packed array of integral values |
| bdlc_packedintarrayutil | Provide common non-primitive operations on bdlc::PackedIntArray |
| bdlc_queue | Provide an in-place double-ended queue of T values |
| ►Package bdlcc | Basic Development Library Concurrency Containers (bdlcc) |
| bdlcc_boundedqueue | Provide a thread-aware bounded queue of values |
| bdlcc_cache | Provide a in-process cache with configurable eviction policy |
| bdlcc_deque | Provide a fully thread-safe deque container |
| bdlcc_fixedqueue | Provide a thread-aware fixed-size queue of values |
| bdlcc_fixedqueueindexmanager | Provide thread-enabled state management for a fixed-size queue |
| bdlcc_multipriorityqueue | Provide a thread-enabled parameterized multi-priority queue |
| bdlcc_objectcatalog | Provide an efficient indexed, thread-safe object container |
| bdlcc_objectpool | Provide a thread-safe object pool |
| bdlcc_queue | Provide a thread-enabled queue of items of parameterized TYPE |
| bdlcc_sharedobjectpool | Provide a thread-safe pool of shared objects |
| bdlcc_singleconsumerqueue | Provide a thread-aware single consumer queue of values |
| bdlcc_singleconsumerqueueimpl | Provide a testable thread-aware single consumer queue of values |
| bdlcc_singleproducerqueue | Provide a thread-aware single producer queue of values |
| bdlcc_singleproducerqueueimpl | Provide a testable thread-aware single producer queue of values |
| bdlcc_singleproducersingleconsumerboundedqueue | Provide a thread-aware SPSC bounded queue of values |
| bdlcc_skiplist | Provide a generic thread-safe Skip List |
| bdlcc_stripedunorderedcontainerimpl | Provide common implementation of striped un-ordered map/multimap |
| bdlcc_stripedunorderedmap | Provide a bucket-group locking (i.e., striped) unordered map |
| bdlcc_stripedunorderedmultimap | Provide a bucket-group locking (striped) unordered multimap |
| bdlcc_timequeue | Provide an efficient queue for time events |
| ►Package bdld | Basic Development Library Datum (bdld) |
| bdld_datum | Provide a discriminated variant type with a small footprint |
| bdld_datumarraybuilder | Provide a utility to build a Datum object holding an array |
| bdld_datumbinaryref | Provide a type to represent binary data and its size |
| bdld_datumerror | Provide a type for an error code with an optional error message |
| bdld_datumintmapbuilder | Provide a utility to build a Datum object holding an int-map |
| bdld_datummaker | Provide a mechanism for easily creating bdld::Datum objects |
| bdld_datummapbuilder | Provide a utility to build a Datum object holding a map |
| bdld_datummapowningkeysbuilder | Provide a utility to build a Datum object holding a map |
| bdld_datumudt | Provide a type to represent a user-defined type |
| bdld_datumutil | Provide extra functions that operate on bdld::Datum objects |
| bdld_manageddatum | Provide a smart-pointer-like manager for a Datum object |
| ►Package bdlde | Basic Development Library Data Encoder (bdlde) |
| bdlde_base64alphabet | Provide an enumeration of the set of possible base 64 alphabets |
| bdlde_base64decoder | Provide automata for converting to and from Base64 encodings |
| bdlde_base64decoderoptions | Provide value-semantic attribute class for decoder options |
| bdlde_base64encoder | Provide automata for converting to and from Base64 encodings |
| bdlde_base64encoderoptions | Provide a value-semantic attribute class for encoder options |
| bdlde_base64ignoremode | Provide an enumeration of the set of possible base64 ignore modes |
| bdlde_byteorder | Provide an enumeration of the set of possible byte orders |
| bdlde_charconvertstatus | Provide masks for interpreting status from charconvert functions |
| bdlde_charconvertucs2 | Provide efficient conversions between UTF-8 and UCS-2 encodings |
| bdlde_charconvertutf16 | Provide fast, safe conversion between UTF-8 and UTF-16 encodings |
| bdlde_charconvertutf32 | Provide fast, safe conversion between UTF-8 encoding and UTF-32 |
| bdlde_crc32 | Provide a mechanism for computing the CRC-32 checksum of a dataset |
| bdlde_crc32c | Provide utilities to calculate the CRC32-C checksum of a dataset |
| bdlde_crc64 | Provide a mechanism for computing the CRC-64 checksum of a dataset |
| bdlde_hexdecoder | Provide mechanism for decoding text from hexadecimal |
| bdlde_hexencoder | Provide mechanism for encoding text into hexadecimal |
| bdlde_md5 | Provide a value-semantic type encoding a message in an MD5 digest |
| bdlde_quotedprintabledecoder | Provide automata converting to and from Quoted-Printable encodings |
| bdlde_quotedprintableencoder | Provide automata converting to and from Quoted-Printable encodings |
| bdlde_sha1 | Provide a value-semantic type encoding a message in a SHA-1 digest |
| bdlde_sha2 | Provide a value-semantic type encoding a message in a SHA-2 digest |
| bdlde_utf8checkinginstreambufwrapper | Provide a stream buffer wrapper for validating UTF-8 input |
| bdlde_utf8util | Provide basic utilities for UTF-8 encodings |
| ►Package bdldfp | Basic Development Library Decimal Floating-Point (bdldfp) |
| bdldfp_decimal | Provide IEEE-754 decimal floating-point types |
| bdldfp_decimalconvertutil | Provide decimal floating-point conversion functions |
| bdldfp_decimalconvertutil_inteldfp | Provide decimal floating-point conversion functions for Intel DFP |
| bdldfp_decimalformatconfig | Provide an attribute class to configure decimal formatting |
| bdldfp_decimalimputil | Provide a unified low-level interface for decimal floating point |
| bdldfp_decimalimputil_inteldfp | Provide utility to implement decimal floats on the Intel library |
| bdldfp_decimalplatform | Provide decimal floating-point platform information macros |
| bdldfp_decimalstorage | Utilities for working with Decimal Storage types |
| bdldfp_decimalutil | Provide utilities dealing with floating point decimal objects |
| bdldfp_intelimpwrapper | Provide a central mechanism to configure the Intel DFP library |
| bdldfp_uint128 | Provide a representation of a 128-bit int for bitwise operations |
| ►Package bdlf | Basic Development Library Functors (bdlf) |
| bdlf_bind | Provide a signature-specific function object (functor) |
| bdlf_memfn | Provide member function pointer wrapper classes and utility |
| bdlf_noop | Provide a functor class that does nothing |
| bdlf_noop_cpp03 | Provide C++03 implementation for bdlf_noop.h |
| bdlf_placeholder | Provide a parameterized placeholder and specialized placeholders |
| ►Package bdljsn | Basic Development Library JSoN (bdljsn) |
| bdljsn_error | Provide a description of an error processing a document |
| bdljsn_json | Provide an in-memory representation of a JSON document |
| bdljsn_jsonliterals | Provide user-defined literals for bdljsn::Json objects |
| bdljsn_jsonnull | Provide a type that represents the JSON null value |
| bdljsn_jsonnumber | Provide a value-semantic type representing a JSON number |
| bdljsn_jsontestsuiteutil | Provide JSON Test Suite for BDE table-driven testing |
| bdljsn_jsontype | Enumerate the set of JSON value types |
| bdljsn_jsonutil | Provide common non-primitive operations on Json objects |
| bdljsn_location | Provide a value-semantic type for location in a JSON document |
| bdljsn_numberutil | Provide utilities converting between JSON text and numeric types |
| bdljsn_readoptions | Provide options for reading a JSON document |
| bdljsn_stringutil | Provide a utility functions for JSON strings |
| bdljsn_tokenizer | Provide a tokenizer for extracting JSON data from a streambuf |
| bdljsn_writeoptions | Provide options for writing a JSON document |
| bdljsn_writestyle | Enumerate the formatting styles for a writing a JSON document |
| ►Package bdlm | Basic Development Library Metrics (bdlm) |
| bdlm_instancecount | Provide a type specific instance count |
| bdlm_metric | Provide a class to store metric values of different types |
| bdlm_metricdescriptor | Provide an attribute class to describe a metric |
| bdlm_metricsadapter | Provide an abstract interface for metrics registration mechanisms |
| bdlm_metricsregistry | Provide a transferable registry of metric registrations |
| ►Package bdlma | Basic Development Library Memory Allocators (bdlma) |
| bdlma_alignedallocator | Provide a protocol for memory allocators that support alignment |
| bdlma_aligningallocator | Provide an allocator-wrapper to allocate with a minimum alignment |
| bdlma_autoreleaser | Release memory to a managed allocator or pool at destruction |
| bdlma_blocklist | Provide allocation and management of a sequence of memory blocks |
| bdlma_bufferedsequentialallocator | Provide an efficient managed allocator using an external buffer |
| bdlma_bufferedsequentialpool | Provide sequential memory using an external buffer and a fallback |
| bdlma_bufferimputil | Provide pure procedures for allocating memory from a buffer |
| bdlma_buffermanager | Provide a memory manager that manages an external buffer |
| bdlma_concurrentallocatoradapter | Provide a thread-enabled adapter for the allocator protocol |
| bdlma_concurrentfixedpool | Provide thread-safe pool of limited # of blocks of uniform size |
| bdlma_concurrentmultipool | Provide a memory manager to manage pools of varying block sizes |
| bdlma_concurrentmultipoolallocator | Provide an allocator to manage pools of varying object sizes |
| bdlma_concurrentpool | Provide thread-safe allocation of memory blocks of uniform size |
| bdlma_concurrentpoolallocator | Provide thread-safe memory-pooling allocator of fixed-size blocks |
| bdlma_countingallocator | Provide a memory allocator that counts allocated bytes |
| bdlma_defaultdeleter | Provide a concrete default deleter w/optionally-supplied allocator |
| bdlma_deleter | Provide a protocol for deleting objects of parameterized type |
| bdlma_factory | Provide a protocol for creator/deleter of parameterized objects |
| bdlma_guardingallocator | Provide a memory allocator that guards against buffer overruns |
| bdlma_heapbypassallocator | Support memory allocation directly from virtual memory |
| bdlma_infrequentdeleteblocklist | Provide allocation and management of infrequently deleted blocks |
| bdlma_localbufferedobject | Provide easy way to create an object with a local arena allocator |
| bdlma_localbufferedobject_cpp03 | Provide C++03 implementation for bdlma_localbufferedobject.h |
| bdlma_localsequentialallocator | Provide an efficient managed allocator using a local buffer |
| bdlma_managedallocator | Provide a protocol for memory allocators that support release |
| bdlma_memoryblockdescriptor | Provide a class describing a block of memory |
| bdlma_multipool | Provide a memory manager to manage pools of varying block sizes |
| bdlma_multipoolallocator | Provide a memory-pooling allocator of heterogeneous block sizes |
| bdlma_pool | Provide efficient allocation of memory blocks of uniform size |
| bdlma_sequentialallocator | Provide a managed allocator using dynamically-allocated buffers |
| bdlma_sequentialpool | Provide sequential memory using dynamically-allocated buffers |
| ►Package bdlmt | Basic Development Library Multi Thread (bdlmt) |
| bdlmt_eventscheduler | Provide a thread-safe recurring and one-time event scheduler |
| bdlmt_fixedthreadpool | Provide portable implementation for a fixed-size pool of threads |
| bdlmt_multiprioritythreadpool | Provide a mechanism to parallelize a prioritized sequence of jobs |
| bdlmt_multiqueuethreadpool | Provide a pool of queues, each processed serially by a thread pool |
| bdlmt_signaler | Provide an implementation of a managed signals and slots system |
| bdlmt_threadmultiplexor | Provide a mechanism for partitioning a collection of threads |
| bdlmt_threadpool | Provide portable implementation for a dynamic pool of threads |
| bdlmt_throttle | Provide mechanism for limiting the rate at which actions may occur |
| bdlmt_timereventscheduler | Provide a thread-safe recurring and non-recurring event scheduler |
| ►Package bdlpcre | Basic Development Library PCRE (bdlpcre) |
| bdlpcre_regex | Provide a mechanism for regular expression pattern matching |
| ►Package bdls | Basic Development Library System-level utilities (bdls) |
| bdls_fdstreambuf | Provide a stream buffer initialized with a file descriptor |
| bdls_filedescriptorguard | Provide a RAII guard class used to close files |
| bdls_filesystemutil | Provide methods for filesystem access with multi-language names |
| bdls_filesystemutil_transitionaluniximputil | Provide testable bdls::FilesystemUtil operations for some Unixes |
| bdls_filesystemutil_uniximputil | Provide testable bdls::FilesystemUtil operations for some Unixes |
| bdls_filesystemutil_unixplatform | Provide Unix timstamp and offset type width detection macros |
| bdls_filesystemutil_windowsimputil | Provide testable bdls::FilesystemUtil operations on Windows |
| bdls_memoryutil | Provide a set of portable utilities for memory manipulation |
| bdls_osutil | Provide utilities related to the operating system |
| bdls_pathutil | Provide portable file path manipulation |
| bdls_pipeutil | Provide basic portable named-pipe utilities |
| bdls_processutil | Provide basic platform-independent utilities related to processes |
| bdls_tempdirectoryguard | Provide a scoped guard that creates a unique temporary directory |
| bdls_testutil | Provide test utilities for components in bdl and above |
| ►Package bdlsb | Basic Development Library Stream Buffers (bdlsb) |
| bdlsb_fixedmeminput | Provide a basic input stream buffer using a client buffer |
| bdlsb_fixedmeminstreambuf | Provide an input basic_streambuf using a client buffer |
| bdlsb_fixedmemoutput | Provide a basic output stream buffer using a client buffer |
| bdlsb_fixedmemoutstreambuf | Provide an output basic_streambuf using a client buffer |
| bdlsb_memoutstreambuf | Provide an output basic_streambuf using managed memory |
| bdlsb_overflowmemoutput | Provide an overflowable output streambuf using a client buffer |
| bdlsb_overflowmemoutstreambuf | Provide an overflowable output streambuf using a client buffer |
| ►Package bdlscm | Basic Development Library Source Control Management (bdlscm) |
| bdlscm_version | Provide source control management (versioning) information |
| bdlscm_versiontag | Provide versioning information for the bdl package group |
| ►Package bdlsta | Basic Development Library STAtistics (bdlsta) |
| bdlsta_linefit | Online algorithm for computing the least squares regression line |
| bdlsta_moment | Online algorithm for mean, variance, skew, and kurtosis |
| ►Package bdlt | Basic Development Library Time (bdlt) |
| bdlt_calendar | Provide fast repository for accessing weekend/holiday information |
| bdlt_calendarcache | Provide an efficient cache for read-only bdlt::Calendar objects |
| bdlt_calendarloader | Provide a protocol (or pure interface) for loading calendars |
| bdlt_calendarreverseiteratoradapter | Provide reverse iterator adapter for calendar iterators |
| bdlt_calendarutil | Provide common date manipulations requiring a calendar |
| bdlt_currenttime | Provide utilities to retrieve the current time |
| bdlt_date | Provide a value-semantic type to represent dates |
| bdlt_datetime | Provide a value-semantic type representing both date and time |
| bdlt_datetimeimputil | Provide constants useful for encoding datetimes |
| bdlt_datetimeinterval | Provide a representation of an interval of time |
| bdlt_datetimeintervalutil | Provide non-primitive operations on bdlt::DatetimeInterval |
| bdlt_datetimetz | Provide a representation of a date and time with time zone offset |
| bdlt_datetimeutil | Provide common non-primitive operations on bdlt::Datetime |
| bdlt_datetz | Provide a representation of a date with time zone offset |
| bdlt_dateutil | Provide common non-primitive operations on date objects |
| bdlt_dayofweek | Provide an enumeration of the set of days of the week |
| bdlt_dayofweekset | Provide an ordered set of (unique) bdlt::DayOfWeek::Enum values |
| bdlt_dayofweekutil | Provide common non-primitive operations on bdlt::DayOfWeek::Enum |
| bdlt_defaultcalendarcache | Provide a process-wide default bdlt::CalendarCache object |
| bdlt_defaulttimetablecache | Provide a process-wide default bdlt::TimetableCache object |
| bdlt_epochutil | Conversion between absolute/relative time with respect to epoch |
| bdlt_fixutil | Provide conversions between date/time objects and FIX strings |
| bdlt_fixutilconfiguration | Provide an attribute class to configure FIX string generation |
| bdlt_fuzzutil | Provide creation of bdlt data types from fuzz data |
| bdlt_intervalconversionutil | Provide functions to convert between time-interval representations |
| bdlt_iso8601util | Provide conversions between date/time objects and ISO 8601 strings |
| bdlt_iso8601utilconfiguration | Provide an attribute class to configure ISO 8601 string generation |
| bdlt_iso8601utilparseconfiguration | Provide an attribute class to configure ISO 8601 string parsing |
| bdlt_localtimeoffset | Provide utilities to retrieve the local time offset |
| bdlt_monthofyear | Enumerate the set of month-of-year values |
| bdlt_packedcalendar | Provide a compact repository for weekend/holiday information |
| bdlt_posixdateimputil | Provide low-level support functions for date-value manipulation |
| bdlt_prolepticdateimputil | Provide low-level support functions for date-value manipulation |
| bdlt_serialdateimputil | Provide low-level support functions for date-value manipulation |
| bdlt_time | Provide a value-semantic type representing time-of-day |
| bdlt_timetable | Provide a repository for accessing timetable information |
| bdlt_timetablecache | Provide an efficient cache for read-only bdlt::Timetable objects |
| bdlt_timetableloader | Provide a protocol (or pure interface) for loading timetables |
| bdlt_timetz | Provide a representation of a time with time zone offset |
| bdlt_timeunitratio | Provide constants characterizing ratios between common time units |
| bdlt_timeutil | Provide common non-primitive operations on bdlt::Time |
| ▼Group bsl | Basic Standard Library (bsl) |
| Package bsl+bslhdrs | Basic Standard Library BSL HeaDerS (bsl+bslhdrs) |
| ►Package bsla | Basic Standard Library Annotations (bsla) |
| bsla_annotations | Provide support for compiler annotations for compile-time safety |
| bsla_deprecated | Provide compiler-hint macros to indicate deprecated entities |
| bsla_error | Provide a macro to emit an error message when a function is called |
| bsla_fallthrough | Provide a macro to suppress warnings on switch fall-throughs |
| bsla_format | Provide a macro to indicate that a return value is a format string |
| bsla_maybeunused | Provide a macro to suppress "unused" warnings |
| bsla_nodiscard | Provide a macro for warning about ignored function results |
| bsla_nonnullarg | Provide macros to hint at null arguments to functions |
| bsla_noreturn | Provide a macro to issue a compiler warning if a function returns |
| bsla_nullterminated | Provide macros for use with NULL-terminated variadic functions |
| bsla_printf | Provide a macro to indicate printf-style arguments |
| bsla_scanf | Provide a macro for checking scanf-style format strings |
| bsla_unreachable | Provide a compiler-hint macro to indicate unreachable code |
| bsla_unused | Provide a macro to suppress "unused" warnings |
| bsla_used | Provide a macro to prevent elision of unused entities |
| bsla_warning | Provide a macro to emit a warning when a function is called |
| ►Package bslalg | Basic Standard Library ALgorithms (bslalg) |
| bslalg_arraydestructionprimitives | Provide primitive algorithms that destroy arrays |
| bslalg_arrayprimitives | Provide primitive algorithms that operate on arrays |
| bslalg_arrayprimitives_cpp03 | Provide C++03 implementation for bslalg_arrayprimitives.h |
| bslalg_autoarraydestructor | Provide a proctor for destroying arrays |
| bslalg_autoarraymovedestructor | Provide a proctor for destroying arrays |
| bslalg_autoscalardestructor | Provide a proctor for destroying an object |
| bslalg_bidirectionallink | Provide a basic link type for building doubly-linked lists |
| bslalg_bidirectionallinklistutil | Provide utilities to maintain bidirectional list data structures |
| bslalg_bidirectionalnode | Provide a node holding a value in a doubly-linked list |
| bslalg_constructorproxy | Provide a proxy for constructing and destroying objects |
| bslalg_containerbase | Provide a wrapper for STL allocators, for container use |
| bslalg_dequeimputil | Provide basic parameters and primitive data structures for deques |
| bslalg_dequeiterator | Provide a primitive iterator over deque data structures |
| bslalg_dequeprimitives | Provide primitive algorithms that operate on deques |
| bslalg_dequeprimitives_cpp03 | Provide C++03 implementation for bslalg_dequeprimitives.h |
| bslalg_functoradapter | Provide an utility that adapts callable objects to functors |
| bslalg_hashtableanchor | Provide a type holding the constituent parts of a hash table |
| bslalg_hashtablebucket | Provide a bucket representation for hash table data structures |
| bslalg_hashtableimputil | Provide algorithms for implementing a hash table |
| bslalg_hashutil | Provide a utility of hash functions |
| bslalg_hasstliterators | Provide a tag type used to detect STL-like iterators traits |
| bslalg_hastrait | Provide a meta-function to detect if a type has a given trait |
| bslalg_nothrowmovableutil | Provide a wrapper that asserts a noexcept move constructor |
| bslalg_nothrowmovablewrapper | Provide a wrapper that asserts a noexcept move constructor |
| bslalg_numericformatterutil | Provide a utility for formatting numbers into strings |
| bslalg_rangecompare | Provide algorithms to compare iterator-ranges of elements |
| bslalg_rbtreeanchor | Encapsulate root, first, and last nodes of a tree with a count |
| bslalg_rbtreenode | Provide a base class for a red-black binary tree node |
| bslalg_rbtreeutil | Provide a suite of primitive algorithms on red-black trees |
| bslalg_scalardestructionprimitives | Provide primitive algorithms that destroy scalars |
| bslalg_scalarprimitives | Provide primitive algorithms that operate on single elements |
| bslalg_selecttrait | Provide a meta-function to select a suitable trait on a type |
| bslalg_swaputil | Provide a simple to use swap algorithm |
| bslalg_synththreewayutil | Provide implementation utilities for operator<=> |
| bslalg_typetraitbitwisecopyable | Provide a trait to mark classes as bit-wise copyable |
| bslalg_typetraitbitwiseequalitycomparable | Provide a trait to mark classes as bit-wise eq.-comparable |
| bslalg_typetraitbitwisemoveable | Provide a trait to mark classes as bit-wise moveable |
| bslalg_typetraithaspointersemantics | Provide a trait to mark classes as having pointer semantics |
| bslalg_typetraithasstliterators | Provide a trait to mark classes as having STL-like iterators |
| bslalg_typetraithastrivialdefaultconstructor | Provide a trait to mark classes as having a trivial default ctor |
| bslalg_typetraitnil | Provide a trait to mark classes as having no other traits |
| bslalg_typetraitpair | Provide a trait to mark classes as similar to std::pair |
| bslalg_typetraits | Provide compile-time traits that can be associated with types |
| bslalg_typetraitusesbslmaallocator | Provide a trait to mark types that use bslma allocators |
| ►Package bsldoc | Basic Standard Library DOCumentation (bsldoc) |
| bsldoc_glossary | Provide definitions for terms used throughout BDE documentation |
| ►Package bslfwd | Basic Standard Library System ForWarding Declarations (bslfwd) |
| bslfwd_bslma_allocator | Provide a forward-declaration for the corresponding BDE type |
| bslfwd_bslma_default | Provide a forward-declaration for the corresponding BDE type |
| bslfwd_bslma_defaultallocatorguard | Provide a forward-declaration for the corresponding BDE type |
| bslfwd_bslmf_nil | Provide a forward-declaration for the corresponding BDE type |
| bslfwd_bsls_asserttestexception | Provide a forward-declaration for the corresponding BDE type |
| bslfwd_bsls_stopwatch | Provide a forward-declaration for the corresponding BDE type |
| bslfwd_bsls_types | Provide a forward-declaration for the corresponding BDE type |
| bslfwd_buildtarget | Supply a compile-time indicator of whether BSL uses C++ namespaces |
| ►Package bslh | Basic Standard Library Hashing (bslh) |
| bslh_defaulthashalgorithm | Provide a reasonable hashing algorithm for default use |
| bslh_defaultseededhashalgorithm | Provide a reasonable seeded hashing algorithm for default use |
| bslh_fibonaccibadhashwrapper | Provide a wrapper to improve "bad" hash algorithms |
| bslh_filesystem | Provide hash for std::filesystem::path |
| bslh_hash | Provide a struct to run bslh hash algorithms on supported types |
| bslh_hashoptional | Provide hashAppend for std::optional |
| bslh_hashpair | Provide hashAppend for std::pair |
| bslh_hashtuple | Provide hashAppend for std::tuple |
| bslh_hashvariant | Provide hashAppend for std::variant |
| bslh_seededhash | Provide a struct to run seeded bslh hash algorithms on types |
| bslh_seedgenerator | Provide a class to generate arbitrary length seeds for algorithms |
| bslh_siphashalgorithm | Provide an implementation of the SipHash algorithm |
| bslh_spookyhashalgorithm | Provide an implementation of the SpookyHash algorithm |
| bslh_spookyhashalgorithmimp | Provide BDE style encapsulation of 3rd party SpookyHash code |
| bslh_wyhashincrementalalgorithm | Provide an implementation of the WyHash algorithm final v3 |
| ►Package bslim | Basic Standard Library Implementation Mechanisms (bslim) |
| bslim_bslstandardheadertest | Provide a location for testing bsl standard library headers |
| bslim_formatguard | Provide a guard for saving the state of a stream object |
| bslim_fuzzdataview | Provide a view of a buffer of fuzz data bytes |
| bslim_fuzzutil | Provide fuzz test utilities for basic types |
| bslim_gtestutil | Provide facilities for debugging BDE with gtest |
| bslim_printer | Provide a mechanism to implement standard print methods |
| bslim_testutil | Provide test utilities for components above bsl |
| ►Package bslma | Basic Standard Library Memory Allocators (bslma) |
| bslma_aamodel | Provide metafunctions to detect a type's allocator-awareness model |
| bslma_aatypeutil | Provide a namespace for utility functions on allocator-aware types |
| bslma_allocator | Provide a pure abstract interface for memory-allocation mechanisms |
| bslma_allocatoradaptor | Provide a polymorphic adaptor for STL-style allocators |
| bslma_allocatortraits | Provide a uniform interface to standard allocator types |
| bslma_allocatortraits_cpp03 | Provide C++03 implementation for bslma_allocatortraits.h |
| bslma_allocatorutil | Provide a namespace for utility functions on allocators |
| bslma_allocatorutil_cpp03 | Provide C++03 implementation for bslma_allocatorutil.h |
| bslma_autodeallocator | Provide a range proctor to managed a block of memory |
| bslma_autodestructor | Provide a range proctor to manage an array of objects |
| bslma_autorawdeleter | Provide a range proctor to manage a sequence objects |
| bslma_bslallocator | Provide an STL-compatible proxy for bslma::Allocator objects |
| bslma_bslallocator_cpp03 | Provide C++03 implementation for bslma_bslallocator.h |
| bslma_bufferallocator | Support efficient memory allocations from a user-supplied buffer |
| bslma_constructionutil | Provide methods to construct arbitrarily-typed objects uniformly |
| bslma_constructionutil_cpp03 | Provide C++03 implementation for bslma_constructionutil.h |
| bslma_deallocatebytesproctor | Provide a proctor to conditionally unwind memory block allocation |
| bslma_deallocateobjectproctor | Provide a proctor to conditionally unwind object allocation |
| bslma_deallocatorguard | Provide a guard to unconditionally manage a block of memory |
| bslma_deallocatorproctor | Provide a proctor to conditionally manage a block memory |
| bslma_default | Provide utilities to set/fetch the default and global allocators |
| bslma_defaultallocatorguard | Provide scoped guard to temporarily change the default allocator |
| bslma_deleteobjectproctor | Provide a proctor to conditionally unwind new object creation |
| bslma_deleterhelper | Provide namespace for functions used to delete objects |
| bslma_destructionutil | Provide routines that destroy objects efficiently |
| bslma_destructorguard | Provide a guard to unconditionally manage an object |
| bslma_destructorproctor | Provide a proctor to conditionally manage an object |
| bslma_exceptionguard | Provide a check that objects throwing exceptions do not change |
| bslma_hasallocatortype | Provide a compile-time check for an allocator_type typedef |
| bslma_infrequentdeleteblocklist | Provide allocation and management of a sequence of memory blocks |
| bslma_isstdallocator | Provide a compile-time check for determining allocator types |
| bslma_mallocfreeallocator | Provide malloc/free adaptor to bslma::Allocator protocol |
| bslma_managedallocator | Provide a protocol for memory allocators that support release |
| bslma_managedptr | Provide a managed pointer class |
| bslma_managedptr_cpp03 | Provide C++03 implementation for bslma_managedptr.h |
| bslma_managedptr_factorydeleter | Provide a factory-based deleter for the managed pointer class |
| bslma_managedptr_members | Provide the internal state of a managed pointer class |
| bslma_managedptr_pairproxy | Provide the internal state of a managed pointer class |
| bslma_managedptrdeleter | Provide an in-core value-semantic class to call a delete function |
| bslma_memoryresource | Provide a pure abstract interface for memory-allocation mechanisms |
| bslma_newdeleteallocator | Provide singleton new/delete adaptor to bslma::Allocator protocol |
| bslma_polymorphicallocator | Provide an allocator interface for bsl::memory_resource objects |
| bslma_polymorphicallocator_cpp03 | Provide C++03 implementation for bslma_polymorphicallocator.h |
| bslma_rawdeleterguard | Provide a guard to unconditionally manage an object |
| bslma_rawdeleterproctor | Provide a proctor to conditionally manage an object |
| bslma_sequentialallocator | Support fast memory allocation for objects of varying sizes |
| bslma_sequentialpool | Provide fast variable-size memory pool with allocation methods |
| bslma_sharedptrinplacerep | Provide an in-place implementation of bslma::SharedPtrRep |
| bslma_sharedptrinplacerep_cpp03 | Provide C++03 implementation for bslma_sharedptrinplacerep.h |
| bslma_sharedptroutofplacerep | Provide an out-of-place implementation of bslma::SharedPtrRep |
| bslma_sharedptrrep | Provide an abstract class for a shared object manager |
| bslma_stdallocator | Provide an STL-compatible proxy for bslma::Allocator objects |
| bslma_stdtestallocator | Provide stl-compatible, bslma-style allocator to track usage |
| bslma_testallocator | Provide instrumented malloc/free allocator to track memory usage |
| bslma_testallocatorexception | Provide an exception class for memory allocation operations |
| bslma_testallocatormonitor | Provide a mechanism to summarize bslma::TestAllocator object use |
| bslma_usesbslmaallocator | Provide a metafunction to indicate the use of bslma allocators |
| ►Package bslmf | Basic Standard Library Meta-Functions (bslmf) |
| bslmf_addconst | Provide a meta-function for adding a top-level const-qualifier |
| bslmf_addcv | Provide a meta-function for adding top-level cv-qualifiers |
| bslmf_addlvaluereference | Provide a compile-time type transformation to lvalue reference |
| bslmf_addpointer | Provide meta-function to transform a type to pointer to that type |
| bslmf_addreference | Provide a meta-function for adding "reference-ness" to a type |
| bslmf_addrvaluereference | Provide a compile-time type transformation to rvalue reference |
| bslmf_addvolatile | Provide a meta-function for adding a volatile-qualifier |
| bslmf_allocatorargt | Provide a tag type to precede allocator arguments |
| bslmf_arraytopointer | Provide a meta-function to convert array types to pointer types |
| bslmf_assert | Provide a compile-time assertion facility |
| bslmf_booleantestable | Provide an exposition-only concept boolean-testable |
| bslmf_conditional | Provide a compile-time conditional type selector |
| bslmf_conjunction | Provide the logical conjunction (AND) for type traits |
| bslmf_conjunction_cpp03 | Provide C++03 implementation for bslmf_conjunction.h |
| bslmf_decay | Convert a type to the type used for pass-by-value |
| bslmf_detectnestedtrait | Provide a facility for defining traits and detecting legacy traits |
| bslmf_disjunction | Provide the logical disjunction (OR) for type traits |
| bslmf_disjunction_cpp03 | Provide C++03 implementation for bslmf_disjunction.h |
| bslmf_enableif | Provide a utility to set up SFINAE conditions in type deduction |
| bslmf_forwardingreftype | Provide a meta-function for determining a forwarding type |
| bslmf_forwardingtype | Provide a meta-function for determining an optimal forwarding type |
| bslmf_functionpointertraits | Provide a meta-function for determining function pointer traits |
| bslmf_functionpointertraits_cpp03 | Provide C++03 implementation for bslmf_functionpointertraits.h |
| bslmf_haspointersemantics | Provide a type trait for pointer semantics |
| bslmf_if | Provide a compile-time if/else (conditional) meta-function |
| bslmf_integersequence | Provide a template parameter pack of integers |
| bslmf_integralconstant | Provide a mapping from integral constants to unique types |
| bslmf_invokeresult | Determine the result type of an invocable expression |
| bslmf_invokeresult_cpp03 | Provide C++03 implementation for bslmf_invokeresult.h |
| bslmf_isaccessiblebaseof | Provide a compile-time check for derived classes |
| bslmf_isarithmetic | Provide a compile-time check for determining arithmetic types |
| bslmf_isarray | Provide a compile-time check for array types |
| bslmf_isbitwisecopyable | Provide a meta-function for determining bitwise copyable types |
| bslmf_isbitwiseequalitycomparable | Provide a type trait for bitwise equality |
| bslmf_isbitwisemoveable | Provide a primitive type trait for bitwise moveable classes |
| bslmf_isclass | Provide a compile-time check for determining class types |
| bslmf_isconst | Provide a compile-time check for const-qualified types |
| bslmf_isconvertible | Provide a compile-time check for type conversion |
| bslmf_isconvertibletoany | Provide a compile-time check for types convertible to any type |
| bslmf_iscopyconstructible | Provide a meta-function to report if a type is copy constructible |
| bslmf_isempty | Provide a compile-time check for detecting an empty class type |
| bslmf_isenum | Provide compile-time check for determining enumerated types |
| bslmf_isfloatingpoint | Provide a compile-time check for floating-point types |
| bslmf_isfunction | Provide a compile-time check for determining function types |
| bslmf_isfundamental | Provide a compile-time check for determining fundamental types |
| bslmf_isintegral | Provide a compile-time check for integral types |
| bslmf_islvaluereference | Provide a compile-time check for lvalue reference types |
| bslmf_ismemberfunctionpointer | Provide a compile-time check for member function pointer types |
| bslmf_ismemberobjectpointer | Provide a compile-time check for member object pointer types |
| bslmf_ismemberpointer | Provide a compile-time check for non-static member pointer types |
| bslmf_isnothrowmoveconstructible | Provide metafunction to identify no-throw move-constructible types |
| bslmf_isnothrowswappable | Provide metafunction to identify nothrow swappable types |
| bslmf_ispair | Provide a compile-time check for the bsl::pair type |
| bslmf_ispointer | Provide a compile-time check for pointer types |
| bslmf_ispolymorphic | Provide a compile-time check for determining polymorphic types |
| bslmf_isreference | Provide a meta-function to test reference types |
| bslmf_isreferencewrapper | Provide a trait to detect reference-wrapper specializations |
| bslmf_isrvaluereference | Provide a compile-time check for rvalue reference types |
| bslmf_issame | Provide a meta-function for testing if two types are the same |
| bslmf_isswappable | Provide metafunction to identify swappable types |
| bslmf_istransparentpredicate | Support detection of whether a predicate functor is transparent |
| bslmf_istriviallycopyable | Provide a meta-function for determining trivially copyable types |
| bslmf_istriviallydefaultconstructible | Provide a compile-time check for trivially default-constructible |
| bslmf_isvoid | Provide a compile-time check for void types |
| bslmf_isvolatile | Provide a compile-time check for volatile-qualified types |
| bslmf_makeintegersequence | Provide a template parameter pack of integers |
| bslmf_matchanytype | Provide a generic type to which any type can be converted |
| bslmf_matcharithmetictype | Provide a class supporting "do-the-right-thing clause" dispatch |
| bslmf_memberfunctionpointertraits | Provide meta-functions to detect member function pointer traits |
| bslmf_memberpointertraits | Provide meta-function to detect pointer to member traits |
| bslmf_metaint | Provide a meta-function to map integral constants to unique types |
| bslmf_movableref | Provide a vocabulary type to enable move semantics |
| bslmf_negation | Provide the logical negation (NOT) for type traits |
| bslmf_nestedtraitdeclaration | Provide a nested declaration to associate a class with a trait |
| bslmf_nil | Provide a nil type |
| bslmf_nthparameter | Metafunction to return the Nth type parameter in a parameter pack |
| bslmf_nthparameter_cpp03 | Provide C++03 implementation for bslmf_nthparameter.h |
| bslmf_removeconst | Provide a meta-function for removing top-level const-qualifier |
| bslmf_removecv | Provide a meta-function for removing top-level cv-qualifiers |
| bslmf_removecvq | Provide a meta-function for removing const/volatile qualifiers |
| bslmf_removecvref | Provide a meta-func for removing reference-ness and cv-qualifiers |
| bslmf_removeextent | Provide a metafunction to return an array type's element type |
| bslmf_removepointer | Provide a meta-function to transform pointer type to referent type |
| bslmf_removereference | Provide a meta-function for stripping reference-ness from types |
| bslmf_removevolatile | Provide a meta-function for removing volatile-qualifier |
| bslmf_resulttype | Provide access to result_type or ResultType nested type |
| bslmf_selecttrait | Provide clean compile-time dispatch based on multiple traits |
| bslmf_switch | Provide a compile-time switch meta-function |
| bslmf_tag | Provide an integral-constant-to-type conversion |
| bslmf_typeidentity | Provide a template metafunction that returns its argument |
| bslmf_typelist | Provide a typelist component |
| bslmf_usesallocator | Provide a meta-function to determine if a type uses an allocator |
| bslmf_usesallocatorargt | Provide a metafunction for allocator_arg_t construction |
| bslmf_util | Provide low-level functions on bslmf types |
| bslmf_voidtype | Provide a helper for implementing SFINAE-based metafunctions |
| ►Package bslmt | Basic Standard Library Multi-Threading (bslmt) |
| bslmt_barrier | Provide a thread barrier component |
| bslmt_chronoutil | Provide utilities related to threading with C++11-style clocks |
| bslmt_condition | Provide a portable, efficient condition variable |
| bslmt_conditionimpl_pthread | Provide a POSIX implementation of bslmt::Condition |
| bslmt_conditionimpl_win32 | Provide a win32 implementation of bslmt::Condition |
| bslmt_configuration | Provide utilities to allow configuration of values for BCE |
| bslmt_entrypointfunctoradapter | Provide types and utilities to simplify thread creation |
| bslmt_fastpostsemaphore | Provide a semaphore class optimizing post |
| bslmt_fastpostsemaphoreimpl | Provide a testable semaphore class optimizing post |
| bslmt_latch | Provide a single-use mechanism for synchronizing on an event count |
| bslmt_lockguard | Provide generic scoped guards for synchronization objects |
| bslmt_meteredmutex | Provide a mutex capable of keeping track of wait and hold time |
| bslmt_mutex | Provide a platform-independent mutex |
| bslmt_mutexassert | Provide an assert macro for verifying that a mutex is locked |
| bslmt_muteximpl_pthread | Provide a POSIX implementation of bslmt::Mutex |
| bslmt_muteximpl_win32 | Provide a win32 implementation of bslmt::Mutex |
| bslmt_once | Provide a thread-safe way to execute code once per process |
| bslmt_platform | Provide platform-dependent thread-related trait definitions |
| bslmt_qlock | Provide small, statically-initializable mutex lock |
| bslmt_readerwriterlock | Provide a multi-reader/single-writer lock |
| bslmt_readerwriterlockassert | Provide an assert macro for verifying reader-writer lock status |
| bslmt_readerwritermutex | Provide a multi-reader/single-writer lock |
| bslmt_readerwritermuteximpl | Provide a multi-reader/single-writer lock |
| bslmt_readlockguard | Provide generic scoped guards for read synchronization objects |
| bslmt_recursivemutex | Provide a platform-independent recursive mutex |
| bslmt_recursivemuteximpl_pthread | Provide a POSIX implementation of bslmt::RecursiveMutex |
| bslmt_recursivemuteximpl_win32 | Provide a win32 implementation of bslmt::RecursiveMutex |
| bslmt_rwmutex | Provide a platform-independent RW mutex class |
| bslmt_saturatedtimeconversionimputil | Provide special narrowing conversions for time types |
| bslmt_semaphore | Provide a semaphore class |
| bslmt_semaphoreimpl_counted | Provide an implementation of bslmt::Semaphore with count |
| bslmt_semaphoreimpl_darwin | Provide a Darwin implementation of bslmt::Semaphore |
| bslmt_semaphoreimpl_pthread | Provide a POSIX implementation of bslmt::Semaphore |
| bslmt_semaphoreimpl_win32 | Provide a win32 implementation of bslmt::Semaphore |
| bslmt_sluice | Provide a "sluice" class |
| bslmt_testutil | Provide thread-safe test utilities for multithreaded components |
| bslmt_threadattributes | Provide a description of the attributes of a thread |
| bslmt_threadgroup | Provide a container for managing a group of threads |
| bslmt_threadlocalvariable | Provide a macro to declare a thread-local variable |
| bslmt_threadutil | Provide platform-independent utilities related to threading |
| bslmt_threadutilimpl_pthread | Provide a POSIX implementation of bslmt::ThreadUtil |
| bslmt_threadutilimpl_win32 | Provide a win32 implementation of bslmt::ThreadUtil |
| bslmt_throughputbenchmark | Provide a performance test harness for multi-threaded components |
| bslmt_throughputbenchmarkresult | Provide result repository for throughput performance test harness |
| bslmt_timedsemaphore | Provide a timed semaphore class |
| bslmt_timedsemaphoreimpl_posixadv | Provide "advanced" POSIX implementation of bslmt::TimedSemaphore |
| bslmt_timedsemaphoreimpl_pthread | Provide a POSIX implementation of bslmt::TimedSemaphore |
| bslmt_timedsemaphoreimpl_win32 | Provide a win32 implementation of bslmt::TimedSemaphore |
| bslmt_turnstile | Provide a mechanism to meter time |
| bslmt_writelockguard | Provide generic scoped guards for write synchronization objects |
| ►Package bsls | Basic Standard Library System utilities (bsls) |
| bsls_alignedbuffer | Provide raw buffers with user-specified size and alignment |
| bsls_alignment | Provide a namespace for enumerating memory alignment strategies |
| bsls_alignmentfromtype | Provide a meta-function that maps a TYPE to its alignment |
| bsls_alignmentimp | Provide implementation meta-functions for alignment computation |
| bsls_alignmenttotype | Provide a meta-function mapping an ALIGNMENT to a primitive type |
| bsls_alignmentutil | Provide constants, types, and operations related to alignment |
| bsls_annotation | Provide support for compiler annotations for compile-time safety |
| bsls_assert | Provide build-specific, runtime-configurable assertion macros |
| bsls_assert_macroreset | Undefine all macros from bsls_assert.h and bsls_review.h |
| bsls_assertimputil | Provide utilities to implement bsls_assert and bsls_review |
| bsls_asserttest | Provide a test facility for assertion macros |
| bsls_asserttest_macroreset | Undefine macros related to bsls_asserttest.h |
| bsls_asserttestexception | Provide an exception type to support testing for failed assertions |
| bsls_atomic | Provide types with atomic operations |
| bsls_atomicoperations | Provide platform-independent atomic operations |
| bsls_atomicoperations_all_all_clangintrinsics | Implement atomic operations using clang __c11_atomic_* intrinsics |
| bsls_atomicoperations_all_all_gccintrinsics | Implement atomic operations using gcc __atomic_* intrinsics |
| bsls_atomicoperations_arm32_win_msvc | Provide implementations of atomic operations for arm32/MSVC/Win |
| bsls_atomicoperations_arm64_win_msvc | Provide implementations of atomic operations for arm64/MSVC/Win |
| bsls_atomicoperations_arm_all_gcc | Provide implementations of atomic operations for ARM/GCC |
| bsls_atomicoperations_default | Provide default implementation for atomic operations |
| bsls_atomicoperations_powerpc32_aix_xlc | Provide implementations of atomic operations for PowerPC/AIX-32bit |
| bsls_atomicoperations_powerpc64_aix_xlc | Provide implementations of atomic operations for PowerPC/AIX-64bit |
| bsls_atomicoperations_powerpc_aix_xlc_default | Provide default base implementations of atomics for PowerPC/AIX |
| bsls_atomicoperations_powerpc_all_gcc | Provide implementations of atomic operations for gcc on PowerPC |
| bsls_atomicoperations_sparc32_sun_cc | Provide implementations of atomic operations for Sparc/Sun (32bit) |
| bsls_atomicoperations_sparc64_sun_cc | Provide implementations of atomic operations for Sparc/Sun (64bit) |
| bsls_atomicoperations_sparc_sun_cc_default | Provide default base implementations of atomics for Sparc/Sun |
| bsls_atomicoperations_x64_all_gcc | Provide implementations of atomic operations for X86_64/GCC |
| bsls_atomicoperations_x64_win_msvc | Provide implementations of atomic operations for X86_64/MSVC/Win64 |
| bsls_atomicoperations_x86_all_gcc | Provide implementations of atomic operations for X86/GCC |
| bsls_atomicoperations_x86_win_msvc | Provide implementations of atomic operations for X86/MSVC/Windows |
| bsls_blockgrowth | Provide a namespace for memory block growth strategies |
| bsls_bsldeprecationinformation | Provide a macro to control bsl deprecations by release version |
| bsls_bslexceptionutil | Provide functions for use in bsl that throw standard exceptions |
| bsls_bsllock | Provide a platform-independent mutex for use below bslmt |
| bsls_bsllockimpl_pthread | Provide a mutex for use below bslmt |
| bsls_bsllockimpl_win32 | Provide a mutex for use below bslmt for windows platform |
| bsls_bslonce | Provide BSL a thread-safe way to execute code once per process |
| bsls_bslsourcenameparserutil | Provide low-level functions for parsing source file names |
| bsls_bsltestutil | Provide test utilities for bsl that do not use <iostream> |
| bsls_buildtarget | Provide build-target information in object files |
| bsls_byteorder | Provide byte-order manipulation macros |
| bsls_byteorderutil | Provide byte-order swapping functions |
| bsls_byteorderutil_impl | Provide implementation of byte-order manipulation functions |
| bsls_compilerfeatures | Provide macros to identify compiler support for C++11 features |
| bsls_consteval | Provide macros related to compile-time evaluation |
| bsls_cpp11 | Provide macros for C++11 forward compatibility |
| bsls_deprecate | Provide machinery to deprecate interfaces on a per-version basis |
| bsls_deprecatefeature | Provide machinery to deprecate entities in C++ code |
| bsls_exceptionutil | Provide simplified exception constructs for non-exception builds |
| bsls_fuzztest | Provide macros for use in fuzz testing narrow-contract functions |
| bsls_fuzztestpreconditionexception | Provide an exception type for handling failed preconditions |
| bsls_ident | Provide macros for inserting SCM Ids into source files |
| bsls_int64 | Provide namespace for platform-dependent 64-bit integer types |
| bsls_keyword | Provide macros for forward language dialect compatibility |
| bsls_libraryfeatures | Provide macros to identify native standard library features |
| bsls_linkcoercion | Provide a way to force a link-time dependency into an object |
| bsls_log | Provide a namespace for low-level logging functions |
| bsls_logseverity | Enumerate a set of logging severity levels |
| bsls_macroincrement | Provide a macro to increment preprocessor numbers |
| bsls_macrorepeat | Repeat a macro invocation with different numeric arguments |
| bsls_nameof | Provide a NameOf type for displaying template type at run-time |
| bsls_nativestd | Define the namespace native_std as an alias for std |
| bsls_nullptr | Provide a distinct type for null pointer literals |
| bsls_objectbuffer | Provide raw buffer with size and alignment of user-specified type |
| bsls_outputredirector | Provide a means for test drivers to redirect and inspect output |
| bsls_performancehint | Provide performance hints for code optimization |
| bsls_platform | Provide compile-time support for platform/attribute identification |
| bsls_platformutil | Provide consistent interface for platform-dependent functionality |
| bsls_pointercastutil | Provide function to cast between function and data pointers |
| bsls_preconditions | Provide macros for use in fuzz testing narrow contract functions |
| bsls_protocoltest | Provide classes and macros for testing abstract protocols |
| bsls_review | Provide assertion macros to safely identify contract violations |
| bsls_review_macroreset | Test driver utility to undefine all macros from bsls_review.h |
| bsls_spinlock | Provide a spin lock |
| bsls_stackaddressutil | Provide a utility for obtaining return addresses from the stack |
| bsls_stackaddressutil_plinktimestamp | Declare and weakly define a plink_timestamp___ global variable |
| bsls_stopwatch | Provide access to user, system, and wall times of current process |
| bsls_systemclocktype | Enumerate the set of system clock types |
| bsls_systemtime | Provide utilities to retrieve the system time |
| bsls_timeinterval | Provide a representation of a time interval |
| bsls_timeutil | Provide a platform-neutral functional interface to system clocks |
| bsls_types | Provide a consistent interface for platform-dependent types |
| bsls_unspecifiedbool | Provide a class supporting the unspecified bool idiom |
| bsls_util | Provide essential, low-level support for portable generic code |
| ►Package bslscm | Basic Standard Library Source Control Management (bslscm) |
| bslscm_patchversion | Provide common patch versioning information |
| bslscm_version | Provide source control management (versioning) information |
| bslscm_versiontag | Provide versioning information for the bsl package group |
| ►Package bslstl | Basic Standard Library STL (bslstl) |
| bslstl_algorithm | Provide implementations for algorithms not in the system library |
| bslstl_algorithmworkaround | Provide a namespace for work arounds for the standard algorithms |
| bslstl_allocator | Provide an STL-compatible proxy for bslma::Allocator objects |
| bslstl_array | Provide an STL compliant array |
| bslstl_badfunctioncall | Provide an exception class thrown by bsl::function |
| bslstl_badoptionalaccess | Provide an exception class thrown by bsl::optional |
| bslstl_badvariantaccess | Provide an exception class thrown by bsl::variant |
| bslstl_badweakptr | Provide an exception class to indicate a weak_ptr has expired |
| bslstl_bidirectionaliterator | Provide a template to create STL-compliant bidirectional iterators |
| bslstl_bidirectionalnodepool | Provide efficient creation of nodes used in a node-based container |
| bslstl_bidirectionalnodepool_cpp03 | Provide C++03 implementation for bslstl_bidirectionalnodepool.h |
| bslstl_bitset | Provide an STL-compliant bitset class |
| bslstl_boyermoorehorspoolsearcher | Provide an STL-compliant boyer_moore_horspool_searcher class |
| bslstl_charconv | Provide implementations for functions not in the system library |
| bslstl_chrono | Provide functionality of the corresponding C++ Standard header |
| bslstl_compare | Provide functionality of the corresponding C++ Standard header |
| bslstl_complex | Provide functionality of the corresponding C++ Standard header |
| bslstl_defaultsearcher | Provide an STL-compliant default_searcher class |
| bslstl_deque | Provide an STL-compliant deque class |
| bslstl_deque_cpp03 | Provide C++03 implementation for bslstl_deque.h |
| bslstl_equalto | Provide a binary functor conforming to the C++11 equal_to spec |
| bslstl_errc | Provide a standard compliant version of errc |
| bslstl_error | Provide standard compliant versions of <system_error> classes |
| bslstl_exception | Provide an implementation of uncaught_exceptions |
| bslstl_forwarditerator | Provide a template to create STL-compliant forward iterators |
| bslstl_function | Provide a polymorphic function object with a specific prototype |
| bslstl_function_cpp03 | Provide C++03 implementation for bslstl_function.h |
| bslstl_function_invokerutil | Provide invoker adaptors for bsl::function |
| bslstl_function_invokerutil_cpp03 | Provide C++03 implementation for bslstl_function_invokerutil.h |
| bslstl_function_isreferencecompatible | Provide a metafunction for substitutability of type references |
| bslstl_function_rep | Provide a non-template, common implementation for bsl::function |
| bslstl_function_smallobjectoptimization | Provide small-object optimization buffer for bsl::function |
| bslstl_hash | Provide a namespace for hash functions |
| bslstl_hashtable | Provide a hash-container with support for duplicate values |
| bslstl_hashtable_cpp03 | Provide C++03 implementation for bslstl_hashtable.h |
| bslstl_hashtablebucketiterator | Provide an STL compliant iterator over hash table buckets |
| bslstl_hashtableiterator | Provide an STL compliant iterator for hash tables |
| bslstl_inplace | Provide a standard-compliant in place construction tag types |
| bslstl_iomanip | Provide BSL implementations for standard <iomanip> features |
| bslstl_ios | Provide functionality of the corresponding C++ Standard header |
| bslstl_iosfwd | Provide forward declarations for Standard stream classes |
| bslstl_iserrorcodeenum | Provide a compliant standard is_error_code_enum trait |
| bslstl_iserrorconditionenum | Provide a compliant standard is_error_condition_enum trait |
| bslstl_istringstream | Provide a C++03-compatible istringstream class |
| bslstl_iterator | Provide basic iterator traits, adaptors, and utilities |
| bslstl_iteratorutil | Provide utilities operating on iterators and iterator ranges |
| bslstl_list | Provide an STL-compliant list class |
| bslstl_list_cpp03 | Provide C++03 implementation for bslstl_list.h |
| bslstl_map | Provide an STL-compliant map class |
| bslstl_map_cpp03 | Provide C++03 implementation for bslstl_map.h |
| bslstl_map_test1 | Provide support for the bslstl_map.t.cpp test driver |
| bslstl_map_test2 | Provide support for the bslstl_map.t.cpp test driver |
| bslstl_map_test3 | Provide support for the bslstl_map.t.cpp test driver |
| bslstl_mapcomparator | Provide a comparator for TreeNode objects and a lookup key |
| bslstl_monostate | Provide a default constructible alternative for bsl::variant |
| bslstl_multimap | Provide an STL-compliant multimap class |
| bslstl_multimap_cpp03 | Provide C++03 implementation for bslstl_multimap.h |
| bslstl_multimap_test | Provide support for the bslstl_multimap.t.cpp test driver |
| bslstl_multiset | Provide an STL-compliant multiset class |
| bslstl_multiset_cpp03 | Provide C++03 implementation for bslstl_multiset.h |
| bslstl_multiset_test | Provide support for the bslstl_multiset.t.cpp test driver |
| bslstl_optional | Provide a standard-compliant allocator aware optional type |
| bslstl_optional_cpp03 | Provide C++03 implementation for bslstl_optional.h |
| bslstl_ostream | Provide aliases and implementations matching standard <ostream> |
| bslstl_ostringstream | Provide a C++03-compatible ostringstream class |
| bslstl_osyncstream | Provide a C++20-compatible basic_osyncstream class template |
| bslstl_ownerequal | Provide an ownership comparison for shared and weak pointers |
| bslstl_ownerhash | Provide an ownership hash functor for shared and weak pointers |
| bslstl_ownerless | Provide an ordering for shared and weak pointers |
| bslstl_pair | Provide a simple struct with two members that may use allocators |
| bslstl_priorityqueue | Provide container adapter class template priority_queue |
| bslstl_priorityqueue_cpp03 | Provide C++03 implementation for bslstl_priorityqueue.h |
| bslstl_queue | Provide container adapter class template queue |
| bslstl_queue_cpp03 | Provide C++03 implementation for bslstl_queue.h |
| bslstl_randomaccessiterator | Provide a template to create STL-compliant random access iterators |
| bslstl_ratio | Provide functionality of the corresponding C++ Standard header |
| bslstl_referencewrapper | Provide copyable, assignable object wrapper for references |
| bslstl_set | Provide an STL-compliant set class |
| bslstl_set_cpp03 | Provide C++03 implementation for bslstl_set.h |
| bslstl_set_test | Provide support for the bslstl_set.t.cpp test driver |
| bslstl_setcomparator | Provide a comparator for TreeNode objects and a lookup key |
| bslstl_sharedptr | Provide a generic reference-counted shared pointer wrapper |
| bslstl_sharedptr_cpp03 | Provide C++03 implementation for bslstl_sharedptr.h |
| bslstl_sharedptrallocateinplacerep | Provide an in-place implementation of bslma::SharedPtrRep |
| bslstl_sharedptrallocateoutofplacerep | Provide an out-of-place implementation of bslma::SharedPtrRep |
| bslstl_simplepool | Provide efficient allocation of memory blocks for a specific type |
| bslstl_span | Provide a (mostly) standard-compliant span class template |
| bslstl_stack | Provide an STL-compliant stack class |
| bslstl_stack_cpp03 | Provide C++03 implementation for bslstl_stack.h |
| bslstl_stdexceptutil | Provide a utility to throw standard exceptions |
| bslstl_stopstate | Provide a stop state for std-compliant stop tokens |
| bslstl_stoptoken | Provide an allocator-aware standard-compliant stop_source type |
| bslstl_string | Provide a standard-compliant basic_string class template |
| bslstl_string_test | Provide support for the bslstl_string.t.cpp test driver |
| bslstl_stringbuf | Provide a C++03-compatible stringbuf class |
| bslstl_stringref | Provide a reference to a const string |
| bslstl_stringrefdata | Provide a base class for bslstl::StringRef |
| bslstl_stringstream | Provide a C++03-compatible stringstream class |
| bslstl_stringview | Provide a standard-compliant basic_string_view class template |
| bslstl_syncbuf | Provide a C++20-compatible basic_syncbuf class template |
| bslstl_syncbufbase | Provide an allocator-independent base-class for basic_syncbuf |
| bslstl_systemerror | Provide a standard compliant system_error class |
| bslstl_treeiterator | Provide an STL compliant iterator for a tree of TreeNode objects |
| bslstl_treenode | Provide a POD-like tree node type holding a parameterized value |
| bslstl_treenodepool | Provide efficient creation of nodes used in tree-based container |
| bslstl_treenodepool_cpp03 | Provide C++03 implementation for bslstl_treenodepool.h |
| bslstl_typeindex | Provide an value-semantic type to represent type_info objects |
| bslstl_unorderedmap | Provide an STL-compliant unordered_map container |
| bslstl_unorderedmap_cpp03 | Provide C++03 implementation for bslstl_unorderedmap.h |
| bslstl_unorderedmap_test | Provide support for the bslstl_unorderedmap.t.cpp test driver |
| bslstl_unorderedmapkeyconfiguration | Provide a class template to extract keys as the first attribute |
| bslstl_unorderedmultimap | Provide an STL-compliant unordered_multimap container |
| bslstl_unorderedmultimap_cpp03 | Provide C++03 implementation for bslstl_unorderedmultimap.h |
| bslstl_unorderedmultimap_test | Provide support for the bslstl_unorderedmultimap.t.cpp test driver |
| bslstl_unorderedmultiset | Provide an STL-compliant unordered_multiset container |
| bslstl_unorderedmultiset_cpp03 | Provide C++03 implementation for bslstl_unorderedmultiset.h |
| bslstl_unorderedmultiset_test | Provide support for the bslstl_unorderedmultiset.t.cpp test driver |
| bslstl_unorderedset | Provide an STL-compliant unordered_set container |
| bslstl_unorderedset_cpp03 | Provide C++03 implementation for bslstl_unorderedset.h |
| bslstl_unorderedset_test | Provide support for the bslstl_unorderedset.t.cpp test driver |
| bslstl_unorderedsetkeyconfiguration | Provide a configuration class to use a whole object as its own key |
| bslstl_utility | Provide implementations for utilities not in the system library |
| bslstl_variant | Provide a standard-compliant allocator aware variant type |
| bslstl_variant_cpp03 | Provide C++03 implementation for bslstl_variant.h |
| bslstl_vector | Provide an STL-compliant vector class |
| bslstl_vector_cpp03 | Provide C++03 implementation for bslstl_vector.h |
| ►Package bslstp | Basic Standard Library STlPort types (bslstp) |
| bslstp_alloc | Provide facilities for STLPort implementation |
| bslstp_exfunctional | Provide a namespace for functional extensions |
| bslstp_hash | Provide a namespace for hash functions |
| bslstp_hashmap | Provide containers indexed by a hashed key value |
| bslstp_hashset | Provide containers hashed by value |
| bslstp_hashtable | Provide facilities for STLPort implementation |
| bslstp_iterator | Provide facility for STLPort implementation |
| bslstp_slist | Provide a singly linked list container |
| bslstp_slistbase | Provide facility for STLPort implementation |
| bslstp_util | Provide a namespace for utility functions for STL functionality |
| ►Package bsltf | Basic Standard Library Test Facility (bsltf) |
| bsltf_allocargumenttype | Provide an allocating test class to represent function arguments |
| bsltf_allocbitwisemoveabletesttype | Provide a class that allocates memory and is bitwise-moveable |
| bsltf_allocemplacabletesttype | Provide an allocating test class used to test emplace methods |
| bsltf_alloctesttype | Provide a class for testing that allocates with bsl::allocator |
| bsltf_argumenttype | Provide a non-allocating class to test variadic function arguments |
| bsltf_bitwisecopyabletesttype | Provide a bitwise-copyable test class |
| bsltf_bitwisemoveabletesttype | Provide a bitwise-moveable test class |
| bsltf_convertiblevaluewrapper | Provide a wrapper class, convertible to a supplied value |
| bsltf_copymovestate | Provide an enumeration of copy/move state, including unsupported |
| bsltf_copymovetracker | Provide a type that tracks if it's been copied or moved |
| bsltf_degeneratefunctor | Provide an awkward type to adapt a user-supplied functor |
| bsltf_emplacabletesttype | Provide a non-allocating test class used to test emplace methods |
| bsltf_enumeratedtesttype | Provide an enumerated test type |
| bsltf_evilbooleantype | Provide the most awkward type that is convertible to bool |
| bsltf_inputiterator | Provide a pure input iterator capable of traversing a range |
| bsltf_movablealloctesttype | Provide an allocating test class that records when moved from |
| bsltf_movabletesttype | Provide a non-allocating test class that records when moved from |
| bsltf_moveonlyalloctesttype | Provide testing type that is move-only & uses bslma allocators |
| bsltf_movestate | Provide an enumeration of move-state, including unsupported |
| bsltf_nonassignabletesttype | Provide an attribute class to which can not be assigned |
| bsltf_noncopyconstructibletesttype | Provide an attribute class that is not copy constructible |
| bsltf_nondefaultconstructibletesttype | Provide an attribute class that is not default constructible |
| bsltf_nonequalcomparabletesttype | Provide an attribute class that is not equal comparable |
| bsltf_nonoptionalalloctesttype | Provide a class for testing that allocates with bslma::Allocator |
| bsltf_nontypicaloverloadstesttype | Provide a class that overloads the non-typical operators |
| bsltf_simpletesttype | Provide a non-allocating test class without type traits |
| bsltf_stdallocatoradaptor | Provide a mechanism to propagate standard allocator state |
| bsltf_stdallocatoradaptor_cpp03 | Provide C++03 implementation for bsltf_stdallocatoradaptor.h |
| bsltf_stdalloctesttype | Provide a class for testing that allocates with standard allocator |
| bsltf_stdstatefulallocator | Provide a minimal standard compliant allocator |
| bsltf_stdstatefulallocator_cpp03 | Provide C++03 implementation for bsltf_stdstatefulallocator.h |
| bsltf_stdtestallocator | Provide a minimal standard compliant allocator |
| bsltf_stdtestallocator_cpp03 | Provide C++03 implementation for bsltf_stdtestallocator.h |
| bsltf_streamutil | Provide streaming output operators for bsltf-defined types |
| bsltf_templatetestfacility | Provide utilities to help with testing templates |
| bsltf_testvaluesarray | Provide a container for values used for testing |
| bsltf_uniontesttype | Provide an union test type |
| bsltf_wellbehavedmoveonlyalloctesttype | Provide well-behaved move-only type using bslma allocators |
| ►Package bslx | Basic Standard Library eXternalization (bslx) |
| bslx_byteinstream | Provide a stream class for unexternalization of fundamental types |
| bslx_byteoutstream | Provide a stream class for externalization of fundamental types |
| bslx_genericinstream | Unexternalization of fundamental types from a parameterized stream |
| bslx_genericoutstream | Externalization of fundamental types to a parameterized stream |
| bslx_instreamfunctions | Facilitate uniform unexternalization of user and fundamental types |
| bslx_marshallingutil | Support platform-independent marshalling of fundamental types |
| bslx_outstreamfunctions | Facilitate uniform externalization of user and fundamental types |
| bslx_streambufinstream | Unexternalization of fundamental types from a bsl::streambuf |
| bslx_streambufoutstream | Externalization of fundamental types to a bsl::streambuf |
| bslx_testinstream | Enable unexternalization of fundamental types with identification |
| bslx_testinstreamexception | Provide an exception class for unexternalization operations |
| bslx_testoutstream | Enable externalization of fundamental types with identification |
| bslx_typecode | Enumerate the fundamental types supported by BDEX |
| bslx_versionfunctions | Provide functions to return BDEX version information for types |
| ▼Standalones | |
| ►Package s_baltst | |
| s_baltst_address | Provide value-semantic attribute classes |
| s_baltst_basicrecord | Provide value-semantic attribute classes |
| s_baltst_basicschema | Provide value-semantic attribute classes |
| s_baltst_basicschemautil | Provide utilities for s_baltst::BasicSchema objects |
| s_baltst_bigrecord | Provide value-semantic attribute classes |
| s_baltst_configschema | Provide the service configuration schema |
| s_baltst_customint | Provide value-semantic attribute classes |
| s_baltst_customizedbase64binary | Provide value-semantic attribute classes |
| s_baltst_customizedhexbinary | Provide value-semantic attribute classes |
| s_baltst_customizedstring | Provide value-semantic attribute classes |
| s_baltst_customstring | Provide value-semantic attribute classes |
| s_baltst_employee | Provide value-semantic attribute classes |
| s_baltst_enumerated | Provide value-semantic attribute classes |
| s_baltst_featuretestmessage | Provide value-semantic attribute classes |
| s_baltst_featuretestmessageutil | Provide utilities for testing codecs with feature-test messages |
| s_baltst_generatetestarray | Provide a component for generating test array types |
| s_baltst_generatetestchoice | Provide a component for generating test choice types |
| s_baltst_generatetestcustomizedtype | Provide a component for generating test customized types |
| s_baltst_generatetestdynamictype | Provide a component for generating test dynamic types |
| s_baltst_generatetestenumeration | Provide a component for generating test enumeration types |
| s_baltst_generatetestnullablevalue | Provide a component for generating test nullable value types |
| s_baltst_generatetestsequence | Provide a component for generating test sequence types |
| s_baltst_generatetesttaggedvalue | Provide a component for generating test tagged value types |
| s_baltst_mychoice | Provide value-semantic attribute classes |
| s_baltst_myenumeration | Provide value-semantic attribute classes |
| s_baltst_myenumerationunpreservedwithfallback | Provide value-semantic attribute classes |
| s_baltst_myenumerationwithfallback | Provide value-semantic attribute classes |
| s_baltst_myintenumeration | Provide value-semantic attribute classes |
| s_baltst_mysequence | Provide value-semantic attribute classes |
| s_baltst_mysequencewithanonymouschoice | Provide value-semantic attribute classes |
| s_baltst_mysequencewitharray | Provide value-semantic attribute classes |
| s_baltst_mysequencewithattributes | Provide value-semantic attribute classes |
| s_baltst_mysequencewithchoice | Provide value-semantic attribute classes |
| s_baltst_mysequencewithchoicearray | Provide value-semantic attribute classes |
| s_baltst_mysequencewithchoices | Provide value-semantic attribute classes |
| s_baltst_mysequencewithcustomizedbase64binary | Provide value-semantic attribute classes |
| s_baltst_mysequencewithcustomizedhexbinary | Provide value-semantic attribute classes |
| s_baltst_mysequencewithdecimalattribute | Provide value-semantic attribute classes |
| s_baltst_mysequencewithdoubleattribute | Provide value-semantic attribute classes |
| s_baltst_mysequencewithnillable | Provide value-semantic attribute classes |
| s_baltst_mysequencewithnillables | Provide value-semantic attribute classes |
| s_baltst_mysequencewithnullable | Provide value-semantic attribute classes |
| s_baltst_mysequencewithnullableanonymouschoice | Provide value-semantic attribute classes |
| s_baltst_mysequencewithnullables | Provide value-semantic attribute classes |
| s_baltst_mysequencewithprecisiondecimalattribute | Provide value-semantic attribute classes |
| s_baltst_mysimplecontent | Provide value-semantic attribute classes |
| s_baltst_mysimpleintcontent | Provide value-semantic attribute classes |
| s_baltst_ratsnest | Provide value-semantic attribute classes |
| s_baltst_rawdata | Provide value-semantic attribute classes |
| s_baltst_rawdataswitched | Provide value-semantic attribute classes |
| s_baltst_rawdataunformatted | Provide value-semantic attribute classes |
| s_baltst_request | Provide value-semantic attribute classes |
| s_baltst_response | Provide value-semantic attribute classes |
| s_baltst_sequencewithanonymity | Provide value-semantic attribute classes |
| s_baltst_simplerequest | Provide value-semantic attribute classes |
| s_baltst_sqrt | Provide value-semantic attribute classes |
| s_baltst_sqrtf | Provide value-semantic attribute classes |
| s_baltst_test | Provide a superficial test of all classes in baltst package |
| s_baltst_testarrayutil | Provide a utilty for generating test arrays |
| s_baltst_testattribute | Provide attribute metadata types for test sequences |
| s_baltst_testchoice | Provide a test implementation of a bdlat "choice" type |
| s_baltst_testchoiceutil | Provide non-primitive operations on s_baltst::TestChoice |
| s_baltst_testcustomizedtype | Provide a test implementation of a bdlat "customized type" |
| s_baltst_testcustomizedtypeutil | Provide non-primitive operations on s_baltst::TestCustomizedType |
| s_baltst_testdynamictype | Provide a test implementation of a bdlat "dynamic type" |
| s_baltst_testdynamictypeutil | Provide non-primitive operations on s_baltst::TestDynamicType |
| s_baltst_testenumeration | Provide a test implementation of a bdlat "enumeration" type |
| s_baltst_testenumerationutil | Provide non-primitive operations on s_baltst::TestEnumeration |
| s_baltst_testenumerator | Provide enumerator metadata types for test enumerations |
| s_baltst_testnilvalue | Provide a singular, valueless, value-semantic type for testing |
| s_baltst_testnullablevalueutil | Provide non-primitive operations on nullable values for testing |
| s_baltst_testplaceholder | Provide a value-level representation of a type for testing |
| s_baltst_testselection | Provide selection metadata types for test choices |
| s_baltst_testsequence | Provide a test implementation of a bdlat "sequence" type |
| s_baltst_testsequenceutil | Provide non-primitive operations on s_baltst::TestSequence |
| s_baltst_testtaggedvalue | Provide a test bdlat-compatible type with interceptable methods |
| s_baltst_testtaggedvalueutil | Provide non-primitive operations on s_baltst::TestTaggedValue |
| s_baltst_timingrequest | Provide value-semantic attribute classes |
| s_baltst_topchoice | Provide value-semantic attribute classes |
| s_baltst_unsignedsequence | Provide value-semantic attribute classes |
| s_baltst_voidsequence | Provide value-semantic attribute classes |
1.9.8