C++ Reactive Programming: Design concurrent and asynchronous applications using the RxCpp library and Modern C++17

Cover
Title Page
Copyright and Credits
Packt Upsell
Contributors
Table of Contents
Preface
Chapter 1: Reactive Programming Model – Overview and History
	Event-driven programming model
		Event-driven programming on X Windows
		Event-driven programming on Microsoft Windows
		Event-driven programming under Qt
		Event-driven programming under MFC
		Other event-driven programming models
		Limitations of classical event processing models
	Reactive programming model
	Functional reactive programming
	The key interfaces of a reactive program
	Pull-versus push-based reactive programming
		The IEnumerable/IObservable duality
	Converting events to IObservable
	The philosophy of our book
	Summary
Chapter 2: A Tour of Modern C++ and its Key Idioms
	The key concerns of the C++ programming language
		Zero cost abstraction
		Expressivity
		Substitutability
	Enhancements to C++ for writing better code
		Type deduction and inference
		Uniform initialization of variables
		Variadic templates
		Rvalue references 
		Move semantics
		Smart pointers
		Lambda functions
		Functors and Lambdas
		Composition, currying, and partial function application
		Function wrappers
	Composing functions together with the pipe operator
	Miscellaneous features
		Fold expressions
		Variant type
		Other important topics
	Range-based for loops and observables
	Summary
Chapter 3: Language-Level Concurrency and Parallelism in C++
	What is concurrency?
	Hello World of concurrency (using std::thread)
	Managing threads
		Thread launch
		Thread join
		Passing arguments into a thread
	Using Lambdas
		Ownership management
	Sharing data between threads
		Mutexes
		Avoiding deadlock
		Locking with std::unique_lock
		Condition variables
	A thread-safe stack data structure
	Summary
Chapter 4: Asynchronous and Lock-Free Programming in C++
	Task-based parallelism in C++
		Future and promise
		std::packaged_task
		std::async
	C++ memory model
	Memory access and concurrency
	The modification contract
	Atomic operations and types in C++
	Atomic types
		std::atomic_flag
		std::atomic
			Standard atomic integral types
		std::atomic – pointer arithmetic
		std::atomic<> primary class template
	Memory ordering
		Sequential consistency
		Acquire-release ordering
		Relaxed ordering
	A lock-free data structure  queue
	Summary
Chapter 5: Introduction to Observables
	The GoF Observer pattern
	The limitations of the GoF Observer pattern
	A holistic look at GoF patterns
	The OOP programming model and hierarchies
	A Composite/Visitor pattern for expression processing
	Flattening the composite for iterative processing
	Map and filter operations on the list
	Reversing the gaze for Observables!
	Summary
Chapter 6: Introduction to Event Stream Programming Using C++
	What is Stream programming model?
		Advantages of the Stream programming model
	Applied Stream programming using the Streams library
	Lazy evaluation
		A simple Stream program
		Aggregating values using the Stream paradigm
		The STL and the Stream paradigm
		A word about the Streams library
	Event Stream programming
		Advantages of Event Stream programming
		The Streamulus library and its programming model
			The Streamulus library – a peek into its internals
			The Streamulus Library – a look into expression processing
		The spreadsheet Library — a change-propagation engine
		RaftLib – another Stream-processing library
		What do these things have to do with Rx programming?
	Summary
Chapter 7: Introduction to Data Flow Computation and the RxCpp Library
	The data flow computation paradigm
	An introduction to the RxCpp library
		The RxCpp library and its programming model
		A simple Observable/Observer interaction
		Filters and Transformations with Observables
		Streaming values from C++ containers
	Creating Observables from the scratch
		Concatenating Observable Streams
		Unsubscribing from Observable Streams
	An introduction to marble diagrams for visual representation
	RxCpp (Stream) Operators
		The average Operator
		The Scan Operator
		Composing Operators through the pipe Operator
		Working with Schedulers
		A tale of two Operators – flatmap versus concatmap
		Other Important Operators
	A peek into the things we haven't covered yet
	Summary
Chapter 8: RxCpp – the Key Elements
	Observables
		What's a Producer?
		Hot versus Cold Observables
		Hot Observables
		Hot Observables and the replay mechanism
	Observers and their variants (Subscribers)
	Subjects
	Schedulers
		ObserveOn versus SubscribeOn
		The RunLoop Scheduler
	Operators
		Creational Operators
		Transformation Operators
		Filtering Operators
		Combining Operators
		Error-handling Operators
		Observable utility Operators
		Conditional and Boolean Operators
		Mathematical and Aggregate operators
		Connectable Observable Operators
	Summary
Chapter 9: Reactive GUI Programming Using Qt/C++
	A quick introduction to Qt GUI programming
		Qt object model
		Signals and slots
		Event system
		Event handlers
		Sending events
		Meta-object system
	Hello World – Qt program
	Qt event model with signals/slots/MOC – an example
		Creating a custom widget
		Creating the application dialog
		Executing the application
	Integrating the RxCpp library with the Qt event model
		Qt event filter – a reactive approach
		Creating the window – setting layouts and alignments
		Event type specific observables
		An introduction to RxQt
	Summary
Chapter 10: Creating Custom Operators in RxCpp
	Philosophy of Rx operators
	Chaining stock operators
	Writing basic RxCpp custom operators
		Writing an RxCpp operator as a function
		Writing an RxCpp operator as a Lambda
		Composing custom RxCpp operators
	Different genres of custom operators
		Writing a custom creational operator
		Writing a custom transformation operator
		Writing a custom operator that involves Schedulers
	Writing custom operators that can be chained
		Using the lift operator to write a custom operator
		Converting an arbitrary Lambda to a custom Rx operator
		Creating a custom RxCpp operator in the library
	Summary
Chapter 11: Design Patterns and Idioms for C++ Rx Programming
	The OOP and Design patterns movement
	Key Pattern catalogs
		The GOF catalog
		The POSA catalog
	The Design pattern redux
	From Design patterns to Reactive programming
		Flattening the hierarchy to navigate through it
		From Iterators to Observables
	The Cell pattern
	The Active object pattern
	The Resource Loan pattern
	The Event bus pattern
	Summary
Chapter 12: Reactive Microservices Using C++
	The C++ language and web programming
		The REST programming model
	The C++ REST SDK
		HTTP client programming using the C++ REST SDK
		HTTP server programming using the C++ REST SDK
	Testing the HTTP server using CURL and POSTMAN
		The libcurl and the HTTP client programming
		Kirk Shoop's libCURL Wrapper library
	The JSON and HTTP protocol
	The C++ REST SDK-based REST server
	Invoking REST services using the RxCurl library
	A word about the Reactive micro-services architecture
		Fine-grained services
		Polyglot persistence
		Independent deployment
		Service orchestration and choreography
		Reactive web service call
	Summary
Chapter 13: Advanced Streams and Handling Errors
	A short recap of the characteristics of a reactive system
	RxCpp error and exception handling Operators
		Executing an action on an error
		Resuming when an error occurs
		Retry when an error occurs
		Cleanup with the finally() Operator
	Schedulers and error handling
	Event-based Stream handling – some examples
		Aggregation based on Stream data
		Application event handling example
	Summary
Other Books You May Enjoy
Index