ScalateI18nSupport

abstract val doNotFound: () ⇒ Any

abstract def requestPath(implicit ctx: SkinnyContext): String

abstract def routeBasePath(implicit ctx: SkinnyContext): String

final def !=(arg0: AnyRef): Boolean

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: AnyRef): Boolean

final def ==(arg0: Any): Boolean

implicit val anyToBoolean: TypeConverter[Any, Boolean]

implicit val anyToByte: TypeConverter[Any, Byte]

implicit val anyToDouble: TypeConverter[Any, Double]

implicit val anyToFloat: TypeConverter[Any, Float]

implicit val anyToInt: TypeConverter[Any, Int]

implicit val anyToLong: TypeConverter[Any, Long]

implicit val anyToShort: TypeConverter[Any, Short]

implicit val anyToString: TypeConverter[Any, String]

final def asInstanceOf[T0]: T0

implicit def booleanBlock2RouteMatcher(block: ⇒ Boolean): RouteMatcher

lazy val charset: Option[String]

def clone(): AnyRef

var config: (ScalateI18nSupport.this)#ConfigT

implicit def configWrapper(config: (ScalateI18nSupport.this)#ConfigT): (ScalateI18nSupport.this)#Config { object initParameters }

def contentType(implicit ctx: SkinnyContext): String

def contentTypeInferrer: ContentTypeInferrer

def contentType_=(contentType: String)(implicit ctx: SkinnyContext): Unit

def context: SkinnyContext

def contextPath: String

implicit def cookieOptions(implicit ctx: SkinnyContext): CookieOptions

def cookies(implicit ctx: SkinnyContext): SweetCookies

def createRenderContext(out: PrintWriter)(implicit ctx: SkinnyContext): SkinnyScalateRenderContext

Added "messages" into the template context so it can be accessed like: #{messages("hello")}

def createTemplateEngine(config: (ScalateI18nSupport.this)#ConfigT): TemplateEngine

Creates the templateMicro from the config.

def currentErrorHandler: ErrorHandler

val defaultCharacterEncoding: String

def defaultIndexName: String

The default index page when the path is a directory.

def defaultLayoutPath: Option[String]

The default path to search for templates.

implicit def defaultStringToSeq[T](implicit elementConverter: TypeConverter[String, T], mf: Manifest[T]): TypeConverter[String, Seq[T]]

def defaultTemplateFormat: String

The default template format.

def defaultTemplatePath: List[String]

The default path to search for templates.

def detectTooManyErrorFilterRegistrationAsAnErrorAtSkinnyMicroBase: Boolean

implicit def enrichRequest(request: HttpServletRequest): RichRequest

implicit def enrichResponse(response: HttpServletResponse): RichResponse

implicit def enrichServletContext(servletContext: ServletContext): RichServletContext

implicit def enrichSession(session: HttpSession): RichHttpServletSession

def environment: String

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def error(handler: ErrorHandler): Unit

def executeRoutes(request: HttpServletRequest, response: HttpServletResponse): Unit

implicit def executionContext: ExecutionContext

def finalize(): Unit

def findTemplate(path: String, extensionSet: Set[String] = templateEngine.extensions): Option[String]

Finds a template for a path.

def format_=(formatValue: String)(implicit ctx: SkinnyContext): Unit

def fullUrl(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean, withSessionId: Boolean)(implicit ctx: SkinnyContext): String

final def getClass(): Class[_]

def halt(result: ActionResult): Nothing

def halt[T](status: Integer, body: T, headers: Map[String, String], reason: String)(implicit arg0: Manifest[T]): Nothing

def handle(req: HttpServletRequest, res: HttpServletResponse): Unit

def hashCode(): Int

def initParameter(name: String): Option[String]

def initialize(config: (ScalateI18nSupport.this)#ConfigT): Unit

def invoke(matchedRoute: MatchedRoute): Option[Any]

def isAsyncExecutable(result: Any): Boolean

def isDevelopmentMode: Boolean

final def isInstanceOf[T0]: Boolean

def isScalateErrorPageEnabled: Boolean

Flag whether the Scalate error page is enabled.

def jade(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

Convenience method for layoutTemplateAs("jade").

def layoutTemplate(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

Finds and renders a template with the current layout strategy, looking for all known extensions, returning the result.

def layoutTemplateAs(ext: Set[String])(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

Finds and renders a template with the current layout strategy, returning the result.

def locale(implicit ctx: SkinnyContext): Locale

def logger: Logger

def loggerName: String

implicit def lowestPriorityAny2T[T](implicit arg0: Manifest[T]): TypeConverter[Any, T]

def maxDurationToAwaitAsyncFilters: Duration

def messages(implicit ctx: SkinnyContext): Messages

def messages(key: String)(implicit ctx: SkinnyContext): String

def methodNotAllowed(f: (Set[HttpMethod]) ⇒ Any): Unit

def mount(ctx: ServletContext): Unit

def multiParams(key: String)(implicit ctx: SkinnyContext): Seq[String]

def multiParams(implicit ctx: SkinnyContext): MultiParams

def mustache(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

Convenience method for layoutTemplateAs("mustache").

final def ne(arg0: AnyRef): Boolean

def notFound(fun: ⇒ Any): Unit

final def notify(): Unit

final def notifyAll(): Unit

def params(implicit ctx: SkinnyContext): Params

def params(key: Symbol)(implicit ctx: SkinnyContext): String

def params(key: String)(implicit ctx: SkinnyContext): String

def pass(): Nothing

implicit def pathPatternParser2RouteMatcher(pattern: PathPattern): RouteMatcher

def provideMessages(locale: Locale)(implicit ctx: SkinnyContext): Messages

def redirect(uri: String)(implicit ctx: SkinnyContext): Nothing

implicit def regex2RouteMatcher(regex: Regex): RouteMatcher

def relativeUrl(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean)(implicit ctx: SkinnyContext): String

def removeRoute(method: String, route: Route): Unit

def removeRoute(method: HttpMethod, route: Route): Unit

def renderHaltException(e: HaltException)(implicit ctx: SkinnyContext): Unit

def renderPipeline(implicit ctx: SkinnyContext): RenderPipeline

def renderResponse(actionResult: Any)(implicit ctx: SkinnyContext): Unit

def renderResponseBody(actionResult: Any)(implicit ctx: SkinnyContext): Unit

def renderUncaughtException(e: Throwable)(implicit ctx: SkinnyContext): Unit

def request(implicit ctx: SkinnyContext): HttpServletRequest

def respondTo: Seq[Format]

def response(implicit ctx: SkinnyContext): HttpServletResponse

val routes: RouteRegistry

def runRoutes(routes: Traversable[Route]): Stream[Any]

implicit def safe[S, T](f: (S) ⇒ T): TypeConverter[S, T]

implicit def safeOption[S, T](f: (S) ⇒ Option[T]): TypeConverter[S, T]

def scaml(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

Convenience method for layoutTemplateAs("scaml").

implicit def seqHead[T](implicit elementConverter: TypeConverter[String, T], mf: Manifest[T]): TypeConverter[Seq[String], T]

implicit def seqToSeq[T](implicit elementConverter: TypeConverter[String, T], mf: Manifest[T]): TypeConverter[Seq[String], Seq[T]]

def serverAuthority(implicit ctx: SkinnyContext): String

def serverHost(implicit ctx: SkinnyContext): String

def serverPort(implicit ctx: SkinnyContext): Int

implicit def servletContext: ServletContext

def session(key: Symbol)(implicit ctx: SkinnyContext): Any

def session(key: String)(implicit ctx: SkinnyContext): Any

implicit def session(implicit ctx: SkinnyContext): HttpSession

def sessionOption(implicit ctx: SkinnyContext): Option[HttpSession]

def setMultiparams[S](matchedRoute: Option[MatchedRoute], originalParams: MultiParams)(implicit ctx: SkinnyContext): Unit

def shutdown(): Unit

def skinnyContext(implicit ctx: ServletContext): SkinnyContext

def ssp(path: String, attributes: (String, Any)*)(implicit ctx: SkinnyContext): String

Convenience method for layoutTemplateAs("ssp").

def status(implicit ctx: SkinnyContext): Int

def status_=(code: Int)(implicit ctx: SkinnyContext): Unit

implicit def string2RouteMatcher(path: String): RouteMatcher

implicit val stringToBoolean: TypeConverter[String, Boolean]

implicit val stringToByte: TypeConverter[String, Byte]

def stringToDate(format: ⇒ String): TypeConverter[String, Date]

def stringToDateFormat(format: ⇒ DateFormat): TypeConverter[String, Date]

implicit val stringToDouble: TypeConverter[String, Double]

implicit val stringToFloat: TypeConverter[String, Float]

implicit val stringToInt: TypeConverter[String, Int]

implicit val stringToLong: TypeConverter[String, Long]

implicit def stringToRicherString(s: String): RicherString

implicit val stringToSelf: TypeConverter[String, String]

def stringToSeq[T](elementConverter: TypeConverter[String, T], separator: String)(implicit arg0: Manifest[T]): TypeConverter[String, Seq[T]]

implicit val stringToShort: TypeConverter[String, Short]

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

def templateAttributes(key: String)(implicit ctx: SkinnyContext): Any

def templateAttributes(implicit ctx: SkinnyContext): Map[String, Any]

A request-scoped map of attributes to pass to the template.

var templateEngine: TemplateEngine

The template engine used by the methods in this support class.

def toString(): String

implicit def toTypedMultiParams(params: MultiParams): (ScalateI18nSupport.this)#TypedMultiParams

implicit def toTypedParams(params: Params): (ScalateI18nSupport.this)#TypedParams

def unstableAccessValidationEnabled: Boolean

def url(path: String, params: Iterable[(String, Any)], includeContextPath: Boolean, includeServletPath: Boolean, absolutize: Boolean, withSessionId: Boolean)(implicit ctx: SkinnyContext): String

def userLocales(implicit ctx: SkinnyContext): Array[Locale]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

def withRequest[A](request: HttpServletRequest)(f: ⇒ A): A

def withRequestResponse[A](request: HttpServletRequest, response: HttpServletResponse)(f: ⇒ A): A

def withResponse[A](response: HttpServletResponse)(f: ⇒ A): A

def withRouteMultiParams[S](matchedRoute: Option[MatchedRoute])(thunk: ⇒ S): S