Type Members

1.  trait BaseEncoding extends AnyRef
2.  abstract class Bootstring extends AnyRef

   Bootstring encoding as defined in From: https://tools.ietf.org/html/rfc3492

3.  class BoundedInputStream extends org.apache.commons.io.input.BoundedInputStream

   This is just org.apache.commons.io.input.BoundedInputStream

   This is just org.apache.commons.io.input.BoundedInputStream

   This cannot be a Scala class because the ScalaSignature will contain a reference to org.apache.commons.io.input.BoundedInputStream even though Proguard rewrites the name.

4.  final class ByteArrayImageInputStream extends ImageInputStreamImpl

   An ImageInputStream implementation that reads from an Array[Byte]

5.  final class ByteArrayImageOutputStream extends ImageOutputStreamImpl

   An ImageOutputStream implementation that writes to a Array[Byte]

6.  class ByteArrayOutputStream extends org.apache.commons.io.output.ByteArrayOutputStream

   This is just org.apache.commons.io.output.ByteArrayOutputStream

   This is just org.apache.commons.io.output.ByteArrayOutputStream

   This cannot be a Scala class because the ScalaSignature will contain a reference to org.apache.commons.io.output.ByteArrayOutputStream even though Proguard rewrites the name.

7.  final class ByteBufferInputStream extends InputStream

   A Simple InputStream wrapper around a ByteBuffer

8.  final class ByteBufferOutputStream extends OutputStream

   A Simple OutputStream wrapper around a ByteBuffer

9.  trait ByteEnum[A <: ByteEnumEntry] extends ValueEnum[Byte, A]

   Value enum with ByteEnumEntry entries

   Value enum with ByteEnumEntry entries

   This is similar to ValueEnum, but different in that values must be literal values. This restraint allows us to enforce uniqueness at compile time.

   Note that uniqueness is only guaranteed if you do not do any runtime string manipulation on values.

10.  abstract class ByteEnumEntry extends ValueEnumEntry[Byte]

    Value Enum Entry parent class for Byte valued entries

11.  sealed class Cache[K, V] extends AnyRef

    Wrapper around com.google.common.cache.Cache

12.  trait CharEnum[A <: CharEnumEntry] extends ValueEnum[Char, A]

    Value enum with CharEnumEntry entries

    Value enum with CharEnumEntry entries

    This is similar to ValueEnum, but different in that values must be literal values. This restraint allows us to enforce uniqueness at compile time.

    Note that uniqueness is only guaranteed if you do not do any runtime string manipulation on values.

13.  abstract class CharEnumEntry extends ValueEnumEntry[Char]

    Value Enum Entry parent class for Char valued entries

14.  trait CodePointReader extends AnyRef

    Similar to Reader except for reading Unicode Code Points instead of Java Characters.

    Similar to Reader except for reading Unicode Code Points instead of Java Characters.

    See java.io.Reader for API descriptions. The behavior of this trait should mimic java.io.Reader.

15.  final class ColorPatternLayoutEncoder extends PatternLayoutEncoder

    A simple Logback extension to the PatternLayoutEncoder that adds simple coloring for WARN and ERROR levels

16.  final class ConcurrentHashMap[A, B] extends ConcurrentHashMapBase[A, B]

    EXPERIMENTAL - A Scala mutable map that wraps a java ConcurrentHashMap and allows null values

17.  final class ConcurrentHashSet[A] extends ConcurrentHashSetBase[A]

    EXPERIMENTAL - A Scala mutable Set based on ConcurrentHashMap

18.  final class Crypto extends Logging

    A Simple Crypto Class

    A Simple Crypto Class

    NOTE: Use at your own risk. We make no claim that any of this Crypto code is correct.

19.  final case class DummyResource[A](a: A) extends Resource[A] with Product with Serializable

    A Dummy Resource that does nothing

