Genie.Router.Route — Type
Genie.Router.Channel — Type
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.
For a more verbose human-readable text output for objects of type T, define show(io::IO, ::MIME"text/plain", ::T) in addition. Checking the :compact IOContext key (often checked as get(io, :compact, false)::Bool) 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!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.
Examples
julia> struct Day
n::Int
end
julia> Base.show(io::IO, ::MIME"text/plain", d::Day) = print(io, d.n, " day")
julia> Day(1)
1 dayContainer 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.
Genie.Router.Params — Type
mutable struct Params{T}Collection of key value pairs representing the parameters of the current request - response cycle.
sourceGenie.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
ispayload()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) :: ResponseFirst step in handling a request: sets up params collection, handles query vars, negotiates content.
sourceGenie.Router.route_ws_request — Function
route_ws_request(req::Request, msg::String, ws_client::HTTP.WebSockets.WebSocket) :: StringFirst step in handling a web socket request: sets up params collection, handles query vars.
sourceBase.push! — Function
push!(collection, items...) -> collectionInsert 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 Vector{Int64}:
1
2
3
4
5
6If 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.
See sizehint! for notes about the performance model.
See also pushfirst!.
Genie.Router.route — Function
Named Genie routes constructors.
sourceGenie.Router.channel — Function
Named Genie channels constructors.
sourceGenie.Router.routename — Function
Genie.Router.channelname — Function
Genie.Router.baptizer — Function
baptizer(params::Union{Route,Channel}, parts::Vector{String}) :: SymbolGenerates default names for routes and channels.
sourceGenie.Router.named_routes — Function
The list of the defined named routes.
sourceGenie.Router.routes — Function
Genie.Router.named_channels — Function
Genie.Router.channels — Function
Genie.Router.get_route — Function
Gets the Route corresponding to routename
Genie.Router.delete! — Function
delete!(route_name::Symbol)Removes the route with the corresponding name from the routes collection and returns the collection of remaining routes.
sourceGenie.Router.to_link — Function
Generates the HTTP link corresponding to route_name using the parameters in d.
Generates the HTTP link corresponding to route_name using the parameters in route_params.
Genie.Router.tolink — Function
Generates the HTTP link corresponding to route_name using the parameters in d.
Generates the HTTP link corresponding to route_name using the parameters in route_params.
Genie.Router.link_to — Function
Generates the HTTP link corresponding to route_name using the parameters in d.
Generates the HTTP link corresponding to route_name using the parameters in route_params.
Genie.Router.linkto — Function
Generates the HTTP link corresponding to route_name using the parameters in d.
Generates the HTTP link corresponding to route_name using the parameters in route_params.
Genie.Router.toroute — Function
Generates the HTTP link corresponding to route_name using the parameters in d.
Generates the HTTP link corresponding to route_name using the parameters in route_params.
Genie.Router.route_params_to_dict — Function
Genie.Router.action_controller_params — Function
action_controller_params(action::Function, params::Params) :: NothingSets up the :action_controller, :action, and :controller key - value pairs of the params collection.
Genie.Router.match_routes — Function
match_routes(req::Request, res::Response, params::Params) :: Union{Route,Nothing}Matches the invoked URL to the corresponding route, sets up the execution environment and invokes the controller method.
sourceGenie.Router.match_channels — Function
match_channels(req::Request, msg::String, ws_client::HTTP.WebSockets.WebSocket, params::Params) :: StringMatches the invoked URL to the corresponding channel, sets up the execution environment and invokes the channel controller method.
sourceGenie.Router.parse_route — Function
parse_route(route::String, context::Module = @__MODULE__) :: Tuple{String,Vector{String},Vector{Any}}Parses a route and extracts its named params and types. context is used to access optional route parts types.
Genie.Router.parse_channel — Function
parse_channel(channel::String) :: Tuple{String,Vector{String},Vector{Any}}Parses a channel and extracts its named parms and types.
sourceGenie.Router.extract_uri_params — Function
extract_uri_params(uri::String, regex_route::Regex, param_names::Vector{String}, param_types::Vector{Any}, params::Params) :: BoolExtracts params from request URI and sets up the params Dict.
Genie.Router.extract_get_params — Function
extract_get_params(uri::URI, params::Params) :: BoolExtracts query vars and adds them to the execution params Dict.
Genie.Router.extract_post_params — Function
extract_post_params(req::Request, params::Params) :: NothingParses POST variables and adds the to the params Dict.
Genie.Router.extract_request_params — Function
extract_request_params(req::HTTP.Request, params::Params) :: NothingSets up the params key-value pairs corresponding to a JSON payload.
Genie.Router.content_type — Function
Genie.Router.content_length — Function
Genie.Router.request_type_is — Function
request_type_is(req::HTTP.Request, request_type::Symbol) :: BoolChecks if the request content-type is of a certain type.
sourceGenie.Router.request_type — Function
Genie.Router.nested_keys — Function
nested_keys(k::String, v, params::Params) :: NothingUtility function to process nested keys and set them up in params.
Genie.Router.setup_base_params — Function
setup_base_params(req::Request, res::Response, params::Dict{Symbol,Any}) :: Dict{Symbol,Any}Populates params with default environment vars.
Genie.Router.to_response — Function
to_response(action_result) :: ResponseConverts the result of invoking the controller action to a Response.
Genie.Router.params — Function
Genie.Router.request — Function
Genie.Router.response_type — Function
response_type{T}(params::Dict{Symbol,T}) :: Symbol
response_type(params::Params) :: SymbolReturns the content-type of the current request-response cycle.
sourceresponse_type{T}(check::Symbol, params::Dict{Symbol,T}) :: BoolChecks if the content-type of the current request-response cycle matches check.
Genie.Router.append_to_routes_file — Function
Genie.Router.is_static_file — Function
Genie.Router.escape_resource_path — Function
Genie.Router.serve_static_file — Function
serve_static_file(resource::String) :: ResponseReads the static file and returns the content as a Response.
Genie.Router.preflight_response — Function
Genie.Router.response_mime — Function
Genie.Router.file_path — Function
file_path(resource::String; within_doc_root = true, root = Genie.config.server_document_root) :: StringReturns the path to a resource file. If within_doc_root it will automatically prepend the document root to resource.
Genie.Router.filepath — Function
file_path(resource::String; within_doc_root = true, root = Genie.config.server_document_root) :: StringReturns the path to a resource file. If within_doc_root it will automatically prepend the document root to resource.