Index
A
- Abstract Syntax Tree (AST) / The OOP programming model and hierarchies
- acquire-release ordering / Acquire-release ordering
- Active object pattern / The Active object pattern
- ActiveX Template Library (ATL) / Event-driven programming under MFC
- aggregate operator / Mathematical and Aggregate operators
- Applicative-order evaluation (AO) / Lazy evaluation
- applied stream programming
- Streams library, using / Applied Stream programming using the Streams library
- arbitrary Lambda
- converting, to custom Rx operator / Converting an arbitrary Lambda to a custom Rx operator
- atomic operations
- about / Atomic operations and types in C++
- store operations / Atomic types
- load operations / Atomic types
- read-modify-write operations / Atomic types
- atomic types
- about / Atomic operations and types in C++, Atomic types
- atomic_flag / std::atomic_flag
- atomic / std::atomic<bool>
- standard atomic integral types / Standard atomic integral types
- pointer arithmetic / std::atomic<T*> – pointer arithmetic
- primary class template / std::atomic<> primary class template
C
- C++ containers
- values, streaming from / Streaming values from C++ containers
- C++ language
- web programming / The C++ language and web programming
- C++ programming language
- concerns / The key concerns of the C++ programming language
- zero cost abstraction / Zero cost abstraction
- expressivity / Expressivity
- substitutability / Substitutability
- enhancements, for writing better code / Enhancements to C++ for writing better code
- type deduction / Type deduction and inference
- inference / Type deduction and inference
- variables, uniform initialization / Uniform initialization of variables
- variadic templates / Variadic templates
- RValue references / Rvalue references
- semantics / Move semantics
- pointers / Smart pointers
- lambda functions / Lambda functions
- lambdas / Functors and Lambdas
- functors / Functors and Lambdas
- composition / Composition, currying, and partial function application
- currying / Composition, currying, and partial function application
- partial function application / Composition, currying, and partial function application
- function wrappers / Function wrappers
- C++ REST SDK
- about / The C++ REST SDK
- used, for HTTP client programming / HTTP client programming using the C++ REST SDK
- used, for HTTP Server programming / HTTP server programming using the C++ REST SDK
- C++ REST SDK-based REST Server / The C++ REST SDK-based REST server
- cell pattern / The Cell pattern
- compare-and-swap (CAS) / std::atomic<bool>
- Composite pattern
- used, for expression processing / A Composite/Visitor pattern for expression processing
- concept / The GoF Observer pattern
- concurrency
- about / What is concurrency?
- Hello World example / Hello World of concurrency (using std::thread)
- and memory access / Memory access and concurrency
- condition variables / Condition variables
- Connectable Observable operators / Connectable Observable Operators
- creational operators / Creational Operators
- CURL
- used, for testing HTTP server / Testing the HTTP server using CURL and POSTMAN
- custom operators
- genres / Different genres of custom operators
- custom creational operator, writing / Writing a custom creational operator
- custom transformation operator, writing / Writing a custom transformation operator
- with schedulers, writing / Writing a custom operator that involves Schedulers
- implementing, for chaining together / Writing custom operators that can be chained
- writing, lift operator used / Using the lift<t> operator to write a custom operator
- custom RxCpp operator
- creating, in library / Creating a custom RxCpp operator in the library
- custom Rx operator
- arbitrary Lambda, converting / Converting an arbitrary Lambda to a custom Rx operator
D
- data flow computation paradigm / The data flow computation paradigm
- deadlock
- avoiding / Avoiding deadlock
- design pattern redux / The Design pattern redux
- design patterns
- migrating, to reactive programming / From Design patterns to Reactive programming
- hierarchy, flattening / Flattening the hierarchy to navigate through it
- Domain Specific Embedded Language (DSEL) / The philosophy of our book, The Streamulus library and its programming model
- double dispatch / From Design patterns to Reactive programming
E
- error handling / Schedulers and error handling
- event-based Stream handling
- about / Event-based Stream handling – some examples
- aggregation, based on Stream data / Aggregation based on Stream data
- application event handling, example / Application event handling example
- event-driven programming model
- about / Event-driven programming model
- on X Windows / Event-driven programming on X Windows
- on Microsoft Windows / Event-driven programming on Microsoft Windows
- with Qt / Event-driven programming under Qt
- MFC / Event-driven programming under MFC
- alternatives / Other event-driven programming models
- limitations / Limitations of classical event processing models
- Event bus pattern
- producers / The Event bus pattern
- consumers / The Event bus pattern
- controllers / The Event bus pattern
- about / The Event bus pattern
- event filter
- Event Stream programming
- about / Event Stream programming
- advantages / Advantages of Event Stream programming
- Streamulus library / The Streamulus library and its programming model, The Streamulus library – a peek into its internals, The Streamulus Library – a look into expression processing
- spreadsheet Library / The spreadsheet Library — a change-propagation engine
- RaftLib / RaftLib – another Stream-processing library
- Rx programming / What do these things have to do with Rx programming?
- exception handling operators
- about / RxCpp error and exception handling Operators
- action, executing on error / Executing an action on an error
- resuming, on error occurrence / Resuming when an error occurs
- retry option / Retry when an error occurs
- cleaning up, with finally() operator / Cleanup with the finally() Operator
F
- features, C++ 17
- about / Miscellaneous features
- fold expressions / Fold expressions
- variant type / Variant type
- filter operation
- applying, on list / Map and filter operations on the list
- functional reactive programming (FRP) / Functional reactive programming
- functions
- composing, with pipe operator / Composing functions together with the pipe operator
- future / Future and promise
G
- Gang of Four (GoF) / The GOF catalog
- GoF Observer pattern
H
- hierarchy
- hot Observables
- versus cold Observables / Hot versus Cold Observables
- replay mechanism / Hot Observables and the replay mechanism
- about / Aggregation based on Stream data
- HTTP protocol / The JSON and HTTP protocol
- HTTP server
- testing, with CURL / Testing the HTTP server using CURL and POSTMAN
- testing, with POSTMAN / Testing the HTTP server using CURL and POSTMAN
- LibCurl / The libcurl and the HTTP client programming
- HTTP client programming / The libcurl and the HTTP client programming
- CURL Wrapper library, Kirk Shoop / Kirk Shoop's libCURL Wrapper library
I
- IObservable
- events, converting / Converting events to IObservable<T>
- iterative processing
- composite, flattening / Flattening the composite for iterative processing
- iterator pattern
- migrating, to observables / From Iterators to Observables
J
- JavaScript Object Notation (JSON) / The REST programming model, The JSON and HTTP protocol
L
- Lambda function
- using / Using Lambdas
- ownership management / Ownership management
- lazy evaluation
- about / Lazy evaluation
- Stream program / A simple Stream program
- values, aggregating with stream paradigm / Aggregating values using the Stream paradigm
- STL / The STL and the Stream paradigm
- Streams library / A word about the Streams library
- linearizability
- lock-free data structure / A lock-free data structure queue
M
- map operation
- applying, on list / Map and filter operations on the list
- marble diagrams
- using, for representation / An introduction to marble diagrams for visual representation
- mathematical operator / Mathematical and Aggregate operators
- memory access / Memory access and concurrency
- memory model / C++ memory model
- memory ordering
- about / Memory ordering
- categories / Memory ordering
- sequential consistency / Sequential consistency
- acquire-release ordering / Acquire-release ordering
- relaxed ordering / Relaxed ordering
- Meta Object Compiler (MOC) / Event-driven programming under Qt, Qt object model
- modification contract / The modification contract
- modification order consistency / Relaxed ordering
- mutexes / Mutexes
N
- Normal-order evaluation (NO) / Lazy evaluation
O
- Object Oriented Programming (OOP) / The OOP programming model and hierarchies, The OOP and Design patterns movement
- Observables
- reversing / Reversing the gaze for Observables!
- transformation, using with / Filters and Transformations with Observables
- transformations / Filters and Transformations with Observables
- creating, from scratch / Creating Observables from the scratch
- Streams, concatenation / Concatenating Observable Streams
- Streams, unsubscribing / Unsubscribing from Observable Streams
- about / Observables
- producer / What's a Producer?
- hot Observables, versus cold Observables / Hot versus Cold Observables
- hot observables / Hot Observables
- hot Observables, replay mechanism / Hot Observables and the replay mechanism
- Observable Utility Operators / Observable utility Operators
- operators
- about / Operators
- creational operators / Creational Operators
- filtering / Filtering Operators
- combining / Combining Operators
- error-handling operators / Error-handling Operators
- Observable Utility Operators / Observable utility Operators
- conditional operators / Conditional and Boolean Operators
- boolean operators / Conditional and Boolean Operators
- aggregate operators / Mathematical and Aggregate operators
- mathematical operators / Mathematical and Aggregate operators
- Connectable Observable operators / Connectable Observable Operators
P
- pattern catalogs
- GOF patterns / The GOF catalog
- POSA catalog / The POSA catalog
- Patterns of Software Architecture (POSA) / The POSA catalog
- pipe operator
- functions, composing / Composing functions together with the pipe operator
- pointer arithmetic / std::atomic<T*> – pointer arithmetic
- Polyglot programming / Polyglot persistence
- POSTMAN
- used, for testing HTTP server / Testing the HTTP server using CURL and POSTMAN
- primary class template / std::atomic<> primary class template
- producers / What's a Producer?
- promise / Future and promise
- pull method / The Design pattern redux
- push-based reactive program
- versus pull-based reactive program / Pull-versus push-based reactive programming
- IEnumerable/IObservable duality / The IEnumerable/IObservable duality
Q
- Qt
- URL / Hello World – Qt program
- Qt event model
- with signals / Qt event model with signals/slots/MOC – an example
- with MOC / Qt event model with signals/slots/MOC – an example
- custom widget, creating / Creating a custom widget
- application dialog, creating / Creating the application dialog
- application, executing / Executing the application
- RxCpp library, integrating / Integrating the RxCpp library with the Qt event model
- event filter / Qt event filter – a reactive approach
- window, creating / Creating the window – setting layouts and alignments
- event type specific observables / Event type specific observables
- RxQt library / An introduction to RxQt
- Qt GUI programming
- about / A quick introduction to Qt GUI programming
- Qt object model / Qt object model
- signals and slots / Signals and slots
- event system / Event system
- event handlers / Event handlers
- meta-object system / Meta-object system
- Qt object model
- features / Qt object model
- Qt program / Hello World – Qt program
R
- race condition / Sharing data between threads
- RaftLib
- range-based
- implementing, for loops / Range-based for loops and observables
- implementing, for observables / Range-based for loops and observables
- reactive manifesto
- Reactive Microservices Architecture
- about / A word about the Reactive micro-services architecture
- fine-grained services / Fine-grained services
- Polyglot persistence / Polyglot persistence
- independent deployment / Independent deployment
- service orchestration / Service orchestration and choreography
- web service call / Reactive web service call
- reactive program
- interfaces / The key interfaces of a reactive program
- reactive programming model / Reactive programming model
- reactive system
- relaxed ordering / Relaxed ordering
- Resource Acquisition Is Initialization (RAII)
- Resource Loan pattern / The Resource Loan pattern
- REST programming model / The REST programming model
- Reverse Polish Notation (RPN) form / A Composite/Visitor pattern for expression processing
- RxCpp (Stream) operators
- about / RxCpp (Stream) Operators
- average Operator / The average Operator
- Scan Operator / The Scan Operator
- composing, through pipe operator / Composing Operators through the pipe Operator
- Schedulers, working with / Working with Schedulers
- flat map, versus concat map / A tale of two Operators – flatmap versus concatmap
- other operators / Other Important Operators
- RxCpp custom operators
- writing / Writing basic RxCpp custom operators
- writing, as function / Writing an RxCpp operator as a function
- writing, as Lambda / Writing an RxCpp operator as a Lambda
- composing / Composing custom RxCpp operators
- RxCpp error / RxCpp error and exception handling Operators
- RxCpp library
- about / An introduction to the RxCpp library
- URL / An introduction to the RxCpp library
- programming model / The RxCpp library and its programming model
- Observable/Observer interaction / A simple Observable/Observer interaction
- filters, with Observables / Filters and Transformations with Observables
- transformations, with Observables / Filters and Transformations with Observables
- integrating, with Qt event model / Integrating the RxCpp library with the Qt event model
- RxCurl library
- used, for invoking REST services / Invoking REST services using the RxCurl library
- Rx operators
- philosophy / Philosophy of Rx operators
- RxQt library / An introduction to RxQt
S
- schedulers
- about / Schedulers, Schedulers and error handling
- ObserveOn, versus SubscribeOn / ObserveOn versus SubscribeOn
- RunLoop scheduler / The RunLoop Scheduler
- sequential consistency / Sequential consistency
- signals and slots
- about / Signals and slots
- URL / Signals and slots
- spurious failure / std::atomic<bool>
- standard template library (STL) / Applied Stream programming using the Streams library
- stock operators
- chaining / Chaining stock operators
- stream programming model
- about / What is Stream programming model?
- advantages / Advantages of the Stream programming model
- subjects / Subjects
- subscribers / Observers and their variants (Subscribers)
T
- task-based parallelism
- about / Task-based parallelism in C++
- future / Future and promise
- promise / Future and promise
- packaged_task / std::packaged_task
- async, using / std::async
- task continuation / HTTP client programming using the C++ REST SDK
- thread-safe stack data structure / A thread-safe stack data structure
- threads
- managing / Managing threads
- launching / Thread launch
- join() / Thread join
- arguments, passing / Passing arguments into a thread
- data, sharing between / Sharing data between threads
- mutexes / Mutexes
- deadlock, avoiding / Avoiding deadlock
- unique_lock, used for locking / Locking with std::unique_lock
- condition variables / Condition variables
- transformation operators / Transformation Operators
U
- user-defined type (UDT) / std::atomic<> primary class template
V
- visitor pattern
- used, for expression processing / A Composite/Visitor pattern for expression processing
W
- web programming
- REST programming model / The REST programming model