20.  final case class EmailSender(user: String, pass: String, host: String) extends Product with Serializable
21.  trait Enum[A <: EnumEntry] extends AnyRef

    All the cool kids have their own Enumeration implementation, most of which try to do so in the name of implementing exhaustive pattern matching.

    All the cool kids have their own Enumeration implementation, most of which try to do so in the name of implementing exhaustive pattern matching.

    This is yet another one.

    Example:

    scala> sealed trait DummyEnum extends EnumEntry
    defined trait DummyEnum
    
    scala> object DummyEnum extends Enum[DummyEnum] {
         |   val values = findValues
         |   case object Hello   extends DummyEnum
         |   case object GoodBye extends DummyEnum
         |   case object Hi      extends DummyEnum
         | }
    
    scala> DummyEnum.withNameOption("Hello")
    res0: Option[DummyEnum] = Some(Hello)
    
    scala> DummyEnum.withNameOption("Nope")
    res1: Option[DummyEnum] = None

    A

    The sealed trait

22.  trait EnumEntry extends AnyRef

    Base type for an enum entry for Enum

    Base type for an enum entry for Enum

    By default, the entryName method used for serialising and deserialising Enum values uses toString, but feel free to override to fit your needs.

    Mix in the supplied stackable traits to convert the entryName to Snakecase, Uppercase, Lowercase etc.

23.  final class FlatMappedResource[A, B] extends Resource[B]

    For Resource.flatMap

24.  final class GrowableByteArray extends OutputStream

    Like java.io.ByteArrayOutputStream but exposes the internal Array

25.  final class IP extends AnyVal with Ordered[IP] with IPOrSubnet

    Simple Wrapper around an IPv4 Address

26.  sealed trait IPMap[T] extends AnyRef
27.  final class IPMapImmutable[T] extends IPMap[T]
28.  final class IPMapMutable[T] extends IPMap[T] with IPMapMutableBase[T]
29.  trait IPOrSubnet extends Any
30.  sealed trait IPSet extends AnyRef
31.  final class IPSetImmutable extends IPSet
32.  final class IPSetMutable extends IPSet with IPSetMutableBase
33.  final case class IPSubnet(ip: IP, bits: Int) extends IPOrSubnet with Product with Serializable
34.  final case class IPSubnets(subnets: Vector[IPSubnet]) extends Product with Serializable
35.  final class ImmutableArray[+A] extends IndexedSeq[A] with IndexedSeqOptimized[A, ImmutableArray[A]]
36.  final class ImmutableArrayBuilder[A] extends Builder[A, ImmutableArray[A]]
37.  final case class ImmutableDate(millis: Long) extends Ordered[ImmutableDate] with Product with Serializable

    Represents an immutable java.util.Date

    Represents an immutable java.util.Date

    This provides an immutable milliseconds since epoch representation of a date when it might be a mismatch to use the newer java.time.Instance (which represents things as nanoseconds since or before epoch)

    NOTE: NOT extending AnyVal so that nulls still work (just like with java.util.Date)

38.  trait Implicits extends JVMImplicitsBase
39.  trait ImplicitsBase extends OrderingImplicits with RichCrossImplicitsBase with typesafeequals.Implicits

    These are the Implicits that are shared between both the JVM and JS Implicits trait/object

    These are the Implicits that are shared between both the JVM and JS Implicits trait/object

    Attributes

    protected

40.  trait IndexedSeqProxy[A] extends AnyRef
41.  final case class InputStreamResource(resource: Resource[InputStream], fileName: String = "", autoDecompress: Boolean = true, autoBuffer: Boolean = true) extends Resource[InputStream] with Logging with Product with Serializable
42.  trait IntEnum[A <: IntEnumEntry] extends ValueEnum[Int, A]

    Value enum with IntEnumEntry entries

43.  abstract class IntEnumEntry extends ValueEnumEntry[Int]

    Value Enum Entry parent class for Int valued entries

44.  final case class Interner[T <: AnyRef]() extends Product with Serializable

    Wraper around Guava's Interner class.

    Wraper around Guava's Interner class.

    Originally I had a generic Intern object that had a map of Class[_] to Guava Interner but that relies on a correct implementation of equals which can make it error prone. For Example an Option[Char] can == an Option[Int]. So instead you have to be explicit about creating an Interner.

45.  abstract class InvalidCharFilterReader extends FilterReader with Logging
46.  final case class InvalidIPException(msg: String) extends IllegalArgumentException with Product with Serializable
47.  type IterableOnce[+A] = TraversableOnce[A]

    Definition Classes

    PackageBase

