- Introduction
- What is ObjectSwitch?
- How is this possible?
- The parts of ObjectSwitch
- The Application Server
- What is the Application Server?
- Architecture of the Application Server
- Adapters
- The ObjectSwitch Design Center
- The Design Center window
- The development process
- Modeling
- Action language
- Building engines
- Deployment
- Sample ObjectSwitch application
- Introduction
- The Sample Application
- Building the Application
- Running and Testing the Application
- Defining the Application
- Modeling the Application
- Entity Model Descriptions
- Introduction
- The ObjectSwitch Design Center
- What is the Design Center?
- The swdc command
- The Design Center GUI
- Opening a new project in the Design Center
- Working with models in the Design Center
- Defining a project
- Building the project
- IDLos
- Overview
- What is IDLos?
- A small example
- A bigger example
- Lexical and syntactic conventions
- Data types
- Entities
- Local entities
- Relationships
- Inheritance
- Packages
- Namespaces
- Properties
- Files and engines
- A big example
- IDLos Reference Pages
- action
- attribute
- enum
- entity
- exception
- expose
- interface
- key
- local entity
- module
- operation
- package
- relationship / role
- signal
- stateset
- struct
- transition
- trigger
- typedef
- Complete IDLos grammar
- Action language
- Overview
- Some basic features of the action language
- Control structures
- Manipulating objects
- SWALScript: a scripting language
- Action language statements and functions
- break
- cardinality
- continue
- create
- create singleton
- declare
- delete
- empty
- Exceptions
- extern
- for
- for ... in
- if else else if
- in
- isnull
- relate
- return
- select
- self
- spawn
- Transactions
- Types
- unrelate
- while
- Complete action language grammar
- More ObjectSwitch essentials
- Using ObjectSwitch builtins
- Using timers
- Calling external libraries
- Building distributed applications
- Model execution
- Runtime implementation
- UML notation for IDLos
- Introduction
- UML as a specification language
- Specifying your application
- Using the profile reference pages
- System model
- Entity model: entities, relationships, operations
- State model
- Entity model: Data types and structures
- ObjectSwitch UML profile summary
- Interfacing and custom adapters
- Simple C++ calls
- SDL wrapping
- Type compatibility
- Managing resources: the fileio adapter
- Other design considerations for adapters
- Callbacks
- Performance enhancement
- Some suggestions
- Real world example: CDR
- Introduction
- Using database adapters
- Overview
- Adding the adapter to your project
- Adding entities to the adapter
- Creating the OID management table
- Caching policies
- Data type mapping
- Supporting legacy databases
- Overview
- Defining legacy entities
- Using the SQL properties
- Generated files
- Create table files
- Name mangling
- Configuring database adapters
- Overview
- Setting environment variables
- Setting up a database
- Configuring the ODBC drivers
- Configuring the engine
- Connection failure handling
- Exposing interfaces to CORBA
- Overview
- Adding the adapter to your project
- Adding interfaces to CSA
- Linking to your CORBA development system
- That's about it!
- Generated IDL and interfaces
- Exported IDL
- Factory IDL
- Interface example
- Factory example
- CORBA-ObjectSwitch support
- Factories
- Support for naming services
- Mapping CORBA and ObjectSwitch data types
- Configuring ObjectSwitch for CORBA
- Overview
- What are directory services?
- The ObjectSwitch directory services adapter
- Using directory services
- The Agent interface
- Interfaces for other directory service entities
- Name formats
- Using directory services
- Configuring directory services
- The ObjectSwitch SNMP adapter
- Architecture
- Mapping IDLos to SMI
- Building an SNMP sub-agent engine
- MIB customization
- Using the EJB adapter
- Building an enterprise bean
- Creating Enterprise Java Beans
- Mapping IDLos data types
- What's generated
- Deploying the enterprise bean
- Accessing an EJB from a Java client
- Required import statements
- Locating a bean's home interface
- Using holder classes
- Handling engine recovery
- Launching the client
- Configuring an EJB engine
- Example EJB and client
- General description
- The IDLos and action language details
- Building the enterprise bean
- Starting the engine
- A Java client accessing the enterprise bean
- Using the Java Client adapter
- Scenario
- Overview
- Building the project
- Wrapping Java classes
- What's generated
- Constraints
- JCA-enabled engines
- Modeling
- Running
- Configuring a JCA component
- JCA example
- Java classes
- Generated IDLos types
- ObjectSwitch Model
- Result
- Introduction
- Scenario
- Overview
- Using the CORBA Client Adapter
- Modeling to wrapped IDL
- The runtime model
- CORBA client configuration
- Example CORBA Client
- The CORBA server
- The CCA component
- The CORBA Client model
- Building the CORBA client
- Running the CORBA client
- Using the PHP adapter
- Overview
- A quick walkthrough
- Writing a PHP script
- Starting a script
- Data types
- Conditional operators
- Comparison operators
- Transactions
- Running an application
- General description
- Building the model application
- Starting the engines
- Starting the PHP process
- PHP extensions reference
- PHP reference
- os_connect
- os_create
- os_delete
- os_disconnect
- os_extent
- os_get_attr
- os_invoke
- os_relate
- os_role
- os_set_attr
- os_unrelate
- Configuring the PHP adapter
- What you get with the PHP adapter
- the PHP extensions
- The osw engine
- Error handling
- Error Conditions
- Error Messages
- Overview
- Importing XML Schemas
- Wrapping a Schema
- Generated IDLos and action language
- The "root" entity
- Using an XSA Service component
- Sending XML documents
- Receiving XML documents
- Building the client engine
- Deploying the XSA engines
- Mapping XML Schema to IDLos
- Structures
- Datatype mapping
- Introduction
- Administration overview
- ObjectSwitch management tools
- Distribution
- Trace files
- More about the registry
- System Coordinator
- Overview
- The command line
- The Engine Control Center
- Overview
- Starting the control center
- Viewing engines on a node
- Starting and stopping engines
- Changing an engine's configuration
- Adding and removing engines
- Replacing engines
- Statistics reports
- System Monitor
- Working with the System Monitor
- Viewing types and instances
- An example model view
- The registry editor
- Starting the registry editor
- The registry editor display
- Command line utilities and scripts
- Overview
- swregistry
- Registry variables
- Overview
- Routine configuration variables
- System configuration variables
- Distribution
- Hash table sizing