ResourceScope

A (managable) object for managing resources with lifetimes that do not nest nicely.

using(new ResourceScope) { rs =>
val in = rs.open(new FileInputStream("a"))
val out = rs.open(new FileOutputStream("b"))
rs.close(in) // explicit close of a resource
throw new Exception // resource scope ensures "out" is closed
}

Resource scopes may themselves be owned by other resource scopes. It is possible to build an object which contains complex sub-resources in this fashion.

def allocateComplexThing() =
using(new ResourceScope("temp")) { tmpScope =>
  new ComplexThing {
    // If ComplexThing's ctor throws, tmpScope will ensure cleanup
    val myScope = tmpScope.open(new ResourceScope("complex thing"))
    val sub1 = myScope.open(subResourceOne())
    val sub2 = myScope.open(subResourceTwo())
    // The very last thing the constructor does is unmanage
    // the scope and so take ownership.
    tmpScope.unmanage(myScope)
    def close() { myScope.close() }
  }
}

All methods on this class are thread-safe up to disposal of the ResourceScope itself.

Linear Supertypes

AnyRef, Any

Instance Constructors

new ResourceScope(name: String = ResourceScope.anonymousScopeName)

Value Members

final def !=(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def !=(arg0: Any): Boolean

Definition Classes
Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def ==(arg0: Any): Boolean

Definition Classes
Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def close(): Unit

Closes all resources contained in this scope, in the reverse order they were added.
def close(value: Any): Unit
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def isManaged(x: Any): Boolean
val name: String
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def open[T](value: ⇒ T, transitiveClose: Seq[Any] = Nil)(implicit res: Resource[T]): T

Manages a resource.
Manages a resource. Once a resource is managed, to close it explicitly use the close(Any) method on the ResourceScope, not any close on the managed object.
Optionally, this function can take a list of values to automatically close when the current resource is closed. Those values must be resources managed by this scope. If this value is transferred to another scope, the other resources will be transferred along with it.

Exceptions thrown
IllegalArgumentException
if the value is already managed by this scope, or if any value listed in transitiveClose is not.
def openUnmanaged[T](value: ⇒ T, transitiveClose: Seq[Any] = Nil): T

Registers an unmanaged value with this scope.
Registers an unmanaged value with this scope. This isn't very useful in itself, but it can take a list of values to transitively close, just like open. This is useful for things like iterator wrappers which are not themselves closeable but which refer to closable things, and which may be transferred to other scopes.

Exceptions thrown
IllegalArgumentException
if the value is already "managed" by this scope, or if any value listed in transitiveClose is not.
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
ResourceScope → AnyRef → Any
def transfer[A](value: A): Transferator[A]

Transfers a resource's ownership (and that of all its dependencies) between two scopes.
Transfers a resource's ownership (and that of all its dependencies) between two scopes.
```
rs1.transfer(something).to(rs2)
rs2.transfer(something).from(rs1) // equivalent
```
If the resource has dependencies, the order in which they are transferred to the other scope is defined only up to what can be inferred by the graph formed by those dependencies. That is:
```
val d1 = rs1.open(f())
val d2 = rs1.open(f())
val r = rs1.open(g(), transitiveClose = List(d1, d2))
// rs1.close() would be guaranteed to close [r, d2, d1]
rs1.transfer(r).to(rs2)
rs2.close() // may close either [r, d2, d1], or [r, d1, d2]
```
Exceptions thrown
IllegalArgumentException
if the value is not managed by the source scope
Note
This function is easy to use incorrectly; it depends on the declared dependency graph being correct.
def unmanage(value: Any): Unit

Un-manages a resource.
Un-manages a resource. If this succeeds, the value will no longer be managed at all.

Exceptions thrown
IllegalArgumentException
if the value is not managed by this scope

def unmanagedWithAssociatedScope[A](associatedScopeName: String = ResourceScope.anonymousScopeName)(f: (ResourceScope) ⇒ A): A

Utility for creating an owned-but-unmanaged object with an associated managed scope.

using(new ResourceScope("scope")) { rs =>
val lines: Iterator[Line] = rs.unmanagedWithAssociatedScope("iterator scope") { itScope =>
  val stream = itScope.open(new FileInputStream("/tmp/foo"))
  linesOfFile(stream) // if this throws, stream will be closed before unmanagedWithAssociatedScope returns
}
rs.close(lines) // closes the associated FileInputStream
}

final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def withCleanup[T, U](value: ⇒ T, transitiveClose: Seq[Any] = Nil)(cleanup: (T) ⇒ U): T

Registers an value with this scope with an ad-hoc cleanup operation.
Registers an value with this scope with an ad-hoc cleanup operation.

Exceptions thrown
IllegalArgumentException
if the value is already managed by this scope, or if any value listed in transitiveClose is not.

final class ResourceScope extends AnyRef

Instance Constructors

new ResourceScope(name: String = ResourceScope.anonymousScopeName)

Value Members

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def close(): Unit

def close(value: Any): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def getClass(): Class[_]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def isManaged(x: Any): Boolean

val name: String

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def open[T](value: ⇒ T, transitiveClose: Seq[Any] = Nil)(implicit res: Resource[T]): T

def openUnmanaged[T](value: ⇒ T, transitiveClose: Seq[Any] = Nil): T

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def transfer[A](value: A): Transferator[A]

def unmanage(value: Any): Unit

def unmanagedWithAssociatedScope[A](associatedScopeName: String = ResourceScope.anonymousScopeName)(f: (ResourceScope) ⇒ A): A

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withCleanup[T, U](value: ⇒ T, transitiveClose: Seq[Any] = Nil)(cleanup: (T) ⇒ U): T

Inherited from AnyRef

Inherited from Any

Ungrouped