Router · Genie - The Highly Productive Julia Web Framework

Genie.Router.Route — Type

mutable struct Route

Representation of a route object

Genie.Router.Channel — Type

mutable struct Channel

Representation of a WebSocket Channel object

Base.show — Function

show([io::IO = stdout], x)

Write a text representation of a value x to the output stream io. New types T should overload show(io::IO, x::T). The representation used by show generally includes Julia-specific formatting and type information, and should be parseable Julia code when possible.

repr returns the output of show as a string.

To customize human-readable text output for objects of type T, define show(io::IO, ::MIME"text/plain", ::T) instead. Checking the :compactIOContext property of io in such methods is recommended, since some containers show their elements by calling this method with :compact => true.

See also print, which writes un-decorated representations.

Examples

julia> show("Hello World!")
"Hello World!"
julia> print("Hello World!")
Hello World!

source

show(io::IO, mime, x)

The display functions ultimately call show in order to write an object x as a given mime type to a given I/O stream io (usually a memory buffer), if possible. In order to provide a rich multimedia representation of a user-defined type T, it is only necessary to define a new show method for T, via: show(io, ::MIME"mime", x::T) = ..., where mime is a MIME-type string and the function body calls write (or similar) to write that representation of x to io. (Note that the MIME"" notation only supports literal strings; to construct MIME types in a more flexible manner use MIME{Symbol("")}.)

For example, if you define a MyImage type and know how to write it to a PNG file, you could define a function show(io, ::MIME"image/png", x::MyImage) = ... to allow your images to be displayed on any PNG-capable AbstractDisplay (such as IJulia). As usual, be sure to import Base.show in order to add new methods to the built-in Julia function show.

Technically, the MIME"mime" macro defines a singleton type for the given mime string, which allows us to exploit Julia's dispatch mechanisms in determining how to display objects of any given type.

The default MIME type is MIME"text/plain". There is a fallback definition for text/plain output that calls show with 2 arguments, so it is not always necessary to add a method for that case. If a type benefits from custom human-readable output though, show(::IO, ::MIME"text/plain", ::T) should be defined. For example, the Day type uses 1 day as the output for the text/plain MIME type, and Day(1) as the output of 2-argument show.

Container types generally implement 3-argument show by calling show(io, MIME"text/plain"(), x) for elements x, with :compact => true set in an IOContext passed as the first argument.

source

Base.show(io::IO, ex::RuntimeException)

Custom printing of RuntimeException

Base.show(io::IO, ex::FileExistsException)

Custom printing for FileExistsException

Genie.Router.Params — Type

mutable struct Params{T}

Collection of key value pairs representing the parameters of the current request - response cycle.

Genie.Router.ispayload — Function

ispayload(req::HTTP.Request)

True if the request can carry a payload - that is, it's a POST, PUT, or PATCH request

Genie.Router.route_request — Function

route_request(req::Request, res::Response, ip::IPv4 = Genie.config.server_host) :: Response

First step in handling a request: sets up @params collection, handles query vars, negotiates content.

Genie.Router.route_ws_request — Function

route_ws_request(req::Request, msg::String, ws_client::HTTP.WebSockets.WebSocket, ip::IPv4 = Genie.config.server_host) :: String

First step in handling a web socket request: sets up @params collection, handles query vars.

Base.push! — Function

push!(collection, items...) -> collection

Insert one or more items in collection. If collection is an ordered container, the items are inserted at the end (in the given order).

Examples

julia> push!([1, 2, 3], 4, 5, 6)
6-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6

If collection is ordered, use append! to add all the elements of another collection to it. The result of the preceding example is equivalent to append!([1, 2, 3], [4, 5, 6]). For AbstractSet objects, union! can be used instead.

source

Genie.Router.route — Function

Named Genie routes constructors.

Genie.Router.channel — Function

Named Genie channels constructors.

Genie.Router.routename — Function

routename(params) :: Symbol

Computes the name of a route.

Genie.Router.channelname — Function

channelname(params) :: Symbol

Computes the name of a channel.

Genie.Router.baptizer — Function

baptizer(params::Union{Route,Channel}, parts::Vector{String}) :: Symbol

Generates default names for routes and channels.

Genie.Router.named_routes — Function

The list of the defined named routes.

Genie.Router.routes — Function

routes() :: Vector{Route}

Returns a vector of defined routes.

Genie.Router.named_channels — Function

named_channels() :: Dict{Symbol,Any}

The list of the defined named channels.

Genie.Router.channels — Function

channels() :: Vector{Channel}

Returns a vector of defined channels.

Genie.Router.get_route — Function

Gets the Route correspoding to routename

Missing docstring.

Missing docstring for routes. Check Documenter's build log for details.

Missing docstring.

Missing docstring for channels. Check Documenter's build log for details.

Genie.Router.delete! — Function

delete!(routes, route_name::Symbol)

Removes the route with the corresponding name from the routes collection and returns the collection of remaining routes.

Genie.Router.to_link — Function

Generates the HTTP link corresponding to route_name using the parameters in d.