org.apache.ode.jacob

## Class JacobRunnable

- java.lang.Object
- - org.apache.ode.jacob.JacobObject
  - - org.apache.ode.jacob.JacobRunnable

- All Implemented Interfaces:
    java.io.Serializable
  Direct Known Subclasses:
    BpelJacobRunnable, CELL_, ReplayerBpelRuntimeContextImpl.TimerResume, Sequence, Sieve, SynchPrinter.SystemPrinter, SynchPrinter.Tester

      public abstract class JacobRunnable
      extends JacobObject

  Base class for process abstractions. An abstraction is a parameterized process template, whose instantiation is termed a concretion. Abstractions may define a set of bound channel names or other parameters which are resolved at the time of the concretion. For example the process term abstraction of a memory cell: `Cell(s,v) := s ? { read(...) = ... & write(...) = ... }` would be represented by the following Java class: `

       public class Cell extends JacobRunnable {
           private CellChannel s;

           private Object v;

           public Cell(CellChannel s, Object v) {
               this.s = s;
               this.v = v;
           }

           public void run() {
            object(new CellChannelListener(s) { read(...) {...}
                                   write(...) {...} } );
          }
       }

  ` An example of the Java expression representing the concretion of this abstraction would look like: `

          .
          .
          // (new c) Cell(c,v)
          Integer v = Integer.valueOf(0);
          CellChannel c = (CellChannel)newChannel(CellChannel.class);
          instance(new Cell(c, v));
          .
          .

  `
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `JacobRunnable()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `java.util.Set<java.lang.reflect.Method>` | `getImplementedMethods()`
    `abstract void` | `run()` Peform the template reduction, i.e.
    `java.lang.String` | `toString()`

    - ### Methods inherited from class org.apache.ode.jacob.JacobObject

      `getClassName, getExtension, getMethod, importChannel, instance, newChannel, newChannel, object, object, object, object, replication, replication`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### JacobRunnable

          public JacobRunnable()

  - ### Method Detail

    - #### getImplementedMethods

          public java.util.Set<java.lang.reflect.Method> getImplementedMethods()

      Specified by:
        `getImplementedMethods` in class `JacobObject`

    - #### run

          public abstract void run()

      Peform the template reduction, i.e. do whatever it is that the templetized process does. This method may do some combination of in-line Java, and JACOB operations.

      Note that JACOB operations are performed in parallel, so the sequencing of JACOB operations is irrelevant

    - #### toString

          public java.lang.String toString()

      Overrides:
        `toString` in class `JacobObject`