The ACE programmer's guide : practical design patterns for network and systems programming
Author(s)
Bibliographic Information
The ACE programmer's guide : practical design patterns for network and systems programming
Addison-Wesley, c2004
Available at 1 libraries
  Aomori
  Iwate
  Miyagi
  Akita
  Yamagata
  Fukushima
  Ibaraki
  Tochigi
  Gunma
  Saitama
  Chiba
  Tokyo
  Kanagawa
  Niigata
  Toyama
  Ishikawa
  Fukui
  Yamanashi
  Nagano
  Gifu
  Shizuoka
  Aichi
  Mie
  Shiga
  Kyoto
  Osaka
  Hyogo
  Nara
  Wakayama
  Tottori
  Shimane
  Okayama
  Hiroshima
  Yamaguchi
  Tokushima
  Kagawa
  Ehime
  Kochi
  Fukuoka
  Saga
  Nagasaki
  Kumamoto
  Oita
  Miyazaki
  Kagoshima
  Okinawa
  Korea
  China
  Thailand
  United Kingdom
  Germany
  Switzerland
  France
  Belgium
  Netherlands
  Sweden
  Norway
  United States of America
Note
"Foreword by Douglas C. Schmidt"--Cover
"Fingures 7.1, 7.2, 7.3, and 8.1 originally published: C++ network programming, Volume 2"--T.p. verso.
Includes bibliographical references (p. 479-480) and index
HTTP:URL=http://www.loc.gov/catdir/toc/ecip045/2003014046.html Information=Table of contents
Description and Table of Contents
Description
The ADAPTIVE Communication Environment (ACE) is an open-source toolkit for building high-performance networked applications and next-generation middleware. ACE's power and flexibility arise from object-oriented frameworks, used to achieve the systematic reuse of networked application software. ACE frameworks handle common network programming tasks and can be customized using C++ language features to produce complete distributed applications. This book will teach developers how they can use the ACE framework to develop their software. It will also show real-world uses of design patterns and C++. Benefits: Reduces the ACE learning curve, gain a clear understanding of how to use ACE to produce high-performance software using less time and effort; Provides a cookbook for solutions to common software engineering problems.
Table of Contents
Illustrations.
Tables.
Foreword.
Preface.
I. ACE BASICS.
1. Introduction to ACE.
A History of ACE.
ACE's Benefits.
ACE's Organization.
Patterns, Class Libraries, and Frameworks.
Porting Your Code to Multiple Operating Systems.
Smoothing the Differences among C++ Compilers.
Using Both Narrow and Wide Characters.
Where to Find More Information and Support.
Summary.
2. How to Build and Use ACE in Your Programs.
A Note about ACE Versions.
Guide to the ACE Distribution.
How to Build ACE.
How to Include ACE in Your Applications.
How to Build Your Applications.
Summary.
3. Using the ACE Logging Facility.
Basic Logging and Tracing.
Enabling and Disabling Logging Severities.
Customizing the ACE Logging Macros.
Redirecting Logging Output.
Using Callbacks.
The Logging Client and Server Daemons.
The LogManager Class.
Runtime Configuration with the ACE Logging Strategy.
Summary.
4. Collecting Runtime Information.
Command Line Arguments and ACE_Get_Opt.
Accessing Configuration Information.
Building Argument Vectors.
Summary.
5. ACE Containers.
Container Concepts.
Sequence Containers.
Associative Containers.
Allocators.
Summary.
II. INTERPROCESS COMMUNICATION.
6. Basic TCP/IP Socket Use.
A Simple Client.
Adding Robustness to a Client.
Building a Server.
Summary.
7. Handling Events and Multiple I/O Streams.
Overview of the Reactor Framework.
Handling Multiple I/O Sources.
Signals.
Notifications.
Timers.
Using the Acceptor-Connector Framework.
Reactor Implementations.
Summary.
8. Asynchronous I/O and the ACE Proactor Framework.
Why Use Asynchronous I/O?.
How to Send and Receive Data.
Establishing Connections.
The ACE_Proactor Completion Demultiplexer.
Using Timers.
Other I/O Factory Classes.
Combining the Reactor and Proactor Frameworks.
Summary.
9. Other IPC Types.
Interhost IPC with UDP/IP.
Intrahost Communication.
Summary.
III. PROCESS AND THREAD MANAGEMENT.
10. Process Management.
Spawning a New Process.
Using the ACE_Process_Manager.
Synchronization Using ACE_Process_Mutex.
Summary.
11. Signals.
Using Wrappers.
Event Handlers.
Guarding Critical Sections.
Signal Management with the Reactor.
Summary.
12. Basic Multithreaded Programming.
Getting Started.
Basic Thread Safety.
Intertask Communication.
Summary.
13. Thread Management.
Types of Threads.
Priorities and Scheduling Classes.
Thread Pools.
Thread Management Using ACE_Thread_Manager.
Signals.
Thread Start-Up Hooks.
Cancellation.
Summary.
14. Thread Safety and Synchronization.
Protection Primitives.
Thread Synchronization.
Thread-Specific Storage.
Summary.
15. Active Objects.
The Pattern.
Using the Pattern.
Summary.
16. Thread Pools.
Understanding Thread Pools.
Half-Sync/Half-Async Model.
Leader/Followers Model.
Thread Pools and the Reactor.
Summary.
IV. ADVANCED ACE.
17. Shared Memory.
ACE_Malloc and ACE_Allocator.
Persistence with ACE_Malloc.
Position-Independent Allocation.
ACE_Malloc for Containers.
Wrappers.
Summary.
18. ACE Streams Framework.
Overview.
Using a One-Way Stream.
A Bidirectional Stream.
Summary.
19. ACE Service Configurator Framework.
Overview.
Configuring Static Services.
Setting Up Dynamic Services.
Setting Up Streams.
Reconfiguring Services During Execution.
Using XML to Configure Services and Streams.
Configuring Services without svc.conf.
Singletons and Services.
Summary.
20. Timers.
Timer Concepts.
Timer Queues.
Prebuilt Dispatchers.
Managing Event Handlers.
Summary.
21. ACE Naming Service.
The ACE_Naming_Context.
A Single-Process Naming Context: PROC_LOCAL.
Sharing a Naming Context on One Node: NODE_LOCAL.
Sharing a Naming Context across the Network: NET_LOCAL.
Summary.
Bibliography.
Index. 0201699710T11042003
by "Nielsen BookData"