SAF Core API [Overview] |
---|
The SOA Assembly Framework (SAF) Core contribution provides an integration point between Eclipse-based tooling (such as editors and builders) and SCA model extension providers. Tooling can call the SAF Core API to accomplish various SCA artifact-related tasks without knowledge of specific artifact implementations, their providers, or their structure. Likewise, SCA model extension providers can make their SCA model extensions available to users of Eclipse-based tooling by supplying code, termed SCA extension handlers, which support a variety of SCA artifact-related operations. The result is that tooling can allow an end user to create and edit various types of SCA components, entry points, external services, and interfaces that the tooling does not need to understand, using code developed by different groups who have expertise in different areas. In this document, references to types or methods in the Java API are enclosed by
fixed-width fonts ( ISAFManager InterfaceTo execute a given operation on an SCA component,
entry point, external service, or interface the client
must first obtain an instance of the corresponding handler.
The IHandler Interface ExtensionsThe
Context ObjectThe SAF Core implementation provides a context object,
IUIContext InterfaceThis interface is meant to be implemented by clients calling the various handlers. This interface provides the UI shell, which may be required by a handler to display a dialog. An implementation of this interface is required in cases where a handler operation must interact with the user to complete. |
SCA Extension Handlers [Top] |
---|
SCA extension providers can make their extensions available to users of SCA tooling by supplying handlers, which support a variety of operations. SCA extension providers must contribute to the org.eclipse.stp.core.saf.handlers
extension point, supplying one or more handler classes that,
depending on the type of extension, implement one of the four specialized
A handler provides a Service Provider Interface (SPI) that the framework uses to call the handler with various requests for creating and operating on an SCA extension object. The handler is identified by the SCA extension element name. The element names are interface.xxx, implementation.xxx, and binding.xxx. xxx can be a name that relates to the type of interface, implementation, or binding concerned. The following example shows component, entry point, external service, and interface handler contributions: |
|
A handler instance can be obtained through various methods provided by the
|
Context and Context Extensions [Top] |
---|
The definition of a context allows for the restriction of SCA extension handler availability based on a given authoring criterion (i.e., context). This definition can be extended by specifying a context extension. These two concepts are described below. Context DefinitionThe context extension point allows for the definition of a context that restricts the handlers that are available to clients of the framework working within the context. A context is generally associated with the root object being authored, usually a subsystem, module, or module fragment. It defines a set of constraints that apply to this root object. For example, if a context is defined for authoring a module of a given type, the component kind constraint could specify that only a subset of all contributed component handlers would be available. A context can be defined by contributing to the org.eclipse.stp.core.saf.context extension point. The following is an example of a context definition: |
|
A context definition is used only when a matching
A context definition can also be specified to be extensible. In that case, a handler contributor can also extend an existing context to add the new handler to its definition by specifying a context extension. Context Extension DefinitionA context extension can be used to augment an existing context definition with a new handler contribution, as long as the context is extensible. If the context with matching context key element is not extensible, this contribution is ignored. In addition, the constraints specified by this extension are also ignored if they conflict with those specified in the context being extended. A context extension can be defined by contributing to the
org.eclipse.stp.core.saf.contextExtension extension point.
The following is an example of a context extension definition that adds
the |
|
This documentation is maintained by Sebastian Carbajales (sebastia{at}ca.ibm.com). Questions or requests for clarifications should be made to the STP Developer mailing list (stp-dev@eclipse.org). See http://www.eclipse.org/mail/index_all.php for details on how to sign up. Copyright (c) 2006 IBM Corporation. All rights reserved. This program and the accompanying materials are made available under the terms of the Eclipse Public License v1.0 which accompanies this distribution, and is available at http://www.eclipse.org/legal/epl-v10.html |
[Overview] [Top] |
---|