•  Web Service Development Guide
  •  PART I Getting Started
    •  Chapter 1 Introduction
      • Welcome
      • HydraExpress Features
      • Organization of This Manual
    •  Chapter 2 Building Web Services with HydraExpress
      • Overview
      •  Supporting a Dynamic System
        • Configurable Transports and Message Handlers
        • Message Patterns and Asynchronous Messaging
        • Support for Named Objects
        • Dynamic Switching at Runtime
      • Handling of Complex Datatypes
      • Web Services and Service-Oriented Architecture (SOA)
      • Summary
    •  Chapter 3 Creating a Web Service
      • Overview
      • Service Description
      • Invoking the Generator
      •  The Generated Application Samples
        •  The Client Proxy
          • Using the Client Proxy and the Client Implementation
        • The Service Implementation
      •  Compiling and Running the Application
        •  Compiling the Application
          • Compiling Using the Makefile
          • Compiling Using MSVC
        •  Deploying the Service
          • Deploying with the makefile
          • Deploying Services Compiled with MSVC Project Files
        • Testing the Service
      • Next Steps
    •  Chapter 4 Extending Your Web Service
      • Overview
      • Add a Secure Transport
      •  Add a Special SOAP Header
        • Add the SOAP Header to the Generated Client
        • Edit the Server-Side Code to Return a Response Based on the Header
      • Compile, Deploy, and Run the Service
      • Next Steps
    •  Chapter 5 Code Generator Basics
      • Overview
      • Invoking the Code Generator
      • Common Generator Options
      • Generated Files
      • Next Steps
    •  Chapter 6 Working with Data
      • Overview
      •  Simple Data
        • Messages with No Parts
        • Messages with a Single Part
        • Messages with Multiple Parts
      •  Complex Data
        • The WSDL and Schema
        • The Generated Data Classes
        • Working with the Generated Data Classes in the Client and Server Implementations
        • The Data “main” Sample Application
  •  PART II Client and Server Options
    •  Chapter 7 Developing Clients
      • Overview
      •  Developing and Running the Example
        • Service Description
        • Invoking the Generator
        • Generated Files
        •  Using the Client Proxy
          • Looking at the Code
          • Using the Client Proxy
        • Compiling and Deploying the Client
      •  Further Options
        • The Asynchronous Client API
        • Multithreading
        • Transports
        •  Client Security
          • Authorization
          • HTTPS Support
        • Error Reporting and Faults
        • Client-Side Logging
        • Turning off Text Escaping to Improve Performance
        •  Customizing the Client Configuration Files
          • Handlers Configuration File: client-handlers.xml
      • Next Steps
    •  Chapter 8 Developing Services
      • Overview
      •  Developing and Running the Example
        • Invoking the Generator
        •  Using the Server Implementation
          • The Generated Abstract Base Class
          • The Generated Sample Implementation
          • The Provided Sample Implementation
        •  Compiling the Service
          • Compiling Using the Makefile
          • Compiling Using MSVC
        •  Deploying the Service
          • Deploying with the Makefile
          • Deploying Services Compiled with MSVC
        • Testing the Service
      •  Further Options
        •  Multithreading
          • A Note on Allocating Objects in Multithreaded Applications
        • Service Security
        • Error Reporting and WSDL-Defined Faults
        • Implementing a Standalone Server
        • Server-Side Logging
        • Session Management
        • Using a Different Implementation Name
        •  Wrapped Style Operations
          • Developing a WSDL to Support the Wrapped Style
          • Generating Code with the -wrapped Option
          • Looking at the Generated Code
        • Turning off Text Escaping to Improve Performance
        • Accessing the Request URL
        •  Customizing the Service Configuration Files
          • Transport Configuration File: transports.xml
          • Servlet Configuration File: web.xml
          • Service Chains Configuration File: handlers.xml
          • Named Objects Configuration File: objects.xml
      • Next Steps
  •  PART III Working with Message Patterns
    •  Chapter 9 Introduction to Message Patterns
      • Overview
      •  Message Patterns in WSDL
        • Weather Summary Service Description
        • The Request-Response Pattern
        • The One Way Pattern
        • The Notification Pattern
        • The Solicit-Response Pattern
        • Message Patterns and Asynchronous Messaging
      • Architecture of the Notification Classes
      • Next Steps
    •  Chapter 10 Implementing Solicit-Response and Notification Services
      • Overview
      •  Generating Code
        • Code Generation Outputs
      •  Implementing the Service
        • The Request-Response Operation
        •  The Solicit-Response and Notification Operations
          • The Notification Proxy
          • Implementing the Call to the Notification Endpoint
          • The Solicit-Response Operation Call
      •  Implementing the Client
        • Setting up a Listener
        • The Request-Response Service Operation Call
        • The One Way Operation Call
        • Implementing the Client-Side Notification and Solicit-Response Endpoints
        • Transport Configuration File Supporting Notification
      • Running the Service
      • Summary
  •  PART IV Extending your Applications
    •  Chapter 11 Custom Transports and Listeners
      • Overview
      • Transport and Listener Configuration Files
      • Transport and Listener Properties
      • Using an Autoconfigured Listener
      •  Making Transports and Listeners Dynamic
        • Selectable Transports and Listeners
        • Interchangeable Transports and Listeners
      •  Creating a Transport
        • A Note on Multithread Safety
      •  Creating a Listener
        • Request Handling and Threading
        • Implementing the Virtual Methods
        • Configuring the Listener
    •  Chapter 12 Web Service Logging
      • Overview
      • Web Service Logger Levels
      •  Logging in Client Code
        • Configuring and Using a Client Logger
        • Logging in a Standalone Service
      •  Logging in Service Code
        • Using the Global Agent Logger in Service Code
        • Server-side Logging through the Web Services Logger
    •  Chapter 13 Asynchronous Messaging
      • Overview
      •  The Asynchronous API
        • Using the Asynchronous API
      •  The Async Example
        • Implementing the Request-Response Method Asynchronously
        • Implementing the One-Way Method Asynchronously
        • Running the Async Example
      • Asynchronous Method Naming Conflicts
    •  Chapter 14 SOAP Message Handlers
      • Overview
      •  Types of SOAP Handlers
        • Transport Handlers
        • Request Handlers
        • Response Handlers
        • Fault Handlers
      • The Message Handler API
      •  Creating Your Own Handlers
        • Generate Code
        •  Write the Handler Implementation
          • Creating a Request Handler
          • Creating a Transport Handler
          • Aborting Handler Processing
        • Add the Handlers to the Proxy
        • Register the Handlers
        • Configure the Handlers
        • Compile and Deploy the Service
      •  Chaining Handlers
        • Chaining Handlers on the Client
        •  Chaining Handlers on the Server
          • The handlers.xml Configuration File
          • Editing the handlers.xml File
      • Adding Initialization Parameters to Handlers
    •  Chapter 15 SOAP and Transport Headers
      • Overview
      •  How Headers Work
        • Defining and Using Headers through the rwsf::CallInfo Interface
      •  SOAP Headers Example
        • Client-Side Code
        • Server-Side Code
        • Viewing the Results
      • Uses for Header Support
      • Summary
    •  Chapter 16 Named Objects
      • Overview
      • How HydraExpress Uses Named Objects
      •  Creating and Using Custom Objects
        • Creating the String Object
        • Creating an Entry Point to the Object
        • Configuring the Named Object
        •  Using the Named Object
          • Summary
    •  Chapter 17 SOAP with Attachments
      • Overview
      • The SOAP with Attachments Specification
      •  Working with Attachments
        • Example Service Description
        •  Define the Attachment in WSDL
          • Define the Schema Type
          • Define the WSDL Message Parts and Operation
          • Define the MIME Bindings
        •  Generate Code and Manipulate the Attachment
          • Sending a Referenced Attachment
          • Retrieving an Unreferenced Attachment
          • Retrieving a Referenced Attachment
        • Build and Run the Example
      • Summary
    •  Chapter 18 Sessions and State
      • Overview
      • Session Management in the Agent’s Servlet Container
      • Manipulating a Service’s Session Data
      • Configuring Session Timeouts
    •  Chapter 19 Internationalizing Your Services
      • Overview
      •  How HydraExpress Performs Character Conversions for Non-UTF-8 Encodings
        • Character Encoding in XML Schemas and WSDLs
        • Character Encoding in Generated Classes
      •  Automatic Character Conversion through a Customized Mapping
        • Create a Customized Mapping
        •  Add the Mapping to a HydraExpress Project File and Generate Code
          • Adding the mappings to an existing HydraExpress Project File
          • Creating a New HydraExpress Project File Containing the Mappings
          • A Look at the Generated Converter
      •  XML and Character Encodings Concepts
        • What is a Character Encoding?
        • Character Encoding in an XML Prolog
  •  PART V HydraExpress Reference
    •  Chapter 20 The HydraExpress Code Generator
      • Overview
      •  Invoking the Generator
        •  Introduction to the HydraExpress Project File
          • Using the HydraExpress Project File to Set Options
      •  Invoking the Generator with an XML Schema
        • Architecture of the Generated Classes
        •  Generated Files
          • HTML Documentation
          • Sample Application Files
          • C++ Makefiles
          • MSVC Project Files
        • Issues with Large Complex Schemas
      •  Invoking the Generator with a WSDL File
        •  Architecture of the Generated Classes
          • Server Classes
          • Client Classes
        •  Generated Files
          • HTML Documentation
          • Sample Application Files
          • C++ Makefiles
          • MSVC Project Files
      •  Generating Code with Multiple Schemas or WSDLs
        • A Note on Namespace Collisions
      •  Generator Options
        •  Adding Options and Customized Mappings to the HydraExpress Project File
          • Providing Customized Type Mappings to the Code Generator
        • Adding Outside Libraries, Includes or Compiler Properties to a Project
        •  Conflicting Options and Property Precedence
          • Platform Properties and Startup Properties Files
          • The HydraExpress Project File
          • Command Line Options
      • Overwrite Protection
      •  Validation Provided during Code Generation
        • WSDL Validation
        • Schema Validation
        • SOAP Message Validation
    •  Chapter 21 The Project File and Directory Structure
      • Overview
      •  The Project File
        • A Sample Project File
        • Adding Options to a Project File Vs. Adding them to the Command Line
        • Creating a Customized Project File for Special Generation Options
      •  The Generated Project Directory
        • The Top-Level Code Generation Directory
        •  The SubDirectories
          • The App Directory
          • The Bin Directory
          • The Codegen Directory
          • The Conf Directory
          • The Docs Directory
          • The Include Directory
          • The Lib Directory
    •  Chapter 22 Options for Compiling
      • Overview
      • The Default Generated Makefiles
      •  Makefile Options
        • The -noserver, -noclient, and -nosample Options
        • The -nomake Option
        • Customizing the Name of a Makefile
        • Adding Third Party Includes to Makefiles
        • Customizing Systems Properties
      • Using the Debug Makefiles
      •  Procedure for Building with the Makefiles
        • Building just a Client or Server
        • Location of Generated Libraries and Binary Files
      • Using your own Makefile
      • Using MSVC Project Files
      • Next Steps
    •  Chapter 23 Options for Deploying Services
      • Overview
      •  Deploying to the Agent
        • Starting and Stopping the Agent
        • Agent Ports
        • Deploying your Service with the Makefile
        • Deploying your Service Using MSVC Files
        • Agent Options
      •  Standalone Server Implementations
        • Standalone Server Options
        • Standalone Server Ports
        • Shutting down a Standalone Server
        • About Configuring a Multithreaded Standalone Server or Listener
      • About the Servlet Used by the Service
  •  PART VI Appendices
    •  Appendix A Code Generation Details
      • Overview
      •  File Generation Conventions
        • Naming Conventions
        • Client-Side Classes
        • Server-Side Classes
        • Notification Classes
        • Methods and Parameters
        • Configuration Files
        • Makefile Naming Conventions
      • Simple Type Mappings
      • Complex Types
      •  SOAP Encoding
        • SOAP-Encoded Arrays
        • SOAP-Encoded Built-in Types and References
        • Recursive Arrays
      • SOAP Headers
