Catalogue


Advanced CORBA programming with C++ /
Michi Henning, Steve Vinoski.
imprint
Reading, Mass. : Addison-Wesley, c1999.
description
xxii, 1083 p. : ill. ; 24 cm.
ISBN
0201379279 (pbk. : alk. paper)
format(s)
Book
Holdings
More Details
added author
imprint
Reading, Mass. : Addison-Wesley, c1999.
isbn
0201379279 (pbk. : alk. paper)
catalogue key
2844362
 
Includes bibliographical references (p. 1035-1042) and index.
A Look Inside
About the Author
Author Affiliation
Michi Henning is the founder of Triodia Technologies in Brisbane, Australia, where he spends much of his time providing CORBA consulting and training to international customers. He has contributed to a number of OMG specifications, and is involved in ongoing CORBA-related research. Michi is also a member of the OMG's Core and C++ Revision Task Forces. Steve Vinoski is chief architect for IONA Technologies, Inc., where he guides the development of advanced CORBA-based products. He frequently presents CORBA C++ tutorials at technical conferences around the globe. In addition, Steve has coauthored several important OMG specifications, and is the chair of the OMG's C++ Revision Task Force.
Excerpts
Introduction or Preface
For years, both of us have been (and still are) teaching CORBA programming with C++ to software engineers all over the world. One of the most frequently asked questions in our courses is, ''''Where can I find a book that covers all this?'''' Although many books have been written about CORBA, most of them focus on high-level concepts and do not address the needs of software engineers. Even though CORBA is conceptually simple, the devil lies in the detail. Or, more bluntly, books focusing on high-level concepts are of little use when you must find out why your program is dumping core. To be sure, there are resources available about CORBA, such as newsgroups, Web pages, and the Object Management Group (OMG) specifications. However, none of them really meets the needs of a programmer who must get the code to work (and preferably by yesterday). We wrote this book so that there would finally be a tutorial and reference that covers CORBA programming with C++ at the level of detail required for real-life software development. (And, of course, we wrote it so that we would have a good answer for our students.) Writing such a book is a tall order. Explaining the CORBA specification and APIs is one thing, and it''s a necessary part of the book. However, knowing the various APIs will not, by itself, make you a competent programmer (only a knowledgeable one). To be competent, you need not only knowledge of the mechanics of the platform but also an understanding of how the different features interact. You must combine them effectively to end up with an application that performs and scales well and is maintainable, extensible, portable, and deployable. To help you become competent (as opposed to merely knowledgeable), we go beyond the basics in a number of ways. For one thing, we provide advice as to what we consider good (and bad) design, and we make no attempt to hide problems with CORBA (which, like any other complex software system, has its share of wrinkles). Second, we go beyond the APIs by explaining some of CORBA''s internal mechanisms. Even though you can use an ORB without knowing what goes on under the hood, it is useful to understand these mechanisms because they have a profound influence on how well (or how poorly) an application will perform. Third, we devote considerable space to a discussion of the merits of various design decisions; typically, when a design provides a gain in one area it also involves a loss in another. Understanding these trade-offs is crucial to building successful applications. And fourth, where appropriate, we make recommendations so that you are not left without guidance. Inevitably, our approach required us to make value judgments, and, just as inevitably, a number of people will disagree with at least some of the recommendations we make. Whether you agree or disagree with us, you should still profit from our approach: if you agree, you can stick to the advice we give; if you disagree, the discussion will have at least encouraged you to think about the topic and form your own opinion. Either way, you are better off than you would be with a book that just dumps the facts on you without providing the deeper insight required to use them. Prerequisites This book is not a beginner''s book, in the sense that we do not devote much space to explaining the structure of the OMG or the pecification adoption process. We also do not provide a high-level overview of the architectural goals of CORBA or all its services and facilities (see 31 for a high-level overview). Instead, we assume that you want to know how to write real CORBA applications with C++. Despite the lack of overview material, you should be able to follow the material even if you have never seen CORBA before. If you have experience in network programming or have used another RPC platform, you will find it easy to pick things up as you go. Much of this book consists of source code, so we expect you to be literate in C++. However, you do not need to be a C++ guru to follow the code. We have avoided obscure or little-understood features of C++, preferring clarity to cleverness. If you understand inheritance, virtual functions, operator overloading, and templates (not necessarily in intricate detail), you will have no problems. Some of the source code uses the Standard Template Library (STL), which is now part of the ISO/IEC C++ Standard. We have limited ourselves to very simple uses of this library, so you should be able to understand the source code even if you have never seen STL code before. If you have never written threaded code, you will find the chapter on writing threaded servers tough going. Unfortunately, there was not enough room to provide an introduction to programming with threads. However, the Bibliography lists a number of excellent books on the topic. Despite our best efforts to show realistic and working source code, we had to make a number of compromises to keep code examples understandable and of manageable size. When we demonstrate a particular feature, we often use straightline code, whereas in a realistic application the code would better be encapsulated in a class or helper function. We have also minimized error handling to avoid obscuring the flow of control with lots of exception handlers. We chose this approach for didactic purposes; it does not imply that the code pretends to reflect best possible engineering practice. (The Bibliography lists a number of excellent books that cover source code design in great detail.) Scope of this Book OMG members are continually improving CORBA and adding new features. As a result, available ORB implementations conform to different revision levels of the specification. This book covers CORBA 2.3. (At the time of writing, CORBA 2.3 is being finalized by the OMG.) Throughout the text, we indicate new features that may not yet be available in your ORB implementation; this allows you to restrict yourself to an earlier feature set for maximum portability. Despite its size, our main regret is that this book is too short. Ever-increasing page counts and ever-closer deadlines forced us to drop chapters on the Dynamic Invocation Interface (DII), the Dynamic Skeleton Interface (DSI), and the Interface Repository (IFR). Fortunately, the vast majority of applications do not need those features, so dropping these chapters is not much of a loss. If your application happens to require the dynamic interfaces, the background we provide here will enable you to easily pick up what you need from the CORBA specification. Another feature notable by its absence is Objects-By-Value (OBV). We chose not to cover OBV because it is too new for anyone to have any substantial engineering experience with it. In addition, at the time of writing, there are still a number of technical wrinkles to be ironed out and we expect the OBV specification to undergo further changes before it settles down. Size and time limitations also meant that we could not cover every possible CORBA service. For example, we did not cover the Transaction Service or Security Service because each of them would require a book of its own. Rather than being complete, we have restricted ourselves to those services that are most essential for building applications: the Naming, Trading, and Event Services. We cover those services in more detail than any other publication we are aware of. An important part of this book is the presentation of the Portable Object Adapter (POA), which was added in CORBA 2.2. The POA provides the server-side source code portability that was missing from the (now deprecated) Basic Object Adapter. The POA also provides a number of features that are essential for building high-performance and scalable applications. We have therefore paid particular attention to showing
Introduction or Preface
For years, both of us have been (and still are) teaching CORBA programming with C++ to software engineers all over the world. One of the most frequently asked questions in our courses is, ''Where can I find a book that covers all this?'' Although many books have been written about CORBA, most of them focus on high-level concepts and do not address the needs of software engineers. Even though CORBA is conceptually simple, the devil lies in the detail. Or, more bluntly, books focusing on high-level concepts are of little use when you must find out why your program is dumping core. To be sure, there are resources available about CORBA, such as newsgroups, Web pages, and the Object Management Group (OMG) specifications. However, none of them really meets the needs of a programmer who must get the code to work (and preferably by yesterday). We wrote this book so that there would finally be a tutorial and reference that covers CORBA programming with C++ at the level of detail required for real-life software development. (And, of course, we wrote it so that we would have a good answer for our students.) Writing such a book is a tall order. Explaining the CORBA specification and APIs is one thing, and it's a necessary part of the book. However, knowing the various APIs will not, by itself, make you a competent programmer (only a knowledgeable one). To be competent, you need not only knowledge of the mechanics of the platform but also an understanding of how the different features interact. You must combine them effectively to end up with an application that performs and scales well and is maintainable, extensible, portable, and deployable. To help you become competent (as opposed to merely knowledgeable), we go beyond the basics in a number of ways. For one thing, we provide advice as to what we consider good (and bad) design, and we make no attempt to hide problems with CORBA (which, like any other complex software system, has its share of wrinkles). Second, we go beyond the APIs by explaining some of CORBA's internal mechanisms. Even though you can use an ORB without knowing what goes on under the hood, it is useful to understand these mechanisms because they have a profound influence on how well (or how poorly) an application will perform. Third, we devote considerable space to a discussion of the merits of various design decisions; typically, when a design provides a gain in one area it also involves a loss in another. Understanding these trade-offs is crucial to building successful applications. And fourth, where appropriate, we make recommendations so that you are not left without guidance. Inevitably, our approach required us to make value judgments, and, just as inevitably, a number of people will disagree with at least some of the recommendations we make. Whether you agree or disagree with us, you should still profit from our approach: if you agree, you can stick to the advice we give; if you disagree, the discussion will have at least encouraged you to think about the topic and form your own opinion. Either way, you are better off than you would be with a book that just dumps the facts on you without providing the deeper insight required to use them. Prerequisites This book is not a beginner's book, in the sense that we do not devote much space to explaining the structure of the OMG or the pecification adoption process. We also do not provide a high-level overview of the architectural goals of CORBA or all its services and facilities (see 31 for a high-level overview). Instead, we assume that you want to know how to write real CORBA applications with C++. Despite the lack of overview material, you should be able to follow the material even if you have never seen CORBA before. If you have experience in network programming or have used another RPC platform, you will find it easy to pick things up as you go. Much of this book consists of source code, so we expect you to
First Chapter
For years, both of us have been (and still are) teaching CORBA programming with C++ to software engineers all over the world. One of the most frequently asked questions in our courses is, ''Where can I find a book that covers all this?'' Although many books have been written about CORBA, most of them focus on high-level concepts and do not address the needs of software engineers. Even though CORBA is conceptually simple, the devil lies in the detail. Or, more bluntly, books focusing on high-level concepts are of little use when you must find out why your program is dumping core.

