Declaration of variables that will be needed below. The types are defined in various modules used above. The drivers_F90Driver_wrap type is a Babel idiom for the private data associated with the particular instance of this component, in an object-oriented sense.

When the framework calls setServices, it passes in a gov.cca.Services object (in C++ gov::cca::Services) that we need to keep a copy of in the private data associated with this instance of our component. Babel uses “reference counting” to track usage of objects in order to know when it is safe to delete them. Because Fortran has no native mechanism for reference counting, we must use Babel's addRef method to indicate that we're storing a reference to the services object that the framework passed in to setServices

The services methods to register uses and provides ports requires a gov.cca.TypeMap (in Fortran TypeMap), which we create here.

In SIDL, methods can throw exceptions. In languages like Fortran, which don't have native support for exceptions (if you're not familiar with exceptions, it is sufficient to think of them as error codes), they are translated into an additional subroutine argument (in this case excpt) which then should be checked (“caught”). We'll add the checkExceptionDriver method in Step 2.

When Babel creates myTypeMap, it will (internally) add a reference to it. Once we're done using it, we can tell Babel that by calling Babel's deleteRef method, which you can see at the end of the routine. When the reference count goes to zero, Babel will destroy the myTypeRef object and reclaim the memory associated with it.

	Caution
	Failure to follow proper reference counting procedures in Babel/Fortran (or other non-OO languages, such as C) code will lead to “memory leaks” in your application. See the Babel Users' Guide for more detailed information.

In order to register the ports that our component will provide with the framework, we use the addProvidesPort method of the gov.cca.Services interface. You can find this interface in the cca.sidl file (where you previously looked up gov.cca.Component and gov.cca.ports.GoPort) in order to check its signature, which is:

...
void addProvidesPort(in gov.cca.Port inPort,
                     in string portName,
                     in string type,
                     in gov.cca.TypeMap properties )
       throws gov.cca.CCAException ;
...

(Of course we're actually calling the Fortran 90 version of the interface.)

The first argument is the object that actually provides the port. The way we wrote the SIDL, the drivers.F90Driver class provides the port, and since we're writing a method within this class, we use Babel's cast method to cast our self pointer to type gov.cca.Port.

The second and third arguments are a local name for the port, which must be unique within the component, and a type, which should be globally unique. If the actual types of the ports don't match between user and provider, it will cause a failed cast or possibly a segmentation fault. The string type here is a convenience to the user, giving a human-readable way to identify the type of the port that can be presented in the framework's user interface. By convention, the SIDL interface name for the port is used for the type.

The final argument is a gov.cca.TypeMap. This is a CCA-defined type that provides a simple hash table that can be used to associate properties with a provides port. In practice, it is rarely used, but must be present.

We must also tell the framework which ports we expect to use from other components. Looking in cca.sidl, we find that the method's signature is:

...
void registerUsesPort(in string portName,
                      in string type,
                      in gov.cca.TypeMap properties ) 
     throws gov.cca.CCAException ;
...

The first and second arguments are a local name for the port, following the same rules and conventions as in the addProvidesPort invocation above. The final argument is, once again, a gov.cca.TypeMap, again like addProvidesPort.

Declarations for modules we need to use in this routine.

Setup the variables and parameters with which to call the integrator.

These portions of the code are associated with getting a handle to the particular integrator.IntegratorPort that the driver's uses port has been connected to.

First, we have to declare variables of the appropriate type to hold the port. Because of the way OO programming works in CCA/Babel, we first get the port as a generic gov.cca.Port (gov_cca_Port_t in Fortran 90) and then cast it to the specific port we need to use, integrator.IntegratorPort (integrator_IntegratorPort_t in Fortran 90). Recall that integrator.IntegratorPort is defined in student-src/ports/sidl/integrator.sidl).

Then, we invoke the getPort on our frameworkServices object. The argument to this method is the local name we used in the registerUsesPort invocation, and it returns a gov.cca.Port (and an exception).

Finally, we use Babel's cast method to cast the generic port to the specific integrator port that we need.

This code checks that the getPort worked, and returned a valid port. If the getPort fails, or if the driver's uses port has not been connected to an appropriate provider, then getPort will return a null port object. The is_null method is automatically available on the Fortran 90 binding of any SIDL object. Because the driver can't do anything without being properly connected to an integrator, the response to getPort failing is to abort by returning a non-zero value.

It is also possible that a valid gov.cca.Port would be returned, but it might not be the integrator.IntegratorPort we expect. If this is the case, the cast will return a null value. The proper action in this case is also to fail gracefully by returning a non-zero result.

	Note
	getPort returning nil need not be treated as a fatal error in all cases. For example, a component may be designed so that certain ports are optional -- to be used if present, but to be ignored if not. Another possibility is that the component may be able to accomplish the same thing through several different ports, so that only one of a given group needs to be connected.

Here we actually call the integrate method on the integrator port we just got a handle for. The signature of the integrate method is defined in student-src/ports/sidl/integrator.sidl. Notice that while the SIDL definition of integrate shows it as a function, returning a double precision result, in Fortran 90, Babel translates this into a subroutine with the return value as an extra argument. This is because Fortran does not support functions returning all types (arrays, for example).

Finally, once we're done using the port, we call releasePort.

It is considered impolite for a component to call exit because it will bring down the entire application, and possibly crash the framework. Instead, components should simply return.