•  XML Binding Development Guide
  •  PART I XML Binding Basics
    •  Chapter 1 Introduction
      • Welcome
      • Dependency on the Core Library
      • Using HydraExpress with SourcePro C++
      • Where to Find Additional Information
      • Organization of this Manual
    •  Chapter 2 XML Binding Concepts
      •  Overview
        • Using XML Binding Classes in a Web Service
      • XML Binding Basics
      • XML Schema
      •  Validation
        • Schema Document Validation
        • Instance Document Validation
      • Internationalization
  •  PART II Code Generation Examples
    •  Chapter 3 Basic Purchase Order Example
      • Purpose
      •  Types Concepts
        • XML Document for Purchase Order Example
        • XML Schema for Purchase Order Example
      •  Generating Code from Schema
        • Execute the Code Generator
        • Code Generator Output
        • Generated Files
      • Implementing your Application
      •  Building and Compiling
        • Command Line Procedure
        • MSVC Procedure
      •  The Example Code
        • Unmarshaling
        • Manipulating XML Content in C++
        • Validating the Instance Document
        • Marshaling
        • Working Without Top-Level Element Classes
      • Summary
    •  Chapter 4 Purchase Order Example With Namespace Qualification
      •  Purpose and Overview
        • The XML Schema
        • The XML Document
      •  Generating Code from Schema
        • Generator Output
      • Building and Compiling
      •  The Example Code
        • C++ Namespaces
        • Unmarshaling
        • Manipulating XML Content in C++
        • Marshaling
      • Summary
    •  Chapter 5 SOAP Example
      • Purpose and Overview
      • The SOAP XML Document
      • Customizing Mappings Using the Project File
      •  Generate Code
        • Generator Output
      • The SOAP Parsing Example
      • The Trade Parsing Example
      • Building and Compiling
      • Summary
    •  Chapter 6 complexContent Example
      • Purpose and Overview
      • The International Purchase Order Schema
      • An International Purchase Order Instance Document
      • Generate Code
      • Building and Compiling
      • Accessing the Address
      • Summary
  •  PART III Advanced Topics
    •  Chapter 7 Advanced Tasks
      • Purpose and Overview
      • Designing a Schema for Extensibility
      • Working With Large Documents
      • Custom Formatting
      • Working with Unsupported Complex Types
      •  Working with the Handle/Body Classes
        •  Working with Shallow and Deep Copies
          • Making a Shallow Copy
          • Making a Deep Copy
        • Managing Circular References
      • Summary
    •  Chapter 8 Mapping XML Schema to C++
      • Purpose and Overview
      •  Names and Identifiers
        •  Static Data Members
          • The DefaultElementName Data Member
          • Contained Element Name and Attribute Data Members
        •  Namespaces
          • Accessing the Fully Qualified XML Name of a Complex Type
          • Mapping XML Namespaces to C++ Namespaces
          • Differentiating Same-Named Items
          • Adding a Namespace to a Root Element
        • File Naming
      •  Simple Types
        • Default Values
        • anyType and anySimpleType
        • Validation of simpleType Data
      • Data Binding Parsing Errors
      •  Complex Types
        • Accessors and Mutators
        •  Marshal and Unmarshal
          • Marshal methods
          • Unmarshal methods
        •  Types Derived By Restriction or Extension
          • Specific Support for Types Derived by Restriction
        • any Element and anyAttribute
        • Optional Elements and Attributes
        • nillable Elements
        • Collections
        • Lists
        • Substitution Groups
        • Unions
        • Key and Keyref Elements
        •  Content Model Groups
          • Single occurrence all or sequence elements
          • Single occurrence or optional choice element
          • Multiple occurrence or optional all and sequence, multiple occurrence choice
          • Top-level groups
        • Attribute Groups
      • Default Values
      •  Creating Customized Mappings
        • Customizing Names and Identifiers
        • Flexible Type Mapping
        • Namespace Mapping
        • String Mapping
