t

sbt

StateOps

trait StateOps extends Any

Convenience methods for State transformations and operations.

Linear Supertypes
Any
Known Subclasses
StateOpsImpl
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. StateOps
  2. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def +(newCommand: Command): State

    Registers newCommand as an available command.

  2. abstract def ++(newCommands: Seq[Command]): State

    Registers newCommands as available commands.

  3. abstract def ++:(newCommands: List[Exec]): State

    Schedules commands to be run before any remaining commands.

  4. abstract def +:(command: Exec): State

    Schedules command to be run before any remaining commands.

  5. abstract def ::(command: String): State

    Schedules command to be run before any remaining commands.

  6. abstract def :::(newCommands: List[String]): State

    Schedules commands to be run before any remaining commands.

  7. abstract def addExitHook(f: ⇒ Unit): State

    Registers a new exit hook, which will run when sbt exits or restarts.

  8. abstract def baseDir: File

    The application base directory, which is not necessarily the current working directory.

  9. abstract def classLoaderCache: ClassLoaderCache

    Get the class loader cache for the application.

  10. abstract def clearGlobalLog: State

    Sets the next command processing action to be to rotate the global log and continue executing commands.

  11. abstract def continue: State

    Sets the next command processing action to be to continue processing the next command.

  12. abstract def exit(ok: Boolean): State

    Sets the next command processing action to be to exit with a zero exit code if ok is true and a nonzero exit code if ok if false.

  13. abstract def fail: State

    Marks the currently executing command as failing.

    Marks the currently executing command as failing. This triggers failure handling by the command processor. See also State.onFailure

  14. abstract def get[T](key: AttributeKey[T]): Option[T]

    Gets the value associated with key from the custom attributes map.

  15. abstract def getClass(): Class[_]
    Definition Classes
    Any
  16. abstract def handleError(t: Throwable): State

    Marks the currently executing command as failing due to the given exception.

    Marks the currently executing command as failing due to the given exception. This displays the error appropriately and triggers failure handling by the command processor. Note that this does not throw an exception and returns normally. It is only once control is returned to the command processor that failure handling at the command level occurs.

  17. abstract def has(key: AttributeKey[_]): Boolean

    Returns true if key exists in the custom attributes map, false if it does not exist.

  18. abstract def initializeClassLoaderCache: State

    Create and register a class loader cache.

    Create and register a class loader cache. This should be called once at the application entry-point.

  19. abstract def interactive: Boolean

    An advisory flag that is true if this application will execute commands based on user input.

  20. abstract def keepLastLog: State

    Sets the next command processing action to be to keep the previous log and continue executing commands.

  21. abstract def locked[T](file: File)(t: ⇒ T): T

    Evaluates the provided expression with a JVM-wide and machine-wide lock on file.

  22. abstract def log: Logger

    The Logger used for general command logging.

  23. abstract def process(f: (Exec, State) ⇒ State): State
  24. abstract def put[T](key: AttributeKey[T], value: T): State

    Sets the value associated with key in the custom attributes map.

  25. abstract def reboot(full: Boolean): State

    Reboots sbt.

    Reboots sbt. A reboot restarts execution from the entry point of the launcher. A reboot is designed to be as close as possible to actually restarting the JVM without actually doing so. Because the JVM is not restarted, JVM exit hooks are not run. State.exitHooks should be used instead and those will be run before rebooting. If full is true, the boot directory is deleted before starting again. This command is currently implemented to not return, but may be implemented in the future to only reboot at the next command processing step.

  26. abstract def reload: State

    Restarts sbt without dropping loaded Scala classes.

    Restarts sbt without dropping loaded Scala classes. It is a shallower restart than reboot. This method takes a snapshot of the remaining commands and will resume executing those commands after reload. This means that any commands added to this State will be dropped.

  27. abstract def remove(key: AttributeKey[_]): State

    Removes the key and any associated value from the custom attributes map.

  28. abstract def runExitHooks(): State

    Runs any defined exitHooks and then clears them.

  29. abstract def setInteractive(flag: Boolean): State

    Changes the advisory interactive flag.

  30. abstract def setNext(n: Next): State

    Sets the next command processing action to do.

  31. abstract def update[T](key: AttributeKey[T])(f: (Option[T]) ⇒ T): State

    Sets the value associated with key in the custom attributes map by transforming the current value.

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    Any
  2. final def ##(): Int
    Definition Classes
    Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def equals(arg0: Any): Boolean
    Definition Classes
    Any
  6. def hashCode(): Int
    Definition Classes
    Any
  7. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  8. def toString(): String
    Definition Classes
    Any

Inherited from Any

Ungrouped