To be sure, there are resources available about CORBA, such as newsgroups, Web pages, and the Object Management Group (OMG) specifications. However, none of them really meets the needs of a programmer who must get the code to work (and preferably by yesterday). We wrote this book so that there would finally be a tutorial and reference that covers CORBA programming with C++ at the level of detail required for real-life software development. (And, of course, we wrote it so that we would have a good answer for our students.)

Writing such a book is a tall order. Explaining the CORBA specification and APIs is one thing, and it's a necessary part of the book. However, knowing the various APIs will not, by itself, make you a competent programmer (only a knowledgeable one). To be competent, you need not only knowledge of the mechanics of the platform but also an understanding of how the different features interact. You must combine them effectively to end up with an application that performs and scales well and is maintainable, extensible, portable, and deployable.

To help you become competent (as opposed to merely knowledgeable), we go beyond the basics in a number of ways. For one thing, we provide advice as to what we consider good (and bad) design, and we make no attempt to hide problems with CORBA (which, like any other complex software system, has its share of wrinkles). Second, we go beyond the APIs by explaining some of CORBA's internal mechanisms. Even though you can use an ORB without knowing what goes on under the hood, it is useful to understand these mechanisms because they have a profound influence on how well (or how poorly) an application will perform. Third, we devote considerable space to a discussion of the merits of various design decisions; typically, when a design provides a gain in one area it also involves a loss in another. Understanding these trade-offs is crucial to building successful applications. And fourth, where appropriate, we make recommendations so that you are not left without guidance.

