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