48.  trait IterableProxy[A] extends AnyRef
49.  trait JVMImplicitsBase extends ImplicitsBase
50.  final class JavaConcurrentHashSet[A] extends Set[A]

    EXPERIMENTAL - A Java Set based on ConcurrentHashMap

51.  class LineIterator extends org.apache.commons.io.LineIterator

    This is just org.apache.commons.io.LineIterator

    This is just org.apache.commons.io.LineIterator

    This cannot be a Scala class because the ScalaSignature will contain a reference to org.apache.commons.io.LineIterator even though Proguard rewrites the name.

52.  final class LoadingCache[K, V] extends Cache[K, V]

    Wrapper around com.google.common.cache.LoadingCache

53.  trait Logger extends AnyRef
54.  trait Logging extends AnyRef

    This can be extended for basic logging functionality

55.  final case class LoggingCaptureConfig(logger: org.slf4j.Logger, pattern: String, file: File, overwrite: Boolean) extends Product with Serializable
56.  trait LongEnum[A <: LongEnumEntry] extends ValueEnum[Long, A]

    Value enum with LongEnumEntry entries

57.  abstract class LongEnumEntry extends ValueEnumEntry[Long]

    Value Enum Entry parent class for Long valued entries

58.  trait MapProxy[K, V] extends AnyRef
59.  final class MappedResource[A, B] extends Resource[B]

    For Resource.map

60.  final class MessageCrypto extends AnyRef

    Compatible with the Rails MessageEncryptor using 'aes-256-cbc' and MessageVerifier using 'sha1' when working with *String* values.

    Compatible with the Rails MessageEncryptor using 'aes-256-cbc' and MessageVerifier using 'sha1' when working with *String* values.

    Also compatible with the custom MessageCrypto which marshalls values as JSON instead of using the ruby Marshal.dump and Marshal.load. Use json=true to dump using JSON.

    MessageEncryptor uses Marshal.dump and Marshal.load on whatever values you are trying to encrypt/sign. A subset of Marshal.dump and Marshal.load have been implemented to support String values.

    NOTE: This is a legacy class that was created when we switched from Rails to Scala. It is still used in a few places but probably needs to be refactored to remove the old Ruby marshalling stuff.

61.  final class MultiReadOnlySeekableByteChannel extends SeekableByteChannel

    Takes multiple SeekableByteChannel instances and turns them into a single virtual one.

    Takes multiple SeekableByteChannel instances and turns them into a single virtual one.

    This is used for reading multi-part 7 Zip archives via commons-compress where we just need to concatenate all the parts of the 7 Zip archive into a single SeekableByteChannel which can then be used with the commons-compress SevenZFile class.

