- “case object” will emit a concrete class without constructor, so put
abstract class in its way in order to obtain an accessible type for
Scala & Java (i.e. without $)
- add “def instance = this” to make access uniform from Java
- this does not work for nested case objects because of missing static
forwarders, so keep those as they were
- fix issue with case object FromConfig colliding with case class
FromConfig by open-coding the “case”iness in this case (should be
thrown out in 2.1)
- there is one remaining bug, which makes it impossible to implement
Function1[T, Boolean] from Java (I wonder if this will ever work,
given that there is no equivalent type expressible in Java)
- hence create Function1 in Scala code, Java only prepares a Filter SAM
which does not inherit from anything
- ugly (one more alloc) but the only way I see right now.
* ActorTimeout (akka.actor.timeout) was used to all sorts of things.
* TestKit default-timeout
* TypedActor timeout for non void methods
* Transactor coordinated-timeout
* ZeroMQ new-socket-timeout
* And in various tests
- PropertyMaster is the only place in Akka which calls
ClassLoader.getClass (apart from kernel, which might be special)
- all PropertyMaster methods (there are only three) take a ClassManifest
of what is to be constructed, and they verify that the obtained object
is actually compatible with the required type
Other stuff:
- noticed that I had forgotten to change to ExtendedActorSystem when
constructing Extensions by ExtensionKey (damn you, reflection!)
- moved Serializer.currentSystem into JavaSerializer, because that’s the
only one needing it (it’s only used in readResolve() methods)
- Serializers are constructed now with one-arg constructor taking
ExtendedActorSystem (if that exists, otherwise no-arg as before), to
allow JavaSerializer to do its magic; possibly necessary for others as
well
- Removed all Option[ClassLoader] signatures
- made it so that the ActorSystem will try context class loader, then
the class loader which loaded the class actually calling into
ActorSystem.apply, then the loader which loaded ActorSystemImpl
- for the second of the above I added a (reflectively accessed hopefully
safe) facility for getting caller Class[_] objects by using
sun.reflect.Reflection; this is optional an defaults to None, e.g. on
Android, which means that getting the caller’s classloader is done on
a best effort basis (there’s nothing we can do because a StackTrace
does not contain actual Class[_] objects).
- refactored DurableMailbox to contain the owner val and use that
instead of declaring that in all subclasses
- add provider, guardian, systemGuardian and deathWatch to it
- make ActorSystemImpl extend ExtendedActorSystem
- use ExtendedActorSystem for creating extensions, thereby limiting the
access extensions get to just those four published methods.
* Added sample and documentation for how to create extension for application specific config
* Simplified java usage of ExtensionIdProvider, more aligned with how it is done in scala