Inevitably, our approach required us to make value judgments, and, just as inevitably, a number of people will disagree with at least some of the recommendations we make. Whether you agree or disagree with us, you should still profit from our approach: if you agree, you can stick to the advice we give; if you disagree, the discussion will have at least encouraged you to think about the topic and form your own opinion. Either way, you are better off than you would be with a book that just dumps the facts on you without providing the deeper insight required to use them.


Prerequisites


This book is not a beginner's book, in the sense that we do not devote much space to explaining the structure of the OMG or the pecification adoption process. We also do not provide a high-level overview of the architectural goals of CORBA or all its services and facilities (see 31 for a high-level overview). Instead, we assume that you want to know how to write real CORBA applications with C++. Despite the lack of overview material, you should be able to follow the material even if you have never seen CORBA before. If you have experience in network programming or have used another RPC platform, you will find it easy to pick things up as you go.

Much of this book consists of source code, so we expect you to be literate in C++. However, you do not need to be a C++ guru to follow the code. We have avoided obscure or little-understood features of C++, preferring clarity to cleverness. If you understand inheritance, virtual functions, operator overloading, and templates (not necessarily in intricate detail), you will have no problems. Some of the source code uses the Standard Template Library (STL), which is now part of the ISO/IEC C++ Standard. We have limited ourselves to very simple uses of this library, so you should be able to understand the source code even if you have never seen STL code before.

