Moved Java API support to japi package.

akka-actor/src/main/scala/actor/Agent.scala

@@ -6,7 +6,7 @@ package se.scalablesolutions.akka.actor
 
 import se.scalablesolutions.akka.stm.Ref
 import se.scalablesolutions.akka.AkkaException
-import se.scalablesolutions.akka.util.JavaAPI.{ Function => JFunc, Procedure => JProc }
+import se.scalablesolutions.akka.japi.{ Function => JFunc, Procedure => JProc }
 import java.util.concurrent.atomic.AtomicReference
 import java.util.concurrent.CountDownLatch
 

akka-actor/src/main/scala/dataflow/DataFlowVariable.scala

@@ -11,7 +11,7 @@ import se.scalablesolutions.akka.actor.{Actor, ActorRef}
 import se.scalablesolutions.akka.actor.Actor._
 import se.scalablesolutions.akka.dispatch.CompletableFuture
 import se.scalablesolutions.akka.AkkaException
-import se.scalablesolutions.akka.util.JavaAPI.{ Function, SideEffect }
+import se.scalablesolutions.akka.japi.{ Function, SideEffect }
 
 /**
  * Implements Oz-style dataflow (single assignment) variables.

akka-actor/src/main/scala/japi/JavaAPI.scala

@@ -0,0 +1,78 @@
+package se.scalablesolutions.akka.japi
+
+/**
+ * A Function interface. Used to create first-class-functions is Java (sort of).
+ */
+trait Function[T,R] {
+  def apply(param: T): R
+}
+
+/** A Procedure is like a Function, but it doesn't produce a return value
+ */
+trait Procedure[T] {
+  def apply(param: T): Unit
+}
+
+/**
+ * An executable piece of code that takes no parameters and doesn't return any value.
+ */
+trait SideEffect {
+  def apply: Unit
+}
+
+/**
+ * This class represents optional values. Instances of <code>Option</code>
+ * are either instances of case class <code>Some</code> or it is case
+ * object <code>None</code>.
+ * <p>
+ * Java API
+ */
+sealed abstract class Option[A] extends java.lang.Iterable[A] {
+  import scala.collection.JavaConversions._
+
+  def get: A
+  def isEmpty: Boolean
+  def isDefined = !isEmpty
+  def asScala: scala.Option[A]
+  def iterator = if (isEmpty) Iterator.empty else Iterator.single(get)
+}
+
+object Option {
+  /**
+   * <code>Option</code> factory that creates <code>Some</code>
+   */
+  def some[A](v: A): Option[A] = Some(v)
+
+  /**
+   * <code>Option</code> factory that creates <code>None</code>
+   */
+  def none[A] = None.asInstanceOf[Option[A]]
+
+  /**
+   * <code>Option</code> factory that creates <code>None</code> if
+   * <code>v</code> is <code>null</code>, <code>Some(v)</code> otherwise.
+   */
+  def option[A](v: A): Option[A] = if (v == null) none else some(v)
+
+  /**
+   * Class <code>Some[A]</code> represents existing values of type
+   * <code>A</code>.
+   */
+  final case class Some[A](v: A) extends Option[A] {
+    def get = v
+    def isEmpty = false
+    def asScala = scala.Some(v)
+  }
+
+  /**
+   * This case object represents non-existent values.
+   */
+  private case object None extends Option[Nothing] {
+    def get = throw new NoSuchElementException("None.get")
+    def isEmpty = true
+    def asScala = scala.None
+  }
+
+  implicit def java2ScalaOption[A](o: Option[A]): scala.Option[A] = o.asScala
+  implicit def scala2JavaOption[A](o: scala.Option[A]): Option[A] = option(o.get)
+}

akka-actor/src/main/scala/util/JavaAPI.scala

