Type Members

1.  trait AbstractRegistry [K, V <: AnyRef] extends LoggingHelper with ThrowingHelper

   Abstract Registry Of Key-Value Pairs This trait implements a key-value map using ConcurrentHashMap to minimize lock contention for multiple threads accessing the registry.

   Abstract Registry Of Key-Value Pairs This trait implements a key-value map using ConcurrentHashMap to minimize lock contention for multiple threads accessing the registry. It is intended to identify race conditions upon insertion and deletion of entries.

   K

   The type of Key

   V

   The type of Value

2.  trait FutureHelper extends LoggingHelper with ThrowingHelper

   Utilities used throughout Scrupla.

   Utilities used throughout Scrupla. Should probably be an aspect, but we just mix this in as needed. Helps with logging, throwing exceptions and dealing with futures.

3.  trait HelperComponent extends LoggingHelper with FutureHelper with ThrowingHelper

   A Software Component This just bundles together various helpers that are commonly used within a software component

4.  trait Identifiable extends AnyRef
5.  trait IdentifiedWithRegistry extends Identifiable
6.  trait LoggingHelper extends AnyRef
7.  class MemoryCache [K, V] extends AnyRef

   This trait makes a simple cache from a ConcurrentHashMap accompanied by a getOrElse function to obtain or create values

   This trait makes a simple cache from a ConcurrentHashMap accompanied by a getOrElse function to obtain or create values

   K

   type of the keys

   V

   type of the values

8.  class NotImplementedException extends TossedException
9.  case class OSSLicense (name: String, description: String, uri: URI) extends Registrable[OSSLicense] with Product with Serializable

   A Registration of the Open Source Software Licenses

10.  abstract class Pluralizer extends AnyRef

    Competently find the plural of most common English words.

    Competently find the plural of most common English words.

    In dealing with logged messages, error messages, and other output that people see, it is always nice to have the correct plural form of nouns be used. This class attempts to get pretty good coverage for the english language based on a variety of pluralization rules. This is also used in URL path matching to distinguish between operations that act on an instance (singular) or a collection of instances (plural)

    Inspired by: https://github.com/atteo/evo-inflector/blob/master/src/main/java/org/atteo/evo/inflector/TwoFormInflector.java Rules from: http://www.barstow.edu/lrc/tutorserv/handouts/015%20Irregular%20Plural%20Nouns.pd Oxford Rules: http://oxforddictionaries.com/words/plurals-of-nouns

11.  trait Registrable [T <: Registrable[T]] extends IdentifiedWithRegistry with LoggingHelper

    Mix this in to anything you want to register and define the "id"; then pass that object to the Registrar you want

12.  trait Registry [T <: Registrable[T]] extends AbstractRegistry[Symbol, T]

    A trait for specifying the registration of some type of object (T) which must have at least Registrable mixed in.

    A trait for specifying the registration of some type of object (T) which must have at least Registrable mixed in. This abstracts the notion of a registry of objects that conform to an interface.

13.  case class RegistryReference [T <: Registrable[T]] extends () ⇒ Option[T] with Product with Serializable

    Reference A Memory Object From The Database

    Reference A Memory Object From The Database

    Many of the objects used in Scrupal are not stored in the database. Essentially those things coming from a Module are just retained in memory: Module, Feature, Entity, Type, Handler, etc. However, we need to reference these things from objects that are stored in the database. We do not want to be loading the low level memory objects all the time but would just like to "find" them. That's what the RegistryReference is for. We can register long-lived immutable objects in a registry and find them later, by name. But, there is a registry per object type, by design. So, we need a way to capture a reference to a named object in one of the registries. We do that by simply caching the registry object and the registrable object's id. This information is then stored in the database and reconstructed into the referenced object with the apply method.

14.  implicit class ThrowableHacks extends AnyRef
15.  trait ThrowableWithComponent extends Throwable
16.  trait ThrowingHelper extends LoggingHelper

    Assistance With Throwing Exceptions Uses LoggingHelper base class to throw an error message that identifies the thrower.

17.  class TossedException extends Exception with ThrowableWithComponent