If you have never written threaded code, you will find the chapter on writing threaded servers tough going. Unfortunately, there was not enough room to provide an introduction to programming with threads. However, the Bibliography lists a number of excellent books on the topic.

Despite our best efforts to show realistic and working source code, we had to make a number of compromises to keep code examples understandable and of manageable size. When we demonstrate a particular feature, we often use straightline code, whereas in a realistic application the code would better be encapsulated in a class or helper function. We have also minimized error handling to avoid obscuring the flow of control with lots of exception handlers. We chose this approach for didactic purposes; it does not imply that the code pretends to reflect best possible engineering practice. (The Bibliography lists a number of excellent books that cover source code design in great detail.)

Scope of this Book


OMG members are continually improving CORBA and adding new features. As a result, available ORB implementations conform to different revision levels of the specification. This book covers CORBA 2.3. (At the time of writing, CORBA 2.3 is being finalized by the OMG.) Throughout the text, we indicate new features that may not yet be available in your ORB implementation; this allows you to restrict yourself to an earlier feature set for maximum portability.

Despite its size, our main regret is that this book is too short. Ever-increasing page counts and ever-closer deadlines forced us to drop chapters on the Dynamic Invocation Interface (DII), the Dynamic Skeleton Interface (DSI), and the Interface Repository (IFR). Fortunately, the vast majority of applications do not need those features, so dropping these chapters is not much of a loss. If your application happens to require the dynamic interfaces, the background we provide here will enable you to easily pick up what you need from the CORBA specification. Another feature notable by its absence is Objects-By-Value (OBV). We chose not to cover OBV because it is too new for anyone to have any substantial engineering experience with it. In addition, at the time of writing, there are still a number of technical wrinkles to be ironed out and we expect the OBV specification to undergo further changes before it settles down.

Size and time limitations also meant that we could not cover every possible CORBA service. For example, we did not cover the Transaction Service or Security Service because each of them would require a book of its own. Rather than being complete, we have restricted ourselves to those services that are most essential for building applications: the Naming, Trading, and Event Services. We cover those services in more detail than any other publication we are aware of.

An important part of this book is the presentation of the Portable Object Adapter (POA), which was added in CORBA 2.2. The POA provides the server-side source code portability that was missing from the (now deprecated) Basic Object Adapter. The POA also provides a number of features that are essential for building high-performance and scalable applications. We have therefore paid particular attention to showing you how to use the POA effectively in your designs.

Overall, we believe this book offers the most comprehensive coverage to date of CORBA programming with C++. We have arranged the material so that you can use the book both as a tutorial and as a reference. Our hope is that after the first reading, you will have this book open at your side when you are sitting at your terminal. If so, we will have achieved our goal of creating a book that is used by real engineers to build real applications.

Acknowledgments


As with any book, the authors are only part of the story, and this is the place to thank the large number of people who have contributed to making this book possible. At Addison Wesley Longman, Mike Hendrickson and our editor, Deborah Lafferty, believed us when we told them that this book needed to be written. Without their faith in us, you would not be reading this. Brian Kernighan reviewed several drafts and made us redo the job where necessary. His clarity of thought and critical eye have greatly improved this book. John Fuller and Genevieve Rajewski, our production editors, put up with all our naive questions and enabled two amateurs to take a book to camera-ready stage. Our copy editor, Betsy Hardinger, edited every page in this book with meticulous attention to detail. Her efforts taught us more about clarity of style than we thought possible.

Particular thanks go to Colm Bergin, Jonathan Biggar, Bart Hanlon, Jishnu Mukerji, and Doug Schmidt, our expert reviewers. They read the entire manu script and spotted many problems that would have otherwise gone unnoticed. Their comments kept us honest throughout. Alan Shalloway reviewed the book from the perspective of a newcomer and made valuable suggestions on how to improve the presentation of some of the more difficult topics.

Todd Goldman and Tim Gill from Hewlett-Packard gave us permission to draw on earlier ORB training material written by Michi. John Vinoski and Dan Rabideau of Green Bay Engraving take credit for designing the Mabius strip on the cover.