@@ -1,81 +0,0 @@
-package se.scalablesolutions.akka.util
-
-object JavaAPI {
-  /**
-   * A Function interface. Used to create first-class-functions is Java (sort of).
-   */
-  trait Function[T,R] {
-    def apply(param: T): R
-  }
-
-  /** A Procedure is like a Function, but it doesn't produce a return value
-   */
-  trait Procedure[T] {
-    def apply(param: T): Unit
-  }
-
-  /**
-   * An executable piece of code that takes no parameters and doesn't return any value.
-   */
-  trait SideEffect {
-    def apply: Unit
-  }
-
-  /**
-   * This class represents optional values. Instances of <code>Option</code>
-   * are either instances of case class <code>Some</code> or it is case
-   * object <code>None</code>.
-   * <p>
-   * Java API
-   */
-  sealed abstract class Option[A] extends java.lang.Iterable[A] {
-    import scala.collection.JavaConversions._
-
-    def get: A
-    def isEmpty: Boolean
-    def isDefined = !isEmpty
-    def asScala: scala.Option[A]
-    def iterator = if (isEmpty) Iterator.empty else Iterator.single(get)
-  }
-
-  object Option {
-    /**
-     * <code>Option</code> factory that creates <code>Some</code>
-     */
-    def some[A](v: A): Option[A] = Some(v)
-
-    /**
-     * <code>Option</code> factory that creates <code>None</code>
-     */
-    def none[A] = None.asInstanceOf[Option[A]]
-
-    /**
-     * <code>Option</code> factory that creates <code>None</code> if
-     * <code>v</code> is <code>null</code>, <code>Some(v)</code> otherwise.
-     */
-    def option[A](v: A): Option[A] = if (v == null) none else some(v)
-
-    /**
-     * Class <code>Some[A]</code> represents existing values of type
-     * <code>A</code>.
-     */
-    private final case class Some[A](v: A) extends Option[A] {
-      def get = v
-      def isEmpty = false
-      def asScala = scala.Some(v)
-    }
-
-    /**
-     * This case object represents non-existent values.
-     */
-    private case object None extends Option[Nothing] {
-      def get = throw new NoSuchElementException("None.get")
-      def isEmpty = true
-      def asScala = scala.None
-    }
-
-    implicit def java2ScalaOption[A](o: Option[A]): scala.Option[A] = o.asScala
-    implicit def scala2JavaOption[A](o: scala.Option[A]): Option[A] = option(o.get)
-  }
-}
-

akka-camel/src/main/scala/CamelContextLifecycle.scala

@@ -10,8 +10,8 @@ import org.apache.camel.{ProducerTemplate, CamelContext}
 import org.apache.camel.impl.DefaultCamelContext
 
 import se.scalablesolutions.akka.camel.component.TypedActorComponent
+import se.scalablesolutions.akka.japi.{Option => JOption}
 import se.scalablesolutions.akka.util.Logging
-import se.scalablesolutions.akka.util.JavaAPI.{Option => JOption}
 
 /**
  * Manages the lifecycle of a CamelContext. Allowed transitions are

akka-camel/src/main/scala/CamelService.scala

@@ -10,7 +10,7 @@ import org.apache.camel.CamelContext
 import se.scalablesolutions.akka.actor.Actor._
 import se.scalablesolutions.akka.actor.{AspectInitRegistry, ActorRegistry}
 import se.scalablesolutions.akka.config.Config._
-import se.scalablesolutions.akka.util.JavaAPI.{Option => JOption}
+import se.scalablesolutions.akka.japi.{Option => JOption}
 import se.scalablesolutions.akka.util.{Logging, Bootable}
 
 /**

akka-spring/src/test/scala/CamelServiceSpringFeatureTest.scala

@@ -21,7 +21,7 @@ class CamelServiceSpringFeatureTest extends FeatureSpec with BeforeAndAfterEach
     import CamelContextManager._
     scenario("with a custom CamelContext and access a registered typed actor") {
       val appctx = new ClassPathXmlApplicationContext("/appContextCamelServiceCustom.xml")
-      assert(context.isInstanceOf[SpringCamelContext])
+      assert(mandatoryContext.isInstanceOf[SpringCamelContext])
       assert("hello sample" === mandatoryTemplate.requestBody("direct:test", "sample"))
       appctx.close
     }
@@ -32,8 +32,8 @@ class CamelServiceSpringFeatureTest extends FeatureSpec with BeforeAndAfterEach
       val registry = new SimpleRegistry
       registry.put("custom", TypedActor.newInstance(classOf[SampleBeanIntf], classOf[SampleBean]))
       // set custom registry in DefaultCamelContext
-      assert(context.isInstanceOf[DefaultCamelContext])
+      assert(mandatoryContext.isInstanceOf[DefaultCamelContext])
-      context.asInstanceOf[DefaultCamelContext].setRegistry(registry)
+      mandatoryContext.asInstanceOf[DefaultCamelContext].setRegistry(registry)
       // access registered typed actor
       assert("hello sample" === mandatoryTemplate.requestBody("typed-actor:custom?method=foo", "sample"))
       appctx.close