Value Members

1.  object AsynchronousPool extends Serializable

   The namespace that contains the implementation of the asynchronous resource pool.

   The namespace that contains the implementation of the asynchronous resource pool.

   Example:

   1. Given a factory that creates resources,

      import scalaz.Tags.Parallel
      import scalaz._
      import scalaz.syntax.tag._
      import scalaz.syntax.all._
      import com.thoughtworks.future._
      import com.thoughtworks.raii.asynchronous._
      import com.thoughtworks.raii.AsynchronousPool
      import java.lang.AutoCloseable
      
      trait MyResource extends AutoCloseable {
        def inUse(): Unit
      }
      
      val myResourceStub0 = stub[MyResource]
      val myResourceStub1 = stub[MyResource]
      val myResourceStub2 = stub[MyResource]
      
      val myResourceFactoryMock = mockFunction[MyResource]
      myResourceFactoryMock.expects().returns(myResourceStub0)
      myResourceFactoryMock.expects().returns(myResourceStub1)
      myResourceFactoryMock.expects().returns(myResourceStub2)

      then it can be converted to a resource pool, which holds some instances of MyResource.

      val myResourcePool: Do[Do[MyResource]] = AsynchronousPool.fixed(
        resourceFactory = Do.autoCloseable(myResourceFactoryMock()),
        poolSize = 3
      )

      When some clients are using the resource pool,

      def client(acquire: Do[MyResource], operationsPerClient: Int): Do[Unit] = {
        Do.nested[Unit](acquire.flatMap { myResource =>
          Do.execute {
              myResource.inUse
            }
            .replicateM_(operationsPerClient)
        })
      }
      def allClients(acquire: Do[MyResource], numberOfClients: Int, operationsPerClient: Int): ParallelDo[Unit] = {
        implicit def keepLastException = new Semigroup[Throwable] {
          override def append(f1: Throwable, f2: => Throwable) = f2
        }
        Applicative[ParallelDo].replicateM_(numberOfClients, Parallel(client(acquire, operationsPerClient)))
      }
      def usingPool(numberOfClients: Int, operationsPerClient: Int) = {
        myResourcePool.flatMap { acquire =>
          allClients(acquire, numberOfClients, operationsPerClient).unwrap
        }
      }

      then the operations from these clients should be distributed on those MyResources, and those MyResources should be closed after being used.

      usingPool(numberOfClients = 10, operationsPerClient = 10).run.map { _: Unit =>
        ((myResourceStub0.inUse _): () => Unit).verify().repeated(30 to 40)
        ((myResourceStub0.close _): () => Unit).verify().once()
      
        ((myResourceStub1.inUse _): () => Unit).verify().repeated(30 to 40)
        ((myResourceStub1.close _): () => Unit).verify().once()
      
        ((myResourceStub2.inUse _): () => Unit).verify().repeated(30 to 40)
        ((myResourceStub2.close _): () => Unit).verify().once()
      
        succeed
      }.toScalaFuture

2.  object AsynchronousSemaphore
3.  object asynchronous

   The namespace that contains Do.

   The namespace that contains Do.

   Author:

   杨博 (Yang Bo) <[email protected]>

4.  object covariant extends CovariantResourceTInstances0

   The namespace that contains the covariant ResourceT.

   The namespace that contains the covariant ResourceT.

   Usage:

   import com.thoughtworks.raii.covariant._

5.  object invariant extends InvariantResourceTInstances0

   The namespace that contains the invariant ResourceT.

   The namespace that contains the invariant ResourceT.

   Usage:

   import com.thoughtworks.raii.invariant._

6.  object shared
   Author:

   杨博 (Yang Bo) <[email protected]>