62.  final class MultiUseResource[+A <: AutoCloseable] extends Resource[A]

    A Resource that can be used multiple times (e.g.

    A Resource that can be used multiple times (e.g. opening an InputStream or Reader for a File)

63.  trait OptionCacheBase extends AnyRef

    Attributes

    protected

64.  trait OrderingImplicits extends AnyRef

    scala.math.Ordering only goes up to Tuple9

65.  final case class OutputStreamResource(resource: Resource[OutputStream], fileName: String = "", autoCompress: Boolean = true, compressionLevel: Int = Deflater.BEST_SPEED, buffered: Boolean = true, internalArchiveFileName: Option[String] = None) extends Resource[OutputStream] with Product with Serializable
66.  trait PackageBase extends AnyRef
67.  final class PriorityTaskRunner extends TaskRunnerBase

    Similar to a TaskRunner but allows you to pass in a priority value such that lower priority tasks will execute before higher priority tasks.

68.  final case class ProgressStats(dotPer: Long = 1000L, statsPer: Long = 25000L, logFinalStats: Boolean = false) extends Logging with Product with Serializable
69.  final class QueryParams extends QueryParamsBase

    Represents immutable query parameters from a query string (e.g.

    Represents immutable query parameters from a query string (e.g. "?foo=bar&asd=qwe").

    This class distinguishes between 3 different types of values for a key:

    • null - "?foo"
    • blank - "?foo="
    • non-blank - "?foo=bar"
70.  final class QueryParamsBuilder extends QueryParamsBuilderBase
71.  final class ReaderCodePointReader extends CodePointReader
72.  abstract class ReloadableFileResource[T] extends ReloadableResource[T]
73.  abstract class ReloadableResource[T] extends Logging
74.  trait Resource[+A] extends AnyRef

    An Automatically Managed Resource that can either be used once (e.g.

    An Automatically Managed Resource that can either be used once (e.g. reading an input stream) or multiple times (e.g. reading a file).

    The purpose of Resource is two-fold: 1 - To automatically handle closing a resource after it is done being used. 2 - To abstract the fact that some resources can be read multiple times while other resources are one-time use.

75.  trait RichCrossImplicitsBase extends Any
76.  final class ScheduledFuture[T] extends Future[T] with ScheduledTask
77.  trait ScheduledTask extends AnyRef
78.  final case class ScheduledTaskRunner(name: String, executor: ScheduledThreadPoolExecutor) extends TaskRunnerNonPriority with Product with Serializable

    Annotations

    @implicitNotFound( ... )

79.  trait SeqProxy[A] extends AnyRef

    This is a replacement for the deprecated scala.collection.SeqProxy.

    This is a replacement for the deprecated scala.collection.SeqProxy.

    This doesn't implement Seq[A] like the original SeqProxy but instead just provides an implicit conversion from this trait into a Seq[A] which then gives you all the Seq functionality

80.  trait Serializer[T] extends AnyRef

    This is here so that LazySeq can be split out into it's own project.

    This is here so that LazySeq can be split out into it's own project.

    Some implementations are still in our internal Util package for now until we get a chance to refactor and possible merge with our fm-serializer project.

81.  trait SetProxy[A] extends AnyRef
82.  trait ShortEnum[A <: ShortEnumEntry] extends ValueEnum[Short, A]

    Value enum with ShortEnumEntry entries

83.  abstract class ShortEnumEntry extends ValueEnumEntry[Short]

    Value Enum Entry parent class for Short valued entries

84.  final class SingleUseResource[+A <: AutoCloseable] extends Resource[A]

    A Resource that can only be used once (e.g.

    A Resource that can only be used once (e.g. reading an InputStream)

85.  class StacklessException extends Exception
86.  class StacklessThrowable extends Throwable
87.  class StringBuilderWriter extends org.apache.commons.io.output.StringBuilderWriter

    This is just org.apache.commons.io.output.StringBuilderWriter

    This is just org.apache.commons.io.output.StringBuilderWriter

    This cannot be a Scala class because the ScalaSignature will contain a reference to org.apache.commons.io.output.StringBuilderWriter even though Proguard rewrites the name.

88.  trait StringEnum[A <: StringEnumEntry] extends ValueEnum[String, A]

    Value enum with StringEnumEntry entries

    Value enum with StringEnumEntry entries

    This is similar to Enum, but different in that values must be literal values. This restraint allows us to enforce uniqueness at compile time.

    Note that uniqueness is only guaranteed if you do not do any runtime string manipulation on values.

89.  abstract class StringEnumEntry extends ValueEnumEntry[String]

    Value Enum Entry parent class for String valued entries

    Value Enum Entry parent class for String valued entries

    This is similar to Enum, but different in that values must be literal values. This restraint allows us to enforce uniqueness at compile time.

    Note that uniqueness is only guaranteed if you do not do any runtime string manipulation on values.

90.  trait StringEscapeUtilsBase extends AnyRef

    Attributes

    protected

91.  final class TaskRunner extends TaskRunnerNonPriority
92.  abstract class TaskRunnerBase extends Closeable with Logging
93.  final class TaskRunnerBuilder extends AnyRef
94.  abstract class TaskRunnerNonPriority extends TaskRunnerBase
95.  class TeeInputStream extends org.apache.commons.io.input.TeeInputStream

    This is just org.apache.commons.io.input.TeeInputStream

    This is just org.apache.commons.io.input.TeeInputStream

    This cannot be a Scala class because the ScalaSignature will contain a reference to org.apache.commons.io.input.TeeInputStream even though Proguard rewrites the name.

96.  class TeeOutputStream extends org.apache.commons.io.output.TeeOutputStream

    This is just org.apache.commons.io.output.TeeOutputStream

    This is just org.apache.commons.io.output.TeeOutputStream

    This cannot be a Scala class because the ScalaSignature will contain a reference to org.apache.commons.io.output.TeeOutputStream even though Proguard rewrites the name.

97.  class ThreadLocalHashMap[K, V] extends AnyRef

    Wraps a Scala mutable.HashMap inside of a ThreadLocal and exposes some simple operations.

    Wraps a Scala mutable.HashMap inside of a ThreadLocal and exposes some simple operations.

    The initial use case of this is for caching NumberFormat instances by Locale. This can be accomplished by overriding the initialValue method and just calling the apply() method with the Locale.

    K

    The HashMap Key

    V

    The HashMap Value

98.  trait TraversableProxy[A] extends AnyRef
99.  type URI = java.net.URI

    A type alias for java.net.URI

100.  type URL = java.net.URL

     A type alias for java.net.URL

101.  final case class UUID(timeAndCounter: Long, nodeIdAndRandom: Long) extends Ordered[UUID] with Product with Serializable

     A custom UUID implementation (not to be confused with java.util.UUID or RFC4122 implementations) that allows natural sorting by timestamp based on the string or numeric representation.

     A custom UUID implementation (not to be confused with java.util.UUID or RFC4122 implementations) that allows natural sorting by timestamp based on the string or numeric representation.

     The UUID consists of 16 bytes (128 bits) broken up into 2 longs:

     timeAndCounter: {6-Byte Millis since epoch}{2-Byte Counter} nodeIdAndRandom: {2-Byte Node ID}{6-Byte Random Number}

     The "pretty" hex encoded representation is: {6-byte millis since epoch}-{2-byte-counter}-{2-byte-optional-node-id}-{4-byte-random}

     Example: 015247f01787-9740-85e0-3e9672a8dfa2

102.  abstract class UUIDFactory[T <: UUIDWrapper[T]] extends AnyRef

     This goes along with the UUIDWrapper

     This goes along with the UUIDWrapper

     See documentation of UUIDWrapper for the intended usage of this class

103.  trait UUIDWrapper[T <: UUIDWrapper[T]] extends Ordered[T]

     An UUID wrapper class that allow you to define custom types that represent an UUID.

     An UUID wrapper class that allow you to define custom types that represent an UUID.

     The intended usage pattern is something like:

     object UserId extends UUIDFactory[UserId](new UserId(_))
     final class UserId(val uuid: UUID) extends UUIDWrapper[UserId]

     This allows you to then reference UserId instead of UUID and to have methods that take a strongly typed UserId instead of an UUID (which could represent something other than a User id)

     Note: The class that extends this should also extends AnyVal so that serialization will just pass through to the underlying uuid

104.  final class UncloseableInputStream extends FilterInputStream

     Wraps an InputStream and makes the close() method do nothing

105.  final class UncloseableOutputStream extends FilterOutputStream

     Wraps an OutputStream and makes the close() method do nothing

106.  trait UnicodeNormalizationBase extends AnyRef

     Attributes

     protected

107.  abstract class UserFriendlyException extends Exception
108.  sealed trait ValueEnum[ValueType, EntryType <: ValueEnumEntry[ValueType]] extends AnyRef

     Base trait for a Value-based enums.

     Base trait for a Value-based enums.

     Example:

     sealed abstract class Greeting(val value: Int) extends IntEnumEntry
     
     object Greeting extends IntEnum[Greeting] {
       val values = findValues
       case object Hello   extends Greeting(1)
       case object GoodBye extends Greeting(2)
       case object Hi      extends Greeting(3)
       case object Bye     extends Greeting(4)
     }
     
     Greeting.withValueOpt(1) == Some(GreetingHello)
     
     Greeting.withValueOpt(6) ==  None

109.  sealed trait ValueEnumEntry[ValueType] extends AnyRef

     Created by Lloyd on 4/11/16.

     Created by Lloyd on 4/11/16.

     Copyright 2016

110.  final class WeakObjectPool[T] extends AnyRef

     DEPRECATED - Should use fm.common.Intern instead

     DEPRECATED - Should use fm.common.Intern instead

     An object pool based on a WeakHashMap (using weak key AND weak values) that can be used to return canonical versions of objects. Once all references to the object go away the WeakHashMap entry will be GC'd.

     This is similar to how String.intern() works (although probably not as efficient)

     Annotations

     @Deprecated