Index
A
- ABI (application binary interface) / Library name components
- Abstract Syntax Tree (AST)
- about / Expression templates
- active endpoints / Synchronous and asynchronous communications
- actors
- about / Boost Phoenix
- allocated objects
- containers / Containers for dynamically-allocated objects
- anchors
- about / Atoms, Anchors
- argument-dependent lookup (ADL) / Ownership semantics of pointer containers
- Argument Dependent Lookup (ADL)
- about / Boost.Swap
- arity
- about / Function objects
- Asio deadline timer / Asio deadline timer
- assignment operator
- about / Copy semantics
- implementing / The nothrow swap
- asymmetric coroutines
- about / Asymmetric coroutines
- using / Asymmetric coroutines
- asynchronous communication / Synchronous and asynchronous communications
- asynchronous I/O / Synchronous and asynchronous communications
- asynchronous TCP server
- about / Asynchronous TCP server
- coroutines, used / Asynchronous TCP server using coroutines
- without coroutines / Asynchronous TCP server without coroutines
- lifetime of TCPAsyncConnection / Lifetime of TCPAsyncConnection
- performance / Performance and concurrency
- concurrency / Performance and concurrency
- inversion of control flow / Inversion of control flow
- asynchronous UDP server
- about / Asynchronous UDP server, Asynchronous UDP server using completion handler chains
- completion handler chains, used / Asynchronous UDP server using completion handler chains
- coroutines, used / Asynchronous UDP server using coroutines
- atomic operation
- about / Data races and atomic operations
- atoms
- about / Atoms
B
- BasicLockable concept / boost::lock_guard
- Bimap documentation
- URL / Projections
- bimaps
- using / More ways to use bimaps
- tagged access / Tagged access
- projections / Projections
- binary
- about / Function objects
- Bipmaps, for many-to-many relations / Collection types
- blocking calls / Synchronous UDP client and server
- Boost
- history / How it all started
- evolution / How it all started
- URL / How it all started, Building and installing the Boost libraries from source
- about / What is Boost?
- boost$$intrusive_ptr
- defining / Intrusive smart pointers – boost::intrusive_ptr
- boost$$scoped_array
- defining / boost::scoped_array
- boost$$scoped_ptr
- defining / boost::scoped_ptr
- boost$$shared_ptr
- versus std$$shared_ptr / boost::shared_ptr and std::shared_ptr
- boost$$weak_ptr
- versus std$$weak_ptr / Nonowning aliases – boost::weak_ptr and std::weak_ptr
- boost**lock_guard / boost::lock_guard
- using / boost::lock_guard
- boost**unique_lock
- about / boost::unique_lock
- using / boost::unique_lock
- boost-devel package
- /usr/include / Installing on Linux
- /usr/lib / Installing on Linux
- boost-dir
- about / Installing on Windows
- boost-dir/doc / Installing on Windows
- boost-dir/include / Building the Boost libraries on Windows
- boost-dir/libs / Building the Boost libraries on Windows
- boost-dir/libs64 / Building the Boost libraries on Windows
- boost-dir/libW-msvc-vcver / Installing on Windows
- Boost.Any
- about / Boost.Any
- used, for storing heterogeneous values of data / Boost.Any
- using / Boost.Any
- Boost.Assign
- used, for assignment / Expressive initialization and assignment using Boost.Assign
- object initialization / Expressive initialization and assignment using Boost.Assign
- list of values, assigning to containers / Assigning lists of values to containers
- containers, initializing with lists of values / Initializing containers with lists of values
- pointer containers, initializing / Initializing pointer containers and assigning values
- values, assigning / Initializing pointer containers and assigning values
- Boost.Auto
- about / Boost.Auto
- Boost.Container library
- about / Boost Container library
- in-place construction / Move-awareness and in-place construction
- move-awareness / Move-awareness and in-place construction
- nonstandard containers / Nonstandard containers
- Boost.Conversion
- used, for storing heterogeneous values of data / Boost.Conversion
- about / Boost.Conversion
- lexical_cast function template, using / lexical_cast
- Boost.Core
- about / Other utilities and compile-time checks
- Boost.Foreach / Boost.Foreach
- Boost.Iterator
- using, with iteration patterns / Iteration patterns using Boost.Iterator
- using, for smart iteration / Smart iteration using Boost.Iterator
- filter iterator / Filter Iterator
- transform iterator / Transform Iterator
- function output iterator / Function Output Iterator
- conforming iterators, creating for custom classes / Creating conforming iterators for custom classes
- Boost.Move library
- using, for move emulation / Move emulation using Boost.Move
- Boost.Optional
- used, for creating simple data structures / Simple data structures, Boost.Optional
- about / Boost.Optional
- implementation / Boost.Optional
- stored values, accessing / Accessing values stored in boost::optional
- get_value_or member function, using / get_value_or
- versus pointers / Boost.Optional versus pointers
- Boost.Program_Options
- using / Using Boost.Program_Options
- positional parameters, parsing / Parsing positional parameters
- multiple option values, parsing / Multiple option values
- Boost.Range library
- about / Text processing with Boost String Algorithms library
- Boost.Regex
- used, for regular expressions / Regular expressions using Boost.Regex
- used, for parsing regular expressions / Using Boost.Regex to parse regular expressions
- text, matching / Matching text
- text, searching / Searching text
- text, tokenizing with regex / Tokenizing text using regex
- text, replacing / Replacing text
- Boost.Swap
- about / Boost.Swap
- using / Boost.Swap
- Boost.Tuple
- used, for creating simple data structures / Simple data structures, Boost.Tuple
- about / Boost.Tuple
- tuples, creating / Creating tuples
- tuple elements, accessing / Accessing tuple elements
- tuples, comparing / Comparing tuples
- generic code, writing with tuples / Writing generic code using tuples
- Boost.Utility
- about / Other utilities and compile-time checks
- Boost.Variant
- used, for storing heterogeneous values of data / Boost.Variant
- about / Boost.Variant
- variants, using / Boost.Variant
- values, accessing in variant / Accessing values in a variant
- compile-time visitation, of variants / Compile-time visitation
- generic visitors, creating / Generic visitors
- visitors, applying to variants in container / Applying visitors to variants in a container
- recursive variants, defining / Defining recursive variants
- recursive variants, defining in JSON format / The JSON format
- JSON content, representing with recursive variants / Representing JSON content with recursive variants
- recursive variants, visiting / Visiting recursive variants
- Boost Bimap
- about / Boost Bimap
- collection types / Collection types
- Boost binary distribution
- installing / Installing a Boost binary distribution
- installing, on Windows / Installing on Windows
- installing, on Linux / Installing on Linux
- Boost Chrono
- about / Using Chrono to measure time
- Boost Coroutine
- about / Boost Coroutine
- asymmetric coroutines / Boost Coroutine
- symmetric coroutines / Boost Coroutine
- Boost IOStreams
- about / Extensible I/O with Boost IOStreams
- architecture / Architecture of Boost IOStreams
- Boost libraries
- categories / What is Boost?
- about / Getting started with Boost libraries
- software support / Necessary software
- obtaining / Obtaining and building Boost libraries
- building / Obtaining and building Boost libraries
- Boost sandbox, planning / Planning your Boost sandbox
- naming conventions / Library naming conventions
- library name components / Library name components
- library name layouts / Library name layouts
- Boost binary distribution, installing / Installing a Boost binary distribution
- building, from source / Building and installing the Boost libraries from source
- installing, from source / Building and installing the Boost libraries from source
- optional packages / Optional packages
- building, on Linux / Building the Boost libraries on Linux
- building, on Windows / Building the Boost libraries on Windows
- using / Using Boost libraries in your projects
- linking against, on Linux / Linking against Boost libraries on Linux
- linking against, on Windows / Linking against Boost libraries on Windows
- code listings, building / Building the code listings in this book
- Boost Metaprogramming Library (MPL)
- about / The Boost Metaprogramming Library (MPL)
- metafunction / Metafunctions
- MPL metafunctions, using / Using MPL metafunctions
- Boost Multi-index containers
- defining / Boost Multi-index containers
- index types / Index types
- range lookups, using lambda / Range lookups using lambda
- insertion updates / Insertions and updates
- Boost Phoenix
- about / Boost Phoenix
- lazy algebraic expressions / Boost Phoenix
- simpler lambdas / Boost Phoenix
- lazy control structures / Boost Phoenix
- actors, for STL algorithms and container member functions / Boost Phoenix
- user defined actors / Boost Phoenix
- STL actors / Boost Phoenix
- Boost Spirit Parser Framework
- about / Boost Spirit Parser Framework
- Spirit Qi, using / Using Spirit Qi, Predefined parsers
- Boost String Algorithms library
- used, for text processing / Text processing with Boost String Algorithms library
- string, modifying to uppercase / Text processing with Boost String Algorithms library
- Boost.Range library / Text processing with Boost String Algorithms library
- using / Using Boost String Algorithms
- find algorithms / Find algorithms
- Boost Threads
- using / Using Boost Threads
- moving / Moving threads and waiting on threads
- waiting on / Moving threads and waiting on threads
- thread IDs, using / Thread IDs
- cores / Cores and threads
- Boost Tokenizer library
- used, for text splitting / Splitting text using the Boost Tokenizer library
- used, for tokenizing based on separators / Tokenizing based on separators
- used, for tokenizing records with metacharacters fields / Tokenizing records with fields containing metacharacters
- used, for tokenizing records with fixed-length fields / Tokenizing records with fixed-length fields
- custom tokenizer functions, writing / Writing your own tokenizer functions
- Boost Type Traits
- about / Boost Type Traits
- SFINAE / SFINAE and enable_if / disable_if
- enable_if / disable_if / SFINAE and enable_if / disable_if
- Boost unordered containers
- using, for fast lookups / Fast lookups using Boost Unordered containers
- BOOST_CURRENT_FUNCTION
- about / BOOST_CURRENT_FUNCTION
- using / BOOST_CURRENT_FUNCTION
- broadcast address / Special addresses
- buffers
- about / Buffers
- buffer sequences for vectored I/O / Buffer sequences for vectored I/O
- Burrows-Wheeler algorithm / Filters for compression and decompression
- Bzip2 library
- URL / Optional packages
C
- C++11
- exception-handling improvements / C++11 exception-handling improvements
- C++11 auto
- about / C++11 auto and Boost.Auto
- type deduction rules / Type deduction rules
- common uses / Common uses
- C++ Standards Committee / How it all started
- capturing sub-expressions
- about / Sub-expressions
- case-conversion algorithms
- for text processing / Case-conversion algorithms
- chain
- about / Architecture of Boost IOStreams
- character class
- about / Atoms, Character classes
- class templates / Compile-time programming with Boost
- client-server model / Synchronous and asynchronous communications
- client program / Synchronous and asynchronous communications
- clocks
- about / Creating date objects
- clocks, Boost Chrono
- process_real_cpu_clock type / Clocks and time points
- process_user_cpu_clock type / Clocks and time points
- process_system_cpu type / Clocks and time points
- thread_clock type / Clocks and time points
- closures
- about / Delegates and closures
- CMake
- about / CMake
- URL / CMake
- for Windows / CMake
- for Linux / CMake
- code listings
- building / Building the code listings in this book
- example source code / Code examples
- command-line arguments
- handling / Handling command-line arguments
- command-line options, designing / Designing command-line options
- Boost.Program_Options, using / Using Boost.Program_Options
- command-line options
- designing / Designing command-line options
- diff command example / The diff command – a case study
- compile-time asserts
- about / Compile-time asserts
- example / Compile-time asserts
- using / Compile-time asserts
- compile-time control flow, using templates
- about / Basic compile-time control flow using templates
- branching / Branching
- recursion / Recursion
- compile-time programming, with Boost
- about / Compile-time programming with Boost
- basic compile-time control flow / Basic compile-time control flow using templates
- Boost Type Traits / Boost Type Traits
- Boost Metaprogramming Library (MPL) / The Boost Metaprogramming Library (MPL)
- complete chain
- about / Architecture of Boost IOStreams
- completion handlers / Handler states – run_one, poll, and poll_one
- concurrent tasks
- creating, with Boost Thread / Creating concurrent tasks with Boost Thread
- creating / Creating and coordinating concurrent tasks
- coordinating / Creating and coordinating concurrent tasks
- boost**future / boost::future and boost::promise
- boost**promise / boost::future and boost::promise
- wait_for member function / Waiting for future
- exceptions, throwing across threads / Throwing exceptions across threads
- shared_future / shared_future
- std**future / std::future and std::promise
- std**promise / std::future and std::promise
- std**packaged_task / std::packaged_task and std::async, std::packaged_task
- std**async / std::packaged_task and std::async, std::async
- launch policy, std**async / Launch policy
- condition variables
- about / Condition variables and producer-consumer problem
- using / Condition variables and producer-consumer problem
- nuances / Condition variable nuances
- Config library
- about / Diagnostics using preprocessor macros
- conforming iterators
- creating, for custom classes / Creating conforming iterators for custom classes
- congestion control / TCP
- ConstBufferSequence / Buffer sequences for vectored I/O
- containers, for allocated objects
- about / Containers for dynamically-allocated objects
- pointer containers / Ownership semantics of pointer containers
- containers, for multi-criteria lookups
- about / Containers for multi-criteria lookups
- copy constructor
- about / Copy semantics
- implementing / The nothrow swap
- Copy Elision
- about / xvalues
- copy operation
- defining / The nothrow swap
- copy semantics / Boost Container library
- about / Copy semantics, Move semantics and rvalue references
- counter filter
- using / Basic filters
- critical section
- about / Mutual exclusion and critical sections
- Curiously Recurring Template Parameter / Creating conforming iterators for custom classes
- custom tokenizer functions
- writing / Writing your own tokenizer functions
D
- data race
- about / Data races and atomic operations
- date and time calculations, with Boost Date_Time
- about / Date and time calculations with Boost Date Time
- dates, from Gregorian calendar / Dates from the Gregorian calendar
- Posix time / Posix time
- dates, from Gregorian calendar
- about / Dates from the Gregorian calendar
- date objects, creating / Creating date objects
- date durations, handling / Handling date durations
- date periods / Date periods
- Date_Time library
- about / Dates from the Gregorian calendar
- boost&&gregorian&&date / Dates from the Gregorian calendar
- boost&&gregorian&&date_duration / Dates from the Gregorian calendar
- boost&&posix_time&&ptime / Posix time
- boost&&posix_time&&time_duration / Posix time
- boost&&posix_time&&time_period / Posix time
- deadlock
- about / Deadlocks
- de facto / Flat associative containers
- DEFLATE algorithm / Filters for compression and decompression
- delegates
- about / Delegates and closures
- dequeue / Condition variables and producer-consumer problem
- device
- about / Architecture of Boost IOStreams, Using devices
- using / Using devices
- for file I/O / Devices for file I/O
- for reading and writing to memory / Devices for reading and writing to memory
- diagnostic macros
- using, from Predef library / Diagnostics using preprocessor macros
- disjunctions
- about / Disjunctions
- domain name
- about / Hostnames and domain names
- Domain Specific Embedded Languages
- about / Domain Specific Embedded Languages, Expression templates
- lazy evaluation / Lazy evaluation
- expression templates / Expression templates
- Boost Phoenix / Boost Phoenix
- Boost Spirit Parser Framework / Boost Spirit Parser Framework
- dual use filter
- about / Architecture of Boost IOStreams
- dynamic memory allocation
- about / Dynamic memory allocation and exception safety
- dynamic scoping
- about / Delegates and closures
E
- eager evaluation
- about / Lazy evaluation
- Embedded Domain Specific Language (EDSL)
- about / Expression templates
- enable_shared_from_this
- defining / A shared_ptr critique – make_shared and enable_shared_from_this
- endpoint
- about / Endpoints, sockets, and name resolution
- endpoint iterator / Name resolution
- enqueue / Condition variables and producer-consumer problem
- exception-handling improvements, C++11
- exceptions, storing / Storing and rethrowing exceptions
- exceptions, re-throwing / Storing and rethrowing exceptions
- exceptions, re-throwing with Boost / Storing and rethrowing exception using Boost
- exceptions, storing with Boost / Storing and rethrowing exception using Boost
- exception safety
- about / Dynamic memory allocation and exception safety
- and RAII / Exception safety and RAII
- Expat library
- URL / Optional packages
- explicit specialization / Branching
- expression templates
- about / Lazy evaluation, Expression templates
- Extended Backus-Naur Form (EBNF) / Boost Spirit Parser Framework
- extensible I/O, with Boost IOStreams
- about / Extensible I/O with Boost IOStreams
- devices, using / Using devices
- filters, using / Using filters
- extension / Breaking paths into components
F
- filename / Breaking paths into components
- files and directories, managing with Boost Filesystem
- about / Managing files and directories with Boost Filesystem
- paths, manipulating / Manipulating paths
- paths, printing / Printing paths
- paths, constructing / Constructing paths
- paths, breaking into components / Breaking paths into components
- directories, traversing / Traversing directories
- filesystem entries, querying / Querying filesystem entries
- operations, performing on files / Performing operations on files
- filter
- about / Architecture of Boost IOStreams
- filtering stream buffers / Using filters
- filters
- about / Using filters
- basic filters / Basic filters
- for compression and decompression / Filters for compression and decompression
- composing / Composing filters
- pipelining / Pipelining
- data streams, branching with tee / Branching data streams with tee
- find algorithms, Boost String Algorithms library
- find_first / find_first
- find_all / find_all
- find_token / find_token
- iter_find / iter_find
- find / find
- find_head / find_head and find_tail
- find_tail / find_head and find_tail
- algorithms, for testing string properties / Other algorithms for testing string properties
- fixed lock-acquisition order / Deadlocks
- flow control / TCP
- fully-qualified domain name
- about / Hostnames and domain names
- function objects
- about / Function objects
- lambdas / Lambdas – unnamed function literals
- delegates / Delegates and closures
- closures / Delegates and closures
- partial function application / Partial function application
- function pointer type / Delegates and closures
- function templates / Compile-time programming with Boost
- function type / Delegates and closures
- functor
- about / Function objects
G
- gather-scatter I/O / Buffer sequences for vectored I/O
- generic format / Printing paths
- GNU Compiler Collection (GCC) / Necessary software
- grep_filter
- using / Basic filters
- guarantees
- basic guarantee / Exception safety and RAII
- gzip compressor and decompressor
- using / Filters for compression and decompression
H
- handler / IO Service, queues, and handlers
- hash table / Flat associative containers
- heterogeneous values, of data
- about / Working with heterogeneous values
- storing / Working with heterogeneous values
- storing, Boost.Variant used / Boost.Variant
- storing, Boost.Any used / Boost.Any
- storing, Boost.Conversion used / Boost.Conversion
- higher-order programming, with Boost
- about / Higher order programming with Boost
- function objects / Function objects
- hostnames
- about / Hostnames and domain names
I
- I/O objects / Sockets
- I/O service object / Sockets
- ICU library
- URL / Optional packages
- iltering streams / Using filters
- img_rotate function
- about / Dynamic memory allocation and exception safety
- implicit destructor
- about / Copy semantics
- initializer list / stable_vector, Expressive initialization and assignment using Boost.Assign
- inorder traversal / Creating conforming iterators for custom classes
- input filter
- about / Architecture of Boost IOStreams
- input iterator / Traversing directories
- insert method / slist
- Interdomain Routing (CIDR) notation / Subnets
- Internet Assigned Numbers Authority (IANA) / Ports
- Internet Protocol / Network I/O using Asio
- intrusive_ptr
- using / Using intrusive_ptr
- IP addresses
- about / IP addresses
- IPv4 addresses / IPv4 addresses
- IPv6 addresses / IPv6 addresses
- IPv4 addresses
- about / IPv4 addresses
- subnets / Subnets
- special addresses / Special addresses
- handling, with Boost / Handling IPv4 addresses with Boost
- IPv6 addresses
- about / IPv6 addresses
- address classes / Address classes, scopes, and subnets
- unicast addresses / Address classes, scopes, and subnets
- multicast addresses / Address classes, scopes, and subnets
- anycast addresses / Address classes, scopes, and subnets
- subnets / Address classes, scopes, and subnets
- scopes / Address classes, scopes, and subnets
- scope / Address classes, scopes, and subnets
- node-local addresses / Address classes, scopes, and subnets
- global addresses / Address classes, scopes, and subnets
- link-local addresses / Address classes, scopes, and subnets
- special addresses / Special addresses
- loopback address / Special addresses
- unspecified address / Special addresses
- handling, with Boost / Handling IPv6 addresses with Boost
- iterator projections
- using / Index types
- itertools / Function Output Iterator
K
- Kleene star
- about / Quantifiers
L
- lambda expressions
- about / Lambdas – unnamed function literals
- lambdas
- about / Function objects, Lambdas – unnamed function literals
- using / Lambdas – unnamed function literals
- lambda introducers / Lambdas – unnamed function literals
- lambda captures / Lambda captures
- capture clauses, specifying / Lambda captures
- lazy evaluation
- about / Lazy evaluation, Expression templates
- lexical_cast function template
- using / lexical_cast
- liboost-all-dev package
- /usr/include / Installing on Linux
- /usr/lib/arch-linux-gnu / Installing on Linux
- library name components
- about / Library name components
- prefix / Library name components
- toolset identifier / Library name components
- threading model / Library name components
- ABI / Library name components
- version / Library name components
- extensions / Library name components
- library name layouts
- about / Library name layouts
- versioned layout / Versioned layout
- system layout / System layout
- tagged layout / Tagged layout
- library naming conventions
- about / Library naming conventions
- Linux
- Boost binary distribution, installing / Installing on Linux
- Boost libraries, building on / Building the Boost libraries on Linux
- Boost libraries, linking against / Linking against Boost libraries on Linux
- Linux toolchain
- about / Linux toolchain
- Listing 9.14 / Code examples
- lock-based thread synchronization methods
- about / Lock-based thread synchronization methods
- data races / Data races and atomic operations
- atomic operation / Data races and atomic operations
- mutual exclusion / Mutual exclusion and critical sections
- critical sections / Mutual exclusion and critical sections
- synchronizing, on conditions / Synchronizing on conditions
- Readers-Writers problem / The Readers-Writers problem
- Standard Library primitives / Standard Library primitives
- Lockable concept / boost::unique_lock
- lookups
- multimaps, used / Containers for multi-criteria lookups
- loopback address / Special addresses
- lvalue expression / rvalue references
- lvalue references / rvalue references
M
- make_shared
- defining / A shared_ptr critique – make_shared and enable_shared_from_this
- metafunction
- about / Writing generic code using tuples
- metafunction forwarding / Using MPL metafunctions
- metaprogramming library (MPL)
- about / Compile-time asserts
- move-construct / Boost Container library
- move assignment operator
- defining / Move assignment
- move constructible / Boost Container library
- move emulation
- Boost.Move library, used / Move emulation using Boost.Move
- multi-criteria lookups
- containers / Containers for multi-criteria lookups
- multi-index containers
- defining / Boost Multi-index containers
- Multiple Readers Single Writer (MRSW) model / The Readers-Writers problem
- MutableBufferSequence / Buffer sequences for vectored I/O
- mutex
- about / Mutual exclusion and critical sections
- using / Mutual exclusion and critical sections
- mutex object
- locked state / Mutual exclusion and critical sections
- unlocked state / Mutual exclusion and critical sections
N
- Named Return Value Optimization (NRVO)
- about / xvalues
- native format / Printing paths
- netmask / Subnets
- network I/O, using Asio
- about / Network I/O using Asio
- UDP / UDP and TCP, UDP
- TCP / UDP and TCP, TCP
- IP addresses / IP addresses
- endpoints / Endpoints, sockets, and name resolution
- ports / Ports
- sockets / Sockets
- hostnames / Hostnames and domain names
- domain names / Hostnames and domain names
- name resolution / Name resolution
- buffers / Buffers
- synchronous communication / Synchronous and asynchronous communications
- asynchronous communication / Synchronous and asynchronous communications
- Asio deadline timer / Asio deadline timer
- asynchronous logic, using Asio coroutines / Asynchronous logic using Asio coroutines
- non-capturing sub-expressions
- about / Sub-expressions
- nonmemory resources
- managing, smart pointers used / Managing non-memory resources using smart pointers
- nonstandard containers
- about / Nonstandard containers
- flat associative containers / Flat associative containers
- slist / slist
- slist, splicing operation / Splicing
- std**vector container / stable_vector
- std**vector container / stable_vector
- static_vector / static_vector
- normalized absolute path / Constructing paths
- nullary
- about / Function objects
- Null Object pattern
- URL / Null pointers in pointer containers
O
- operations, performing on files
- about / Performing operations on files
- directories, creating / Creating directories
- symbolic links, creating / Creating symbolic links
- files, copying / Copying files
- files, moving / Moving and deleting files
- files, deleting / Moving and deleting files
- path aware fstreams / Path-aware fstreams
- output filter
- about / Architecture of Boost IOStreams
P
- parent path / Breaking paths into components
- parser expressions
- about / Parser operators and expressions
- parser operators / Using Spirit Qi
- about / Parser operators and expressions
- parsing directives
- about / Parsing directives
- parsing timestamps
- about / Parsing timestamps
- partial function application
- about / Partial function application
- partial specializations / Branching
- passive endpoints / Synchronous and asynchronous communications
- Pimpl Idiom
- about / As a class member
- Pipable concept / Pipelining
- plain old data (POD)
- about / As a class member
- plain old data (POD) types
- about / Working with heterogeneous values
- pointer containers
- ownership semantics / Ownership semantics of pointer containers
- null pointers / Null pointers in pointer containers
- pointers
- versus Boost.Optional / Boost.Optional versus pointers
- poll member function / Handler states – run_one, poll, and poll_one
- poll_one member function / Handler states – run_one, poll, and poll_one
- ports
- about / Ports
- Posix time
- about / Posix time
- time points and durations, constructing / Constructing time points and durations
- resolution / Resolution
- time periods / Time periods
- time iterator / Time iterator
- predefined parsers / Predefined parsers
- Predef library
- about / Diagnostics using preprocessor macros
- diagnostic macros, using / Diagnostics using preprocessor macros
- predicate
- about / Function objects
- predicates
- about / Function objects
- preprocessor macros
- using / Diagnostics using preprocessor macros
- primary template / Branching
- producer-consumer problem
- about / Condition variables and producer-consumer problem
- program performance
- measuring, Boost timer used / Measuring program performance using Boost Timer
- cpu_timer / cpu_timer
- auto_cpu_timer / auto_cpu_timer
- pure function
- about / Function objects
Q
- Qi parsing API / Using Spirit Qi
- about / The parsing API
- quantifiers
- about / Quantifiers
R
- RAII
- about / Exception safety and RAII, RAII
- implementing / RAII
- range
- about / Text processing with Boost String Algorithms library
- range-based for-loops
- about / Range-based for-loops
- Boost.Foreach / Boost.Foreach
- range-based for loop syntax
- about / find_all
- range adaptors
- about / Case-conversion algorithms
- range declaration / Range-based for-loops
- range lookup
- using / Range lookups using lambda
- read-preferring solutions / Performance of shared_mutex
- Readers-Writers problem
- about / The Readers-Writers problem
- recursive variants
- defining / Defining recursive variants
- defining, in JSON format / The JSON format
- JSON content, representing / Representing JSON content with recursive variants
- visiting / Visiting recursive variants
- regular expressions
- Boost.Regex, using / Regular expressions using Boost.Regex
- syntax / Regular expression syntax
- parsing, with Boost.Regex / Using Boost.Regex to parse regular expressions
- regular expressions, syntax
- atoms / Atoms
- quantifiers / Quantifiers
- character class / Character classes
- anchors / Anchors
- sub-expressions / Sub-expressions
- disjunctions / Disjunctions
- relative path / Breaking paths into components
- replace and erase algorithms
- for text processing / The replace and erase algorithms
- Representation type parameter / Durations
- resolver / Name resolution
- Resource Acquisition Is Initialization (RAII) / boost::lock_guard
- Return Value Optimization (RVO)
- about / xvalues
- root directory / Breaking paths into components
- root name / Printing paths, Breaking paths into components
- root path / Breaking paths into components
- Rule of Three / Copy semantics
- Rule of Zero / Copy semantics
- run function / Handler states – run_one, poll, and poll_one
- Runtime Type Identification (RTTI)
- about / Boost.Any
- run_one member function / Handler states – run_one, poll, and poll_one
- rvalue / Move-awareness and in-place construction
- rvalue expressions / rvalue references
- rvalue references
- about / rvalue references
- overloads / rvalue-reference overloads
- move assignment / Move assignment
- xvalues / xvalues
S
- scoped_ptr
- uses / Uses of scoped_ptr
- about / Uses of scoped_ptr
- exception safe scopes, creating / Creating exception-safe scopes
- object ownership across functions, transferring / Transferring object ownership across functions
- using, as class member / As a class member
- semantic actions
- about / Semantic actions
- sequence expression / Range-based for-loops
- sequence of buffers / Buffer sequences for vectored I/O
- shallow copy / Copy semantics
- shared data, managing
- about / Managing shared data
- concurrent tasks, creating / Creating and coordinating concurrent tasks
- concurrent tasks, coordinating / Creating and coordinating concurrent tasks
- lock-based thread synchronization methods / Lock-based thread synchronization methods
- shared ownership semantics
- about / Shared ownership semantics
- boost$$shared_ptr, versus std$$shared_ptr / boost::shared_ptr and std::shared_ptr
- boost$$intrusive_ptr / Intrusive smart pointers – boost::intrusive_ptr
- shared_array / shared_array
- shared_array
- about / shared_array
- shared_mutex
- about / Performance of shared_mutex
- performance / Performance of shared_mutex
- shared_ptr
- uses / Uses of shared_ptr
- used, as class member / As a class member
- allocated objects, storing in Standard Library containers / Storing dynamically-allocated objects in Standard Library containers
- simple data structures
- creating, with Boost.Optional / Simple data structures
- creating, with Boost.Tuple / Simple data structures
- sink
- about / Architecture of Boost IOStreams
- smart pointer
- about / Smart pointers
- unique ownership semantics / Unique ownership semantics
- shared ownership semantics / Shared ownership semantics
- smart pointers
- used, for managing nonmemory resources / Managing non-memory resources using smart pointers
- socket
- about / Sockets
- source
- about / Architecture of Boost IOStreams
- Spirit Qi
- using / Using Spirit Qi
- predefined parsers / Predefined parsers
- parsing API / The parsing API
- parser operators / Parser operators and expressions
- parser expression / Parser operators and expressions
- parsing directives / Parsing directives
- semantic actions / Semantic actions
- rules / Rules
- parsing timestamps / Parsing timestamps
- split and join algorithms
- for text processing / The split and join algorithms
- standard associative containers
- ordered / Flat associative containers
- unordered / Flat associative containers
- Standard Library IOStreams facility
- about / Extensible I/O with Boost IOStreams
- Standard Template Library (STL)
- about / Working with heterogeneous values
- std$$shared_ptr
- versus boost$$shared_ptr / boost::shared_ptr and std::shared_ptr
- std$$unique_ptr
- defining / std::unique_ptr
- std$$weak_ptr
- versus boost$$weak_ptr / Nonowning aliases – boost::weak_ptr and std::weak_ptr
- strands
- using / Serialized and ordered execution via strands
- stream buffers
- about / Architecture of Boost IOStreams
- streams
- about / Architecture of Boost IOStreams
- strict weak ordering / Fast lookups using Boost Unordered containers
- sub-expressions
- about / Sub-expressions
- subnets / Subnets
- Substitution Failure Is Not An Error (SFINAE) / SFINAE and enable_if / disable_if
- swap member function
- implementing / The nothrow swap
- symmetric coroutines
- about / Boost Coroutine
- synchronous communication / Synchronous and asynchronous communications
- synchronous TCP client
- about / Synchronous TCP client and server
- synchronous TCP server
- about / Synchronous TCP client and server
- synchronous UDP client / Synchronous UDP client and server
- synchronous UDP server / Synchronous UDP client and server
- synthesized attribute
- about / Rules
- system layout
- about / System layout
T
- tagged layout
- about / Tagged layout
- task execution, with Asio
- about / Task execution with Asio
- IO Service / IO Service, queues, and handlers
- handlers / IO Service, queues, and handlers
- queues / IO Service, queues, and handlers
- handler states / Handler states – run_one, poll, and poll_one
- post, versus dispatch / post versus dispatch
- concurrent execution, via thread pools / Concurrent execution via thread pools
- io_service**work / io_service::work
- serialized and ordered execution, via strands / Serialized and ordered execution via strands
- TCP
- about / UDP and TCP, TCP
- connection, establishing / Establishing a TCP connection
- synchronous TCP client / Synchronous TCP client and server
- synchronous TCP server / Synchronous TCP client and server
- concurrency / Concurrency and performance
- performance / Concurrency and performance
- asynchronous TCP server / Asynchronous TCP server
- TCP 3-way handshake / Establishing a TCP connection
- TCP client / Establishing a TCP connection
- TCP connection
- client- and server-side calls / Client- and server-side calls
- TCP server / Establishing a TCP connection
- TCP socket
- about / Move semantics and rvalue references
- Technical Report 1 (TR1)
- about / A shared_ptr critique – make_shared and enable_shared_from_this
- tee device / Branching data streams with tee
- template identifier / Branching
- text processing
- with Boost String Algorithms library / Text processing with Boost String Algorithms library
- with case-conversion algorithms / Case-conversion and trimming algorithms, Case-conversion algorithms
- with trimming algorithms / Case-conversion and trimming algorithms, Trimming algorithms
- with replace and erase algorithms / The replace and erase algorithms
- with split and join algorithms / The split and join algorithms
- text splitting
- Boost Tokenizer library, using / Splitting text using the Boost Tokenizer library
- The Abrahams exception safety guarantees
- about / Exception safety and RAII
- thread group / Condition variables and producer-consumer problem
- thread pool / Concurrent execution via thread pools
- time calculations, with Chrono
- about / Using Chrono to measure time
- duration / Durations
- duration arithmetic / Duration arithmetic
- time point / Clocks and time points
- clocks / Clocks and time points
- token generator
- about / Writing your own tokenizer functions
- trimming algorithms
- for text processing / Trimming algorithms
- tuples
- creating / Creating tuples
- elements, accessing / Accessing tuple elements
- comparing / Comparing tuples
- generic code, writing / Writing generic code using tuples
U
- UDP
- about / UDP and TCP, UDP
- caveats / UDP and TCP
- synchronous UDP client / Synchronous UDP client and server
- synchronous UDP server / Synchronous UDP client and server
- asynchronous UDP server / Asynchronous UDP server
- asynchronous UDP server, using completion handler chains / Asynchronous UDP server using completion handler chains
- asynchronous UDP server, using coroutines / Asynchronous UDP server using coroutines
- performance / Performance and concurrency
- concurrency / Performance and concurrency
- unary
- about / Function objects
- uniform initialization / Expressive initialization and assignment using Boost.Assign
- unique ownership semantics
- about / Unique ownership semantics
- boost$$scoped_ptr / boost::scoped_ptr
- boost$$scoped_array / boost::scoped_array
- std$$unique_ptr / std::unique_ptr
- unique_ptr
- used, for ownership transfer / Ownership transfer using unique_ptr
- arrays, wrapping / Wrapping arrays in unique_ptr
- make_unique, in C++14 / make_unique in C++14
- universal assignment operator
- defining / Move assignment
- Unix time / Querying filesystem entries
- unspecified address / Special addresses
- unstable container / stable_vector
- upgradable locks / Upgradable locks
V
- vectored I/O / Buffer sequences for vectored I/O
- versioned layout
- about / Versioned layout
W
- wildcard
- about / Atoms
- Windows
- Boost binary distribution, installing / Installing on Windows
- Boost libraries, building on / Building the Boost libraries on Windows
- Boost libraries, linking against / Linking against Boost libraries on Windows
- Windows toolchain
- about / Windows toolchain
- write-preferring solutions / Performance of shared_mutex
X
- xvalues
- about / xvalues
Z
- Zlib library
- URL / Optional packages
