//设置package包名称以及导入依赖的类
package chapter17


  import scala.collection.immutable.TreeSet
  val ts = TreeSet(9, 3, 1, 8, 0, 2, 7, 4, 6, 5)
  println(ts)
  val ts2 = TreeSet(ts.toSeq: _*)(ts.ordering.reverse)
  println(ts2)
  val cs = TreeSet('f', 'u', 'n')
  println(cs)

  import scala.collection.immutable.TreeMap
  var tm = TreeMap(3 -> 'x', 1 -> 'x', 4 -> 'x')
  tm += (2 -> 'x')
  println(tm)

  val tm2 = TreeMap(tm.toSeq: _*)(tm.ordering.reverse)
  println(tm2)

} 

//设置package包名称以及导入依赖的类
package akka.stream

import akka.stream.testkit.AkkaSpec
import akka.stream.scaladsl.Flow
import akka.actor.ActorContext
import scala.concurrent.Await
import scala.concurrent.duration._
import akka.actor.ActorRef
import scala.collection.immutable.TreeSet
import scala.util.control.NonFatal
import akka.stream.impl.ActorBasedFlowMaterializer

class ProcessorHierarchySpec extends AkkaSpec("akka.actor.debug.lifecycle=off\nakka.loglevel=INFO") {

  val materializer = FlowMaterializer(MaterializerSettings())

  def self = ActorBasedFlowMaterializer.currentActorContext().self

  "An ActorBasedFlowMaterializer" must {

    "generate the right level of descendants" in {
      val f = Flow(() ? {
        testActor ! self
        Flow(List(1)).map(x ? { testActor ! self; x }).toProducer(materializer)
      }).take(3).foreach(x ? {
        testActor ! self
        Flow(x).foreach(_ ? testActor ! self).consume(materializer)
      }).toFuture(materializer)
      Await.result(f, 3.seconds)
      val refs = receiveWhile(idle = 250.millis) {
        case r: ActorRef ? r
      }
      try {
        refs.toSet.size should be(8)
        refs.distinct.map(_.path.elements.size).groupBy(x ? x).mapValues(x ? x.size) should be(Map(2 -> 2, 3 -> 6))
      } catch {
        case NonFatal(e) ?
          println(refs.map(_.toString).to[TreeSet].mkString("\n"))
          throw e
      }
    }

  }

} 

//设置package包名称以及导入依赖的类
package com.rklaehn.persistentsummary

import scala.collection.immutable.{ CollectionTreeUtil, TreeSet }
import scala.util.Random

object TreePrinter extends App {
  var t = TreeSet.empty[Int]
  val r = new Random()
  for (i ? 0 until 10)
    t += r.nextInt(100)
  val text = CollectionTreeUtil.toGraphVizDot(t)
  println(text)

  t += r.nextInt(100)
  val text2 = CollectionTreeUtil.toGraphVizDot(t)
  println(text2)
} 

//设置package包名称以及导入依赖的类
package com.rklaehn.persistentsummary

import ichi.bench.Thyme

import scala.collection.immutable.TreeSet

object SimpleTreeSetSummaryBench extends App {

  val th = Thyme.warmed(warmth = Thyme.HowWarm.BenchOff, verbose = println)

  val summarizer = PersistentSummary.treeSet(IntLongSummary)

  def buildCached(n: Int): Long = {
    var current = TreeSet.empty[Int]
    var totalSum = 0L
    for (i ? 0 until n) {
      current += i
      totalSum += summarizer(current)
    }
    totalSum
  }

  def buildUncached(n: Int): Long = {
    var current = TreeSet.empty[Int]
    var totalSum = 0L
    for (i ? 0 until n) {
      current += i
      totalSum += current.iterator.map(_.toLong).sum
    }
    totalSum
  }

  val n = 5000
  val s = TreeSet(0 until n: _*)
  def accessSummary(): Long = {
    summarizer(s)
  }

  def summarySmallChange(): Long = {
    val s1 = s + 10000
    summarizer(s)
  }

  def sumSmallChange(): Long = {
    val s1 = s + 10000
    s1.iterator.map(_.toLong).sum
  }

  println("measures the time to access an already existing summary from a guava cache with weak keys")
  th.pbenchWarm(th.Warm(accessSummary()), title = "access")

  println("compares persistent summary with recalculating from scratch every time")
  th.pbenchOffWarm(s"build 1 to $n uncached vs. cached")(th.Warm(buildUncached(n)))(th.Warm(buildCached(n)))

  println("compare persistent summary with recalculating from scratch (single update to large collection)")
  th.pbenchOffWarm(s"update 5000 / 1 uncached vs. cached")(th.Warm(sumSmallChange()))(th.Warm(summarySmallChange()))

} 

//设置package包名称以及导入依赖的类
package cwe.scala.library.audit.listener
import cwe.scala.library.audit._
import cwe.scala.library.audit.data._
import cwe.scala.library.runtime.io.Logger
import scala.collection.immutable.TreeSet


class BootstrapListener extends AuditEventListener {
	private var forwardListener: AuditEventListener = null
	private var eventBuffer = new TreeSet[AuditEvent]

	// Dependency injection

	def setForwardListener(l: AuditEventListener) = {
		if (l == null) throw new IllegalArgumentException("AuditEventListener cannot be null")
		else synchronized { forwardListener = l }
	}
	def getForwardListener(): AuditEventListener = {
		if (forwardListener == null) synchronized { if (forwardListener == null) setForwardListener(getTraceService) }
		forwardListener
	}
	private def getTraceService = {
		val ts = AuditServiceProvider.createTraceService
		ts.setLogger(Logger.createInstance("bootstrap"))
		ts
	}

	// Implementation

	def handleAuditEvent(e: AuditEvent) = {
		// if first event, then forces the creation of the forwardListener to force all remaining events
		if (eventBuffer.isEmpty) getForwardListener()
		eventBuffer += e
	}

	def unregistred() = {
		val l = this.getForwardListener()
		this.eventBuffer.foreach((e) => { l.handleAuditEvent(e) })
		l.unregistred()
	}
	private def myThreadId = Thread.currentThread().getId()
	private def currentTime = System.currentTimeMillis()
} 

//设置package包名称以及导入依赖的类
package net.woaf.jono.phonehome

import scala.language.experimental.macros

import scala.reflect.macros.blackbox.Context
import scala.collection.immutable.TreeSet


object EnumerationMacros {
  def sealedInstancesOf[A]: TreeSet[A] = macro sealedInstancesOfImpl[A]

  def sealedInstancesOfImpl[A: c.WeakTypeTag](c: Context): c.Expr[TreeSet[A]] = {
    import c.universe._ // scalastyle:ignore

    val symbol = weakTypeOf[A].typeSymbol.asClass

    if  (!symbol.isClass || !symbol.isSealed) {
      c.abort(c.enclosingPosition, "Can only enumerate values of a sealed trait or class.")
    } else {

      val children = symbol.knownDirectSubclasses.toList

      if (!children.forall(_.isModuleClass)) {
        c.abort(c.enclosingPosition, "All children must be objects.")
      } else {
        c.Expr[TreeSet[A]] {

          def sourceModuleRef(sym: Symbol) = Ident(sym.asInstanceOf[scala.reflect.internal.Symbols#Symbol
            ].sourceModule.asInstanceOf[Symbol]
          )

          Apply(
            Select(
              reify(TreeSet).tree,
              TermName("apply")
            ),
            children.map(sourceModuleRef(_))
          )
        }
      }
    }
  }
}