We are grateful to Steve's employer, IONA Technologies, for allowing us to use the next generation of their Orbix product (called ''ART'') to develop and test our code examples. Their generosity provided us with the opportunity to make sure that our examples were correct and functional. The fact that ART conforms to CORBA 2.3 allowed us to target the most recent version of the CORBA specification available as of this writing.

We also would like to thank the many contributors to comp.object.corba and the corba-dev mailing list. The discussions there have influenced much of the content of this book.

A number of people have provided feedback, corrections, and constructive criticism since the first printing of this book. Rather than list them all here (and have to keep updating this Preface for each new printing), we have placed a list of everyone who contributed at http://www.triodia.com/staff/michi/advanced_corba/acknowledgments.html. Our thanks go to all these people for helping to make this a better book.

Michi's Acknowledgments


I would like to thank my former employer, DSTC Pty Ltd, for providing me with an environment that was conducive to writing. Joachim Achtzehnter, Martin Chilvers, Wil Evers, Ted McFadden, and Michael Neville reviewed parts of the manuscript and made valuable suggestions for improvement. Particular thanks go to David Jackson, who read all my drafts and made sure that loose ends were not allowed to remain hanging. Finally, I would like to thank my wife, Jocelyn, and our son, Tyson, for their love and encouragement. Without their support and patience, this book would have never been written.

Steve's Acknowledgments


I would like to thank my employer, IONA Technologies, for supporting my efforts to write this book, which occasionally kept me away from the office. In particular, I would like to thank Barry Morris for his support and encouragement, Stephen Keating for taking up the slack when I had to miss work because of all-night writing sessions, and the whole IONA Boston product development team for their patience and support.

I would also like to thank Bart Hanlon, who not only reviewed this book but also was my manager at my former employer, for continually encouraging me for several years to tackle this project and for teaching me a lot about tackling projects in general. In the technical realm, I have learned from many people over the course of my career, but I owe much to John Morris, Craig Bardenheuer, Denis deRuijter, Dale LaBossiere, Tom Moreau, and Bob Kukura, who at one time or another greatly influenced my education in the realms of distributed systems and engineering in general. I would also like to thank my C++ Report co-columnist, Doug Schmidt, a true technical visionary whose work in object-oriented network programming, C++ frameworks, and CORBA has paved the way for books such as this one. He not only helped review this book, but also agreed to let me use material from our columns in writing it.

Finally, without the support of my family, I would have never been able to even consider writing this book. I'd like to thank my wife, Cindy, and our children, Ryan and Erin, for putting up with my extremely long hours and days of writing and working. Thanks also to my parents, Ed and Dooley, who have always supported me with their seemingly limitless patience and love. I also owe my brother, John, a special thanks for his wonderful artwork on our book cover.

Michi Henning and Steve Vinoski
October 1998


