TimeHelpers

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

object TimeSpan

The TimeSpan object provides class represents an amount of time.

def ^[T](i: T*): List[T]

This operator transforms its arguments into a List

final def asInstanceOf[T0]: T0

def boxParseInternetDate(dateString: String): Box[Date]

def calcTime[T](f: ⇒ T): (Long, T)

def callableMethod_?(meth: Method): Boolean

def classHasControllerMethod(clz: Class[_], name: String): Boolean

Check that the method 'name' is callable for class 'clz'

def classHierarchy(in: Class[_]): List[Class[_]]

def clone(): AnyRef

def containsClass[C](clz: Class[C], toMatch: List[Class[_]]): Boolean

Is the clz an instance of (assignable from) any of the classes in the list

def createInvoker[C <: AnyRef](name: String, on: C): Box[() ⇒ Box[Any]]

Create a function (the 'invoker') which will trigger any public, parameterless method That function will throw the cause exception if the method can't be invoked

def currentYear: Int

def dateFormatter: SimpleDateFormat

def day(in: Date): Int

def days(in: Long): Long

def daysSinceEpoch: Long

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def findClass(where: List[(String, List[String])]): Box[Class[AnyRef]]

Find a class given a list of possible names and corresponding packages, turning underscored names to CamelCase if necessary

def findClass(name: String, where: List[String]): Box[Class[AnyRef]]

Find a class given its name and a list of packages, turning underscored names to CamelCase if necessary.

def findClass[C <: AnyRef](name: String, where: List[String], targetType: Class[C]): Box[Class[C]]

Find a class given its name and a list of packages, turning underscored names to CamelCase if necessary.

def findClass(name: String, where: List[String], modifiers: List[(String) ⇒ String]): Box[Class[AnyRef]]

General method to in find a class according to its name, a list of possible packages and a list of functions modifying the given name create a target name to look for (e.

def findClass[C <: AnyRef](name: String, where: List[String], modifiers: List[(String) ⇒ String], targetType: Class[C]): Box[Class[C]]

General method to in find a class according to its name, a list of possible packages, a list of functions modifying the given name create a target name to look for (e.

def findType[C <: AnyRef](where: List[(String, List[String])])(implicit m: Manifest[C]): Box[Class[C]]

Find a class given its type, a list of possible names and corresponding packages, turning underscored names to CamelCase if necessary

def findType[C <: AnyRef](name: String, where: List[String])(implicit m: Manifest[C]): Box[Class[C]]

Find a class given its type, its name and a list of packages, turning underscored names to CamelCase if necessary.

def findType[C <: AnyRef](name: String, where: List[String], modifiers: List[(String) ⇒ String])(implicit m: Manifest[C]): Box[Class[C]]

General method to in find a class according to its type, its name, a list of possible packages and a list of functions modifying the given name create a target name to look for (e.

def formattedDateNow: String

def formattedTimeNow: String

final def getClass(): Class[_]

def hashCode(): Int

def hourFormat(in: Date): String

def hourFormat: SimpleDateFormat

def hours(in: Long): Long

def instantiate[C](clz: Class[C]): Box[C]

Create a new instance of a class

implicit def intToTimeSpan(in: Int): TimeSpan

transforms an int to a TimeSpan object.

implicit def intToTimeSpanBuilder(in: Int): TimeSpanBuilder

transforms an int to a TimeSpanBuilder object.

def internetDateFormatter: SimpleDateFormat

def invokeControllerMethod(clz: Class[_], meth: String): Any

Invoke a controller method (parameterless, public) on a class

def invokeMethod[C](clz: Class[C], inst: AnyRef, meth: String, params: Array[AnyRef], ptypes: Array[Class[_]]): Box[Any]

Invoke the given method for the given class, with some parameters and their types Tries the method name, then the method as a CamelCased name and the method as a camelCased name The class is not instanciated if the method is static, otherwise the passed instance is used

def invokeMethod[C](clz: Class[C], inst: AnyRef, meth: String, params: Array[AnyRef]): Box[Any]

Invoke the given method for the given class, with some parameters.

def invokeMethod[C](clz: Class[C], inst: AnyRef, meth: String): Box[Any]

Invoke the given method for the given class, with no params.

final def isInstanceOf[T0]: Boolean

def logTime[T](f: ⇒ (String, T)): T

Call f and log the string returned together with the time taken in millis.

def logTime[T](msg: String)(f: ⇒ T): T

Log a message with the time taken in millis to do something and return the result

implicit def longToTimeSpan(in: Long): TimeSpan

transforms a long to a TimeSpan object.

implicit def longToTimeSpanBuilder(in: Long): TimeSpanBuilder

transforms a long to a TimeSpanBuilder object.

def millis: Long

def millisToDays(millis: Long): Long

def minutes(in: Long): Long

def month(in: Date): Int

def nano: Long

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def now: Date

def nowAsInternetDate: String

def parseInternetDate(dateString: String): Date

def seconds(in: Long): Long

final def synchronized[T0](arg0: ⇒ T0): T0

def time(when: Long): Date

alias for new Date(millis)

def timeFormatter: SimpleDateFormat

implicit def toCalendarExtension(c: Calendar): CalendarExtension

implicit def used to add the setXXX methods to the Calendar class

def toDate(in: Any): Box[Date]

implicit def toDateExtension(d: Date): DateExtension

implicit def used to add the noTime method to the Date class

def toInternetDate(in: Long): String

def toInternetDate(in: Date): String

def toString(): String

def today: Calendar

def tryo[T](ignore: Class[_])(f: ⇒ T): Box[T]

Wraps a "try" block around the function f.

def tryo[T](ignore: List[Class[_]])(f: ⇒ T): Box[T]

Wraps a "try" block around the function f

def tryo[T](onError: (Throwable) ⇒ Unit)(f: ⇒ T): Box[T]

Wraps a "try" block around the function f and trigger a callback function if an exception is thrown

def tryo[T](f: ⇒ T): Box[T]

Wraps a "try" block around the function f

def tryo[T](handler: PartialFunction[Throwable, T], f: ⇒ T): Box[T]

Wraps a "try" block around the function f.

def tryo[T](ignore: List[Class[_]], onError: Box[(Throwable) ⇒ Unit])(f: ⇒ T): Box[T]

Wraps a "try" block around the function f.

val utc: TimeZone

The UTC TimeZone

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def weeks(in: Long): Long

def year(in: Date): Int

def camelCase(name: String): String

def camelCaseMethod(name: String): String

def dayNow: Date

def timeNow: Date

def unCamelCase(name: String): String