├── .gitignore ├── sonatype.sbt ├── work └── PowerScala Logo.ai ├── command └── src │ └── main │ └── scala │ └── org │ └── powerscala │ └── command │ ├── Command.scala │ ├── CommandInterpreter.scala │ ├── CommandImplementation.scala │ ├── CommandManager.scala │ ├── StandardIO.scala │ └── test │ └── Test.scala ├── core ├── src │ ├── main │ │ └── scala │ │ │ └── org │ │ │ └── powerscala │ │ │ ├── group │ │ │ ├── package.scala │ │ │ └── TypedGroup.scala │ │ │ ├── Compass.scala │ │ │ ├── easing │ │ │ ├── Linear.scala │ │ │ ├── Sine.scala │ │ │ ├── Quadratic.scala │ │ │ ├── Cubic.scala │ │ │ ├── Quartic.scala │ │ │ ├── Quintic.scala │ │ │ ├── Circular.scala │ │ │ ├── Back.scala │ │ │ ├── Exponential.scala │ │ │ ├── Bounce.scala │ │ │ ├── Elastic.scala │ │ │ └── Easing.scala │ │ │ ├── ref │ │ │ ├── SoftReference.scala │ │ │ ├── WeakReference.scala │ │ │ ├── ReferenceType.scala │ │ │ ├── Reference.scala │ │ │ ├── HardReference.scala │ │ │ └── PhantomReference.scala │ │ │ ├── collection │ │ │ ├── HierarchicalIterator.scala │ │ │ └── BiMap.scala │ │ │ ├── Unique.scala │ │ │ ├── StringUtil.scala │ │ │ ├── encryption │ │ │ └── PasswordFactory.scala │ │ │ ├── Version.scala │ │ │ ├── Color.scala │ │ │ ├── Country.scala │ │ │ ├── Currency.scala │ │ │ └── Language.scala │ └── test │ │ └── scala │ │ └── spec │ │ └── HierarchicalIteratorSpec.scala └── .jvm │ └── src │ └── main │ └── scala │ └── org │ └── powerscala │ └── util │ └── NetUtil.scala ├── README.md ├── console └── src │ └── main │ └── scala │ └── org │ └── powerscala │ └── console │ ├── Text.scala │ ├── ctrl │ ├── Tab.scala │ ├── Return.scala │ ├── ClearLine.scala │ ├── FormFeed.scala │ ├── NewLine.scala │ ├── Backspace.scala │ ├── Reset.scala │ ├── EraseLine.scala │ ├── ClearScreen.scala │ ├── SavePosition.scala │ ├── RestorePosition.scala │ ├── CursorUp.scala │ ├── CursorBack.scala │ ├── CursorDown.scala │ ├── CursorForward.scala │ └── Alignment.scala │ ├── bg │ ├── Red.scala │ ├── Black.scala │ ├── Blue.scala │ ├── Cyan.scala │ ├── Green.scala │ ├── White.scala │ ├── Yellow.scala │ └── Magenta.scala │ ├── fg │ ├── Blue.scala │ ├── Cyan.scala │ ├── Red.scala │ ├── Black.scala │ ├── Green.scala │ ├── White.scala │ ├── Magenta.scala │ └── Yellow.scala │ ├── fx │ ├── Bold.scala │ ├── Blink.scala │ ├── Invisible.scala │ ├── Reversed.scala │ └── Underlined.scala │ ├── StringText.scala │ ├── package.scala │ ├── GroupedText.scala │ ├── ControlText.scala │ ├── Line.scala │ └── Console.scala ├── project ├── plugins.sbt └── PowerScalaBuild.scala ├── io └── src │ └── main │ └── scala │ └── org │ └── powerscala │ └── io │ ├── watcher │ ├── EventKind.scala │ ├── PathEvent.scala │ └── Watcher.scala │ ├── package.scala │ └── IO.scala ├── .travis.yml └── concurrent └── src └── main └── scala └── org └── powerscala └── concurrent ├── AtomicBoolean.scala ├── Precision.scala ├── AtomicInt.scala └── Time.scala /.gitignore: -------------------------------------------------------------------------------- 1 | */target/ 2 | target/ 3 | .idea/ -------------------------------------------------------------------------------- /sonatype.sbt: -------------------------------------------------------------------------------- 1 | sonatypeProfileName := "org.powerscala" -------------------------------------------------------------------------------- /work/PowerScala Logo.ai: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/outr/powerscala/HEAD/work/PowerScala Logo.ai -------------------------------------------------------------------------------- /command/src/main/scala/org/powerscala/command/Command.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.command 2 | 3 | trait Command -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/group/package.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | package object group { 4 | } -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | powerscala 2 | ========== 3 | 4 | Powerful framework providing many useful utilities and features on top of the Scala language. 5 | 6 | -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/Text.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console 2 | 3 | trait Text { 4 | def content: String 5 | def length: Int 6 | } 7 | -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/Tab.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Tab extends ControlText("\t") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/bg/Red.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.bg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Red extends ControlText(Console.RED_B) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/Return.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Return extends ControlText("\r") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fg/Blue.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Blue extends ControlText(Console.BLUE) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fg/Cyan.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Cyan extends ControlText(Console.CYAN) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fg/Red.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Red extends ControlText(Console.RED) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fx/Bold.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fx 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Bold extends ControlText(Console.BOLD) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/bg/Black.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.bg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Black extends ControlText(Console.BLACK_B) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/bg/Blue.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.bg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Blue extends ControlText(Console.BLUE_B) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/bg/Cyan.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.bg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Cyan extends ControlText(Console.CYAN_B) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/bg/Green.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.bg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Green extends ControlText(Console.GREEN_B) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/bg/White.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.bg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object White extends ControlText(Console.WHITE_B) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/ClearLine.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object ClearLine extends ControlText("") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/FormFeed.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object FormFeed extends ControlText("\f") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/NewLine.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object NewLine extends ControlText("\n") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fg/Black.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Black extends ControlText(Console.BLACK) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fg/Green.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Green extends ControlText(Console.GREEN) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fg/White.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object White extends ControlText(Console.WHITE) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fx/Blink.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fx 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Blink extends ControlText(Console.BLINK) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/bg/Yellow.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.bg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Yellow extends ControlText(Console.YELLOW_B) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/Backspace.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Backspace extends ControlText("\b") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/Reset.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Reset extends ControlText(Console.RESET) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fg/Magenta.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Magenta extends ControlText(Console.MAGENTA) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fg/Yellow.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Yellow extends ControlText(Console.YELLOW) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/StringText.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console 2 | 3 | case class StringText(content: String) extends Text { 4 | lazy val length: Int = content.length 5 | } 6 | -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/bg/Magenta.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.bg 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Magenta extends ControlText(Console.MAGENTA_B) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/EraseLine.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object EraseLine extends ControlText("\u001b[K") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fx/Invisible.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fx 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Invisible extends ControlText(Console.INVISIBLE) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fx/Reversed.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fx 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Reversed extends ControlText(Console.REVERSED) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/ClearScreen.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object ClearScreen extends ControlText("\u001b[2J") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/SavePosition.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object SavePosition extends ControlText("\u001b[s") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/fx/Underlined.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.fx 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object Underlined extends ControlText(Console.UNDERLINED) -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/RestorePosition.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | object RestorePosition extends ControlText("\u001b[u") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/CursorUp.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | case class CursorUp(lines: Int = 1) extends ControlText(s"\033[${lines}A") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/package.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | import scala.language.implicitConversions 4 | 5 | package object console { 6 | implicit def string2Text(s: String): Text = StringText(s) 7 | } -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/CursorBack.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | case class CursorBack(lines: Int = 1) extends ControlText(s"\033[${lines}D") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/CursorDown.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | case class CursorDown(lines: Int = 1) extends ControlText(s"\033[${lines}B") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/CursorForward.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | case class CursorForward(lines: Int = 1) extends ControlText(s"\033[${lines}C") -------------------------------------------------------------------------------- /project/plugins.sbt: -------------------------------------------------------------------------------- 1 | addSbtPlugin("com.eed3si9n" % "sbt-unidoc" % "0.3.3") 2 | 3 | addSbtPlugin("org.scala-js" % "sbt-scalajs" % "0.6.14") 4 | 5 | addSbtPlugin("org.xerial.sbt" % "sbt-sonatype" % "1.1") 6 | 7 | addSbtPlugin("com.jsuereth" % "sbt-pgp" % "1.0.0") -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/GroupedText.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console 2 | 3 | case class GroupedText(items: Seq[Text]) extends Text { 4 | lazy val content: String = items.map(_.content).mkString 5 | lazy val length: Int = items.map(_.length).sum 6 | } -------------------------------------------------------------------------------- /io/src/main/scala/org/powerscala/io/watcher/EventKind.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.io.watcher 2 | 3 | sealed trait EventKind 4 | 5 | object EventKind { 6 | case object Create extends EventKind 7 | case object Modify extends EventKind 8 | case object Delete extends EventKind 9 | } -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ControlText.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console 2 | 3 | class ControlText(val content: String, val length: Int = 0) extends Text { 4 | def apply(text: Text*): GroupedText = GroupedText(Seq(this) ++ text ++ Seq(ctrl.Reset)) 5 | 6 | override def toString: String = getClass.getSimpleName 7 | } 8 | -------------------------------------------------------------------------------- /command/src/main/scala/org/powerscala/command/CommandInterpreter.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.command 2 | 3 | /** 4 | * CommandInterpreter interprets commands that are received by an implementation. 5 | */ 6 | trait CommandInterpreter { 7 | def toCommand(line: String): Option[Command] 8 | 9 | def fromCommand(command: Command): String 10 | } -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/Line.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console 2 | 3 | import org.powerscala.console.ctrl._ 4 | 5 | class Line(console: Console) { 6 | console.write(NewLine) 7 | 8 | def write(text: Text*): Unit = console.write(Seq(Return, CursorUp(1), ClearLine) ++ text.diff(Seq(NewLine)) ++ Seq(NewLine): _*) 9 | } 10 | -------------------------------------------------------------------------------- /command/src/main/scala/org/powerscala/command/CommandImplementation.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.command 2 | 3 | /** 4 | * CommandImplementation handles the method of communication. 5 | */ 6 | trait CommandImplementation { 7 | def start(manager: CommandManager): Unit 8 | 9 | def send(line: String): Unit 10 | 11 | def dispose(): Unit 12 | } 13 | -------------------------------------------------------------------------------- /io/src/main/scala/org/powerscala/io/watcher/PathEvent.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.io.watcher 2 | 3 | import java.nio.file.Path 4 | 5 | case class PathEvent(path: Path, directory: Path, kinds: Set[EventKind], lastModified: Long) { 6 | override def toString: String = s"PathEvent(path: $path, directory: $directory, kinds: $kinds, lastModified: $lastModified)" 7 | } 8 | -------------------------------------------------------------------------------- /.travis.yml: -------------------------------------------------------------------------------- 1 | sudo: false 2 | language: scala 3 | scala: 4 | - 2.11.8 5 | jdk: 6 | - oraclejdk8 7 | cache: 8 | directories: 9 | - $HOME/.ivy2/cache 10 | - $HOME/.sbt/boot 11 | before_cache: 12 | - find $HOME/.ivy2 -name "ivydata-*.properties" -delete 13 | - find $HOME/.sbt -name "*.lock" -delete 14 | notifications: 15 | slack: outr:A8tndkIibmnKjv7YBMnAK7SE -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/ctrl/Alignment.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console.ctrl 2 | 3 | import org.powerscala.console.ControlText 4 | 5 | sealed abstract class Alignment extends ControlText("") 6 | 7 | object Alignment { 8 | case object Left extends Alignment 9 | case object Center extends Alignment 10 | case object Right extends Alignment 11 | } -------------------------------------------------------------------------------- /command/src/main/scala/org/powerscala/command/CommandManager.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.command 2 | 3 | trait CommandManager { 4 | def implementation: CommandImplementation 5 | def interpreter: CommandInterpreter 6 | 7 | def process(command: Command): Unit 8 | def send(command: Command): Unit = { 9 | val line = interpreter.fromCommand(command) 10 | implementation.send(line) 11 | } 12 | 13 | implementation.start(this) 14 | } -------------------------------------------------------------------------------- /concurrent/src/main/scala/org/powerscala/concurrent/AtomicBoolean.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.concurrent 2 | 3 | import java.util.concurrent.atomic.{AtomicBoolean => JavaAtomic} 4 | 5 | class AtomicBoolean extends JavaAtomic { 6 | def apply() = get() 7 | 8 | def attempt[R](f: => R): Option[R] = if (compareAndSet(false, true)) { 9 | try { 10 | Some(f) 11 | } finally { 12 | set(false) 13 | } 14 | } else { 15 | None 16 | } 17 | } 18 | -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/Compass.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | import enumeratum._ 4 | 5 | /** 6 | * Compass represents the points on a compass as an enum. 7 | */ 8 | sealed abstract class Compass extends EnumEntry 9 | 10 | object Compass extends Enum[Compass] { 11 | case object North extends Compass 12 | case object South extends Compass 13 | case object East extends Compass 14 | case object West extends Compass 15 | 16 | val values = findValues.toVector 17 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Linear.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | object Linear { 4 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 5 | change * time / duration + start 6 | } 7 | 8 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 9 | change * time / duration + start 10 | } 11 | 12 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 13 | change * time / duration + start 14 | } 15 | } -------------------------------------------------------------------------------- /concurrent/src/main/scala/org/powerscala/concurrent/Precision.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.concurrent 2 | 3 | import enumeratum._ 4 | 5 | /** 6 | * Precision is an enum defining numeric precisions and conversions. 7 | */ 8 | sealed abstract class Precision(val conversion: Double, f: () => Long) extends EnumEntry { 9 | def time = f() 10 | } 11 | 12 | object Precision extends Enum[Precision] { 13 | case object Milliseconds extends Precision(1000.0, () => System.currentTimeMillis) 14 | case object Nanoseconds extends Precision(1000000000.0, () => System.nanoTime) 15 | 16 | val values = findValues.toVector 17 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Sine.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | import scala.math._ 4 | 5 | object Sine { 6 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 7 | -change * cos(time / duration * (Pi / 2.0)) + change + start 8 | } 9 | 10 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 11 | change * sin(time / duration * (Pi / 2.0)) + start 12 | } 13 | 14 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 15 | -change / 2.0 * (cos(Pi * time / duration) - 1.0) + start 16 | } 17 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/ref/SoftReference.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.ref 2 | 3 | import ref.{SoftReference => JSR} 4 | 5 | /** 6 | * SoftReference wraps Scala's SoftReference with additional features. 7 | */ 8 | class SoftReference[T <: AnyRef] private(private val ref: JSR[T]) extends Reference[T] { 9 | def apply() = ref.apply() 10 | 11 | def clear() = ref.clear() 12 | 13 | def enqueue() = ref.enqueue() 14 | 15 | def get = ref.get 16 | 17 | def getOrNull = ref.underlying.get() 18 | 19 | def isEnqueued = ref.isEnqueued() 20 | } 21 | 22 | object SoftReference { 23 | def apply[T <: AnyRef](value: T) = new SoftReference[T](new JSR(value)) 24 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/ref/WeakReference.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.ref 2 | 3 | import scala.ref.{WeakReference => JWR} 4 | 5 | /** 6 | * WeakReference wraps Scala's WeakReference with additional features. 7 | */ 8 | class WeakReference[T <: AnyRef] private(private val ref: JWR[T]) extends Reference[T] { 9 | def apply() = ref.apply() 10 | 11 | def clear() = ref.clear() 12 | 13 | def enqueue() = ref.enqueue() 14 | 15 | def get = ref.get 16 | 17 | def getOrNull = ref.underlying.get() 18 | 19 | def isEnqueued = ref.isEnqueued() 20 | } 21 | 22 | object WeakReference { 23 | def apply[T <: AnyRef](value: T) = new WeakReference(new JWR(value)) 24 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/ref/ReferenceType.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.ref 2 | 3 | import enumeratum._ 4 | 5 | sealed trait ReferenceType extends EnumEntry { 6 | def apply[T <: AnyRef](value: T): Reference[T] 7 | } 8 | 9 | object ReferenceType extends Enum[ReferenceType] { 10 | case object Hard extends ReferenceType { 11 | def apply[T <: AnyRef](value: T) = HardReference(value) 12 | } 13 | case object Soft extends ReferenceType { 14 | def apply[T <: AnyRef](value: T) = SoftReference(value) 15 | } 16 | case object Weak extends ReferenceType { 17 | def apply[T <: AnyRef](value: T) = WeakReference(value) 18 | } 19 | 20 | val values = findValues.toVector 21 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/ref/Reference.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.ref 2 | 3 | /** 4 | * Reference wraps Scala's Reference objects to provide additional functionality. 5 | */ 6 | trait Reference[T <: AnyRef] extends Function0[T] { 7 | def apply(): T 8 | 9 | def clear(): Unit 10 | 11 | def enqueue(): Boolean 12 | 13 | def get: Option[T] 14 | 15 | def getOrNull: T 16 | 17 | def isEnqueued: Boolean 18 | 19 | def isCleared = get.isEmpty 20 | 21 | /** 22 | * Referential equality occurs on both the Reference and the wrapped object. 23 | */ 24 | override def equals(obj: Any) = if (super.equals(obj)) { 25 | true 26 | } else { 27 | getOrNull == obj 28 | } 29 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/ref/HardReference.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.ref 2 | 3 | /** 4 | * HardReference represents a reference that will never be cleared except with an explicit call to clear(). 5 | */ 6 | class HardReference[T <: AnyRef] private(private var value: T) extends Reference[T] { 7 | def apply() = value 8 | 9 | def clear() = value = null.asInstanceOf[T] 10 | 11 | def enqueue() = if (value != null) { 12 | clear() 13 | true 14 | } else { 15 | false 16 | } 17 | 18 | def get = Option(value) 19 | 20 | def getOrNull = value 21 | 22 | def isEnqueued = value == null 23 | } 24 | 25 | object HardReference { 26 | def apply[T <: AnyRef](value: T) = new HardReference(value) 27 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/ref/PhantomReference.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.ref 2 | 3 | import ref.{ReferenceQueue, PhantomReference => JPR} 4 | 5 | /** 6 | * PhantomReference wraps Scala's PhantomReference with additional features. 7 | */ 8 | class PhantomReference[T <: AnyRef] private(ref: JPR[T]) extends Reference[T] { 9 | def apply() = ref.apply() 10 | 11 | def clear() = ref.clear() 12 | 13 | def enqueue() = ref.enqueue() 14 | 15 | def get = ref.get 16 | 17 | def getOrNull = ref.underlying.get() 18 | 19 | def isEnqueued = ref.isEnqueued() 20 | } 21 | 22 | object PhantomReference { 23 | def apply[T <: AnyRef](value: T, queue: ReferenceQueue[T]) = new PhantomReference(new JPR(value, queue)) 24 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Quadratic.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | object Quadratic { 4 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 5 | val t = time / duration 6 | change * t * t + start 7 | } 8 | 9 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 10 | val t = time / duration 11 | -change * t * (t - 2.0f) + start 12 | } 13 | 14 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 15 | val t = time / (duration / 2.0) 16 | if (t < 1.0) { 17 | change / 2.0 * t * t + start 18 | } else { 19 | val t2 = t - 1.0 20 | -change / 2.0 * (t2 * (t2 - 2.0) - 1.0) + start 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Cubic.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | object Cubic { 4 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 5 | val t = time / duration 6 | change * t * t * t + start 7 | } 8 | 9 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 10 | val t = time / duration - 1.0 11 | change * (t * t * t + 1.0) + start 12 | } 13 | 14 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 15 | val t = time / (duration / 2.0) 16 | if (t < 1.0) { 17 | change / 2.0 * t * t * t + start 18 | } else { 19 | val t2 = t - 2.0 20 | change / 2.0 * (t2 * t2 * t2 + 2.0) + start 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Quartic.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | object Quartic { 4 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 5 | val t = time / duration 6 | change * t * t * t * t + start 7 | } 8 | 9 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 10 | val t = time / duration - 1.0 11 | -change * (t * t * t * t - 1.0) + start 12 | } 13 | 14 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 15 | val t = time / (duration / 2.0) 16 | if (t < 1.0) { 17 | change / 2.0 * t * t * t * t + start 18 | } else { 19 | val t2 = t - 2.0 20 | -change / 2.0 * (t2 * t2 * t2 * t2 - 2.0) + start 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Quintic.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | object Quintic { 4 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 5 | val t = time / duration 6 | change * t * t * t * t * t + start 7 | } 8 | 9 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 10 | val t = time / duration - 1.0 11 | change * (t * t * t * t * t + 1.0) + start 12 | } 13 | 14 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 15 | val t = time / (duration / 2.0) 16 | if (t < 1.0) { 17 | change / 2.0 * t * t * t * t * t + start 18 | } else { 19 | val t2 = t - 2.0 20 | change / 2.0 * (t2 * t2 * t2 * t2 * t2 + 2.0) + start 21 | } 22 | } 23 | } -------------------------------------------------------------------------------- /core/.jvm/src/main/scala/org/powerscala/util/NetUtil.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.util 2 | 3 | import java.net.ServerSocket 4 | 5 | import scala.annotation.tailrec 6 | 7 | object NetUtil { 8 | @tailrec 9 | final def nextTCPPort(from: Int = 1024, to: Int = Int.MaxValue): Option[Int] = { 10 | if (isTCPPortFree(from)) { 11 | Some(from) 12 | } else if (from == to) { 13 | None 14 | } else { 15 | nextTCPPort(from + 1, to) 16 | } 17 | } 18 | 19 | def availableTCPPort(): Int = { 20 | val ss = new ServerSocket(0) 21 | try { 22 | ss.getLocalPort 23 | } finally { 24 | ss.close() 25 | } 26 | } 27 | 28 | def isTCPPortFree(port: Int): Boolean = try { 29 | new ServerSocket(port).close() 30 | true 31 | } catch { 32 | case t: Throwable => false 33 | } 34 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Circular.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | import scala.math._ 4 | 5 | object Circular { 6 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 7 | val t = time / duration 8 | -change * (sqrt(1.0 - t * t) - 1.0) + start 9 | } 10 | 11 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 12 | val t = (time / duration) - 1.0 13 | change * sqrt(1.0 - t * t) + start 14 | } 15 | 16 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 17 | val t = time / (duration / 2) 18 | if (t < 1) { 19 | -change / 2.0 * (sqrt(1.0 - t * t) - 1.0) + start 20 | } else { 21 | val t2 = t - 2.0 22 | change / 2.0 * (sqrt(1.0 - t2 * t2) + 1.0) + start 23 | } 24 | } 25 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Back.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | object Back { 4 | private val overshoot = 1.70158d; 5 | 6 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 7 | val t = time / duration 8 | change * t * t * ((overshoot + 1.0) * t - overshoot) + start 9 | } 10 | 11 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 12 | val t = time / duration - 1 13 | change * (t * t * ((overshoot + 1.0) * t + overshoot) + 1) + start 14 | } 15 | 16 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 17 | val t = time / (duration / 2.0) 18 | val o = overshoot * 1.525 19 | if (t < 1.0) { 20 | change / 2.0 * (t * t * ((o + 1.0) * t - o)) + start 21 | } else { 22 | val t2 = t - 2.0 23 | change / 2.0 * (t2 * t2 * ((o + 1.0) * t2 + o) + 2.0) + start 24 | } 25 | } 26 | } -------------------------------------------------------------------------------- /command/src/main/scala/org/powerscala/command/StandardIO.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.command 2 | 3 | import java.io.{BufferedReader, InputStreamReader} 4 | 5 | class StandardIO extends CommandImplementation { 6 | private var keepAlive = true 7 | private var manager: CommandManager = _ 8 | 9 | private lazy val reader = new BufferedReader(new InputStreamReader(System.in)) 10 | private lazy val thread = new Thread(new Runnable { 11 | override def run(): Unit = while(keepAlive) { 12 | val line = reader.readLine() 13 | manager.interpreter.toCommand(line) match { 14 | case Some(command) => manager.process(command) 15 | case None => // Not a known command 16 | } 17 | } 18 | }) 19 | override def start(manager: CommandManager): Unit = { 20 | this.manager = manager 21 | thread.setDaemon(true) 22 | thread.start() 23 | } 24 | 25 | override def send(line: String): Unit = println(line) 26 | 27 | override def dispose(): Unit = { 28 | keepAlive = false 29 | thread.interrupt() 30 | } 31 | } 32 | -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/collection/HierarchicalIterator.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.collection 2 | 3 | import scala.annotation.tailrec 4 | import scala.collection.mutable 5 | 6 | /** 7 | * HierarchicalIterator, as the name suggests, allows you to flatly iterate over a hierarchical structure. 8 | * 9 | * @param root the root element to begin iterating with 10 | * @param childrenIterator a function that takes in `T` and returns an `Iterator` of its children. 11 | * @tparam T the type to be iterated over 12 | */ 13 | class HierarchicalIterator[T](root: T, childrenIterator: T => Iterator[T]) extends Iterator[T] { 14 | private val stack = mutable.Stack[Iterator[T]](Iterator.single(root)) 15 | 16 | override def hasNext: Boolean = stack.exists(_.hasNext) 17 | 18 | @tailrec 19 | override final def next(): T = { 20 | val iterator = stack.head 21 | if (iterator.hasNext) { 22 | val t = iterator.next() 23 | stack.push(childrenIterator(t)) 24 | t 25 | } else { 26 | stack.pop() 27 | next() 28 | } 29 | } 30 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Exponential.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | import scala.math._ 4 | 5 | object Exponential { 6 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 7 | if (time == 0.0) { 8 | start 9 | } else { 10 | change * pow(2.0, 10.0 * (time / duration - 1.0)) + start 11 | } 12 | } 13 | 14 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 15 | if (time == duration) { 16 | start + change 17 | } else { 18 | change * (-pow(2.0, -10.0 * time / duration) + 1.0) + start 19 | } 20 | } 21 | 22 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 23 | val t = time / (duration / 2.0) 24 | if (time == 0.0) { 25 | start 26 | } else if (time == duration) { 27 | start + change 28 | } else if (t < 1.0) { 29 | change / 2.0 * pow(2.0, 10.0 * (t - 1.0)) + start 30 | } else { 31 | change / 2.0 * (-pow(2.0, -10.0 * (t - 1.0)) + 2.0) + start 32 | } 33 | } 34 | } -------------------------------------------------------------------------------- /core/src/test/scala/spec/HierarchicalIteratorSpec.scala: -------------------------------------------------------------------------------- 1 | package spec 2 | 3 | import org.powerscala.collection.HierarchicalIterator 4 | import org.scalatest.{Matchers, WordSpec} 5 | 6 | class HierarchicalIteratorSpec extends WordSpec with Matchers { 7 | "HierarchicalIterator" should { 8 | "create a simple structure and organize back out properly" in { 9 | val root = new Test("root", List( 10 | new Test("Numbers", List( 11 | new Test("One"), 12 | new Test("Two"), 13 | new Test("Three") 14 | )), 15 | new Test("Animals", List( 16 | new Test("Cute", List( 17 | new Test("Pandas"), 18 | new Test("Bunnies"), 19 | new Test("Dogs") 20 | )) 21 | )), 22 | new Test("Nothing") 23 | )) 24 | val iterator = new HierarchicalIterator[Test](root, (t: Test) => t.children.iterator) 25 | val names = iterator.toList.map(_.name) 26 | names should equal(List("root", "Numbers", "One", "Two", "Three", "Animals", "Cute", "Pandas", "Bunnies", "Dogs", "Nothing")) 27 | } 28 | } 29 | 30 | class Test(val name: String, val children: List[Test] = Nil) 31 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Bounce.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | object Bounce { 4 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 5 | change - easeOut(duration - time, 0, change, duration) + start 6 | } 7 | 8 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 9 | val t = time / duration 10 | if (t < (1.0 / 2.75)) { 11 | change * (7.5625 * t * t) + start 12 | } else if (t < (2.0 / 2.75)) { 13 | val t2 = t - (1.5 / 2.75) 14 | change * (7.5625 * t2 * t2 + 0.75) + start 15 | } else if (t < (2.5 / 2.75)) { 16 | val t3 = t - (2.25 / 2.75) 17 | change * (7.5625 * t3 * t3 + 0.9375) + start 18 | } else { 19 | val t4 = t - (2.625 / 2.75) 20 | change * (7.5625 * t4 * t4 + 0.984375) + start 21 | } 22 | } 23 | 24 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 25 | if (time < duration / 2.0) { 26 | return easeIn(time * 2.0, 0.0, change, duration) * 0.5 + start; 27 | } else { 28 | return easeOut(time * 2.0 - duration, 0.0, change, duration) * 0.5 + change * 0.5 + start; 29 | } 30 | } 31 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/Unique.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | import java.util.concurrent.ThreadLocalRandom 4 | 5 | object Unique { 6 | val LettersLower = "abcdefghijklmnopqrstuvwxyz" 7 | val LettersUpper = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" 8 | val Numbers = "0123456789" 9 | val LettersAndNumbers = s"$LettersLower$Numbers" 10 | val AllLettersAndNumbers = s"$LettersLower$LettersUpper$Numbers" 11 | 12 | private def r = ThreadLocalRandom.current() 13 | 14 | /** 15 | * Generates a unique String using the characters supplied at the length defined. 16 | * 17 | * @param length the length of the resulting String. Defaults to 32. 18 | * @param characters the characters for use in the String. Defaults to AllLettersAndNumbers. 19 | * @return a unique String 20 | */ 21 | def apply(length: Int = 32, characters: String = AllLettersAndNumbers): String = { 22 | val charMax = characters.length 23 | (0 until length).map(i => characters.charAt(r.nextInt(charMax))).mkString 24 | } 25 | 26 | /** 27 | * Returns the number of possible values for a specific length and characters. 28 | */ 29 | def poolSize(length: Int = 32, characters: String = AllLettersAndNumbers): Long = { 30 | math.pow(characters.length, length).toLong 31 | } 32 | } -------------------------------------------------------------------------------- /command/src/main/scala/org/powerscala/command/test/Test.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.command.test 2 | 3 | import org.powerscala.command.{Command, CommandImplementation, CommandInterpreter, CommandManager, StandardIO} 4 | 5 | object Test extends CommandManager { 6 | override def implementation: CommandImplementation = new StandardIO 7 | 8 | override def interpreter: CommandInterpreter = Interpreter 9 | 10 | override def process(command: Command): Unit = command match { 11 | case Quit => { 12 | println(s"Asked to quit, quitting!") 13 | System.exit(0) 14 | } 15 | case e: Echo => { 16 | println(e.message) 17 | } 18 | } 19 | 20 | def main(args: Array[String]): Unit = { 21 | println("Keeping alive for 30 seconds...") 22 | Thread.sleep(30000) 23 | } 24 | } 25 | 26 | object Interpreter extends CommandInterpreter { 27 | override def toCommand(line: String): Option[Command] = line match { 28 | case "quit" => Some(Quit) 29 | case _ if line.startsWith("echo ") => Some(Echo(line.substring(5))) 30 | case _ => None 31 | } 32 | 33 | override def fromCommand(command: Command): String = command match { 34 | case Quit => "quit" 35 | case e: Echo => s"echo ${e.message}" 36 | } 37 | } 38 | 39 | object Quit extends Command 40 | 41 | case class Echo(message: String) extends Command -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/StringUtil.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | object StringUtil { 4 | /** 5 | * Converts space and dash separated to camel-case 6 | */ 7 | def toCamelCase(name: String) = "[- _]([a-zA-Z0-9])".r.replaceAllIn(name, m => m.group(1).toUpperCase) 8 | 9 | /** 10 | * Converts camelCase to dash-separated. 11 | */ 12 | def fromCamelCase(name: String) = "([A-Z])".r.replaceAllIn(name, m => "-" + m.group(0).toLowerCase) 13 | 14 | /** 15 | * Generates a human readable label for this name. 16 | */ 17 | def generateLabel(name: String) = { 18 | val b = new StringBuilder 19 | var p = ' ' 20 | name.foreach { 21 | case '$' => // Ignore $ 22 | case c => { 23 | if (b.length > 1 && (p.isUpper || p.isDigit) && (!c.isUpper && !c.isDigit)) { 24 | b.insert(b.length - 1, ' ') 25 | } 26 | b.append(c) 27 | p = c 28 | } 29 | } 30 | b.toString().capitalize 31 | } 32 | 33 | private val TrimRegex = """(\p{Z}*)(.*?)(\p{Z}*)""".r 34 | def trim(s: String) = s match { 35 | case TrimRegex(left, content, right) => content 36 | } 37 | 38 | def humanReadableByteCount(bytes: Long, si: Boolean = true): String = { 39 | val unit = if (si) 1000 else 1024 40 | if (bytes < unit) { 41 | s"$bytes B" 42 | } else { 43 | val exp = (math.log(bytes) / math.log(unit)).toInt 44 | val pre = (if (si) "kMGTPE" else "KMGTPE").charAt(exp - 1) + (if (si) "" else "i") 45 | "%.1f %sB".format(bytes / Math.pow(unit, exp), pre) 46 | } 47 | } 48 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/collection/BiMap.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.collection 2 | 3 | /** 4 | * Bi-Directional `Map` that adds `getLeft`, `getRight`, `left`, and `right` in order to access values in a specific 5 | * way. Utilizes two underlying maps to give improved lookup speed for value for key or key for value lookups. 6 | * 7 | * @tparam A the left type 8 | * @tparam B the right type 9 | */ 10 | class BiMap[A, B] extends Map[A, B] { 11 | private var forward = Map.empty[A, B] 12 | private var backward = Map.empty[B, A] 13 | 14 | override def +[B1 >: B](kv: (A, B1)): Map[A, B1] = { 15 | forward += kv._1 -> kv._2.asInstanceOf[B] 16 | backward += kv._2.asInstanceOf[B] -> kv._1 17 | this 18 | } 19 | 20 | override def get(key: A): Option[B] = forward.get(key) 21 | 22 | /** 23 | * Alias to `get` returns `Option[B]` for key `A`. 24 | */ 25 | def getLeft(key: A): Option[B] = forward.get(key) 26 | 27 | /** 28 | * The reverse of `get` returns `Option[A]` for key `B`. 29 | */ 30 | def getRight(key: B): Option[A] = backward.get(key) 31 | 32 | /** 33 | * Alias to `apply` returns `B` for key `A`. 34 | */ 35 | def left(key: A): B = forward(key) 36 | 37 | /** 38 | * The reverse of `apply` returns `A` for key `B`. 39 | */ 40 | def right(key: B): A = backward(key) 41 | 42 | override def iterator: Iterator[(A, B)] = forward.iterator 43 | 44 | override def -(key: A): Map[A, B] = { 45 | forward.get(key) match { 46 | case Some(value) => { 47 | forward -= key 48 | backward -= value 49 | } 50 | case None => // Not found 51 | } 52 | this 53 | } 54 | } 55 | 56 | object BiMap { 57 | def empty[A, B]: BiMap[A, B] = new BiMap[A, B] 58 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/encryption/PasswordFactory.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.encryption 2 | 3 | import javax.crypto.SecretKeyFactory 4 | import java.security.SecureRandom 5 | import javax.crypto.spec.PBEKeySpec 6 | import java.util 7 | import scala.util.Random 8 | 9 | object PasswordFactory { 10 | val CharactersNumbersAndUnderscore = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_0123456789" 11 | val ReadableCharacters = "ABCDEFGHIJKLMNPQRSTUVWXYZ23456789" 12 | 13 | var saltType = "SHA1PRNG" 14 | 15 | def authenticate(attemptedPassword: String, encryptedPassword: Array[Byte], salt: Array[Byte]) = { 16 | val encryptedAttemptedPassword = encryptPassword(attemptedPassword, salt) 17 | util.Arrays.equals(encryptedPassword, encryptedAttemptedPassword) 18 | } 19 | 20 | def encryptPassword(password: String, salt: Array[Byte]) = { 21 | val algorithm = "PBKDF2WithHmacSHA1" 22 | val derivedKeyLength = 160 23 | val iterations = 20000 24 | val spec = new PBEKeySpec(password.toCharArray, salt, iterations, derivedKeyLength) 25 | val factory = SecretKeyFactory.getInstance(algorithm) 26 | factory.generateSecret(spec).getEncoded 27 | } 28 | 29 | def generateSalt() = if (saltType.equalsIgnoreCase("TEST")) { 30 | Array[Byte](1, 2, 3, 4, 5, 6, 7, 8) 31 | } else { 32 | val random = SecureRandom.getInstance(saltType) 33 | val salt = new Array[Byte](8) 34 | random.nextBytes(salt) 35 | salt 36 | } 37 | 38 | def generatePassword(chars: String = CharactersNumbersAndUnderscore, 39 | digits: Int = 8, 40 | dashesEvery: Int = Int.MaxValue) = { 41 | val r = new Random() 42 | (0 until digits).map(index => chars.charAt(r.nextInt(chars.length))).mkString.grouped(dashesEvery).mkString("-") 43 | } 44 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Elastic.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | import scala.math._ 4 | 5 | object Elastic { 6 | def easeIn(time: Double, start: Double, change: Double, duration: Double): Double = { 7 | val t = time / duration 8 | if (time == 0.0) { 9 | start 10 | } else if (t == 1.0) { 11 | start + change 12 | } else { 13 | val period = duration * 0.3 14 | val amplitude = change 15 | val s = period / 4.0 16 | val t2 = t - 1.0 17 | -(amplitude * pow(2.0, 10.0 * t2) * sin((t2 * duration - s) * (2.0 * Pi) / period)) + start 18 | } 19 | } 20 | 21 | def easeOut(time: Double, start: Double, change: Double, duration: Double): Double = { 22 | val t = time / duration 23 | if (time == 0.0) { 24 | start 25 | } else if (t == 1.0) { 26 | start + change 27 | } else { 28 | val period = duration * 0.3 29 | val amplitude = change 30 | val s = period / 4.0 31 | 32 | amplitude * pow(2.0, -10.0 * t) * sin((t * duration - s) * (2.0 * Pi) / period) + change + start 33 | } 34 | } 35 | 36 | def easeInOut(time: Double, start: Double, change: Double, duration: Double): Double = { 37 | val t = time / (duration / 2.0) 38 | if (time == 0.0) { 39 | start 40 | } else if (t == 2.0) { 41 | start + change 42 | } else { 43 | val period = duration * (0.3 * 1.5) 44 | val amplitude = change 45 | val s = period / 4.0 46 | val t2 = t - 1.0 47 | 48 | if (t < 1.0) { 49 | -0.5 * (amplitude * pow(2.0, 10.0 * t2) * sin((t2 * duration - s) * (2.0 * Pi) / period)) + start 50 | } else { 51 | amplitude * pow(2.0, -10.0 * t2) * sin((t2 * duration - s) * (2.0 * Pi) / period) * 0.5 + change + start 52 | } 53 | } 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /console/src/main/scala/org/powerscala/console/Console.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.console 2 | 3 | import org.jline.terminal.TerminalBuilder 4 | import org.powerscala.console.ctrl._ 5 | 6 | import scala.collection.mutable.ListBuffer 7 | 8 | class Console(writer: String => Unit) { 9 | def width: Int = { 10 | val terminal = TerminalBuilder.terminal() 11 | try { 12 | terminal.getWidth 13 | } finally { 14 | terminal.close() 15 | } 16 | } 17 | 18 | def write(text: Text*): Unit = { 19 | val blocks = ListBuffer.empty[List[Text]] 20 | var block = ListBuffer.empty[Text] 21 | text.foreach { t => 22 | t match { 23 | case a: Alignment if block.nonEmpty => { 24 | blocks += block.toList 25 | block.clear() 26 | } 27 | case _ => // Ignore 28 | } 29 | block += t 30 | } 31 | if (block.nonEmpty) { 32 | blocks += block.toList 33 | block.clear() 34 | } 35 | 36 | blocks.toList.foreach { b => 37 | val length = b.foldLeft(0)((len, t) => len + t.length) 38 | 39 | b.foreach { 40 | case ClearLine => { 41 | writer(s"${SavePosition.content}${Return.content}${EraseLine.content}${RestorePosition.content}") 42 | } 43 | case Alignment.Left => writer(Return.content) 44 | case Alignment.Center => writer(s"${Return.content}${CursorForward(math.round((width.toDouble / 2.0) - (length.toDouble / 2.0)).toInt).content}") 45 | case Alignment.Right => writer(s"${Return.content}${CursorForward(width - length).content}") 46 | case t => writer(t.content) 47 | } 48 | } 49 | } 50 | 51 | def writeLine(text: Text*): Unit = write(text.toList ::: List(NewLine): _*) 52 | 53 | def line(): Line = new Line(this) 54 | 55 | def repeating(c: Char, length: Int): String = { 56 | val b = new StringBuilder 57 | (0 until length).foreach { index => 58 | b.append(c) 59 | } 60 | b.toString() 61 | } 62 | } 63 | 64 | object Console extends Console((s: String) => print(s)) -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/group/TypedGroup.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.group 2 | 3 | sealed trait TypedGroup[T] { 4 | def toVector: Vector[T] 5 | } 6 | 7 | object TypedGroup { 8 | def apply[T](t: T): TypedGroup1[T] = TypedGroup1(t) 9 | def apply[T, T1 <: T, T2 <: T](t1: T1, t2: T2): TypedGroup2[T, T1, T2] = TypedGroup2(t1, t2) 10 | def apply[T, T1 <: T, T2 <: T, T3 <: T](t1: T1, t2: T2, t3: T3): TypedGroup3[T, T1, T2, T3] = TypedGroup3(t1, t2, t3) 11 | def apply[T, T1 <: T, T2 <: T, T3 <: T, T4 <: T](t1: T1, t2: T2, t3: T3, t4: T4): TypedGroup4[T, T1, T2, T3, T4] = { 12 | TypedGroup4(t1, t2, t3, t4) 13 | } 14 | def apply[T, T1 <: T, T2 <: T, T3 <: T, T4 <: T, T5 <: T](t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): TypedGroup5[T, T1, T2, T3, T4, T5] = { 15 | TypedGroup5(t1, t2, t3, t4, t5) 16 | } 17 | def apply[T, T1 <: T, T2 <: T, T3 <: T, T4 <: T, T5 <: T, T6 <: T](t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6): TypedGroup6[T, T1, T2, T3, T4, T5, T6] = { 18 | TypedGroup6(t1, t2, t3, t4, t5, t6) 19 | } 20 | } 21 | 22 | case class TypedGroup1[T](t: T) extends TypedGroup[T] { 23 | def toVector: Vector[T] = Vector(t) 24 | } 25 | 26 | case class TypedGroup2[T, T1 <: T, T2 <: T](t1: T1, t2: T2) extends TypedGroup[T] { 27 | def toVector: Vector[T] = Vector(t1, t2) 28 | } 29 | 30 | case class TypedGroup3[T, T1 <: T, T2 <: T, T3 <: T](t1: T1, t2: T2, t3: T3) extends TypedGroup[T] { 31 | def toVector: Vector[T] = Vector(t1, t2, t3) 32 | } 33 | 34 | case class TypedGroup4[T, T1 <: T, T2 <: T, T3 <: T, T4 <: T](t1: T1, t2: T2, t3: T3, t4: T4) extends TypedGroup[T] { 35 | def toVector: Vector[T] = Vector(t1, t2, t3, t4) 36 | } 37 | 38 | case class TypedGroup5[T, T1 <: T, T2 <: T, T3 <: T, T4 <: T, T5 <: T](t1: T1, t2: T2, t3: T3, t4: T4, t5: T5) extends TypedGroup[T] { 39 | def toVector: Vector[T] = Vector(t1, t2, t3, t4, t5) 40 | } 41 | 42 | case class TypedGroup6[T, T1 <: T, T2 <: T, T3 <: T, T4 <: T, T5 <: T, T6 <: T](t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6) extends TypedGroup[T] { 43 | def toVector: Vector[T] = Vector(t1, t2, t3, t4, t5, t6) 44 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/Version.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | /** 4 | * Version represents a version numbering. 5 | */ 6 | case class Version(major: Int = 1, minor: Int = 0, maintenance: Int = 0, build: Int = 0, extra: Option[String] = None, original: Option[String] = None) extends Ordered[Version] { 7 | private lazy val string = { 8 | val b = new StringBuilder 9 | b.append(general) 10 | if (build > 0) { 11 | b.append('.') 12 | b.append(build) 13 | } 14 | extra match { 15 | case Some(e) => b.append(s"-$e") 16 | case None => // No extra 17 | } 18 | b.toString() 19 | } 20 | 21 | lazy val general = s"$major.$minor.$maintenance" 22 | 23 | def snapshot: Boolean = extra.contains("SNAPSHOT") 24 | 25 | override def toString = original.getOrElse(string) 26 | 27 | def compare(that: Version) = if (major != that.major) { 28 | major.compare(that.major) 29 | } else if (minor != that.minor) { 30 | minor.compare(that.minor) 31 | } else if (maintenance != that.maintenance) { 32 | maintenance.compare(that.maintenance) 33 | } else if (build != that.build) { 34 | build.compare(that.build) 35 | } else if (extra != that.extra && extra != null) { 36 | extra.getOrElse("").compare(that.extra.getOrElse("")) 37 | } else if (extra != that.extra && that.extra != null) { 38 | -1 39 | } else { 40 | 0 41 | } 42 | } 43 | 44 | object Version { 45 | val Zero = Version(0) 46 | val Matcher = """(\d+)[.]?(\d*)[.]?(\d*)[.]?(\d*)[-]?(.*)""".r 47 | 48 | def apply(version: String): Version = version match { 49 | case Version(v) => v 50 | case _ => Version(major = 0, original = Option(version)) 51 | } 52 | 53 | def unapply(version: String): Option[Version] = version match { 54 | case null | "" => None 55 | case Matcher(major, minor, maintenance, build, extra) => { 56 | Some(Version(n(major), n(minor), n(maintenance), n(build), if (extra != null && extra.nonEmpty) Some(extra) else None, Some(version))) 57 | } 58 | case _ => None 59 | } 60 | 61 | private def n(s: String) = s match { 62 | case "" => 0 63 | case _ => s.toInt 64 | } 65 | } 66 | -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/easing/Easing.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.easing 2 | 3 | import enumeratum._ 4 | 5 | trait Easing extends EnumEntry { 6 | def apply(elapsed: Double, start: Double, target: Double, duration: Double): Double 7 | } 8 | 9 | sealed abstract class EasingEnum(val f: Function4[Double, Double, Double, Double, Double]) extends Easing { 10 | def apply(elapsed: Double, start: Double, target: Double, duration: Double) = { 11 | f(elapsed, start, target - start, duration) 12 | } 13 | } 14 | 15 | object Easing extends Enum[EasingEnum] { 16 | case object BackIn extends EasingEnum(Back.easeIn) 17 | case object BackOut extends EasingEnum(Back.easeOut) 18 | case object BackInOut extends EasingEnum(Back.easeInOut) 19 | case object BounceIn extends EasingEnum(Bounce.easeIn) 20 | case object BounceOut extends EasingEnum(Bounce.easeOut) 21 | case object BounceInOut extends EasingEnum(Bounce.easeInOut) 22 | case object CircularIn extends EasingEnum(Circular.easeIn) 23 | case object CircularOut extends EasingEnum(Circular.easeOut) 24 | case object CircularInOut extends EasingEnum(Circular.easeInOut) 25 | case object CubicIn extends EasingEnum(Cubic.easeIn) 26 | case object CubicOut extends EasingEnum(Cubic.easeOut) 27 | case object CubicInOut extends EasingEnum(Cubic.easeInOut) 28 | case object ElasticIn extends EasingEnum(Elastic.easeIn) 29 | case object ElasticOut extends EasingEnum(Elastic.easeOut) 30 | case object ElasticInOut extends EasingEnum(Elastic.easeInOut) 31 | case object ExponentialIn extends EasingEnum(Exponential.easeIn) 32 | case object ExponentialOut extends EasingEnum(Exponential.easeOut) 33 | case object ExponentialInOut extends EasingEnum(Exponential.easeInOut) 34 | case object LinearIn extends EasingEnum(Linear.easeIn) 35 | case object LinearOut extends EasingEnum(Linear.easeOut) 36 | case object LinearInOut extends EasingEnum(Linear.easeInOut) 37 | case object QuadraticIn extends EasingEnum(Quadratic.easeIn) 38 | case object QuadraticOut extends EasingEnum(Quadratic.easeOut) 39 | case object QuadraticInOut extends EasingEnum(Quadratic.easeInOut) 40 | case object QuarticIn extends EasingEnum(Quartic.easeIn) 41 | case object QuarticOut extends EasingEnum(Quartic.easeOut) 42 | case object QuarticInOut extends EasingEnum(Quartic.easeInOut) 43 | case object QuinticIn extends EasingEnum(Quintic.easeIn) 44 | case object QuinticOut extends EasingEnum(Quintic.easeOut) 45 | case object QuinticInOut extends EasingEnum(Quintic.easeInOut) 46 | case object SineIn extends EasingEnum(Sine.easeIn) 47 | case object SineOut extends EasingEnum(Sine.easeOut) 48 | case object SineInOut extends EasingEnum(Sine.easeInOut) 49 | 50 | val values = findValues.toVector 51 | } -------------------------------------------------------------------------------- /io/src/main/scala/org/powerscala/io/package.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | import java.io.File 4 | import java.io.InputStream 5 | import java.io.FileInputStream 6 | import java.io.OutputStream 7 | import java.io.{ByteArrayInputStream, FileOutputStream} 8 | import java.net.URL 9 | 10 | import scala.language.implicitConversions 11 | 12 | package object io { 13 | implicit class InputStreamReader(input: InputStream) extends Reader { 14 | override def length: Option[Long] = None 15 | 16 | override def read(buffer: Array[Byte]): Int = input.read(buffer) 17 | 18 | override def close(): Unit = input.close() 19 | } 20 | 21 | implicit def javaReader2Reader(reader: java.io.Reader): Reader = new Reader { 22 | override def length: Option[Long] = None 23 | 24 | override def read(buffer: Array[Byte]): Int = { 25 | val b = new Array[Char](buffer.length) 26 | val len = reader.read(b) 27 | b.zipWithIndex.foreach { 28 | case (c, index) => buffer(index) = c.toByte 29 | } 30 | len 31 | } 32 | 33 | override def close(): Unit = reader.close() 34 | } 35 | 36 | implicit def file2Reader(file: File): InputStreamReader = new InputStreamReader(new FileInputStream(file)) { 37 | override def length: Option[Long] = Some(file.length()) 38 | } 39 | 40 | implicit def url2Reader(url: URL): InputStreamReader = { 41 | val connection = url.openConnection() 42 | val len = connection.getContentLengthLong 43 | new InputStreamReader(connection.getInputStream) { 44 | override def length: Option[Long] = len match { 45 | case _ if len < 0 => None 46 | case _ => Some(len) 47 | } 48 | } 49 | } 50 | 51 | implicit def string2Reader(s: String): InputStreamReader = new InputStreamReader(new ByteArrayInputStream(s.getBytes)) { 52 | override def length: Option[Long] = Some(s.length) 53 | } 54 | 55 | implicit class OutputStreamWriter(output: OutputStream) extends Writer { 56 | override def write(buffer: Array[Byte], offset: Int, length: Int): Unit = output.write(buffer, offset, length) 57 | 58 | override def flush(): Unit = output.flush() 59 | 60 | override def close(): Unit = output.close() 61 | 62 | override def complete(): Unit = {} 63 | } 64 | 65 | implicit def file2Writer(file: File): OutputStreamWriter = { 66 | val temp = new File(file.getParentFile, s".${file.getName}.temp") 67 | new OutputStreamWriter(new FileOutputStream(temp)) { 68 | override def complete(): Unit = { 69 | super.complete() 70 | 71 | file.delete() // Make sure the original file doesn't exist 72 | temp.renameTo(file) // Two-stage write to avoid partials 73 | } 74 | } 75 | } 76 | 77 | implicit class StringBuilderWriter(sb: StringBuilder) extends Writer { 78 | override def write(buffer: Array[Byte], offset: Int, length: Int): Unit = { 79 | sb.append(new String(buffer, offset, length)) 80 | } 81 | 82 | override def flush(): Unit = {} 83 | 84 | override def close(): Unit = {} 85 | 86 | override def complete(): Unit = {} 87 | 88 | override def toString: String = sb.toString() 89 | } 90 | } -------------------------------------------------------------------------------- /io/src/main/scala/org/powerscala/io/IO.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.io 2 | 3 | import java.io.{File, IOException} 4 | 5 | import scala.annotation.tailrec 6 | 7 | object IO { 8 | @tailrec 9 | final def stream(reader: Reader, 10 | writer: Writer, 11 | monitor: Monitor = Monitor.Ignore, 12 | buffer: Array[Byte] = new Array[Byte](512), 13 | closeOnComplete: Boolean = true): Writer = { 14 | monitor.open(reader.length) 15 | val len = reader.read(buffer) 16 | if (len == -1) { 17 | writer.flush() 18 | if (closeOnComplete) { 19 | writer.close() 20 | reader.close() 21 | monitor.closed() 22 | } 23 | writer.complete() 24 | monitor.completed() 25 | writer 26 | } else { 27 | try { 28 | writer.write(buffer, 0, len) 29 | monitor.written(len) 30 | } catch { 31 | case t: Throwable => { 32 | monitor.failure(t) 33 | throw new IOException(s"IO failed to write to writer with length: $len with reader: $reader, writer: $writer.", t) 34 | } 35 | } 36 | stream(reader, writer, monitor, buffer, closeOnComplete) 37 | } 38 | } 39 | 40 | /** 41 | * Uses IO.stream, but supports recursive directory copying. 42 | * 43 | * @param source file or directory 44 | * @param destination file or directory 45 | */ 46 | def copy(source: File, destination: File): Unit = if (source.isDirectory) { 47 | destination.mkdirs() 48 | assert(destination.isDirectory, s"Destination ${destination.getAbsolutePath} is a file, not a directory!") 49 | source.listFiles().foreach { file => 50 | copy(file, new File(destination, file.getName)) 51 | } 52 | } else if (source.isFile) { 53 | if (destination.isDirectory) { 54 | stream(source, new File(destination, source.getName)) 55 | } else { 56 | stream(source, destination) 57 | } 58 | } 59 | 60 | def delete(file: File): Boolean = { 61 | if (file.isDirectory) { 62 | deleteFiles(file.listFiles().toList) 63 | } 64 | file.delete() 65 | } 66 | 67 | @tailrec 68 | final def deleteFiles(files: List[File]): Unit = { 69 | if (files.nonEmpty) { 70 | val f = files.head 71 | delete(f) 72 | deleteFiles(files.tail) 73 | } 74 | } 75 | } 76 | 77 | trait Reader { 78 | def length: Option[Long] 79 | def read(buffer: Array[Byte]): Int 80 | def close(): Unit 81 | } 82 | 83 | trait Writer { 84 | def write(buffer: Array[Byte], offset: Int, length: Int): Unit 85 | def flush(): Unit 86 | def complete(): Unit 87 | def close(): Unit 88 | } 89 | 90 | trait Monitor { 91 | def open(length: Option[Long]): Unit 92 | def written(length: Long): Unit 93 | def failure(t: Throwable): Unit 94 | def closed(): Unit 95 | def completed(): Unit 96 | } 97 | 98 | object Monitor { 99 | object Ignore extends Monitor { 100 | override def open(length: Option[Long]): Unit = {} 101 | 102 | override def written(length: Long): Unit = {} 103 | 104 | override def failure(t: Throwable): Unit = {} 105 | 106 | override def completed(): Unit = {} 107 | 108 | override def closed(): Unit = {} 109 | } 110 | } -------------------------------------------------------------------------------- /concurrent/src/main/scala/org/powerscala/concurrent/AtomicInt.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2011 PowerScala 3 | * All rights reserved. 4 | * 5 | * Redistribution and use in source and binary forms, with or without 6 | * modification, are permitted provided that the following conditions are 7 | * met: 8 | * 9 | * Redistributions of source code must retain the above copyright 10 | * notice, this list of conditions and the following disclaimer. 11 | * 12 | * Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * Neither the name of 'PowerScala' nor the names of its contributors 17 | * may be used to endorse or promote products derived from this software 18 | * without specific prior written permission. 19 | * 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 | * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 24 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 25 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 26 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 27 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 28 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 29 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 30 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 | */ 32 | 33 | package org.powerscala.concurrent 34 | 35 | import java.util.concurrent.atomic.AtomicInteger 36 | import annotation.tailrec 37 | 38 | /** 39 | * AtomicInt extends the functionality of AtomicInteger to provide additional convenience functionality. 40 | */ 41 | class AtomicInt(initial: Int) extends AtomicInteger(initial) { 42 | def apply() = get() 43 | 44 | /** 45 | * Modifies the value atomicly without locking if the resulting value of the function is Some. 46 | */ 47 | @tailrec 48 | final def modify(f: Int => Option[Int]): Boolean = { 49 | val current = get() 50 | f(current) match { 51 | case Some(v) => if (compareAndSet(current, v)) { 52 | true 53 | } 54 | else { 55 | modify(f) 56 | } 57 | case None => false 58 | } 59 | } 60 | 61 | /** 62 | * Increments and returns the new value 63 | */ 64 | def ++ = incrementAndGet() 65 | 66 | /** 67 | * Decrements and returns the new value 68 | */ 69 | def -- = decrementAndGet() 70 | 71 | /** 72 | * Adds the value and returns the new value 73 | */ 74 | def +=(value: Int) = addAndGet(value) 75 | 76 | /** 77 | * Subtracts the value and returns the new value 78 | */ 79 | def -=(value: Int) = addAndGet(-value) 80 | 81 | /** 82 | * Increments the value if the current value is less than the max value supplied. 83 | * 84 | * This method is thread-safe without locking. 85 | */ 86 | def incrementIfLessThan(max: Int) = modify((value: Int) => { 87 | if (value < max) { 88 | Some(value + 1) 89 | } 90 | else { 91 | None 92 | } 93 | }) 94 | 95 | /** 96 | * Decrements the value if the current value is greater than the max value supplied. 97 | * 98 | * This method is thread-safe without locking. 99 | */ 100 | def decrementIfGreaterThan(min: Int) = modify((value: Int) => { 101 | if (value > min) { 102 | Some(value - 1) 103 | } 104 | else { 105 | None 106 | } 107 | }) 108 | } -------------------------------------------------------------------------------- /io/src/main/scala/org/powerscala/io/watcher/Watcher.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala.io.watcher 2 | 3 | import java.nio.file.LinkOption.NOFOLLOW_LINKS 4 | import java.nio.file.StandardWatchEventKinds.{ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY} 5 | import java.nio.file.attribute.BasicFileAttributes 6 | import java.nio.file.{FileSystems, FileVisitResult, Files, Path, SimpleFileVisitor, WatchEvent, WatchKey} 7 | 8 | import scala.annotation.tailrec 9 | import scala.collection.mutable 10 | import scala.collection.JavaConverters._ 11 | 12 | abstract class Watcher(directory: Path, 13 | ignoreMatchers: Set[String] = Watcher.DefaultIgnores, 14 | eventDelay: Long = 1000L) extends Runnable { 15 | private val enqueued = mutable.Map.empty[String, PathEvent] 16 | private val watcher = FileSystems.getDefault.newWatchService() 17 | private var keys = Map.empty[WatchKey, Path] 18 | private val thread = new Thread(this) { 19 | setDaemon(true) 20 | } 21 | private var keepAlive = true 22 | 23 | private def registerAll(start: Path): Unit = { 24 | Files.walkFileTree(start, new SimpleFileVisitor[Path] { 25 | override def preVisitDirectory(dir: Path, attrs: BasicFileAttributes): FileVisitResult = { 26 | register(dir) 27 | FileVisitResult.CONTINUE 28 | } 29 | }) 30 | } 31 | 32 | private def register(directory: Path): Unit = { 33 | val watchKey = directory.register(watcher, ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY) 34 | keys += watchKey -> directory 35 | } 36 | 37 | def start(): Unit = { 38 | registerAll(directory) 39 | thread.start() 40 | } 41 | 42 | def dispose(): Unit = keepAlive = false 43 | 44 | override def run(): Unit = processEvents() 45 | 46 | @tailrec 47 | private def processEvents(): Unit = { 48 | val time = System.currentTimeMillis() 49 | 50 | // Poll for events 51 | Option(watcher.poll()) match { 52 | case Some(key) => { 53 | val directory = keys(key) 54 | 55 | key.pollEvents().asScala.foreach { event => 56 | val kind = event.kind() match { 57 | case ENTRY_CREATE => EventKind.Create 58 | case ENTRY_MODIFY => EventKind.Modify 59 | case ENTRY_DELETE => EventKind.Delete 60 | } 61 | val watchEvent = event.asInstanceOf[WatchEvent[Path]] 62 | val name = watchEvent.context() 63 | val child = directory.resolve(name) 64 | val fileName = name.toString 65 | 66 | if (!ignoreMatchers.exists(fileName.matches)) { 67 | val pathEvent = enqueued.getOrElse(child.toString, PathEvent(child, directory, Set.empty, 0L)) 68 | enqueued += child.toString -> pathEvent.copy(kinds = pathEvent.kinds + kind, lastModified = time) 69 | } 70 | 71 | if (kind == ENTRY_CREATE && Files.isDirectory(child, NOFOLLOW_LINKS)) { 72 | registerAll(child) 73 | } 74 | } 75 | 76 | val valid = key.reset() 77 | if (!valid) { 78 | keys -= key 79 | } 80 | } 81 | case None => // Nothing to process 82 | } 83 | 84 | // Check for queued changes 85 | enqueued.foreach { 86 | case (key, pathEvent) if time - pathEvent.lastModified > eventDelay => { 87 | enqueued -= key 88 | fire(pathEvent) 89 | } 90 | case _ => // Not old enough 91 | } 92 | 93 | if (keys.nonEmpty && keepAlive) { 94 | Thread.sleep(100) 95 | processEvents() 96 | } 97 | } 98 | 99 | def fire(pathEvent: PathEvent): Unit 100 | } 101 | 102 | object Watcher { 103 | val DefaultIgnores = Set( 104 | ".*___jb_tmp___", // JetBrains tmp file 105 | ".*___jb_old___" // JetBrains old file 106 | ) 107 | } -------------------------------------------------------------------------------- /project/PowerScalaBuild.scala: -------------------------------------------------------------------------------- 1 | import Dependencies._ 2 | import sbt.Keys._ 3 | import sbt._ 4 | import sbtunidoc.Plugin._ 5 | import org.scalajs.sbtplugin.ScalaJSPlugin.autoImport._ 6 | 7 | object PowerScalaBuild extends Build { 8 | lazy val root = project.in(file(".")) 9 | .settings(sharedSettings()) 10 | .settings(unidocSettings: _*) 11 | .settings(publishArtifact := false) 12 | .aggregate(core.js, core.jvm, command, concurrent, console, io) 13 | lazy val core = crossProject.crossType(CrossType.Pure).in(file("core")) 14 | .settings(withCompatUnmanagedSources(jsJvmCrossProject = true, include_210Dir = false, includeTestSrcs = true): _*) 15 | .settings(sharedSettings(Some("core")): _*) 16 | .settings(libraryDependencies += enumeratum) 17 | lazy val coreJs = core.js 18 | lazy val coreJvm = core.jvm 19 | lazy val command = project.in(file("command")) 20 | .settings(sharedSettings(Some("command")): _*) 21 | lazy val concurrent = project.in(file("concurrent")) 22 | .settings(sharedSettings(Some("concurrent")): _*) 23 | .settings(libraryDependencies += enumeratum) 24 | lazy val console = project.in(file("console")) 25 | .settings(sharedSettings(Some("console")): _*) 26 | .settings(libraryDependencies += jLine) 27 | lazy val io = project.in(file("io")) 28 | .settings(sharedSettings(Some("io")): _*) 29 | 30 | private def sharedSettings(projectName: Option[String] = None) = Seq( 31 | name := s"${Details.name}${projectName.map(pn => s"-$pn").getOrElse("")}", 32 | version := Details.version, 33 | organization := Details.organization, 34 | scalaVersion := Details.scalaVersion, 35 | crossScalaVersions := Details.scalaVersions, 36 | sbtVersion := Details.sbtVersion, 37 | scalacOptions ++= Seq("-unchecked", "-deprecation", "-feature"), 38 | resolvers ++= Seq( 39 | Resolver.sonatypeRepo("snapshots"), 40 | Resolver.sonatypeRepo("releases"), 41 | Resolver.typesafeRepo("releases") 42 | ), 43 | addCompilerPlugin("org.scalamacros" % "paradise" % "2.1.0" cross CrossVersion.full), 44 | libraryDependencies += scalaTest, 45 | publishArtifact in Test := false, 46 | pomExtra := ${Details.url} 47 | 48 | 49 | {Details.licenseType} 50 | {Details.licenseURL} 51 | repo 52 | 53 | 54 | 55 | scm:{Details.repoURL} 56 | scm:{Details.repoURL} 57 | {Details.projectURL} 58 | 59 | 60 | 61 | {Details.developerId} 62 | {Details.developerName} 63 | {Details.developerURL} 64 | 65 | 66 | ) 67 | 68 | /** 69 | * Helper function to add unmanaged source compat directories for different scala versions 70 | */ 71 | private def withCompatUnmanagedSources(jsJvmCrossProject: Boolean, include_210Dir: Boolean, includeTestSrcs: Boolean): Seq[Setting[_]] = { 72 | def compatDirs(projectbase: File, scalaVersion: String, isMain: Boolean) = { 73 | val base = if (jsJvmCrossProject ) projectbase / ".." else projectbase 74 | CrossVersion.partialVersion(scalaVersion) match { 75 | case Some((2, scalaMajor)) if scalaMajor >= 11 => Seq(base / "compat" / "src" / (if (isMain) "main" else "test") / "scala-2.11").map(_.getCanonicalFile) 76 | case Some((2, scalaMajor)) if scalaMajor == 10 && include_210Dir => Seq(base / "compat" / "src" / (if (isMain) "main" else "test") / "scala-2.10").map(_.getCanonicalFile) 77 | case _ => Nil 78 | } 79 | } 80 | val unmanagedMainDirsSetting = Seq( 81 | unmanagedSourceDirectories in Compile ++= { 82 | compatDirs(projectbase = baseDirectory.value, scalaVersion = scalaVersion.value, isMain = true) 83 | } 84 | ) 85 | if (includeTestSrcs) { 86 | unmanagedMainDirsSetting ++ { 87 | unmanagedSourceDirectories in Test ++= { 88 | compatDirs(projectbase = baseDirectory.value, scalaVersion = scalaVersion.value, isMain = false) 89 | } 90 | } 91 | } else { 92 | unmanagedMainDirsSetting 93 | } 94 | } 95 | } 96 | 97 | object Details { 98 | val organization = "org.powerscala" 99 | val name = "powerscala" 100 | val version = "2.0.5" 101 | val url = "http://outr.com" 102 | val licenseType = "Apache 2.0" 103 | val licenseURL = "http://opensource.org/licenses/Apache-2.0" 104 | val projectURL = "https://github.com/outr/powerscala" 105 | val repoURL = "https://github.com/outr/powerscala.git" 106 | val developerId = "darkfrog" 107 | val developerName = "Matt Hicks" 108 | val developerURL = "http://matthicks.com" 109 | 110 | val sbtVersion = "0.13.13" 111 | val scalaVersion = "2.12.1" 112 | val scalaVersions = List("2.12.1", "2.11.8") 113 | } 114 | 115 | object Dependencies { 116 | val enumeratum = "com.beachape" %% "enumeratum" % "1.5.7" 117 | val jLine = "org.jline" % "jline" % "3.1.3" 118 | val scalaTest = "org.scalatest" %% "scalatest" % "3.0.1" % "test" 119 | } 120 | -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/Color.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | /** 4 | * Color provides a simple wrapper around RGBA color information. 5 | */ 6 | case class Color(red: Double = 0.0, green: Double = 0.0, blue: Double = 0.0, alpha: Double = 0.0) { 7 | override def toString: String = s"Color(red = $red, green = $green, blue = $blue, alpha = $alpha)" 8 | } 9 | 10 | object Color { 11 | lazy val Clear = fromLong(0x00000000) 12 | 13 | lazy val AliceBlue = fromLong(0xF0F8FFFF) 14 | lazy val AntiqueWhite = fromLong(0xFAEBD7FF) 15 | lazy val Aqua = fromLong(0x00FFFFFF) 16 | lazy val Aquamarine = fromLong(0x7FFFD4FF) 17 | lazy val Azure = fromLong(0xF0FFFFFF) 18 | lazy val Beige = fromLong(0xF5F5DCFF) 19 | lazy val Bisque = fromLong(0xFFE4C4FF) 20 | lazy val Black = fromLong(0x000000FF) 21 | lazy val BlanchedAlmond = fromLong(0xFFEBCDFF) 22 | lazy val Blue = fromLong(0x0000FFFF) 23 | lazy val BlueViolet = fromLong(0x8A2BE2FF) 24 | lazy val Brown = fromLong(0xA52A2AFF) 25 | lazy val BurlyWood = fromLong(0xDEB887FF) 26 | lazy val CadetBlue = fromLong(0x5F9EA0FF) 27 | lazy val Chartreuse = fromLong(0x7FFF00FF) 28 | lazy val Chocolate = fromLong(0xD2691EFF) 29 | lazy val Coral = fromLong(0xFF7F50FF) 30 | lazy val CornflowerBlue = fromLong(0x6495EDFF) 31 | lazy val Cornsilk = fromLong(0xFFF8DCFF) 32 | lazy val Crimson = fromLong(0xDC143CFF) 33 | lazy val Cyan = fromLong(0x00FFFFFF) 34 | lazy val DarkBlue = fromLong(0x00008BFF) 35 | lazy val DarkCyan = fromLong(0x008B8BFF) 36 | lazy val DarkGoldenRod = fromLong(0xB8860BFF) 37 | lazy val DarkGray = fromLong(0xA9A9A9FF) 38 | lazy val DarkGreen = fromLong(0x006400FF) 39 | lazy val DarkKhaki = fromLong(0xBDB76BFF) 40 | lazy val DarkMagenta = fromLong(0x8B008BFF) 41 | lazy val DarkOliveGreen = fromLong(0x556B2FFF) 42 | lazy val DarkOrange = fromLong(0xFF8C00FF) 43 | lazy val DarkOrchid = fromLong(0x9932CCFF) 44 | lazy val DarkRed = fromLong(0x8B0000FF) 45 | lazy val DarkSalmon = fromLong(0xE9967AFF) 46 | lazy val DarkSeaGreen = fromLong(0x8FBC8FFF) 47 | lazy val DarkSlateBlue = fromLong(0x483D8BFF) 48 | lazy val DarkSlateGray = fromLong(0x2F4F4FFF) 49 | lazy val DarkTurquoise = fromLong(0x00CED1FF) 50 | lazy val DarkViolet = fromLong(0x9400D3FF) 51 | lazy val DeepPink = fromLong(0xFF1493FF) 52 | lazy val DeepSkyBlue = fromLong(0x00BFFFFF) 53 | lazy val DimGray = fromLong(0x696969FF) 54 | lazy val DodgerBlue = fromLong(0x1E90FFFF) 55 | lazy val FireBrick = fromLong(0xB22222FF) 56 | lazy val FloralWhite = fromLong(0xFFFAF0FF) 57 | lazy val ForestGreen = fromLong(0x228B22FF) 58 | lazy val Fuchsia = fromLong(0xFF00FFFF) 59 | lazy val Gainsboro = fromLong(0xDCDCDCFF) 60 | lazy val GhostWhite = fromLong(0xF8F8FFFF) 61 | lazy val Gold = fromLong(0xFFD700FF) 62 | lazy val GoldenRod = fromLong(0xDAA520FF) 63 | lazy val Gray = fromLong(0x808080FF) 64 | lazy val Green = fromLong(0x008000FF) 65 | lazy val GreenYellow = fromLong(0xADFF2FFF) 66 | lazy val HoneyDew = fromLong(0xF0FFF0FF) 67 | lazy val HotPink = fromLong(0xFF69B4FF) 68 | lazy val IndianRed = fromLong(0xCD5C5CFF) 69 | lazy val Indigo = fromLong(0x4B0082FF) 70 | lazy val Ivory = fromLong(0xFFFFF0FF) 71 | lazy val Khaki = fromLong(0xF0E68CFF) 72 | lazy val Lavender = fromLong(0xE6E6FAFF) 73 | lazy val LavenderBlush = fromLong(0xFFF0F5FF) 74 | lazy val LawnGreen = fromLong(0x7CFC00FF) 75 | lazy val LemonChiffon = fromLong(0xFFFACDFF) 76 | lazy val LightBlue = fromLong(0xADD8E6FF) 77 | lazy val LightCoral = fromLong(0xF08080FF) 78 | lazy val LightCyan = fromLong(0xE0FFFFFF) 79 | lazy val LightGoldenRodYellow = fromLong(0xFAFAD2FF) 80 | lazy val LightGray = fromLong(0xD3D3D3FF) 81 | lazy val LightGreen = fromLong(0x90EE90FF) 82 | lazy val LightPink = fromLong(0xFFB6C1FF) 83 | lazy val LightSalmon = fromLong(0xFFA07AFF) 84 | lazy val LightSeaGreen = fromLong(0x20B2AAFF) 85 | lazy val LightSkyBlue = fromLong(0x87CEFAFF) 86 | lazy val LightSlateGray = fromLong(0x778899FF) 87 | lazy val LightSteelBlue = fromLong(0xB0C4DEFF) 88 | lazy val LightYellow = fromLong(0xFFFFE0FF) 89 | lazy val Lime = fromLong(0x00FF00FF) 90 | lazy val LimeGreen = fromLong(0x32CD32FF) 91 | lazy val Linen = fromLong(0xFAF0E6FF) 92 | lazy val Magenta = fromLong(0xFF00FFFF) 93 | lazy val Maroon = fromLong(0x800000FF) 94 | lazy val MediumAquaMarine = fromLong(0x66CDAAFF) 95 | lazy val MediumBlue = fromLong(0x0000CDFF) 96 | lazy val MediumOrchid = fromLong(0xBA55D3FF) 97 | lazy val MediumPurple = fromLong(0x9370DBFF) 98 | lazy val MediumSeaGreen = fromLong(0x3CB371FF) 99 | lazy val MediumSlateBlue = fromLong(0x7B68EEFF) 100 | lazy val MediumSpringGreen = fromLong(0x00FA9AFF) 101 | lazy val MediumTurquoise = fromLong(0x48D1CCFF) 102 | lazy val MediumVioletRed = fromLong(0xC71585FF) 103 | lazy val MidnightBlue = fromLong(0x191970FF) 104 | lazy val MintCream = fromLong(0xF5FFFAFF) 105 | lazy val MistyRose = fromLong(0xFFE4E1FF) 106 | lazy val Moccasin = fromLong(0xFFE4B5FF) 107 | lazy val NavajoWhite = fromLong(0xFFDEADFF) 108 | lazy val Navy = fromLong(0x000080FF) 109 | lazy val OldLace = fromLong(0xFDF5E6FF) 110 | lazy val Olive = fromLong(0x808000FF) 111 | lazy val OliveDrab = fromLong(0x6B8E23FF) 112 | lazy val Orange = fromLong(0xFFA500FF) 113 | lazy val OrangeRed = fromLong(0xFF4500FF) 114 | lazy val Orchid = fromLong(0xDA70D6FF) 115 | lazy val PaleGoldenRod = fromLong(0xEEE8AAFF) 116 | lazy val PaleGreen = fromLong(0x98FB98FF) 117 | lazy val PaleTurquoise = fromLong(0xAFEEEEFF) 118 | lazy val PaleVioletRed = fromLong(0xDB7093FF) 119 | lazy val PapayaWhip = fromLong(0xFFEFD5FF) 120 | lazy val PeachPuff = fromLong(0xFFDAB9FF) 121 | lazy val Peru = fromLong(0xCD853FFF) 122 | lazy val Pink = fromLong(0xFFC0CBFF) 123 | lazy val Plum = fromLong(0xDDA0DDFF) 124 | lazy val PowderBlue = fromLong(0xB0E0E6FF) 125 | lazy val Purple = fromLong(0x800080FF) 126 | lazy val RebeccaPurple = fromLong(0x663399FF) 127 | lazy val Red = fromLong(0xFF0000FF) 128 | lazy val RosyBrown = fromLong(0xBC8F8FFF) 129 | lazy val RoyalBlue = fromLong(0x4169E1FF) 130 | lazy val SaddleBrown = fromLong(0x8B4513FF) 131 | lazy val Salmon = fromLong(0xFA8072FF) 132 | lazy val SandyBrown = fromLong(0xF4A460FF) 133 | lazy val SeaGreen = fromLong(0x2E8B57FF) 134 | lazy val SeaShell = fromLong(0xFFF5EEFF) 135 | lazy val Sienna = fromLong(0xA0522DFF) 136 | lazy val Silver = fromLong(0xC0C0C0FF) 137 | lazy val SkyBlue = fromLong(0x87CEEBFF) 138 | lazy val SlateBlue = fromLong(0x6A5ACDFF) 139 | lazy val SlateGray = fromLong(0x708090FF) 140 | lazy val Snow = fromLong(0xFFFAFAFF) 141 | lazy val SpringGreen = fromLong(0x00FF7FFF) 142 | lazy val SteelBlue = fromLong(0x4682B4FF) 143 | lazy val Tan = fromLong(0xD2B48CFF) 144 | lazy val Teal = fromLong(0x008080FF) 145 | lazy val Thistle = fromLong(0xD8BFD8FF) 146 | lazy val Tomato = fromLong(0xFF6347FF) 147 | lazy val Turquoise = fromLong(0x40E0D0FF) 148 | lazy val Violet = fromLong(0xEE82EEFF) 149 | lazy val Wheat = fromLong(0xF5DEB3FF) 150 | lazy val White = fromLong(0xFFFFFFFF) 151 | lazy val WhiteSmoke = fromLong(0xF5F5F5FF) 152 | lazy val Yellow = fromLong(0xFFFF00FF) 153 | lazy val YellowGreen = fromLong(0x9ACD32FF) 154 | 155 | /** 156 | * Creates a new Color instance from a Long value 0xRRGGBBAA 157 | * 158 | * @param value the numeric RGBA value 159 | */ 160 | def fromLong(value: Long): Color = Color( 161 | red = (value >> 24 & 0xff) / 255.0, 162 | green = (value >> 16 & 0xff) / 255.0, 163 | blue = (value >> 8 & 0xff) / 255.0, 164 | alpha = (value >> 0 & 0xff) / 255.0 165 | ) 166 | 167 | /** 168 | * Creates a new Color instance from a hex value. It is flexible for 3-digit and 6-digit with or without a leading 169 | * hash. 170 | * 171 | * @param hex String representation of a hex String 172 | */ 173 | def fromHex(hex: String): Color = { 174 | if (hex.startsWith("#")) { 175 | fromHex(hex.substring(1)) 176 | } else if (hex.length == 6) { 177 | fromHex(s"${hex}ff") 178 | } else if (hex.length == 3) { 179 | val r = hex.charAt(0) 180 | val g = hex.charAt(1) 181 | val b = hex.charAt(2) 182 | fromHex(s"$r$r$g$g$b${b}ff") 183 | } else { 184 | fromLong(java.lang.Long.parseLong(hex, 16)) 185 | } 186 | } 187 | 188 | def toHex(color: Color, 189 | prefixHash: Boolean = true, 190 | red: Boolean = true, 191 | green: Boolean = true, 192 | blue: Boolean = true, 193 | alpha: Boolean = false): String = { 194 | val b = new StringBuilder 195 | if (prefixHash) b.append("#") 196 | if (red) b.append("%02x".format((color.red * 255.0).toInt)) 197 | if (green) b.append("%02x".format((color.green * 255.0).toInt)) 198 | if (blue) b.append("%02x".format((color.blue * 255.0).toInt)) 199 | if (alpha) b.append("%02x".format((color.alpha * 255.0).toInt)) 200 | b.toString() 201 | } 202 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/Country.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | import enumeratum._ 4 | 5 | sealed abstract class Country(val fullName: String) extends EnumEntry { 6 | override def toString = fullName 7 | } 8 | 9 | object Country extends Enum[Country] { 10 | case object US extends Country("United States of America") 11 | case object CA extends Country("Canada") 12 | case object GB extends Country("United Kingdom") 13 | case object AD extends Country("Andorra") 14 | case object AF extends Country("Afghanistan") 15 | case object AL extends Country("Albania") 16 | case object DZ extends Country("Algeria") 17 | case object AO extends Country("Angola") 18 | case object AI extends Country("Anguilla") 19 | case object AQ extends Country("Antarctica") 20 | case object AG extends Country("Antigua") 21 | case object AR extends Country("Argentina") 22 | case object AM extends Country("Armenia") 23 | case object AW extends Country("Aruba") 24 | case object AU extends Country("Australia") 25 | case object AT extends Country("Austria") 26 | case object AZ extends Country("Azerbaijan") 27 | case object BS extends Country("Bahamas") 28 | case object BH extends Country("Bahrain") 29 | case object BD extends Country("Bangladesh") 30 | case object BB extends Country("Barbados") 31 | case object BY extends Country("Belrus") 32 | case object BE extends Country("Belgium") 33 | case object BM extends Country("Bermuda") 34 | case object BT extends Country("Bhutan") 35 | case object BO extends Country("Bolivia") 36 | case object XB extends Country("Bonaire") 37 | case object BA extends Country("Bosnia and Herzegovina") 38 | case object BW extends Country("Botswana") 39 | case object BR extends Country("Brazil") 40 | case object BG extends Country("Bulgaria") 41 | case object BF extends Country("Burkina Faso") 42 | case object CV extends Country("Cabo Verde") 43 | case object KH extends Country("Cambodia") 44 | case object KY extends Country("Cayman Islands") 45 | case object CL extends Country("Chile") 46 | case object CN extends Country("China") 47 | case object CO extends Country("Colombia") 48 | case object CR extends Country("Costa Rica") 49 | case object CI extends Country("Cote d'Ivoire") 50 | case object HR extends Country("Croatia") 51 | case object CU extends Country("Cuba") 52 | case object XC extends Country("Curacao") 53 | case object CY extends Country("Cyprus") 54 | case object CZ extends Country("Czech Republic") 55 | case object DK extends Country("Denmark") 56 | case object DJ extends Country("Djibouti") 57 | case object DM extends Country("Dominica") 58 | case object DO extends Country("Dominican Republic") 59 | case object EC extends Country("Ecuador") 60 | case object EG extends Country("Egypt") 61 | case object SV extends Country("El Salvador") 62 | case object EE extends Country("Estonia") 63 | case object ET extends Country("Ethiopia") 64 | case object FJ extends Country("Fiji") 65 | case object FI extends Country("Finland") 66 | case object FR extends Country("France") 67 | case object GA extends Country("Gabon") 68 | case object GE extends Country("Georgia") 69 | case object DE extends Country("Germany") 70 | case object GH extends Country("Ghana") 71 | case object GI extends Country("Gibratar") 72 | case object GR extends Country("Greece") 73 | case object GL extends Country("Greenland") 74 | case object GD extends Country("Grenada") 75 | case object GP extends Country("Guadeloupe") 76 | case object GU extends Country("Guam") 77 | case object GT extends Country("Guatemala") 78 | case object GY extends Country("Guyana (British)") 79 | case object GF extends Country("Guyana (French)") 80 | case object HT extends Country("Haiti") 81 | case object HN extends Country("Honduras") 82 | case object HK extends Country("Hong Kong") 83 | case object HU extends Country("Hungary") 84 | case object IS extends Country("Iceland") 85 | case object IN extends Country("India") 86 | case object ID extends Country("Indonesia") 87 | case object IR extends Country("Iran") 88 | case object IQ extends Country("Iraq") 89 | case object IE extends Country("Ireland, Republic Of") 90 | case object IL extends Country("Israel") 91 | case object IT extends Country("Italy") 92 | case object JM extends Country("Jamaica") 93 | case object JP extends Country("Japan") 94 | case object JO extends Country("Jordan") 95 | case object KZ extends Country("Kazakhstan") 96 | case object KE extends Country("Kenya") 97 | case object KP extends Country("Korea, Democratic People's Republic of") 98 | case object KR extends Country("Korea, Republic Of") 99 | case object KW extends Country("Kuwait") 100 | case object LV extends Country("Latvia") 101 | case object LB extends Country("Lebanon") 102 | case object LS extends Country("Lesotho") 103 | case object LR extends Country("Liberia") 104 | case object LI extends Country("Liechtenstein") 105 | case object LT extends Country("Lithuania") 106 | case object LU extends Country("Luxembourg") 107 | case object MO extends Country("Macao") 108 | case object MK extends Country("Macedonia") 109 | case object MY extends Country("Malaysia") 110 | case object MT extends Country("Malta") 111 | case object MQ extends Country("Martinique") 112 | case object MU extends Country("Mauritius") 113 | case object MX extends Country("Mexico") 114 | case object MC extends Country("Monaco") 115 | case object MN extends Country("Mongolia") 116 | case object ME extends Country("Montenegro") 117 | case object MS extends Country("Montserrat") 118 | case object MA extends Country("Morocco") 119 | case object MZ extends Country("Mozambique") 120 | case object NA extends Country("Namibia") 121 | case object NP extends Country("Nepal") 122 | case object NL extends Country("Netherlands") 123 | case object AN extends Country("Netherlands Antilles") 124 | case object XN extends Country("Nevis") 125 | case object NZ extends Country("New Zealand") 126 | case object NI extends Country("Nicaragua") 127 | case object NG extends Country("Nigeria") 128 | case object NO extends Country("Norway") 129 | case object OM extends Country("Oman") 130 | case object PK extends Country("Pakistan") 131 | case object PS extends Country("Palestine, State of") 132 | case object PA extends Country("Panama") 133 | case object PG extends Country("Papua New Guinea") 134 | case object PY extends Country("Paraguay") 135 | case object PE extends Country("Peru") 136 | case object PH extends Country("Philippines") 137 | case object PL extends Country("Poland") 138 | case object PT extends Country("Portugal") 139 | case object PR extends Country("Puerto Rico") 140 | case object QA extends Country("Qatar") 141 | case object UG extends Country("Republic of Uganda") 142 | case object RE extends Country("Reunion Islands") 143 | case object RO extends Country("Romania") 144 | case object RU extends Country("Russian Federation The") 145 | case object SA extends Country("Saudi Arabia") 146 | case object RS extends Country("Serbia") 147 | case object CS extends Country("Serbia and Montenegro") 148 | case object SC extends Country("Seychelles") 149 | case object SG extends Country("Singapore") 150 | case object SK extends Country("Slovak Republic") 151 | case object SI extends Country("Slovenia") 152 | case object SY extends Country("Syria") 153 | case object ZA extends Country("South Africa") 154 | case object ES extends Country("Spain") 155 | case object LK extends Country("Sri Lanka") 156 | case object XY extends Country("St Barthelem") 157 | case object XE extends Country("St Eustatius") 158 | case object KN extends Country("St Kitts") 159 | case object LC extends Country("St Lucia") 160 | case object VC extends Country("St Vincent") 161 | case object XM extends Country("St. Maarten") 162 | case object SR extends Country("Suriname") 163 | case object SE extends Country("Sweden") 164 | case object CH extends Country("Switzerland") 165 | case object TW extends Country("Taiwan") 166 | case object TJ extends Country("Tajikistan") 167 | case object ZZ extends Country("Test Country") 168 | case object TH extends Country("Thailand") 169 | case object TT extends Country("Trinidad and Tobago") 170 | case object TN extends Country("Tunisia") 171 | case object TR extends Country("Turkey") 172 | case object TC extends Country("Turks and Caicos Islands") 173 | case object UA extends Country("Ukraine") 174 | case object AE extends Country("United Arab Emirates") 175 | case object TZ extends Country("United Republic of Tanzania") 176 | case object UM extends Country("United States Minor Outlying Islands") 177 | case object UY extends Country("Uruguay") 178 | case object UZ extends Country("Uzbekistan") 179 | case object VE extends Country("Venezuela") 180 | case object VN extends Country("Vietnam") 181 | case object VG extends Country("Virgin Islands (British)") 182 | case object VI extends Country("Virgin Islands (US)") 183 | case object ZM extends Country("Zambia") 184 | case object ZW extends Country("Zimbabwe") 185 | 186 | val values = findValues.toVector 187 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/Currency.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | import enumeratum._ 4 | 5 | sealed abstract class Currency(val description: String) extends EnumEntry { 6 | override def toString = s"$description ($entryName)" 7 | } 8 | 9 | object Currency extends Enum[Currency] { 10 | case object USD extends Currency("United States dollar") 11 | case object CAD extends Currency("Canadian dollar") 12 | case object EUR extends Currency("Euro") 13 | case object GBP extends Currency("British pound") 14 | case object AFN extends Currency("Afghan afghani") 15 | case object ALL extends Currency("Albanian lek") 16 | case object DZD extends Currency("Algerian dinar") 17 | case object AOA extends Currency("Angolan kwanza") 18 | case object ARS extends Currency("Argentine peso") 19 | case object AMD extends Currency("Armenian dram") 20 | case object AWG extends Currency("Aruban florin") 21 | case object AUD extends Currency("Australian dollar") 22 | case object AZN extends Currency("Azerbaijani manat") 23 | case object BSD extends Currency("Bahamian dollar") 24 | case object BHD extends Currency("Bahraini dinar") 25 | case object BDT extends Currency("Bangladeshi taka") 26 | case object BBD extends Currency("Barbadian dollar") 27 | case object BYR extends Currency("Belarusian ruble") 28 | case object BZD extends Currency("Belize dollar") 29 | case object BMD extends Currency("Bermudian dollar") 30 | case object BTN extends Currency("Bhutanese ngultrum") 31 | case object BOB extends Currency("Bolivian boliviano") 32 | case object BAM extends Currency("Bosnia and Herzegovina convertible mark") 33 | case object BWP extends Currency("Botswana pula") 34 | case object BRL extends Currency("Brazilian real") 35 | case object BND extends Currency("Brunei dollar") 36 | case object BGN extends Currency("Bulgarian lev") 37 | case object MMK extends Currency("Burmese kyat") 38 | case object BIF extends Currency("Burundian franc") 39 | case object XPF extends Currency("CFP franc") 40 | case object KHR extends Currency("Cambodian riel") 41 | case object CVE extends Currency("Cape Verdean escudo") 42 | case object KYD extends Currency("Cayman Islands dollar") 43 | case object XAF extends Currency("Central African CFA franc") 44 | case object CLP extends Currency("Chilean peso") 45 | case object CNY extends Currency("Chinese yuan") 46 | case object COP extends Currency("Colombian peso") 47 | case object KMF extends Currency("Comorian franc") 48 | case object CDF extends Currency("Congolese franc") 49 | case object CRC extends Currency("Costa Rican colón") 50 | case object HRK extends Currency("Croatian kuna") 51 | case object CUC extends Currency("Cuban convertible peso") 52 | case object CUP extends Currency("Cuban peso") 53 | case object CZK extends Currency("Czech koruna") 54 | case object DKK extends Currency("Danish krone") 55 | case object DJF extends Currency("Djiboutian franc") 56 | case object DOP extends Currency("Dominican peso") 57 | case object XCD extends Currency("East Caribbean dollar") 58 | case object EGP extends Currency("Egyptian pound") 59 | case object ERN extends Currency("Eritrean nakfa") 60 | case object ETB extends Currency("Ethiopian birr") 61 | case object FKP extends Currency("Falkland Islands pound") 62 | case object FJD extends Currency("Fijian dollar") 63 | case object GMD extends Currency("Gambian dalasi") 64 | case object GEL extends Currency("Georgian lari") 65 | case object GHS extends Currency("Ghana cedi") 66 | case object GIP extends Currency("Gibraltar pound") 67 | case object GTQ extends Currency("Guatemalan quetzal") 68 | case object GNF extends Currency("Guinean franc") 69 | case object GYD extends Currency("Guyanese dollar") 70 | case object HTG extends Currency("Haitian gourde") 71 | case object HNL extends Currency("Honduran lempira") 72 | case object HKD extends Currency("Hong Kong dollar") 73 | case object HUF extends Currency("Hungarian forint") 74 | case object ISK extends Currency("Icelandic króna") 75 | case object INR extends Currency("Indian rupee") 76 | case object IDR extends Currency("Indonesian rupiah") 77 | case object IRR extends Currency("Iranian rial") 78 | case object IQD extends Currency("Iraqi dinar") 79 | case object ILS extends Currency("Israeli new shekel") 80 | case object JMD extends Currency("Jamaican dollar") 81 | case object JPY extends Currency("Japanese yen") 82 | case object KZT extends Currency("Kazakhstani tenge") 83 | case object KES extends Currency("Kenyan shilling") 84 | case object KWD extends Currency("Kuwaiti dinar") 85 | case object KGS extends Currency("Kyrgyzstani som") 86 | case object LAK extends Currency("Lao kip") 87 | case object LVL extends Currency("Latvian lats") 88 | case object LBP extends Currency("Lebanese pound") 89 | case object LSL extends Currency("Lesotho loti") 90 | case object LRD extends Currency("Liberian dollar") 91 | case object LYD extends Currency("Libyan dinar") 92 | case object LTL extends Currency("Lithuanian litas") 93 | case object MOP extends Currency("Macanese pataca") 94 | case object MKD extends Currency("Macedonian denar") 95 | case object MGA extends Currency("Malagasy ariary") 96 | case object MWK extends Currency("Malawian kwacha") 97 | case object MYR extends Currency("Malaysian ringgit") 98 | case object MVR extends Currency("Maldivian rufiyaa") 99 | case object MRO extends Currency("Mauritanian ouguiya") 100 | case object MUR extends Currency("Mauritian rupee") 101 | case object MXN extends Currency("Mexican peso") 102 | case object MDL extends Currency("Moldovan leu") 103 | case object MNT extends Currency("Mongolian tögrög") 104 | case object MAD extends Currency("Moroccan dirham") 105 | case object MZN extends Currency("Mozambican metical") 106 | case object NAD extends Currency("Namibian dollar") 107 | case object NPR extends Currency("Nepalese rupee") 108 | case object ANG extends Currency("Netherlands Antillean guilder") 109 | case object TWD extends Currency("New Taiwan dollar") 110 | case object NZD extends Currency("New Zealand dollar") 111 | case object NIO extends Currency("Nicaraguan córdoba") 112 | case object NGN extends Currency("Nigerian naira") 113 | case object KPW extends Currency("North Korean won") 114 | case object NOK extends Currency("Norwegian krone") 115 | case object OMR extends Currency("Omani rial") 116 | case object PKR extends Currency("Pakistani rupee") 117 | case object PAB extends Currency("Panamanian balboa") 118 | case object PGK extends Currency("Papua New Guinean kina") 119 | case object PYG extends Currency("Paraguayan guaraní") 120 | case object PEN extends Currency("Peruvian nuevo sol") 121 | case object PHP extends Currency("Philippine peso") 122 | case object PLN extends Currency("Polish złoty") 123 | case object QAR extends Currency("Qatari riyal") 124 | case object RON extends Currency("Romanian leu") 125 | case object RUB extends Currency("Russian ruble") 126 | case object RWF extends Currency("Rwandan franc") 127 | case object SHP extends Currency("Saint Helena pound") 128 | case object SVC extends Currency("Salvadoran colón") 129 | case object WST extends Currency("Samoan tālā") 130 | case object SAR extends Currency("Saudi riyal") 131 | case object RSD extends Currency("Serbian dinar") 132 | case object SCR extends Currency("Seychellois rupee") 133 | case object SLL extends Currency("Sierra Leonean leone") 134 | case object SGD extends Currency("Singapore dollar") 135 | case object SBD extends Currency("Solomon Islands dollar") 136 | case object SOS extends Currency("Somali shilling") 137 | case object ZAR extends Currency("South African rand") 138 | case object KRW extends Currency("South Korean won") 139 | case object SSP extends Currency("South Sudanese pound") 140 | case object LKR extends Currency("Sri Lankan rupee") 141 | case object SDG extends Currency("Sudanese pound") 142 | case object SRD extends Currency("Surinamese dollar") 143 | case object SZL extends Currency("Swazi lilangeni") 144 | case object SEK extends Currency("Swedish krona") 145 | case object CHF extends Currency("Swiss franc") 146 | case object SYP extends Currency("Syrian pound") 147 | case object STD extends Currency("São Tomé and Príncipe dobra") 148 | case object TJS extends Currency("Tajikistani somoni") 149 | case object TZS extends Currency("Tanzanian shilling") 150 | case object THB extends Currency("Thai baht") 151 | case object TOP extends Currency("Tongan paʻanga") 152 | case object TTD extends Currency("Trinidad and Tobago dollar") 153 | case object TND extends Currency("Tunisian dinar") 154 | case object TRY extends Currency("Turkish lira") 155 | case object TMT extends Currency("Turkmenistan manat") 156 | case object UGX extends Currency("Ugandan shilling") 157 | case object UAH extends Currency("Ukrainian hryvnia") 158 | case object AED extends Currency("United Arab Emirates dirham") 159 | case object UYU extends Currency("Uruguayan peso") 160 | case object UZS extends Currency("Uzbekistani som") 161 | case object VUV extends Currency("Vanuatu vatu") 162 | case object VEF extends Currency("Venezuelan bolívar") 163 | case object VND extends Currency("Vietnamese đồng") 164 | case object XOF extends Currency("West African CFA franc") 165 | case object YER extends Currency("Yemeni rial") 166 | case object ZMK extends Currency("Zambian kwacha") 167 | case object ZWL extends Currency("Zimbabwean dollar") 168 | 169 | val values = findValues.toVector 170 | } -------------------------------------------------------------------------------- /concurrent/src/main/scala/org/powerscala/concurrent/Time.scala: -------------------------------------------------------------------------------- 1 | /* 2 | * Copyright (c) 2011 PowerScala 3 | * All rights reserved. 4 | * 5 | * Redistribution and use in source and binary forms, with or without 6 | * modification, are permitted provided that the following conditions are 7 | * met: 8 | * 9 | * Redistributions of source code must retain the above copyright 10 | * notice, this list of conditions and the following disclaimer. 11 | * 12 | * Redistributions in binary form must reproduce the above copyright 13 | * notice, this list of conditions and the following disclaimer in the 14 | * documentation and/or other materials provided with the distribution. 15 | * 16 | * Neither the name of 'PowerScala' nor the names of its contributors 17 | * may be used to endorse or promote products derived from this software 18 | * without specific prior written permission. 19 | * 20 | * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 21 | * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 22 | * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 23 | * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR 24 | * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 25 | * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 26 | * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 27 | * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF 28 | * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 29 | * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 30 | * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 31 | */ 32 | 33 | package org.powerscala.concurrent 34 | 35 | import scala.math._ 36 | import java.util.Calendar 37 | import java.text.SimpleDateFormat 38 | import collection.mutable.ListBuffer 39 | 40 | /** 41 | * Time represents convenience values and utilities 42 | * for lengths of time. All values are represented 43 | * as Doubles of time in seconds. 44 | */ 45 | case class Time(value: Double, pattern: String) { 46 | private lazy val dateFormat = new SimpleDateFormat(pattern) 47 | 48 | def format(calendar: Calendar) = dateFormat.format(calendar.getTime) 49 | 50 | def millis = Time.millis(value) 51 | 52 | /** 53 | * Parses the Calendar and then returns a Long shortened to the precision of this format in milliseconds. 54 | */ 55 | def toLong(calendar: Calendar) = { 56 | val formatted = format(calendar) 57 | parse(formatted) 58 | } 59 | 60 | def parse(source: String) = dateFormat.parse(source).getTime 61 | 62 | def parseCalendar(source: String, calendar: Calendar = Calendar.getInstance()) = { 63 | val time = parse(source) 64 | calendar.setTimeInMillis(time) 65 | calendar 66 | } 67 | } 68 | 69 | object Time { 70 | import language.implicitConversions 71 | 72 | val Second = new Time(1.0, "MM/dd/yyyy hh:mm:ss a") 73 | val Minute = new Time(60.0 * Second.value, "MM/dd/yyyy hh:mm a") 74 | val Hour = new Time(60.0 * Minute.value, "MM/dd/yyyy hh a") 75 | val Day = new Time(24.0 * Hour.value, "MM/dd/yyyy") 76 | val Week = new Time(7.0 * Day.value, "yyyy w") 77 | val Month = new Time(30.0 * Day.value, "MM yyyy") 78 | val Year = new Time(12.0 * Month.value, "yyyy") 79 | 80 | implicit def double2TimeAmount(time: Double): TimeAmount = TimeAmount(time) 81 | implicit def timeAmount2Double(timeAmount: TimeAmount): Double = timeAmount.time 82 | 83 | private val reports = new ThreadLocal[Report] 84 | 85 | /** 86 | * Generates a report for timing of segments of code defined by block names. 87 | * 88 | * Use the block(name) method to define segments of application context during the invocation of the function. 89 | */ 90 | def report(f: => Any): Report = { 91 | val report = reportStart() 92 | try { 93 | f 94 | } finally { 95 | reportFinish() 96 | } 97 | report 98 | } 99 | 100 | def reportStart() = { 101 | val report = new Report(System.nanoTime()) 102 | reports.set(report) 103 | report 104 | } 105 | 106 | def reportFinish() = { 107 | val report = reports.get() 108 | reports.set(null) 109 | report 110 | } 111 | 112 | /** 113 | * @see report 114 | */ 115 | def block(name: String) = reports.get()(name) 116 | 117 | /** 118 | * Invokes the wrapped function and returns the time in seconds it took to complete as a Double. 119 | */ 120 | def elapsed(f: => Any): Double = { 121 | val time = System.nanoTime 122 | f 123 | (System.nanoTime - time) / Precision.Nanoseconds.conversion 124 | } 125 | 126 | def elapsedReturn[R](f: R): (R, Double) = { 127 | val time = System.nanoTime() 128 | val result: R = f 129 | result -> fromNanos(System.nanoTime - time) 130 | } 131 | 132 | /** 133 | * Converts time in milliseconds to an Elapsed instance. 134 | */ 135 | def elapsed(time: Long): Elapsed = elapsed(time.toDouble / 1000.0) 136 | 137 | /** 138 | * Converts time in seconds to an Elapsed instance. 139 | */ 140 | def elapsed(time: Double) = Elapsed(time) 141 | 142 | /** 143 | * Convenience method to sleep a specific amount of time in seconds. 144 | */ 145 | def sleep(time: Double) = Thread.sleep(millis(time)) 146 | 147 | /** 148 | * Converts time in seconds to milliseconds. 149 | */ 150 | def millis(time: Double) = round(time * 1000.0) 151 | 152 | /** 153 | * Converts time in nanoseconds to seconds. 154 | */ 155 | def fromNanos(nanoseconds: Long) = nanoseconds / 1000000000.0 156 | 157 | /** 158 | * Converts time in milliseconds to seconds. 159 | */ 160 | def fromMillis(milliseconds: Long) = milliseconds / 1000.0 161 | 162 | /** 163 | * Waits for condition to return true. This method will wait 164 | * time (in seconds) for the condition and will return false 165 | * if the condition is not met within that time. Further, a negative value 166 | * for time will cause the wait to occur until the condition 167 | * is true. 168 | * 169 | * @param time 170 | * The time to wait for the condition to return true. 171 | * @param precision 172 | * The recycle period between checks. Defaults to 0.01s. 173 | * @param start 174 | * The start time in milliseconds since epoc. Defaults to 175 | * System.currentTimeMillis. 176 | * @param errorOnTimeout 177 | * If true, throws a java.util.concurrent.TimeoutException upon 178 | * timeout. Defaults to false. 179 | * @param condition 180 | * The functional condition that must return true. 181 | */ 182 | @scala.annotation.tailrec 183 | def waitFor(time: Double, precision: Double = 0.01, start: Long = System.currentTimeMillis, errorOnTimeout: Boolean = false)(condition: => Boolean): Boolean = { 184 | val p = round(precision * 1000.0) 185 | if (!condition) { 186 | if ((time >= 0.0) && (System.currentTimeMillis - start > millis(time))) { 187 | if (errorOnTimeout) throw new java.util.concurrent.TimeoutException() 188 | false 189 | } else { 190 | Thread.sleep(p) 191 | 192 | waitFor(time, precision, start, errorOnTimeout)(condition) 193 | } 194 | } else { 195 | true 196 | } 197 | } 198 | 199 | def futureCalendar(timeFromNow: Double) = { 200 | val c = Calendar.getInstance() 201 | c.setTimeInMillis(System.currentTimeMillis() + millis(timeFromNow)) 202 | c 203 | } 204 | } 205 | 206 | case class TimeAmount(time: Double) { 207 | def years = TimeAmount(time * Time.Year.value) 208 | def months = TimeAmount(time * Time.Month.value) 209 | def weeks = TimeAmount(time * Time.Week.value) 210 | def days = TimeAmount(time * Time.Day.value) 211 | def hours = TimeAmount(time * Time.Hour.value) 212 | def minutes = TimeAmount(time * Time.Minute.value) 213 | def seconds = TimeAmount(time * Time.Second.value) 214 | def and(timeAmount: TimeAmount) = TimeAmount(time + timeAmount.time) 215 | 216 | def toMilliseconds = Time.millis(time) 217 | } 218 | 219 | class Report(_start: Long) { 220 | protected var _last = _start 221 | protected var _finished = 0L 222 | protected var blocks = ListBuffer.empty[(String, Long)] 223 | protected var absolute = ListBuffer.empty[(String, Long)] 224 | 225 | def apply(name: String) = { 226 | val current = System.nanoTime() 227 | blocks += name -> (current - _last) 228 | absolute += name -> current 229 | _last = current 230 | } 231 | 232 | /** 233 | * The amount of time the named block took to the beginning of the next block 234 | */ 235 | def block(name: String) = blocks.find(t => t._1 == name).get._2 / Precision.Nanoseconds.conversion 236 | 237 | /** 238 | * The amount of time the named block took from the beginning of the report 239 | */ 240 | def elapsed(name: String) = (when(name) - _start) / Precision.Nanoseconds.conversion 241 | 242 | /** 243 | * The actual time in nanoseconds when the block started 244 | */ 245 | def when(name: String) = absolute.find(t => t._1 == name).get._2 246 | 247 | override def toString = { 248 | val b = new StringBuilder 249 | blocks.foreach { 250 | case (name, length) => { 251 | b.append("%s - Block: %ss, Elapsed: %ss\r\n".format(name, block(name), elapsed(name))) 252 | } 253 | } 254 | b.toString() 255 | } 256 | } 257 | 258 | case class Elapsed(time: Double) { 259 | val (days, hours, minutes, seconds, milliseconds) = evaluate() 260 | 261 | private def evaluate() = { 262 | val days = (time / Time.Day.value).toInt 263 | var t = time - (days * Time.Day.value) 264 | val hours = (time / Time.Hour.value).toInt 265 | t -= hours * Time.Hour.value 266 | val minutes = (t / Time.Minute.value).toInt 267 | t -= minutes * Time.Minute.value 268 | val seconds = t.toInt 269 | t -= seconds 270 | val milliseconds = (t * 1000).toInt 271 | (days, hours, minutes, seconds, milliseconds) 272 | } 273 | 274 | lazy val shorthand = { 275 | import Time._ 276 | var value: Double = time 277 | val ending = if (time > Year.value) { 278 | value = time / Year.value 279 | "year" 280 | } else if (time > Month.value) { 281 | value = time / Month.value 282 | "month" 283 | } else if (time > Week.value) { 284 | value = time / Week.value 285 | "week" 286 | } else if (time > Day.value) { 287 | value = time / Day.value 288 | "day" 289 | } else if (time > Hour.value) { 290 | value = time / Hour.value 291 | "hour" 292 | } else if (time > Minute.value) { 293 | value = time / Minute.value 294 | "minute" 295 | } else if (time > Second.value) { 296 | value = time / Second.value 297 | "second" 298 | } else { 299 | "ms" 300 | } 301 | val round = math.round(value) 302 | val s = if (round != 1 && ending != "ms") "s" else "" 303 | 304 | s"$round $ending$s" 305 | } 306 | 307 | override def toString = { 308 | var l = ListBuffer.empty[String] 309 | if (days > 0) l += s"$days days" 310 | if (hours > 0) l += s"$hours hours" 311 | if (minutes > 0) l += s"$minutes minutes" 312 | if (seconds > 0) l += s"$seconds seconds" 313 | if (milliseconds > 0) l += s"$milliseconds milliseconds" 314 | if (l.nonEmpty) { 315 | l.mkString(", ") 316 | } else { 317 | "0 milliseconds" 318 | } 319 | } 320 | } -------------------------------------------------------------------------------- /core/src/main/scala/org/powerscala/Language.scala: -------------------------------------------------------------------------------- 1 | package org.powerscala 2 | 3 | import enumeratum._ 4 | 5 | sealed abstract class Language(val bibliographic: String, 6 | val terminology: String, 7 | val iso639_1: Option[String], 8 | val englishNames: List[String], 9 | val frenchNames: List[String], 10 | val germanNames: List[String]) extends EnumEntry { 11 | Language.init(this) 12 | } 13 | 14 | object Language extends Enum[Language] { 15 | private var lookup = Map.empty[String, Language] 16 | 17 | case object Abkhazian extends Language("abk", "abk", Some("ab"), List("Abkhazian"), List("abkhaze"), List("Abchasisch")) 18 | case object Achinese extends Language("ace", "ace", None, List("Achinese"), List("aceh"), List("Aceh-Sprache")) 19 | case object Acoli extends Language("ach", "ach", None, List("Acoli"), List("acoli"), List("Acholi-Sprache")) 20 | case object Adangme extends Language("ada", "ada", None, List("Adangme"), List("adangme"), List("Adangme-Sprache")) 21 | case object Adyghe extends Language("ady", "ady", None, List("Adyghe", "Adygei"), List("adyghé"), List("Adygisch")) 22 | case object Afar extends Language("aar", "aar", Some("aa"), List("Afar"), List("afar"), List("Danakil-Sprache")) 23 | case object Afrihili extends Language("afh", "afh", None, List("Afrihili"), List("afrihili"), List("Afrihili")) 24 | case object Afrikaans extends Language("afr", "afr", Some("af"), List("Afrikaans"), List("afrikaans"), List("Afrikaans")) 25 | case object AfroAsiaticLanguages extends Language("afa", "afa", None, List("Afro-Asiatic languages"), List("afro-asiatiques, langues"), List("Hamitosemitische Sprachen (Andere)")) 26 | case object Ainu extends Language("ain", "ain", None, List("Ainu"), List("aïnou"), List("Ainu-Sprache")) 27 | case object Akan extends Language("aka", "aka", Some("ak"), List("Akan"), List("akan"), List("Akan-Sprache")) 28 | case object Akkadian extends Language("akk", "akk", None, List("Akkadian"), List("akkadien"), List("Akkadisch")) 29 | case object Albanian extends Language("alb", "sqi", Some("sq"), List("Albanian"), List("albanais"), List("Albanisch")) 30 | case object Aleut extends Language("ale", "ale", None, List("Aleut"), List("aléoute"), List("Aleutisch")) 31 | case object AlgonquianLanguages extends Language("alg", "alg", None, List("Algonquian languages"), List("algonquines, langues"), List("Algonkin-Sprachen (Andere)")) 32 | case object AltaicLanguages extends Language("tut", "tut", None, List("Altaic languages"), List("altaïques, langues"), List("Altaische Sprachen (Andere)")) 33 | case object Amharic extends Language("amh", "amh", Some("am"), List("Amharic"), List("amharique"), List("Amharisch")) 34 | case object Angika extends Language("anp", "anp", None, List("Angika"), List("angika"), List("Anga-Sprache")) 35 | case object ApacheLanguages extends Language("apa", "apa", None, List("Apache languages"), List("apaches, langues"), List("Apachen-Sprachen")) 36 | case object Arabic extends Language("ara", "ara", Some("ar"), List("Arabic"), List("arabe"), List("Arabisch")) 37 | case object Aragonese extends Language("arg", "arg", Some("an"), List("Aragonese"), List("aragonais"), List("Aragonesisch")) 38 | case object Arapaho extends Language("arp", "arp", None, List("Arapaho"), List("arapaho"), List("Arapaho-Sprache")) 39 | case object Arawak extends Language("arw", "arw", None, List("Arawak"), List("arawak"), List("Arawak-Sprachen")) 40 | case object Armenian extends Language("arm", "hye", Some("hy"), List("Armenian"), List("arménien"), List("Armenisch")) 41 | case object Aromanian extends Language("rup", "rup", None, List("Aromanian", "Arumanian", "Macedo-Romanian"), List("aroumain", "macédo-roumain"), List("Aromunisch")) 42 | case object ArtificialLanguages extends Language("art", "art", None, List("Artificial languages"), List("artificielles, langues"), List("Kunstsprachen (Andere)")) 43 | case object Assamese extends Language("asm", "asm", Some("as"), List("Assamese"), List("assamais"), List("Assamesisch")) 44 | case object Asturian extends Language("ast", "ast", None, List("Asturian", "Bable", "Leonese", "Asturleonese"), List("asturien", "bable", "léonais", "asturoléonais"), List("Asturisch")) 45 | case object AthapascanLanguages extends Language("ath", "ath", None, List("Athapascan languages"), List("athapascanes, langues"), List("Athapaskische Sprachen (Andere)")) 46 | case object AustralianLanguages extends Language("aus", "aus", None, List("Australian languages"), List("australiennes, langues"), List("Australische Sprachen")) 47 | case object AustronesianLanguages extends Language("map", "map", None, List("Austronesian languages"), List("austronésiennes, langues"), List("Austronesische Sprachen (Andere)")) 48 | case object Avaric extends Language("ava", "ava", Some("av"), List("Avaric"), List("avar"), List("Awarisch")) 49 | case object Avestan extends Language("ave", "ave", Some("ae"), List("Avestan"), List("avestique"), List("Avestisch")) 50 | case object Awadhi extends Language("awa", "awa", None, List("Awadhi"), List("awadhi"), List("Awadhi")) 51 | case object Aymara extends Language("aym", "aym", Some("ay"), List("Aymara"), List("aymara"), List("Aymará-Sprache")) 52 | case object Azerbaijani extends Language("aze", "aze", Some("az"), List("Azerbaijani"), List("azéri"), List("Aserbeidschanisch")) 53 | case object Balinese extends Language("ban", "ban", None, List("Balinese"), List("balinais"), List("Balinesisch")) 54 | case object BalticLanguages extends Language("bat", "bat", None, List("Baltic languages"), List("baltes, langues"), List("Baltische Sprachen (Andere)")) 55 | case object Baluchi extends Language("bal", "bal", None, List("Baluchi"), List("baloutchi"), List("Belutschisch")) 56 | case object Bambara extends Language("bam", "bam", Some("bm"), List("Bambara"), List("bambara"), List("Bambara-Sprache")) 57 | case object BamilekeLanguages extends Language("bai", "bai", None, List("Bamileke languages"), List("bamiléké, langues"), List("Bamileke-Sprachen")) 58 | case object BandaLanguages extends Language("bad", "bad", None, List("Banda languages"), List("banda, langues"), List("Banda-Sprachen (Ubangi-Sprachen)")) 59 | case object BantuLanguages extends Language("bnt", "bnt", None, List("Bantu languages"), List("bantou, langues"), List("Bantusprachen (Andere)")) 60 | case object Basa extends Language("bas", "bas", None, List("Basa"), List("basa"), List("Basaa-Sprache")) 61 | case object Bashkir extends Language("bak", "bak", Some("ba"), List("Bashkir"), List("bachkir"), List("Baschkirisch")) 62 | case object Basque extends Language("baq", "eus", Some("eu"), List("Basque"), List("basque"), List("Baskisch")) 63 | case object BatakLanguages extends Language("btk", "btk", None, List("Batak languages"), List("batak, langues"), List("Batak-Sprache")) 64 | case object Beja extends Language("bej", "bej", None, List("Beja", "Bedawiyet"), List("bedja"), List("Bedauye")) 65 | case object Belarusian extends Language("bel", "bel", Some("be"), List("Belarusian"), List("biélorusse"), List("Weißrussisch")) 66 | case object Bemba extends Language("bem", "bem", None, List("Bemba"), List("bemba"), List("Bemba-Sprache")) 67 | case object Bengali extends Language("ben", "ben", Some("bn"), List("Bengali"), List("bengali"), List("Bengali")) 68 | case object BerberLanguages extends Language("ber", "ber", None, List("Berber languages"), List("berbères, langues"), List("Berbersprachen (Andere)")) 69 | case object Bhojpuri extends Language("bho", "bho", None, List("Bhojpuri"), List("bhojpuri"), List("Bhojpuri")) 70 | case object BihariLanguages extends Language("bih", "bih", Some("bh"), List("Bihari languages"), List("langues biharis"), List("Bihari (Andere)")) 71 | case object Bikol extends Language("bik", "bik", None, List("Bikol"), List("bikol"), List("Bikol-Sprache")) 72 | case object Bini extends Language("bin", "bin", None, List("Bini", "Edo"), List("bini", "edo"), List("Edo-Sprache")) 73 | case object Bislama extends Language("bis", "bis", Some("bi"), List("Bislama"), List("bichlamar"), List("Beach-la-mar")) 74 | case object Blin extends Language("byn", "byn", None, List("Blin", "Bilin"), List("blin", "bilen"), List("Bilin-Sprache")) 75 | case object Blissymbols extends Language("zbl", "zbl", None, List("Blissymbols", "Blissymbolics", "Bliss"), List("symboles Bliss", "Bliss"), List("Bliss-Symbol")) 76 | case object BokmålNorwegian extends Language("nob", "nob", Some("nb"), List("Bokmål, Norwegian", "Norwegian Bokmål"), List("norvégien bokmål"), List("Bokmål")) 77 | case object Bosnian extends Language("bos", "bos", Some("bs"), List("Bosnian"), List("bosniaque"), List("Bosnisch")) 78 | case object Braj extends Language("bra", "bra", None, List("Braj"), List("braj"), List("Braj-Bhakha")) 79 | case object Breton extends Language("bre", "bre", Some("br"), List("Breton"), List("breton"), List("Bretonisch")) 80 | case object Buginese extends Language("bug", "bug", None, List("Buginese"), List("bugi"), List("Bugi-Sprache")) 81 | case object Bulgarian extends Language("bul", "bul", Some("bg"), List("Bulgarian"), List("bulgare"), List("Bulgarisch")) 82 | case object Buriat extends Language("bua", "bua", None, List("Buriat"), List("bouriate"), List("Burjatisch")) 83 | case object Burmese extends Language("bur", "mya", Some("my"), List("Burmese"), List("birman"), List("Birmanisch")) 84 | case object Caddo extends Language("cad", "cad", None, List("Caddo"), List("caddo"), List("Caddo-Sprachen")) 85 | case object Catalan extends Language("cat", "cat", Some("ca"), List("Catalan", "Valencian"), List("catalan", "valencien"), List("Katalanisch")) 86 | case object CaucasianLanguages extends Language("cau", "cau", None, List("Caucasian languages"), List("caucasiennes, langues"), List("Kaukasische Sprachen (Andere)")) 87 | case object Cebuano extends Language("ceb", "ceb", None, List("Cebuano"), List("cebuano"), List("Cebuano")) 88 | case object CelticLanguages extends Language("cel", "cel", None, List("Celtic languages"), List("celtiques, langues", "celtes, langues"), List("Keltische Sprachen (Andere)")) 89 | case object CentralAmericanIndianLanguages extends Language("cai", "cai", None, List("Central American Indian languages"), List("amérindiennes de l'Amérique centrale, langues"), List("Indianersprachen, Zentralamerika (Andere)")) 90 | case object CentralKhmer extends Language("khm", "khm", Some("km"), List("Central Khmer"), List("khmer central"), List("Kambodschanisch")) 91 | case object Chagatai extends Language("chg", "chg", None, List("Chagatai"), List("djaghataï"), List("Tschagataisch")) 92 | case object ChamicLanguages extends Language("cmc", "cmc", None, List("Chamic languages"), List("chames, langues"), List("Cham-Sprachen")) 93 | case object Chamorro extends Language("cha", "cha", Some("ch"), List("Chamorro"), List("chamorro"), List("Chamorro-Sprache")) 94 | case object Chechen extends Language("che", "che", Some("ce"), List("Chechen"), List("tchétchène"), List("Tschetschenisch")) 95 | case object Cherokee extends Language("chr", "chr", None, List("Cherokee"), List("cherokee"), List("Cherokee-Sprache")) 96 | case object Cheyenne extends Language("chy", "chy", None, List("Cheyenne"), List("cheyenne"), List("Cheyenne-Sprache")) 97 | case object Chibcha extends Language("chb", "chb", None, List("Chibcha"), List("chibcha"), List("Chibcha-Sprachen")) 98 | case object Chichewa extends Language("nya", "nya", Some("ny"), List("Chichewa", "Chewa", "Nyanja"), List("chichewa", "chewa", "nyanja"), List("Nyanja-Sprache")) 99 | case object Chinese extends Language("chi", "zho", Some("zh"), List("Chinese", "Mandarin"), List("chinois"), List("Chinesisch")) 100 | case object ChinookJargon extends Language("chn", "chn", None, List("Chinook jargon"), List("chinook, jargon"), List("Chinook-Jargon")) 101 | case object Chipewyan extends Language("chp", "chp", None, List("Chipewyan", "Dene Suline"), List("chipewyan"), List("Chipewyan-Sprache")) 102 | case object Choctaw extends Language("cho", "cho", None, List("Choctaw"), List("choctaw"), List("Choctaw-Sprache")) 103 | case object ChurchSlavic extends Language("chu", "chu", Some("cu"), List("Church Slavic", "Old Slavonic", "Church Slavonic", "Old Bulgarian", "Old Church Slavonic"), List("slavon d'église", "vieux slave", "slavon liturgique", "vieux bulgare"), List("Kirchenslawisch")) 104 | case object Chuukese extends Language("chk", "chk", None, List("Chuukese"), List("chuuk"), List("Trukesisch")) 105 | case object Chuvash extends Language("chv", "chv", Some("cv"), List("Chuvash"), List("tchouvache"), List("Tschuwaschisch")) 106 | case object ClassicalNewari extends Language("nwc", "nwc", None, List("Classical Newari", "Old Newari", "Classical Nepal Bhasa"), List("newari classique"), List("Alt-Newari")) 107 | case object ClassicalSyriac extends Language("syc", "syc", None, List("Classical Syriac"), List("syriaque classique"), List("Syrisch")) 108 | case object Coptic extends Language("cop", "cop", None, List("Coptic"), List("copte"), List("Koptisch")) 109 | case object Cornish extends Language("cor", "cor", Some("kw"), List("Cornish"), List("cornique"), List("Kornisch")) 110 | case object Corsican extends Language("cos", "cos", Some("co"), List("Corsican"), List("corse"), List("Korsisch")) 111 | case object Cree extends Language("cre", "cre", Some("cr"), List("Cree"), List("cree"), List("Cree-Sprache")) 112 | case object Creek extends Language("mus", "mus", None, List("Creek"), List("muskogee"), List("Muskogisch")) 113 | case object CreolesAndPidgins extends Language("crp", "crp", None, List("Creoles and pidgins"), List("créoles et pidgins"), List("Kreolische Sprachen", "Pidginsprachen (Andere)")) 114 | case object CreolesAndPidginsEnglishBased extends Language("cpe", "cpe", None, List("Creoles and pidgins, English based"), List("créoles et pidgins basés sur l'anglais"), List("Kreolisch-Englisch (Andere)")) 115 | case object CreolesAndPidginsFrenchBased extends Language("cpf", "cpf", None, List("Creoles and pidgins, French-based"), List("créoles et pidgins basés sur le français"), List("Kreolisch-Französisch (Andere)")) 116 | case object CreolesAndPidginsPortugueseBased extends Language("cpp", "cpp", None, List("Creoles and pidgins, Portuguese-based"), List("créoles et pidgins basés sur le portugais"), List("Kreolisch-Portugiesisch (Andere)")) 117 | case object CrimeanTatar extends Language("crh", "crh", None, List("Crimean Tatar", "Crimean Turkish"), List("tatar de Crimé"), List("Krimtatarisch")) 118 | case object Croatian extends Language("hrv", "hrv", Some("hr"), List("Croatian"), List("croate"), List("Kroatisch")) 119 | case object CushiticLanguages extends Language("cus", "cus", None, List("Cushitic languages"), List("couchitiques, langues"), List("Kuschitische Sprachen (Andere)")) 120 | case object Czech extends Language("cze", "ces", Some("cs"), List("Czech"), List("tchèque"), List("Tschechisch")) 121 | case object Dakota extends Language("dak", "dak", None, List("Dakota"), List("dakota"), List("Dakota-Sprache")) 122 | case object Danish extends Language("dan", "dan", Some("da"), List("Danish"), List("danois"), List("Dänisch")) 123 | case object Dargwa extends Language("dar", "dar", None, List("Dargwa"), List("dargwa"), List("Darginisch")) 124 | case object Delaware extends Language("del", "del", None, List("Delaware"), List("delaware"), List("Delaware-Sprache")) 125 | case object Dinka extends Language("din", "din", None, List("Dinka"), List("dinka"), List("Dinka-Sprache")) 126 | case object Divehi extends Language("div", "div", Some("dv"), List("Divehi", "Dhivehi", "Maldivian"), List("maldivien"), List("Maledivisch")) 127 | case object Dogri extends Language("doi", "doi", None, List("Dogri"), List("dogri"), List("Dogri")) 128 | case object Dogrib extends Language("dgr", "dgr", None, List("Dogrib"), List("dogrib"), List("Dogrib-Sprache")) 129 | case object DravidianLanguages extends Language("dra", "dra", None, List("Dravidian languages"), List("dravidiennes, langues"), List("Drawidische Sprachen (Andere)")) 130 | case object Duala extends Language("dua", "dua", None, List("Duala"), List("douala"), List("Duala-Sprachen")) 131 | case object Dutch extends Language("dut", "nld", Some("nl"), List("Dutch", "Flemish"), List("néerlandais", "flamand"), List("Niederländisch")) 132 | case object DutchMiddle extends Language("dum", "dum", None, List("Dutch, Middle (ca.1050-1350)"), List("néerlandais moyen (ca. 1050-1350)"), List("Mittelniederländisch")) 133 | case object Dyula extends Language("dyu", "dyu", None, List("Dyula"), List("dioula"), List("Dyula-Sprache")) 134 | case object Dzongkha extends Language("dzo", "dzo", Some("dz"), List("Dzongkha"), List("dzongkha"), List("Dzongkha")) 135 | case object EasternFrisian extends Language("frs", "frs", None, List("Eastern Frisian"), List("frison oriental"), List("Ostfriesisch")) 136 | case object Efik extends Language("efi", "efi", None, List("Efik"), List("efik"), List("Efik")) 137 | case object Egyptian extends Language("egy", "egy", None, List("Egyptian (Ancient)"), List("égyptien"), List("Ägyptisch")) 138 | case object Ekajuk extends Language("eka", "eka", None, List("Ekajuk"), List("ekajuk"), List("Ekajuk")) 139 | case object Elamite extends Language("elx", "elx", None, List("Elamite"), List("élamite"), List("Elamisch")) 140 | case object English extends Language("eng", "eng", Some("en"), List("English"), List("anglais"), List("Englisch")) 141 | case object EnglishMiddle extends Language("enm", "enm", None, List("English, Middle (1100-1500)"), List("anglais moyen (1100-1500)"), List("Mittelenglisch")) 142 | case object EnglishOld extends Language("ang", "ang", None, List("English, Old (ca.450-1100)"), List("anglo-saxon (ca.450-1100)"), List("Altenglisch")) 143 | case object Erzya extends Language("myv", "myv", None, List("Erzya"), List("erza"), List("Erza-Mordwinisch")) 144 | case object Esperanto extends Language("epo", "epo", Some("eo"), List("Esperanto"), List("espéranto"), List("Esperanto")) 145 | case object Estonian extends Language("est", "est", Some("et"), List("Estonian"), List("estonien"), List("Estnisch")) 146 | case object Ewe extends Language("ewe", "ewe", Some("ee"), List("Ewe"), List("éwé"), List("Ewe-Sprache")) 147 | case object Ewondo extends Language("ewo", "ewo", None, List("Ewondo"), List("éwondo"), List("Ewondo")) 148 | case object Fang extends Language("fan", "fan", None, List("Fang"), List("fang"), List("Pangwe-Sprache")) 149 | case object Fanti extends Language("fat", "fat", None, List("Fanti"), List("fanti"), List("Fante-Sprache")) 150 | case object Faroese extends Language("fao", "fao", Some("fo"), List("Faroese"), List("féroïen"), List("Färöisch")) 151 | case object Fijian extends Language("fij", "fij", Some("fj"), List("Fijian"), List("fidjien"), List("Fidschi-Sprache")) 152 | case object Filipino extends Language("fil", "fil", None, List("Filipino", "Pilipino"), List("filipino", "pilipino"), List("Pilipino")) 153 | case object Finnish extends Language("fin", "fin", Some("fi"), List("Finnish"), List("finnois"), List("Finnisch")) 154 | case object FinnoUgrianLanguages extends Language("fiu", "fiu", None, List("Finno-Ugrian languages"), List("finno-ougriennes, langues"), List("Finnougrische Sprachen (Andere)")) 155 | case object Fon extends Language("fon", "fon", None, List("Fon"), List("fon"), List("Fon-Sprache")) 156 | case object French extends Language("fre", "fra", Some("fr"), List("French"), List("français"), List("Französisch")) 157 | case object FrenchMiddle extends Language("frm", "frm", None, List("French, Middle (ca.1400-1600)"), List("français moyen (1400-1600)"), List("Mittelfranzösisch")) 158 | case object FrenchOld extends Language("fro", "fro", None, List("French, Old (842-ca.1400)"), List("français ancien (842-ca.1400)"), List("Altfranzösisch")) 159 | case object Friulian extends Language("fur", "fur", None, List("Friulian"), List("frioulan"), List("Friulisch")) 160 | case object Fulah extends Language("ful", "ful", Some("ff"), List("Fulah"), List("peul"), List("Ful")) 161 | case object Ga extends Language("gaa", "gaa", None, List("Ga"), List("ga"), List("Ga-Sprache")) 162 | case object Gaelic extends Language("gla", "gla", Some("gd"), List("Gaelic", "Scottish Gaelic"), List("gaélique", "gaélique écossais"), List("Gälisch-Schottisch")) 163 | case object GalibiCarib extends Language("car", "car", None, List("Galibi Carib"), List("karib", "galibi", "carib"), List("Karibische Sprachen")) 164 | case object Galician extends Language("glg", "glg", Some("gl"), List("Galician"), List("galicien"), List("Galicisch")) 165 | case object Ganda extends Language("lug", "lug", Some("lg"), List("Ganda"), List("ganda"), List("Ganda-Sprache")) 166 | case object Gayo extends Language("gay", "gay", None, List("Gayo"), List("gayo"), List("Gayo-Sprache")) 167 | case object Gbaya extends Language("gba", "gba", None, List("Gbaya"), List("gbaya"), List("Gbaya-Sprache")) 168 | case object Geez extends Language("gez", "gez", None, List("Geez"), List("guèze"), List("Altäthiopisch")) 169 | case object Georgian extends Language("geo", "kat", Some("ka"), List("Georgian"), List("géorgien"), List("Georgisch")) 170 | case object German extends Language("ger", "deu", Some("de"), List("German"), List("allemand"), List("Deutsch")) 171 | case object GermanMiddleHigh extends Language("gmh", "gmh", None, List("German, Middle High (ca.1050-1500)"), List("allemand, moyen haut (ca. 1050-1500)"), List("Mittelhochdeutsch")) 172 | case object GermanOldHigh extends Language("goh", "goh", None, List("German, Old High (ca.750-1050)"), List("allemand, vieux haut (ca. 750-1050)"), List("Althochdeutsch")) 173 | case object GermanicLanguages extends Language("gem", "gem", None, List("Germanic languages"), List("germaniques, langues"), List("Germanische Sprachen (Andere)")) 174 | case object Gilbertese extends Language("gil", "gil", None, List("Gilbertese"), List("kiribati"), List("Gilbertesisch")) 175 | case object Gondi extends Language("gon", "gon", None, List("Gondi"), List("gond"), List("Gondi-Sprache")) 176 | case object Gorontalo extends Language("gor", "gor", None, List("Gorontalo"), List("gorontalo"), List("Gorontalesisch")) 177 | case object Gothic extends Language("got", "got", None, List("Gothic"), List("gothique"), List("Gotisch")) 178 | case object Grebo extends Language("grb", "grb", None, List("Grebo"), List("grebo"), List("Grebo-Sprache")) 179 | case object GreekAncient extends Language("grc", "grc", None, List("Greek, Ancient (to 1453)"), List("grec ancien (jusqu'à 1453)"), List("Griechisch")) 180 | case object GreekModern extends Language("gre", "ell", Some("el"), List("Greek", "Greek, Modern (1453-)"), List("grec moderne (après 1453)"), List("Neugriechisch")) 181 | case object Guarani extends Language("grn", "grn", Some("gn"), List("Guarani"), List("guarani"), List("Guaraní-Sprache")) 182 | case object Gujarati extends Language("guj", "guj", Some("gu"), List("Gujarati"), List("goudjrati"), List("Gujarati-Sprache")) 183 | case object GwichIn extends Language("gwi", "gwi", None, List("Gwich'in"), List("gwich'in"), List("Kutchin-Sprache")) 184 | case object Haida extends Language("hai", "hai", None, List("Haida"), List("haida"), List("Haida-Sprache")) 185 | case object Haitian extends Language("hat", "hat", Some("ht"), List("Haitian", "Haitian Creole"), List("haïtien", "créole haïtien"), List("Haïtien (Haiti-Kreolisch)")) 186 | case object Hausa extends Language("hau", "hau", Some("ha"), List("Hausa"), List("haoussa"), List("Haussa-Sprache")) 187 | case object Hawaiian extends Language("haw", "haw", None, List("Hawaiian"), List("hawaïen"), List("Hawaiisch")) 188 | case object Hebrew extends Language("heb", "heb", Some("he"), List("Hebrew"), List("hébreu"), List("Hebräisch")) 189 | case object Herero extends Language("her", "her", Some("hz"), List("Herero"), List("herero"), List("Herero-Sprache")) 190 | case object Hiligaynon extends Language("hil", "hil", None, List("Hiligaynon"), List("hiligaynon"), List("Hiligaynon-Sprache")) 191 | case object HimachaliLanguages extends Language("him", "him", None, List("Himachali languages", "Western Pahari languages"), List("langues himachalis", "langues paharis occidentales"), List("Himachali")) 192 | case object Hindi extends Language("hin", "hin", Some("hi"), List("Hindi", "Hindustani"), List("hindi"), List("Hindi")) 193 | case object HiriMotu extends Language("hmo", "hmo", Some("ho"), List("Hiri Motu"), List("hiri motu"), List("Hiri-Motu")) 194 | case object Hittite extends Language("hit", "hit", None, List("Hittite"), List("hittite"), List("Hethitisch")) 195 | case object Hmong extends Language("hmn", "hmn", None, List("Hmong", "Mong"), List("hmong"), List("Miao-Sprachen")) 196 | case object Hungarian extends Language("hun", "hun", Some("hu"), List("Hungarian"), List("hongrois"), List("Ungarisch")) 197 | case object Hupa extends Language("hup", "hup", None, List("Hupa"), List("hupa"), List("Hupa-Sprache")) 198 | case object Iban extends Language("iba", "iba", None, List("Iban"), List("iban"), List("Iban-Sprache")) 199 | case object Icelandic extends Language("ice", "isl", Some("is"), List("Icelandic"), List("islandais"), List("Isländisch")) 200 | case object Ido extends Language("ido", "ido", Some("io"), List("Ido"), List("ido"), List("Ido")) 201 | case object Igbo extends Language("ibo", "ibo", Some("ig"), List("Igbo"), List("igbo"), List("Ibo-Sprache")) 202 | case object IjoLanguages extends Language("ijo", "ijo", None, List("Ijo languages"), List("ijo, langues"), List("Ijo-Sprache")) 203 | case object Iloko extends Language("ilo", "ilo", None, List("Iloko"), List("ilocano"), List("Ilokano-Sprache")) 204 | case object InariSami extends Language("smn", "smn", None, List("Inari Sami"), List("sami d'Inari"), List("Inarisaamisch")) 205 | case object IndicLanguages extends Language("inc", "inc", None, List("Indic languages"), List("indo-aryennes, langues"), List("Indoarische Sprachen (Andere)")) 206 | case object IndoEuropeanLanguages extends Language("ine", "ine", None, List("Indo-European languages"), List("indo-européennes, langues"), List("Indogermanische Sprachen (Andere)")) 207 | case object Indonesian extends Language("ind", "ind", Some("id"), List("Indonesian"), List("indonésien"), List("Bahasa Indonesia")) 208 | case object Ingush extends Language("inh", "inh", None, List("Ingush"), List("ingouche"), List("Inguschisch")) 209 | case object Interlingua extends Language("ina", "ina", Some("ia"), List("Interlingua (International Auxiliary Language Association)"), List("interlingua (langue auxiliaire internationale)"), List("Interlingua")) 210 | case object Interlingue extends Language("ile", "ile", Some("ie"), List("Interlingue", "Occidental"), List("interlingue"), List("Interlingue")) 211 | case object Inuktitut extends Language("iku", "iku", Some("iu"), List("Inuktitut"), List("inuktitut"), List("Inuktitut")) 212 | case object Inupiaq extends Language("ipk", "ipk", Some("ik"), List("Inupiaq"), List("inupiaq"), List("Inupik")) 213 | case object IranianLanguages extends Language("ira", "ira", None, List("Iranian languages"), List("iraniennes, langues"), List("Iranische Sprachen (Andere)")) 214 | case object Irish extends Language("gle", "gle", Some("ga"), List("Irish"), List("irlandais"), List("Irisch")) 215 | case object IrishMiddle extends Language("mga", "mga", None, List("Irish, Middle (900-1200)"), List("irlandais moyen (900-1200)"), List("Mittelirisch")) 216 | case object IrishOld extends Language("sga", "sga", None, List("Irish, Old (to 900)"), List("irlandais ancien (jusqu'à 900)"), List("Altirisch")) 217 | case object IroquoianLanguages extends Language("iro", "iro", None, List("Iroquoian languages"), List("iroquoises, langues"), List("Irokesische Sprachen")) 218 | case object Italian extends Language("ita", "ita", Some("it"), List("Italian"), List("italien"), List("Italienisch")) 219 | case object Japanese extends Language("jpn", "jpn", Some("ja"), List("Japanese"), List("japonais"), List("Japanisch")) 220 | case object Javanese extends Language("jav", "jav", Some("jv"), List("Javanese"), List("javanais"), List("Javanisch")) 221 | case object JudeoArabic extends Language("jrb", "jrb", None, List("Judeo-Arabic"), List("judéo-arabe"), List("Jüdisch-Arabisch")) 222 | case object JudeoPersian extends Language("jpr", "jpr", None, List("Judeo-Persian"), List("judéo-persan"), List("Jüdisch-Persisch")) 223 | case object Kabardian extends Language("kbd", "kbd", None, List("Kabardian"), List("kabardien"), List("Kabardinisch")) 224 | case object Kabyle extends Language("kab", "kab", None, List("Kabyle"), List("kabyle"), List("Kabylisch")) 225 | case object Kachin extends Language("kac", "kac", None, List("Kachin", "Jingpho"), List("kachin", "jingpho"), List("Kachin-Sprache")) 226 | case object Kalaallisut extends Language("kal", "kal", Some("kl"), List("Kalaallisut", "Greenlandic"), List("groenlandais"), List("Grönländisch")) 227 | case object Kalmyk extends Language("xal", "xal", None, List("Kalmyk", "Oirat"), List("kalmouk", "oïrat"), List("Kalmückisch")) 228 | case object Kamba extends Language("kam", "kam", None, List("Kamba"), List("kamba"), List("Kamba-Sprache")) 229 | case object Kannada extends Language("kan", "kan", Some("kn"), List("Kannada"), List("kannada"), List("Kannada")) 230 | case object Kanuri extends Language("kau", "kau", Some("kr"), List("Kanuri"), List("kanouri"), List("Kanuri-Sprache")) 231 | case object KaraKalpak extends Language("kaa", "kaa", None, List("Kara-Kalpak"), List("karakalpak"), List("Karakalpakisch")) 232 | case object KarachayBalkar extends Language("krc", "krc", None, List("Karachay-Balkar"), List("karatchai balkar"), List("Karatschaiisch-Balkarisch")) 233 | case object Karelian extends Language("krl", "krl", None, List("Karelian"), List("carélien"), List("Karelisch")) 234 | case object KarenLanguages extends Language("kar", "kar", None, List("Karen languages"), List("karen, langues"), List("Karenisch")) 235 | case object Kashmiri extends Language("kas", "kas", Some("ks"), List("Kashmiri"), List("kashmiri"), List("Kaschmiri")) 236 | case object Kashubian extends Language("csb", "csb", None, List("Kashubian"), List("kachoube"), List("Kaschubisch")) 237 | case object Kawi extends Language("kaw", "kaw", None, List("Kawi"), List("kawi"), List("Kawi")) 238 | case object Kazakh extends Language("kaz", "kaz", Some("kk"), List("Kazakh"), List("kazakh"), List("Kasachisch")) 239 | case object Khasi extends Language("kha", "kha", None, List("Khasi"), List("khasi"), List("Khasi-Sprache")) 240 | case object KhoisanLanguages extends Language("khi", "khi", None, List("Khoisan languages"), List("khoïsan, langues"), List("Khoisan-Sprachen (Andere)")) 241 | case object Khotanese extends Language("kho", "kho", None, List("Khotanese", "Sakan"), List("khotanais", "sakan"), List("Sakisch")) 242 | case object Kikuyu extends Language("kik", "kik", Some("ki"), List("Kikuyu", "Gikuyu"), List("kikuyu"), List("Kikuyu-Sprache")) 243 | case object Kimbundu extends Language("kmb", "kmb", None, List("Kimbundu"), List("kimbundu"), List("Kimbundu-Sprache")) 244 | case object Kinyarwanda extends Language("kin", "kin", Some("rw"), List("Kinyarwanda"), List("rwanda"), List("Rwanda-Sprache")) 245 | case object Kirghiz extends Language("kir", "kir", Some("ky"), List("Kirghiz", "Kyrgyz"), List("kirghiz"), List("Kirgisisch")) 246 | case object Klingon extends Language("tlh", "tlh", None, List("Klingon", "tlhIngan-Hol"), List("klingon"), List("Klingonisch")) 247 | case object Komi extends Language("kom", "kom", Some("kv"), List("Komi"), List("kom"), List("Komi-Sprache")) 248 | case object Kongo extends Language("kon", "kon", Some("kg"), List("Kongo"), List("kongo"), List("Kongo-Sprache")) 249 | case object Konkani extends Language("kok", "kok", None, List("Konkani"), List("konkani"), List("Konkani")) 250 | case object Korean extends Language("kor", "kor", Some("ko"), List("Korean"), List("coréen"), List("Koreanisch")) 251 | case object Kosraean extends Language("kos", "kos", None, List("Kosraean"), List("kosrae"), List("Kosraeanisch")) 252 | case object Kpelle extends Language("kpe", "kpe", None, List("Kpelle"), List("kpellé"), List("Kpelle-Sprache")) 253 | case object KruLanguages extends Language("kro", "kro", None, List("Kru languages"), List("krou, langues"), List("Kru-Sprachen (Andere)")) 254 | case object Kuanyama extends Language("kua", "kua", Some("kj"), List("Kuanyama", "Kwanyama"), List("kuanyama", "kwanyama"), List("Kwanyama-Sprache")) 255 | case object Kumyk extends Language("kum", "kum", None, List("Kumyk"), List("koumyk"), List("Kumükisch")) 256 | case object Kurdish extends Language("kur", "kur", Some("ku"), List("Kurdish"), List("kurde"), List("Kurdisch")) 257 | case object Kurukh extends Language("kru", "kru", None, List("Kurukh"), List("kurukh"), List("Oraon-Sprache")) 258 | case object Kutenai extends Language("kut", "kut", None, List("Kutenai"), List("kutenai"), List("Kutenai-Sprache")) 259 | case object Ladino extends Language("lad", "lad", None, List("Ladino"), List("judéo-espagnol"), List("Judenspanisch")) 260 | case object Lahnda extends Language("lah", "lah", None, List("Lahnda"), List("lahnda"), List("Lahnda")) 261 | case object Lamba extends Language("lam", "lam", None, List("Lamba"), List("lamba"), List("Lamba-Sprache (Bantusprache)")) 262 | case object LandDayakLanguages extends Language("day", "day", None, List("Land Dayak languages"), List("dayak, langues"), List("Dajakisch")) 263 | case object Lao extends Language("lao", "lao", Some("lo"), List("Lao"), List("lao"), List("Laotisch")) 264 | case object Latin extends Language("lat", "lat", Some("la"), List("Latin"), List("latin"), List("Latein")) 265 | case object Latvian extends Language("lav", "lav", Some("lv"), List("Latvian"), List("letton"), List("Lettisch")) 266 | case object Lezghian extends Language("lez", "lez", None, List("Lezghian"), List("lezghien"), List("Lesgisch")) 267 | case object Limburgan extends Language("lim", "lim", Some("li"), List("Limburgan", "Limburger", "Limburgish"), List("limbourgeois"), List("Limburgisch")) 268 | case object Lingala extends Language("lin", "lin", Some("ln"), List("Lingala"), List("lingala"), List("Lingala")) 269 | case object Lithuanian extends Language("lit", "lit", Some("lt"), List("Lithuanian"), List("lituanien"), List("Litauisch")) 270 | case object Lojban extends Language("jbo", "jbo", None, List("Lojban"), List("lojban"), List("Lojban")) 271 | case object LowGerman extends Language("nds", "nds", None, List("Low German", "Low Saxon", "German, Low", "Saxon, Low"), List("bas allemand", "bas saxon", "allemand, bas", "saxon, bas"), List("Niederdeutsch")) 272 | case object LowerSorbian extends Language("dsb", "dsb", None, List("Lower Sorbian"), List("bas-sorabe"), List("Niedersorbisch")) 273 | case object Lozi extends Language("loz", "loz", None, List("Lozi"), List("lozi"), List("Rotse-Sprache")) 274 | case object LubaKatanga extends Language("lub", "lub", Some("lu"), List("Luba-Katanga"), List("luba-katanga"), List("Luba-Katanga-Sprache")) 275 | case object LubaLulua extends Language("lua", "lua", None, List("Luba-Lulua"), List("luba-lulua"), List("Lulua-Sprache")) 276 | case object Luiseno extends Language("lui", "lui", None, List("Luiseno"), List("luiseno"), List("Luiseño-Sprache")) 277 | case object LuleSami extends Language("smj", "smj", None, List("Lule Sami"), List("sami de Lule"), List("Lulesaamisch")) 278 | case object Lunda extends Language("lun", "lun", None, List("Lunda"), List("lunda"), List("Lunda-Sprache")) 279 | case object Luo extends Language("luo", "luo", None, List("Luo (Kenya and Tanzania)"), List("luo (Kenya et Tanzanie)"), List("Luo-Sprache")) 280 | case object Lushai extends Language("lus", "lus", None, List("Lushai"), List("lushai"), List("Lushai-Sprache")) 281 | case object Luxembourgish extends Language("ltz", "ltz", Some("lb"), List("Luxembourgish", "Letzeburgesch"), List("luxembourgeois"), List("Luxemburgisch")) 282 | case object Macedonian extends Language("mac", "mkd", Some("mk"), List("Macedonian"), List("macédonien"), List("Makedonisch")) 283 | case object Madurese extends Language("mad", "mad", None, List("Madurese"), List("madourais"), List("Maduresisch")) 284 | case object Magahi extends Language("mag", "mag", None, List("Magahi"), List("magahi"), List("Khotta")) 285 | case object Maithili extends Language("mai", "mai", None, List("Maithili"), List("maithili"), List("Maithili")) 286 | case object Makasar extends Language("mak", "mak", None, List("Makasar"), List("makassar"), List("Makassarisch")) 287 | case object Malagasy extends Language("mlg", "mlg", Some("mg"), List("Malagasy"), List("malgache"), List("Malagassi-Sprache")) 288 | case object Malay extends Language("may", "msa", Some("ms"), List("Malay"), List("malais"), List("Malaiisch")) 289 | case object Malayalam extends Language("mal", "mal", Some("ml"), List("Malayalam"), List("malayalam"), List("Malayalam")) 290 | case object Maltese extends Language("mlt", "mlt", Some("mt"), List("Maltese"), List("maltais"), List("Maltesisch")) 291 | case object Manchu extends Language("mnc", "mnc", None, List("Manchu"), List("mandchou"), List("Mandschurisch")) 292 | case object Mandar extends Language("mdr", "mdr", None, List("Mandar"), List("mandar"), List("Mandaresisch")) 293 | case object Mandingo extends Language("man", "man", None, List("Mandingo"), List("mandingue"), List("Malinke-Sprache")) 294 | case object Manipuri extends Language("mni", "mni", None, List("Manipuri"), List("manipuri"), List("Meithei-Sprache")) 295 | case object ManoboLanguages extends Language("mno", "mno", None, List("Manobo languages"), List("manobo, langues"), List("Manobo-Sprachen")) 296 | case object Manx extends Language("glv", "glv", Some("gv"), List("Manx"), List("manx", "mannois"), List("Manx")) 297 | case object Maori extends Language("mao", "mri", Some("mi"), List("Maori"), List("maori"), List("Maori-Sprache")) 298 | case object Mapudungun extends Language("arn", "arn", None, List("Mapudungun", "Mapuche"), List("mapudungun", "mapuche", "mapuce"), List("Arauka-Sprachen")) 299 | case object Marathi extends Language("mar", "mar", Some("mr"), List("Marathi"), List("marathe"), List("Marathi")) 300 | case object Mari extends Language("chm", "chm", None, List("Mari"), List("mari"), List("Tscheremissisch")) 301 | case object Marshallese extends Language("mah", "mah", Some("mh"), List("Marshallese"), List("marshall"), List("Marschallesisch")) 302 | case object Marwari extends Language("mwr", "mwr", None, List("Marwari"), List("marvari"), List("Marwari")) 303 | case object Masai extends Language("mas", "mas", None, List("Masai"), List("massaï"), List("Massai-Sprache")) 304 | case object MayanLanguages extends Language("myn", "myn", None, List("Mayan languages"), List("maya, langues"), List("Maya-Sprachen")) 305 | case object Mende extends Language("men", "men", None, List("Mende"), List("mendé"), List("Mende-Sprache")) 306 | case object MiKmaq extends Language("mic", "mic", None, List("Mi'kmaq", "Micmac"), List("mi'kmaq", "micmac"), List("Micmac-Sprache")) 307 | case object Minangkabau extends Language("min", "min", None, List("Minangkabau"), List("minangkabau"), List("Minangkabau-Sprache")) 308 | case object Mirandese extends Language("mwl", "mwl", None, List("Mirandese"), List("mirandais"), List("Mirandesisch")) 309 | case object Mohawk extends Language("moh", "moh", None, List("Mohawk"), List("mohawk"), List("Mohawk-Sprache")) 310 | case object Moksha extends Language("mdf", "mdf", None, List("Moksha"), List("moksa"), List("Mokscha-Sprache")) 311 | case object MonKhmerLanguages extends Language("mkh", "mkh", None, List("Mon-Khmer languages"), List("môn-khmer, langues"), List("Mon-Khmer-Sprachen (Andere)")) 312 | case object Mongo extends Language("lol", "lol", None, List("Mongo"), List("mongo"), List("Mongo-Sprache")) 313 | case object Mongolian extends Language("mon", "mon", Some("mn"), List("Mongolian"), List("mongol"), List("Mongolisch")) 314 | case object Mossi extends Language("mos", "mos", None, List("Mossi"), List("moré"), List("Mossi-Sprache")) 315 | case object MultipleLanguages extends Language("mul", "mul", None, List("Multiple languages"), List("multilingue"), List("Mehrere Sprachen")) 316 | case object MundaLanguages extends Language("mun", "mun", None, List("Munda languages"), List("mounda, langues"), List("Mundasprachen (Andere)")) 317 | case object NKo extends Language("nqo", "nqo", None, List("N'Ko"), List("n'ko"), List("N'Ko")) 318 | case object NahuatlLanguages extends Language("nah", "nah", None, List("Nahuatl languages"), List("nahuatl, langues"), List("Nahuatl")) 319 | case object Nauru extends Language("nau", "nau", Some("na"), List("Nauru"), List("nauruan"), List("Nauruanisch")) 320 | case object Navajo extends Language("nav", "nav", Some("nv"), List("Navajo", "Navaho"), List("navaho"), List("Navajo-Sprache")) 321 | case object NdebeleNorth extends Language("nde", "nde", Some("nd"), List("Ndebele, North", "North Ndebele"), List("ndébélé du Nord"), List("Ndebele-Sprache (Simbabwe)")) 322 | case object NdebeleSouth extends Language("nbl", "nbl", Some("nr"), List("Ndebele, South", "South Ndebele"), List("ndébélé du Sud"), List("Ndebele-Sprache (Transvaal)")) 323 | case object Ndonga extends Language("ndo", "ndo", Some("ng"), List("Ndonga"), List("ndonga"), List("Ndonga")) 324 | case object Neapolitan extends Language("nap", "nap", None, List("Neapolitan"), List("napolitain"), List("Neapel / Mundart")) 325 | case object NepalBhasa extends Language("new", "new", None, List("Nepal Bhasa", "Newari"), List("nepal bhasa", "newari"), List("Newari")) 326 | case object Nepali extends Language("nep", "nep", Some("ne"), List("Nepali"), List("népalais"), List("Nepali")) 327 | case object Nias extends Language("nia", "nia", None, List("Nias"), List("nias"), List("Nias-Sprache")) 328 | case object NigerKordofanianLanguages extends Language("nic", "nic", None, List("Niger-Kordofanian languages"), List("nigéro-kordofaniennes, langues"), List("Nigerkordofanische Sprachen (Andere)")) 329 | case object NiloSaharanLanguages extends Language("ssa", "ssa", None, List("Nilo-Saharan languages"), List("nilo-sahariennes, langues"), List("Nilosaharanische Sprachen (Andere)")) 330 | case object Niuean extends Language("niu", "niu", None, List("Niuean"), List("niué"), List("Niue-Sprache")) 331 | case object NoLinguisticContent extends Language("zxx", "zxx", None, List("No linguistic content", "Not applicable"), List("pas de contenu linguistique", "non applicable"), List("Kein linguistischer Inhalt")) 332 | case object Nogai extends Language("nog", "nog", None, List("Nogai"), List("nogaï", "nogay"), List("Nogaisch")) 333 | case object NorseOld extends Language("non", "non", None, List("Norse, Old"), List("norrois, vieux"), List("Altnorwegisch")) 334 | case object NorthAmericanIndianLanguages extends Language("nai", "nai", None, List("North American Indian languages"), List("nord-amérindiennes, langues"), List("Indianersprachen, Nordamerika (Andere)")) 335 | case object NorthernFrisian extends Language("frr", "frr", None, List("Northern Frisian"), List("frison septentrional"), List("Nordfriesisch")) 336 | case object NorthernSami extends Language("sme", "sme", Some("se"), List("Northern Sami"), List("sami du Nord"), List("Nordsaamisch")) 337 | case object Norwegian extends Language("nor", "nor", Some("no"), List("Norwegian"), List("norvégien"), List("Norwegisch")) 338 | case object NorwegianNynorsk extends Language("nno", "nno", Some("nn"), List("Norwegian Nynorsk", "Nynorsk, Norwegian"), List("norvégien nynorsk", "nynorsk, norvégien"), List("Nynorsk")) 339 | case object NubianLanguages extends Language("nub", "nub", None, List("Nubian languages"), List("nubiennes, langues"), List("Nubische Sprachen")) 340 | case object Nyamwezi extends Language("nym", "nym", None, List("Nyamwezi"), List("nyamwezi"), List("Nyamwezi-Sprache")) 341 | case object Nyankole extends Language("nyn", "nyn", None, List("Nyankole"), List("nyankolé"), List("Nkole-Sprache")) 342 | case object Nyoro extends Language("nyo", "nyo", None, List("Nyoro"), List("nyoro"), List("Nyoro-Sprache")) 343 | case object Nzima extends Language("nzi", "nzi", None, List("Nzima"), List("nzema"), List("Nzima-Sprache")) 344 | case object Occitan extends Language("oci", "oci", Some("oc"), List("Occitan (post 1500)"), List("occitan (après 1500)"), List("Okzitanisch")) 345 | case object OfficialAramaic extends Language("arc", "arc", None, List("Official Aramaic (700-300 BCE)", "Imperial Aramaic (700-300 BCE)"), List("araméen d'empire (700-300 BCE)"), List("Aramäisch")) 346 | case object Ojibwa extends Language("oji", "oji", Some("oj"), List("Ojibwa"), List("ojibwa"), List("Ojibwa-Sprache")) 347 | case object Oriya extends Language("ori", "ori", Some("or"), List("Oriya"), List("oriya"), List("Oriya-Sprache")) 348 | case object Oromo extends Language("orm", "orm", Some("om"), List("Oromo"), List("galla"), List("Galla-Sprache")) 349 | case object Osage extends Language("osa", "osa", None, List("Osage"), List("osage"), List("Osage-Sprache")) 350 | case object Ossetian extends Language("oss", "oss", Some("os"), List("Ossetian", "Ossetic"), List("ossète"), List("Ossetisch")) 351 | case object OtomianLanguages extends Language("oto", "oto", None, List("Otomian languages"), List("otomi, langues"), List("Otomangue-Sprachen")) 352 | case object Pahlavi extends Language("pal", "pal", None, List("Pahlavi"), List("pahlavi"), List("Mittelpersisch")) 353 | case object Palauan extends Language("pau", "pau", None, List("Palauan"), List("palau"), List("Palau-Sprache")) 354 | case object Pali extends Language("pli", "pli", Some("pi"), List("Pali"), List("pali"), List("Pali")) 355 | case object Pampanga extends Language("pam", "pam", None, List("Pampanga", "Kapampangan"), List("pampangan"), List("Pampanggan-Sprache")) 356 | case object Pangasinan extends Language("pag", "pag", None, List("Pangasinan"), List("pangasinan"), List("Pangasinan-Sprache")) 357 | case object Panjabi extends Language("pan", "pan", Some("pa"), List("Panjabi", "Punjabi"), List("pendjabi"), List("Pandschabi-Sprache")) 358 | case object Papiamento extends Language("pap", "pap", None, List("Papiamento"), List("papiamento"), List("Papiamento")) 359 | case object PapuanLanguages extends Language("paa", "paa", None, List("Papuan languages"), List("papoues, langues"), List("Papuasprachen (Andere)")) 360 | case object Pedi extends Language("nso", "nso", None, List("Pedi", "Sepedi", "Northern Sotho"), List("pedi", "sepedi", "sotho du Nord"), List("Pedi-Sprache")) 361 | case object Persian extends Language("per", "fas", Some("fa"), List("Persian"), List("persan"), List("Persisch")) 362 | case object PersianOld extends Language("peo", "peo", None, List("Persian, Old (ca.600-400 B.C.)"), List("perse, vieux (ca. 600-400 av. J.-C.)"), List("Altpersisch")) 363 | case object PhilippineLanguages extends Language("phi", "phi", None, List("Philippine languages"), List("philippines, langues"), List("Philippinisch-Austronesisch (Andere)")) 364 | case object Phoenician extends Language("phn", "phn", None, List("Phoenician"), List("phénicien"), List("Phönikisch")) 365 | case object Pohnpeian extends Language("pon", "pon", None, List("Pohnpeian"), List("pohnpei"), List("Ponapeanisch")) 366 | case object Polish extends Language("pol", "pol", Some("pl"), List("Polish"), List("polonais"), List("Polnisch")) 367 | case object Portuguese extends Language("por", "por", Some("pt"), List("Portuguese"), List("portugais"), List("Portugiesisch")) 368 | case object PrakritLanguages extends Language("pra", "pra", None, List("Prakrit languages"), List("prâkrit, langues"), List("Prakrit")) 369 | case object ProvençalOld extends Language("pro", "pro", None, List("Provençal, Old (to 1500)", "Occitan, Old (to 1500)"), List("provençal ancien (jusqu'à 1500)", "occitan ancien (jusqu'à 1500)"), List("Altokzitanisch")) 370 | case object Pushto extends Language("pus", "pus", Some("ps"), List("Pushto", "Pashto"), List("pachto"), List("Paschtu")) 371 | case object Quechua extends Language("que", "que", Some("qu"), List("Quechua"), List("quechua"), List("Quechua-Sprache")) 372 | case object Rajasthani extends Language("raj", "raj", None, List("Rajasthani"), List("rajasthani"), List("Rajasthani")) 373 | case object Rapanui extends Language("rap", "rap", None, List("Rapanui"), List("rapanui"), List("Osterinsel-Sprache")) 374 | case object Rarotongan extends Language("rar", "rar", None, List("Rarotongan", "Cook Islands Maori"), List("rarotonga", "maori des îles Cook"), List("Rarotonganisch")) 375 | case object ReservedForLocalUse extends Language("qaa", "qtz", None, List("Reserved for local use"), List("réservée à l'usage local"), List("Reserviert für lokale Verwendung")) 376 | case object RomanceLanguages extends Language("roa", "roa", None, List("Romance languages"), List("romanes, langues"), List("Romanische Sprachen (Andere)")) 377 | case object Romanian extends Language("rum", "ron", Some("ro"), List("Romanian", "Moldavian", "Moldovan"), List("roumain", "moldave"), List("Rumänisch")) 378 | case object Romansh extends Language("roh", "roh", Some("rm"), List("Romansh"), List("romanche"), List("Rätoromanisch")) 379 | case object Romany extends Language("rom", "rom", None, List("Romany"), List("tsigane"), List("Romani (Sprache)")) 380 | case object Rundi extends Language("run", "run", Some("rn"), List("Rundi"), List("rundi"), List("Rundi-Sprache")) 381 | case object Russian extends Language("rus", "rus", Some("ru"), List("Russian"), List("russe"), List("Russisch")) 382 | case object SalishanLanguages extends Language("sal", "sal", None, List("Salishan languages"), List("salishennes, langues"), List("Salish-Sprache")) 383 | case object SamaritanAramaic extends Language("sam", "sam", None, List("Samaritan Aramaic"), List("samaritain"), List("Samaritanisch")) 384 | case object SamiLanguages extends Language("smi", "smi", None, List("Sami languages"), List("sames, langues"), List("Saamisch")) 385 | case object Samoan extends Language("smo", "smo", Some("sm"), List("Samoan"), List("samoan"), List("Samoanisch")) 386 | case object Sandawe extends Language("sad", "sad", None, List("Sandawe"), List("sandawe"), List("Sandawe-Sprache")) 387 | case object Sango extends Language("sag", "sag", Some("sg"), List("Sango"), List("sango"), List("Sango-Sprache")) 388 | case object Sanskrit extends Language("san", "san", Some("sa"), List("Sanskrit"), List("sanskrit"), List("Sanskrit")) 389 | case object Santali extends Language("sat", "sat", None, List("Santali"), List("santal"), List("Santali")) 390 | case object Sardinian extends Language("srd", "srd", Some("sc"), List("Sardinian"), List("sarde"), List("Sardisch")) 391 | case object Sasak extends Language("sas", "sas", None, List("Sasak"), List("sasak"), List("Sasak")) 392 | case object Scots extends Language("sco", "sco", None, List("Scots"), List("écossais"), List("Schottisch")) 393 | case object Selkup extends Language("sel", "sel", None, List("Selkup"), List("selkoupe"), List("Selkupisch")) 394 | case object SemiticLanguages extends Language("sem", "sem", None, List("Semitic languages"), List("sémitiques, langues"), List("Semitische Sprachen (Andere)")) 395 | case object Serbian extends Language("srp", "srp", Some("sr"), List("Serbian"), List("serbe"), List("Serbisch")) 396 | case object Serer extends Language("srr", "srr", None, List("Serer"), List("sérère"), List("Serer-Sprache")) 397 | case object Shan extends Language("shn", "shn", None, List("Shan"), List("chan"), List("Schan-Sprache")) 398 | case object Shona extends Language("sna", "sna", Some("sn"), List("Shona"), List("shona"), List("Schona-Sprache")) 399 | case object SichuanYi extends Language("iii", "iii", Some("ii"), List("Sichuan Yi", "Nuosu"), List("yi de Sichuan"), List("Lalo-Sprache")) 400 | case object Sicilian extends Language("scn", "scn", None, List("Sicilian"), List("sicilien"), List("Sizilianisch")) 401 | case object Sidamo extends Language("sid", "sid", None, List("Sidamo"), List("sidamo"), List("Sidamo-Sprache")) 402 | case object SignLanguages extends Language("sgn", "sgn", None, List("Sign Languages"), List("langues des signes"), List("Zeichensprachen")) 403 | case object Siksika extends Language("bla", "bla", None, List("Siksika"), List("blackfoot"), List("Blackfoot-Sprache")) 404 | case object Sindhi extends Language("snd", "snd", Some("sd"), List("Sindhi"), List("sindhi"), List("Sindhi-Sprache")) 405 | case object Sinhala extends Language("sin", "sin", Some("si"), List("Sinhala", "Sinhalese"), List("singhalais"), List("Singhalesisch")) 406 | case object SinoTibetanLanguages extends Language("sit", "sit", None, List("Sino-Tibetan languages"), List("sino-tibétaines, langues"), List("Sinotibetische Sprachen (Andere)")) 407 | case object SiouanLanguages extends Language("sio", "sio", None, List("Siouan languages"), List("sioux, langues"), List("Sioux-Sprachen (Andere)")) 408 | case object SkoltSami extends Language("sms", "sms", None, List("Skolt Sami"), List("sami skolt"), List("Skoltsaamisch")) 409 | case object Slave extends Language("den", "den", None, List("Slave (Athapascan)"), List("esclave (athapascan)"), List("Slave-Sprache")) 410 | case object SlavicLanguages extends Language("sla", "sla", None, List("Slavic languages"), List("slaves, langues"), List("Slawische Sprachen (Andere)")) 411 | case object Slovak extends Language("slo", "slk", Some("sk"), List("Slovak"), List("slovaque"), List("Slowakisch")) 412 | case object Slovenian extends Language("slv", "slv", Some("sl"), List("Slovenian"), List("slovène"), List("Slowenisch")) 413 | case object Sogdian extends Language("sog", "sog", None, List("Sogdian"), List("sogdien"), List("Sogdisch")) 414 | case object Somali extends Language("som", "som", Some("so"), List("Somali"), List("somali"), List("Somali")) 415 | case object SonghaiLanguages extends Language("son", "son", None, List("Songhai languages"), List("songhai, langues"), List("Songhai-Sprache")) 416 | case object Soninke extends Language("snk", "snk", None, List("Soninke"), List("soninké"), List("Soninke-Sprache")) 417 | case object SorbianLanguages extends Language("wen", "wen", None, List("Sorbian languages"), List("sorabes, langues"), List("Sorbisch (Andere)")) 418 | case object SothoSouthern extends Language("sot", "sot", Some("st"), List("Sotho, Southern"), List("sotho du Sud"), List("Süd-Sotho-Sprache")) 419 | case object SouthAmericanIndianLanguages extends Language("sai", "sai", None, List("South American Indian languages"), List("sud-amérindiennes, langues"), List("Indianersprachen, Südamerika (Andere)")) 420 | case object SouthernAltai extends Language("alt", "alt", None, List("Southern Altai"), List("altai du Sud"), List("Altaisch")) 421 | case object SouthernSami extends Language("sma", "sma", None, List("Southern Sami"), List("sami du Sud"), List("Südsaamisch")) 422 | case object Spanish extends Language("spa", "spa", Some("es"), List("Spanish", "Castilian"), List("espagnol", "castillan"), List("Spanisch")) 423 | case object SrananTongo extends Language("srn", "srn", None, List("Sranan Tongo"), List("sranan tongo"), List("Sranantongo")) 424 | case object StandardMoroccanTamazight extends Language("zgh", "zgh", None, List("Standard Moroccan Tamazight"), List("amazighe standard marocain"), List("")) 425 | case object Sukuma extends Language("suk", "suk", None, List("Sukuma"), List("sukuma"), List("Sukuma-Sprache")) 426 | case object Sumerian extends Language("sux", "sux", None, List("Sumerian"), List("sumérien"), List("Sumerisch")) 427 | case object Sundanese extends Language("sun", "sun", Some("su"), List("Sundanese"), List("soundanais"), List("Sundanesisch")) 428 | case object Susu extends Language("sus", "sus", None, List("Susu"), List("soussou"), List("Susu")) 429 | case object Swahili extends Language("swa", "swa", Some("sw"), List("Swahili"), List("swahili"), List("Swahili")) 430 | case object Swati extends Language("ssw", "ssw", Some("ss"), List("Swati"), List("swati"), List("Swasi-Sprache")) 431 | case object Swedish extends Language("swe", "swe", Some("sv"), List("Swedish"), List("suédois"), List("Schwedisch")) 432 | case object SwissGerman extends Language("gsw", "gsw", None, List("Swiss German", "Alemannic", "Alsatian"), List("suisse alémanique", "alémanique", "alsacien"), List("Schweizerdeutsch")) 433 | case object Syriac extends Language("syr", "syr", None, List("Syriac"), List("syriaque"), List("Neuostaramäisch")) 434 | case object Tagalog extends Language("tgl", "tgl", Some("tl"), List("Tagalog"), List("tagalog"), List("Tagalog")) 435 | case object Tahitian extends Language("tah", "tah", Some("ty"), List("Tahitian"), List("tahitien"), List("Tahitisch")) 436 | case object TaiLanguages extends Language("tai", "tai", None, List("Tai languages"), List("tai, langues"), List("Thaisprachen (Andere)")) 437 | case object Tajik extends Language("tgk", "tgk", Some("tg"), List("Tajik"), List("tadjik"), List("Tadschikisch")) 438 | case object Tamashek extends Language("tmh", "tmh", None, List("Tamashek"), List("tamacheq"), List("Tamašeq")) 439 | case object Tamil extends Language("tam", "tam", Some("ta"), List("Tamil"), List("tamoul"), List("Tamil")) 440 | case object Tatar extends Language("tat", "tat", Some("tt"), List("Tatar"), List("tatar"), List("Tatarisch")) 441 | case object Telugu extends Language("tel", "tel", Some("te"), List("Telugu"), List("télougou"), List("Telugu-Sprache")) 442 | case object Tereno extends Language("ter", "ter", None, List("Tereno"), List("tereno"), List("Tereno-Sprache")) 443 | case object Tetum extends Language("tet", "tet", None, List("Tetum"), List("tetum"), List("Tetum-Sprache")) 444 | case object Thai extends Language("tha", "tha", Some("th"), List("Thai"), List("thaï"), List("Thailändisch")) 445 | case object Tibetan extends Language("tib", "bod", Some("bo"), List("Tibetan"), List("tibétain"), List("Tibetisch")) 446 | case object Tigre extends Language("tig", "tig", None, List("Tigre"), List("tigré"), List("Tigre-Sprache")) 447 | case object Tigrinya extends Language("tir", "tir", Some("ti"), List("Tigrinya"), List("tigrigna"), List("Tigrinja-Sprache")) 448 | case object Timne extends Language("tem", "tem", None, List("Timne"), List("temne"), List("Temne-Sprache")) 449 | case object Tiv extends Language("tiv", "tiv", None, List("Tiv"), List("tiv"), List("Tiv-Sprache")) 450 | case object Tlingit extends Language("tli", "tli", None, List("Tlingit"), List("tlingit"), List("Tlingit-Sprache")) 451 | case object TokPisin extends Language("tpi", "tpi", None, List("Tok Pisin"), List("tok pisin"), List("Neumelanesisch")) 452 | case object Tokelau extends Language("tkl", "tkl", None, List("Tokelau"), List("tokelau"), List("Tokelauanisch")) 453 | case object Tonga extends Language("tog", "tog", None, List("Tonga (Nyasa)"), List("tonga (Nyasa)"), List("Tonga (Bantusprache, Sambia)")) 454 | case object TongaIslands extends Language("ton", "ton", Some("to"), List("Tonga (Tonga Islands)"), List("tongan (Îles Tonga)"), List("Tongaisch")) 455 | case object Tsimshian extends Language("tsi", "tsi", None, List("Tsimshian"), List("tsimshian"), List("Tsimshian-Sprache")) 456 | case object Tsonga extends Language("tso", "tso", Some("ts"), List("Tsonga"), List("tsonga"), List("Tsonga-Sprache")) 457 | case object Tswana extends Language("tsn", "tsn", Some("tn"), List("Tswana"), List("tswana"), List("Tswana-Sprache")) 458 | case object Tumbuka extends Language("tum", "tum", None, List("Tumbuka"), List("tumbuka"), List("Tumbuka-Sprache")) 459 | case object TupiLanguages extends Language("tup", "tup", None, List("Tupi languages"), List("tupi, langues"), List("Tupi-Sprache")) 460 | case object Turkish extends Language("tur", "tur", Some("tr"), List("Turkish"), List("turc"), List("Türkisch")) 461 | case object TurkishOttoman extends Language("ota", "ota", None, List("Turkish, Ottoman (1500-1928)"), List("turc ottoman (1500-1928)"), List("Osmanisch")) 462 | case object Turkmen extends Language("tuk", "tuk", Some("tk"), List("Turkmen"), List("turkmène"), List("Turkmenisch")) 463 | case object Tuvalu extends Language("tvl", "tvl", None, List("Tuvalu"), List("tuvalu"), List("Elliceanisch")) 464 | case object Tuvinian extends Language("tyv", "tyv", None, List("Tuvinian"), List("touva"), List("Tuwinisch")) 465 | case object Twi extends Language("twi", "twi", Some("tw"), List("Twi"), List("twi"), List("Twi-Sprache")) 466 | case object Udmurt extends Language("udm", "udm", None, List("Udmurt"), List("oudmourte"), List("Udmurtisch")) 467 | case object Ugaritic extends Language("uga", "uga", None, List("Ugaritic"), List("ougaritique"), List("Ugaritisch")) 468 | case object Uighur extends Language("uig", "uig", Some("ug"), List("Uighur", "Uyghur"), List("ouïgour"), List("Uigurisch")) 469 | case object Ukrainian extends Language("ukr", "ukr", Some("uk"), List("Ukrainian"), List("ukrainien"), List("Ukrainisch")) 470 | case object Umbundu extends Language("umb", "umb", None, List("Umbundu"), List("umbundu"), List("Mbundu-Sprache")) 471 | case object UncodedLanguages extends Language("mis", "mis", None, List("Uncoded languages"), List("langues non codées"), List("Einzelne andere Sprachen")) 472 | case object Undetermined extends Language("und", "und", None, List("Undetermined"), List("indéterminée"), List("Nicht zu entscheiden")) 473 | case object UpperSorbian extends Language("hsb", "hsb", None, List("Upper Sorbian"), List("haut-sorabe"), List("Obersorbisch")) 474 | case object Urdu extends Language("urd", "urd", Some("ur"), List("Urdu"), List("ourdou"), List("Urdu")) 475 | case object Uzbek extends Language("uzb", "uzb", Some("uz"), List("Uzbek"), List("ouszbek"), List("Usbekisch")) 476 | case object Vai extends Language("vai", "vai", None, List("Vai"), List("vaï"), List("Vai-Sprache")) 477 | case object Venda extends Language("ven", "ven", Some("ve"), List("Venda"), List("venda"), List("Venda-Sprache")) 478 | case object Vietnamese extends Language("vie", "vie", Some("vi"), List("Vietnamese"), List("vietnamien"), List("Vietnamesisch")) 479 | case object Volapük extends Language("vol", "vol", Some("vo"), List("Volapük"), List("volapük"), List("Volapük")) 480 | case object Votic extends Language("vot", "vot", None, List("Votic"), List("vote"), List("Wotisch")) 481 | case object WakashanLanguages extends Language("wak", "wak", None, List("Wakashan languages"), List("wakashanes, langues"), List("Wakash-Sprachen")) 482 | case object Walloon extends Language("wln", "wln", Some("wa"), List("Walloon"), List("wallon"), List("Wallonisch")) 483 | case object Waray extends Language("war", "war", None, List("Waray"), List("waray"), List("Waray")) 484 | case object Washo extends Language("was", "was", None, List("Washo"), List("washo"), List("Washo-Sprache")) 485 | case object Welsh extends Language("wel", "cym", Some("cy"), List("Welsh"), List("gallois"), List("Kymrisch")) 486 | case object WesternFrisian extends Language("fry", "fry", Some("fy"), List("Western Frisian"), List("frison occidental"), List("Friesisch")) 487 | case object Wolaitta extends Language("wal", "wal", None, List("Wolaitta", "Wolaytta"), List("wolaitta", "wolaytta"), List("Walamo-Sprache")) 488 | case object Wolof extends Language("wol", "wol", Some("wo"), List("Wolof"), List("wolof"), List("Wolof-Sprache")) 489 | case object Xhosa extends Language("xho", "xho", Some("xh"), List("Xhosa"), List("xhosa"), List("Xhosa-Sprache")) 490 | case object Yakut extends Language("sah", "sah", None, List("Yakut"), List("iakoute"), List("Jakutisch")) 491 | case object Yao extends Language("yao", "yao", None, List("Yao"), List("yao"), List("Yao-Sprache (Bantusprache)")) 492 | case object Yapese extends Language("yap", "yap", None, List("Yapese"), List("yapois"), List("Yapesisch")) 493 | case object Yiddish extends Language("yid", "yid", Some("yi"), List("Yiddish"), List("yiddish"), List("Jiddisch")) 494 | case object Yoruba extends Language("yor", "yor", Some("yo"), List("Yoruba"), List("yoruba"), List("Yoruba-Sprache")) 495 | case object YupikLanguages extends Language("ypk", "ypk", None, List("Yupik languages"), List("yupik, langues"), List("Ypik-Sprachen")) 496 | case object ZandeLanguages extends Language("znd", "znd", None, List("Zande languages"), List("zandé, langues"), List("Zande-Sprachen")) 497 | case object Zapotec extends Language("zap", "zap", None, List("Zapotec"), List("zapotèque"), List("Zapotekisch")) 498 | case object Zaza extends Language("zza", "zza", None, List("Zaza", "Dimili", "Dimli", "Kirdki", "Kirmanjki", "Zazaki"), List("zaza", "dimili", "dimli", "kirdki", "kirmanjki", "zazaki"), List("Zazaki")) 499 | case object Zenaga extends Language("zen", "zen", None, List("Zenaga"), List("zenaga"), List("Zenaga")) 500 | case object Zhuang extends Language("zha", "zha", Some("za"), List("Zhuang", "Chuang"), List("zhuang", "chuang"), List("Zhuang")) 501 | case object Zulu extends Language("zul", "zul", Some("zu"), List("Zulu"), List("zoulou"), List("Zulu-Sprache")) 502 | case object Zuni extends Language("zun", "zun", None, List("Zuni"), List("zuni"), List("Zuñi-Sprache")) 503 | 504 | private def init(l: Language) = synchronized { 505 | lookup += l.terminology -> l 506 | lookup += l.bibliographic -> l 507 | l.iso639_1 match { 508 | case Some(v) => lookup += v.toLowerCase -> l 509 | case None => // Ignore 510 | } 511 | (l.englishNames ::: l.frenchNames ::: l.germanNames).foreach { 512 | case n => lookup += n.toLowerCase -> l 513 | } 514 | } 515 | 516 | def get(name: String, caseSensitive: Boolean) = lookup.get(name.toLowerCase) 517 | 518 | val values = findValues.toVector 519 | } --------------------------------------------------------------------------------