C++ Reactive Programming
Praseed Pai Peter Abraham更新时间：2021-06-18 19:06:01
最新章节：Leave a review - let other readers know what you think封面
版权信息
Packt Upsell
Why subscribe?
PacktPub.com
Contributors
About the authors
About the reviewer
Packt is searching for authors like you
Preface
Who this book is for
What this book covers
To get the most out of this book
Download the example code files
Download the color images
Conventions used
Get in touch
Reviews
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<T>
The philosophy of our book
Summary
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
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
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<bool>
Standard atomic integral types
std::atomic<T*> – pointer arithmetic
std::atomic<> primary class template
Memory ordering
Sequential consistency
Acquire-release ordering
Relaxed ordering
A lock-free data structure queue
Summary
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
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
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
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
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
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<t> operator to write a custom operator
Converting an arbitrary Lambda to a custom Rx operator
Creating a custom RxCpp operator in the library
Summary
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
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
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
Leave a review - let other readers know what you think
更新时间：2021-06-18 19:06:01