0201379279P04062001
Summaries
Long Description
This book provides designers and developers the tools required to understand CORBA technology at the architectural, design, and code levels.This book offers hands-on explanations for building efficient applications, as well as lucid examples that provide practical advice on avoiding costly mistakes. With this book as a guide, programmers will find the support they need to successfully undertake CORBA development projects. The content is systematically arranged and presented so the book may be used as both a tutorial and a reference. The rich example programs in this definitive text show CORBA developers how to write clearer code that is more maintainable, portable, and efficient. The authors' detailed coverage of the IDL-to-C++ mapping moves beyond the mechanics of the APIs to discuss topics such aspotential pitfalls and efficiency. An in-depth presentation of the new Portable Object Adapter (POA) explains how to take advantage of its numerous features to create scalable and high-performance servers. In addition, detailed discussion of advanced topics, such as garbage collection and multithreading, provides developers with the knowledge they need to write commercial applications.
Main Description
Written for C++ practitioners, this book is the first to explore advanced Common Object Request Broker Architecture (CORBA) topics and techniques. Michi Henning and Steve Vinoski share the benefits of their extensive experience with CORBA programming, and arm the programmer with the skills necessary to overcome the intricate programming issues that arise in a real-world environment. By learning proven, hands-on explanations for building CORBA applications, the reader will be well on the way to building more successful distributed objects for industrial-strength development projects.
Bowker Data Service Summary
Written for C++ practitioners, this text provides tools needed to understand CORBA technology at the architectural, design and source code level.
Back Cover Copy
Here is the CORBA book that every C++ software engineer has been waiting for.Advanced CORBAreg; Programming with C++provides designers and developers with the tools required to understand CORBA technology at the architectural, design, and source code levels. This book offers hands-on explanations for building efficient applications, as well as lucid examples that provide practical advice on avoiding costly mistakes. With this book as a guide, programmers will find the support they need to successfully undertake industrial-strength CORBA development projects. The content is systematically arranged and presented so the book may be used as both a tutorial and a reference. The rich example programs in this definitive text show CORBA developers how to write clearer code that is more maintainable, portable, and efficient. The authors' detailed coverage of the IDL-to-C++ mapping moves beyond the mechanics of the APIs to discuss topics such as potential pitfalls and efficiency. An in-depth presentation of the new Portable Object Adapter (POA) explains how to take advantage of its numerous features to create scalable and high-performance servers. In addition, detailed discussion of advanced topics, such as garbage collection and multithreading, provides developers with the knowledge they need to write commercial applications. Other highlights In-depth coverage of IDL, including common idioms and design trade-offs Complete and detailed explanations of the Life Cycle, Naming, Trading, and Event Services Discussion of IIOP and implementation repositories Insight into the dynamic aspects of CORBA, such as dynamic typing and the new DynAny interfaces Advice on selecting appropriate application architectures and designs Detailed, portable, and vendor-independent source code 0201379279B04062001
Back Cover Copy
Here is the CORBA book that every C++ software engineer has been waiting for. Advanced CORBA Programming with C++provides designers and developers with the tools required to understand CORBA technology at the architectural, design, and source code levels. This book offers hands-on explanations for building efficient applications, as well as lucid examples that provide practical advice on avoiding costly mistakes. With this book as a guide, programmers will find the support they need to successfully undertake industrial-strength CORBA development projects. The content is systematically arranged and presented so the book may be used as both a tutorial and a reference. The rich example programs in this definitive text show CORBA developers how to write clearer code that is more maintainable, portable, and efficient. The authors' detailed coverage of the IDL-to-C++ mapping moves beyond the mechanics of the APIs to discuss topics such as potential pitfalls and efficiency. An in-depth presentation of the new Portable Object Adapter (POA) explains how to take advantage of its numerous features to create scalable and high-performance servers. In addition, detailed discussion of advanced topics, such as garbage collection and multithreading, provides developers with the knowledge they need to write commercial applications. Other highlights In-depth coverage of IDL, including common idioms and design trade-offs Complete and detailed explanations of the Life Cycle, Naming, Trading, and Event Services Discussion of IIOP and implementation repositories Insight into the dynamic aspects of CORBA, such as dynamic typing and the new DynAny interfaces Advice on selecting appropriate application architectures and designs Detailed, portable, and vendor-independent source code 0201379279B04062001
Table of Contents
Prefacep. xvii
Introductionp. 1
Introductionp. 1
Organization of the Bookp. 3
CORBA Versionp. 4
Typographical Conventionsp. 5
Source Code Examplesp. 5
Vendor Dependenciesp. 6
Contacting the Authorsp. 6
Introduction to CORBAp. 7
An Overview of CORBAp. 9
Introductionp. 9
The Object Management Groupp. 11
Concepts and Terminologyp. 14
CORBA Featuresp. 15
Request Invocationp. 23
General CORBA Application Developmentp. 33
Summaryp. 35
A Minimal CORBA Applicationp. 37
Chapter Overviewp. 37
Writing and Compiling an IDL Definitionp. 37
Writing and Compiling a Serverp. 39
Writing and Compiling a Clientp. 44
Running Client and Serverp. 47
Summaryp. 48
Core CORBAp. 49
The OMG Interface Definition Languagep. 51
Chapter Overviewp. 51
Introductionp. 51
Compilationp. 52
Source Filesp. 56
Lexical Rulesp. 57
Basic IDL Typesp. 59
User-Defined Typesp. 62
Interfaces and Operationsp. 77
User Exceptionsp. 88
System Exceptionsp. 91
System Exceptions or User Exceptions?p. 94
Oneway Operationsp. 95
Contextsp. 97
Attributesp. 98
Modulesp. 100
Forward Declarationsp. 102
Inheritancep. 103
Names and Scopingp. 112
Repository Identifiers and pragma Directivesp. 116
Standard Include Filesp. 120
Recent IDL Extensionsp. 121
Summaryp. 125
IDL for a Climate Control Systemp. 127
Chapter Overviewp. 127
The Climate Control Systemp. 127
IDL for the Climate Control Systemp. 130
The Complete Specificationp. 136
Basic IDL-to-C++ Mappingp. 139
Chapter Overviewp. 139
Introductionp. 140
Mapping for Identifiersp. 141
Mapping for Modulesp. 142
The CORBA Modulep. 144
Mapping for Basic Typesp. 144
Mapping for Constantsp. 148
Mapping for Enumerated Typesp. 150
Variable-Length Types and_var Typesp. 151
The String_var Wrapper Classp. 156
Mapping for Wide Stringsp. 169
Mapping for Fixed-Point Typesp. 169
Mapping for Structuresp. 173
Mapping for Sequencesp. 179
Mapping for Arraysp. 198
Mapping for Unionsp. 201
Mapping for Recursive Structures and Unionsp. 209
Mapping for Type Definitionsp. 210
User-Defined Types and -var Classesp. 211
Summaryp. 222
Client-Side C++ Mappingp. 223
Chapter Overviewp. 223
Introductionp. 223
Mapping for Interfacesp. 224
Object Reference Typesp. 225
Life Cycle of Object Referencesp. 227
Semantics of _ptr Referencesp. 234
Pseudo-Objectsp. 241
ORB Initializationp. 242
Initial Referencesp. 245
Stringified Referencesp. 249
The Object Pseudo-Interfacep. 251
_var Referencesp. 259
Mapping for Operations and Attributesp. 271
Parameter Passing Rulesp. 274
Mapping for Exceptionsp. 307
Mapping for Contextsp. 322
Summaryp. 323
Developing a Client for the Climate Control Systemp. 325
Chapter Overviewp. 325
Introductionp. 325
Overall Client Structurep. 326
Included Filesp. 327
Helper Functionsp. 328
The main Programp. 333
The Complete Client Codep. 341
Summaryp. 346
Server-Side C++ Mappingp. 349
Chapter Overviewp. 349
Introductionp. 349
Mapping for Interfacesp. 351
Servant Classesp. 353
Object Incarnationp. 355
Server mainp. 356
Parameter Passing Rulesp. 358
Raising Exceptionsp. 376
Tie Classesp. 382
Summaryp. 387
Developing a Server for the Climate Control Systemp. 389
Chapter Overviewp. 389
Introductionp. 389
The Instrument Control Protocol APIp. 390
Designing the Thermometer Servant Classp. 393
Implementing the Thermometer Servant Classp. 396
Designing the Thermostat Servant Classp. 399
Implementing the Thermostat Servant Classp. 402
Designing the Controller Servant Classp. 405
Implementing the Controller Servant Classp. 407
Implementing the Server main Functionp. 413
The Complete Server Codep. 414
Summaryp. 427
The Portable Object Adapterp. 429
Chapter Overviewp. 429
Introductionp. 430
POA Fundamentalsp. 430
POA Policiesp. 434
POA Creationp. 447
Servant IDL Typep. 451
Object Creation and Activationp. 455
Reference, ObjectId, and Servantp. 496
Object Deactivationp. 499
Request Flow Controlp. 502
ORB Event Handlingp. 506
POA Activationp. 514
POA Destructionp. 520
Applying POA Policiesp. 522
Summaryp. 531
Object Life Cyclep. 533
Chapter Overviewp. 533
Introductionp. 533
Object Factoriesp. 534
Destroying, Copying, and Moving Objectsp. 548
A Critique of the Life Cycle Servicep. 564
The Evictor Patternp. 570
Garbage Collection of Servantsp. 589
Garbage Collection of CORBA Objectsp. 598
Summaryp. 600
CORBA Mechanismsp. 603
GIOP, IIOP, and IORsp. 605
Chapter Overviewp. 605
An Overview of GIOPp. 606
Common Data Representationp. 607
GIOP Message Formatsp. 612
GIOP Connection Managementp. 621
Detecting Disorderly Shutdownp. 623
An Overview of IIOPp. 624
Structure of an IORp. 626
Bidirectional IIOPp. 629
Summaryp. 630
Implementation Repositories and Bindingp. 631
Chapter Overviewp. 631
Binding Modesp. 631
Direct Bindingp. 632
Indirect Binding via an Implementation Repositoryp. 636
Migration, Reliability, Performance, and Scalabilityp. 648
Activation Modesp. 652
Race Conditionsp. 653
Security Considerationsp. 656
Summaryp. 659
Dynamic CORBAp. 661
C++ Mapping for Type anyp. 663
Chapter Overviewp. 663
Introductionp. 663
Type any C++ Mappingp. 667
Pitfalls in Type Definitionsp. 689
Summaryp. 690
Type Codesp. 691
Chapter Overviewp. 691
Introductionp. 692
The TypeCode Pseudo-Objectp. 692
C++ Mapping for the TypeCode Pseudo-Objectp. 703
Type Code Comparisonsp. 715
Type Code Constantsp. 721
Type Code Comparison for Type anyp. 725
Creating Type Codes Dynamicallyp. 727
Summaryp. 736
Type DynAnyp. 737
Chapter Overviewp. 737
Introductionp. 737
The DynAny Interfacep. 738
C++ Mapping for the DynAny Pseudo-Objectp. 750
Using DynAny for Generic Displayp. 763
Obtaining Type Informationp. 766
Summaryp. 768
CORBAservicesp. 769
The OMG Naming Servicep. 771
Chapter Overviewp. 771
Introductionp. 771
Basic Conceptsp. 772
Structure of the Naming Service IDLp. 774
Semantics of Namesp. 775
Naming Context IDLp. 780
Iteratorsp. 800
Pitfalls in the Naming Servicep. 808
The Names Libraryp. 810
Naming Service Toolsp. 810
What to Advertisep. 811
When to Advertisep. 812
Federated Namingp. 813
Adding Naming to the Climate Control Systemp. 817
Summaryp. 824
The OMG Trading Servicep. 827
Chapter Overviewp. 827
Introductionp. 828
Trading Concepts and Terminologyp. 828
IDL Overviewp. 834
The Service Type Repositoryp. 835
The Trader Interfacesp. 854
Exporting Service Offersp. 860
Withdrawing Service Offersp. 866
Modifying Service Offersp. 867
The Trader Constraint Languagep. 869
Importing Service Offersp. 873
Bulk Withdrawalp. 890
The Admin Interfacep. 891
Inspecting Service Offersp. 894
Exporting Dynamic Propertiesp. 894
Trader Federationp. 898
Trader Toolsp. 911
Architectural Considerationsp. 911
What to Advertisep. 913
Avoiding Duplicate Service Offersp. 914
Adding Trading to the Climate Control Systemp. 915
Summaryp. 920
The OMG Event Servicep. 923
Chapter Overviewp. 923
Introductionp. 923
Distributed Callbacksp. 924
Event Service Basicsp. 931
Event Service Interfacesp. 936
Implementing Consumers and Suppliersp. 945
Choosing an Event Modelp. 958
Event Service Limitationsp. 961
Summaryp. 963
Power CORBAp. 965
Multithreaded Applicationsp. 967
Chapter Overviewp. 967
Introductionp. 967
Motivation for Multithreaded Programsp. 968
Fundamentals of Multithreaded Serversp. 972
Multithreading Strategiesp. 980
Implementing a Multithreaded Serverp. 981
Servant Activators and the Evictor Patternp. 996
Summaryp. 997
Performance, Scalability, and Maintainabilityp. 999
Chapter Overviewp. 999
Introductionp. 999
Reducing Messaging Overheadp. 1000
Optimizing Server Implementationsp. 1011
Federating Servicesp. 1013
Improving Physical Designp. 1014
Summaryp. 1017
Source Code for the ICP Simulatorp. 1019
Overviewp. 1019
Transient Simulator Codep. 1019
Persistent Simulator Codep. 1026
CORBA Resourcesp. 1031
World Wide Webp. 1031
Newsgroupsp. 1032
Mailing Listsp. 1032
Magazinesp. 1033
Bibliographyp. 1035
Indexp. 1043
Table of Contents provided by Syndetics. All Rights Reserved.

This information is provided by a service that aggregates data from review sources and other sources that are often consulted by libraries, and readers. The University does not edit this information and merely includes it as a convenience for users. It does not warrant that reviews are accurate. As with any review users should approach reviews critically and where deemed necessary should consult multiple review sources. Any concerns or questions about particular reviews should be directed to the reviewer and/or publisher.

  link to old catalogue

Report a problem