•  Servlet Development Guide
  •  PART I Introduction
    •  Chapter 1 Introduction
      • Welcome
      • Organization of this Manual
      • Where to Find Additional Information
    •  Chapter 2 The Servlet Container and Servlet Concepts
      • The Servlet Approach
      •  The Servlet Container and Web Applications
        • Network Connection
        • Contexts
      •  Servlets
        • Request and Response
        • Maintaining State
      • Filters
      • Listeners and Events
      • Named Objects
    •  Chapter 3 Introduction to Servlet Programming
      •  Introduction
        • Servlet Initialization and Destruction
      • Deriving from rwsf::HttpServlet
      • Defining the Servlet
      • Implementing Request Handlers
      • Compiling the Servlet
      • Installing the Compiled Object Files
      • Adding the Servlet to the web.xml file
      • Stopping and Starting the Agent, and Executing the Servlet
      • Debugging a Servlet
      • Next Steps
  •  PART II Administration
    •  Chapter 4 Configuring Objects in the Servlet Container
      •  Introduction
        • Procedure for Adding a Context
        • Procedure for Adding a Servlet
        • Procedure for Adding a Filter
        • Procedure for Adding a Listener
      •  Configuration File Example
        • Character Set
      • Servlet and Filter Initialization Parameters
      •  URL Patterns
        • URL Pattern Syntax
        • Servlet Matching Procedure
        • Default Servlet
      • Deploy the Compiled Object Files
      • Create a Context Directory
      • Set Context Parameters
      •  Define and Map Servlets
        • Defining the Servlet Instance
        • Mapping Servlets to URLs
        • Single-thread Access
      •  Define and Map Filters
        • Defining the Filter Instance
        • Mapping Filters to URLs
      • Define Listeners
      • Configure Error Pages
      • Configure Sessions
      • Forward Requests From a Web Server
    •  Chapter 5 Troubleshooting
      • Introduction
      • Agent Starts, No Contexts Load
      • Servlet Does Not Load
      • Context Does Not Load
      • Browser Displays HTML Code from Servlet
  •  PART III Programming
    •  Chapter 6 The Servlet API
      • Introduction
      • Using rwsf::Enumeration
      • Using rwsf::Attribute
      • Defining Filters, Servlets, and Listeners
      • Implementing a Filter
      • Implementing a Listener
      • Reading Initialization Parameters
      • Reading Context Parameters
    •  Chapter 7 Working With Requests
      • Introduction
      • Understanding Request Routing
      • Inspecting HTTP Headers
      • Reading Parameters From a Form
      • Recovering Session State
      • Managing State on the Client with Cookies
    •  Chapter 8 Creating Responses
      • Introduction
      • Saving Session State
      • Creating HTTP Headers
      •  Creating an HTTP Response
        • Using Java-Like Output Functions
        • Setting the Response from a String
      • Returning the URL of a Servlet
      • Returning an Error
      • Redirecting the Client
      • Forwarding a Request
    •  Chapter 9 Creating Servlets
      • Introduction
      • Designing the Servlet Class
      • Implementing the Servlet Class
      • Compiling Servlets
      •  Deploying Servlets
        • Changing the Default Deployment Directories
  •  PART IV Appendices
    •  Appendix A Resources
      • Books and Articles
      • Web Sites
    •  Appendix B Configuration Quick Reference
      • Conventions
      • Global web.xml
      • Context web.xml
    •  Appendix C Library Loading Reference
      • Environment Variables
      • Library Name Format

Web Service Development Guide

Library Name Format