Roadmap
Past three weeks:
- How do we use a functional language?
Next three weeks:
- How do we implement a functional language?
- … in a functional language (of course)
This week: Interpreter
- How do we evaluate a program given its abstract syntax tree (AST)?
- How do we prove properties about our interpreter (e.g. that certain programs never crash)?
The Nano Language
Features of Nano:
- Arithmetic
- Variables
- Let-bindings
- Functions
- Recursion
1. Nano: Arithmetic
A grammar of arithmetic expressions:
::= n
e | e1 + e2
| e1 - e2
| e1 * e2
Examples:
| Expression | Value | |
|---|---|---|
4 |
==> |
4 |
4 + 12 |
==> |
16 |
(4 + 12) - 5 |
==> |
11 |
Representing Expressions and Values
Let’s represent arithmetic expressions as a type:
data Expr = Num Int
| Add Expr Expr
| Sub Expr Expr
| Mul Expr Expr
Let’s represent arithmetic values as a type:
type Value = Int
Evaluating Arithmetic Expressions
We can now write a Haskell function to evaluate an expression:
eval :: Expr -> Value
Num n) = n
eval (Add e1 e2) = eval e1 + eval e2
eval (Sub e1 e2) = eval e1 - eval e2
eval (Mul e1 e2) = eval e1 * eval e2 eval (
Alternative representation
Let’s factor out the operators into a separate type
data Binop = Add | Sub | Mul
data Expr = Num Int -- number
| Bin Binop Expr Expr -- binary expression
QUIZ
Evaluator for alternative representation:
eval :: Expr -> Value
Num n) = n
eval (Bin op e1 e2) = evalOp op (eval e1) (eval e2) eval (
What’s a suitable type for evalOp
?
(A) Binop -> Value
(B) Binop -> Value -> Value -> Value
(C) Binop -> Expr -> Expr -> Value
(D) Binop -> Expr -> Expr -> Expr
(E) Binop -> Expr -> Value
Answer: B
The Nano Language
Features of Nano:
- Arithmetic [done]
- Variables
- Let-bindings
- Functions
- Recursion
2. Nano: Variables
Let’s add variables!
::= n -- OLD
e | e1 + e2
| e1 - e2
| e1 * e2
| x -- NEW
Let’s extend the representation of expressions:
data Expr = Num Int -- number
| Bin Binop Expr Expr -- binary expression
| ??? -- variable
type Id = String
data Expr = Num Int -- number
| Bin Binop Expr Expr -- binary expression
| Var Id -- variable
Now let’s extend the evaluation function!
QUIZ
What should the following expression evaluate to?
+ 1 x
(A) 0
(B) 1
(C) Runtime error
Answer: C
Environment
An expression is evaluated in an environment
- It’s like a phone book that maps variables to values
"x" := 0, "y" := 12, ...] [
We can represent an environment using the following type:
type Env = [(Id, Value)]
Evaluation in an Environment
We write
==> value eval env expr
To mean that evaluating expr
in the environment env
returns value
QUIZ
What should the result of?
"x" := 0, "y" := 12, ...] (x + 1) eval [
(A) 0
(B) 1
(C) Runtime error
Answer: B
To evaluate a variable, look up its value in the environment!
| Environment | Expression | Value | |
|---|---|---|---|
["x" := 5] |
x |
==> |
5 |
["x" := 5] |
x + 12 |
==> |
17 |
["x" := 5] |
y - 5 |
==> |
error |
Evaluating Variables
We need to update our evaluation function to take the environment as an argument:
eval :: Env -> Expr -> Value
Num n) = ???
eval env (Bin op e1 e2) = ???
eval env (Var x) = ??? eval env (
eval :: Env -> Expr -> Value
Num n) = n
eval env (Bin op e1 e2) = evalOp op (eval env e1) (eval env e2)
eval env (Var x) = lookup x env eval env (
But how do variables get into the environment?
The Nano Language
Features of Nano:
- Arithmetic [done]
- Variables [done]
- Let-bindings
- Functions
- Recursion
3. Nano: Let Bindings
Let’s add let bindings!
::= n -- OLD
e | e1 + e2
| e1 - e2
| e1 * e2
| x
| let x = e1 in e2 -- NEW
Example:
| Environment | Expression | Value | |
|---|---|---|---|
[] |
let x = 2 + 3 in x * 2 |
==> |
10 |
Let’s extend the representation of expressions:
data Expr = Num Int -- number
| Bin Binop Expr Expr -- binary expression
| Var x -- variable
| ??? -- let binding
data Expr = Num Int -- number
| Bin Binop Expr Expr -- binary expression
| Var Id -- variable
| Let Id Expr Expr -- let binding
Now let’s extend the evaluation function!
eval :: Env -> Expr -> Value
Num n) = n
eval env (Bin op e1 e2) = evalOp op (eval env e1) (eval env e2)
eval env (Var x) = lookup x env
eval env (Let x def body) = ??? eval env (
Let’s develop intuition with examples!
QUIZ
What should this evaluate to?
let x = 5
in
+ 1 x
(A) 1
(B) 5
(C) 6
(D) Error: unbound variable x
(E) Error: unbound variable y
Answer: C
QUIZ
What should this evaluate to?
let x = 5
in
let y = x + 1
in
* y x
(A) 5
(B) 6
(C) 30
(D) Error: unbound variable x
(E) Error: unbound variable y
Answer: C
QUIZ
What should this evaluate to?
let x = 0
in
let x = 100
(in
+ 1
x + x )
(A) 1
(B) 101
(C) 201
(D) 2
(E) Error: multiple definitions of x
Answer: B
Principle: Static (Lexical) Scoping
Every variable use (occurrence) gets its value from the most local definition (binding)
- in a pure language, the value never changes once defined
- easy to tell by looking at the program, where a variable’s value came from!
Implementing Lexical Scoping
Example 1:
-- environment:
let x = 5 -- []
in -- [x := 5]
+ 1 -- | x
Example 2:
-- environment:
let x = 5 -- []
in -- [x := 5]
let y = x + 1 -- |
in -- | [y := 6, x := 5]
* y -- | | x
Note: [y := 6]
got added to the environment
Example 3:
-- environment:
let x = 0 -- []
in -- [x := 0]
let x = 100 -- |
(in -- | [x := 100, x := 0]
+ 1 -- | |
x -- | |
) + x -- |
Note: [x := 100]
was only added for the inner scope
Evaluating let Expressions
To evaluate let x = e1 in e2
in env
:
- Evaluate
e1
inenv
toval
- Extend
env
with a mapping["x" := val]
- Evaluate
e2
in this extended environment
eval :: Env -> Expr -> Value
Num n) = n
eval env (Bin op e1 e2) = evalOp op (eval e1) (eval e2)
eval env (Var x) = lookup x env
eval env (Let x e1 e2) = eval env' e2
eval env (where
= eval env e1
v = (x, v) : env env'
The Nano Language
Features of Nano:
- Arithmetic [done]
- Variables [done]
- Let binding [done]
- Functions
- Recursion
4. Nano: Functions
Let’s add:
- lambda abstraction (aka function definitions)
- applications (aka function calls)
::= n -- OLD
e | e1 + e2
| e1 - e2
| e1 * e2
| x
| let x = e1 in e2
-- NEW
| \x -> e -- abstraction
| e1 e2 -- application
Example:
let inc = \x -> x + 1 in
10 inc
QUIZ
What should this evaluate to?
let inc = \x -> x + 1 in
10 inc
(A) Undefined variable x
(B) Undefined variable inc
(C) 1
(D) 10
(E) 11
Answer: E
Representing functions
Let’s extend the representation of expressions:
data Expr = Num Int -- number
| Bin Binop Expr Expr -- binary expression
| Var Id -- variable
| Let Id Expr Expr -- let expression
| ??? -- abstraction
| ??? -- application
data Expr = Num Int -- number
| Bin Binop Expr Expr -- binary expression
| Var Id -- variable
| Let Id Expr Expr -- let expression
| Lam Id Expr -- abstraction: formal + body
| App Expr Expr -- application: function + actual
Example:
let inc = \x -> x + 1 in
10 inc
represented as:
Let "inc"
Lam "x" (Bin Add (Var "x") (Num 1)))
(App (Var "inc") (Num 10)) (
Evaluating Functions
-- environment
let inc = \x -> x + 1
in -- [inc := ???]
10 -- use the value of inc to evaluate this inc
What is the value of inc
???
Rethinking our values
Until now: a program evaluates to an integer (or fails)
type Value = Int
type Env = [(Id, Value)]
eval :: Env -> Expr -> Value
What do these programs evaluate to?
1)
(-> x + 1
\x ==> ???
2)
(let f = \x y -> x + y in
1
f ==> ???
Conceptually, they both evaluate to a function that increments its argument
Now: a program evaluates to an integer or a function (or fails)
- Remember: functions are first-class values
Let’s change our definition of values!
data Value = VNum Int
| VFun ??? -- What info do we need to store?
-- Other types stay the same
type Env = [(Id, Value)]
eval :: Env -> Expr -> Value
Function values
How should we represent a function value?
let inc = \x -> x + 1 in
10 inc
We need to store enough information about inc
so that we can later evaluate any application of inc
(like inc 0
, inc 5
, inc 10
, inc (factorial 100)
)
The value of a function is its code!
Representing Function Values (First Attempt)
Grammar for values:
::= n -- OLD: number
v | <x, e> -- NEW: formal + body
Haskell representation:
data Value = VNum Int
| VFun Id Expr -- formal + body
Let’s try this!
-- environment
let inc = \x -> x + 1
in -- [inc := <x, x + 1>]
10 -- how do we evaluate this? inc
Evaluating applications
-- environment
let inc = \x -> x + 1
in -- [inc := <x, x + 1>]
10 -- how do we evaluate this? inc
To evaluate inc 10
:
- Evaluate
inc
, get<x, x + 1>
- Evaluate
10
, get10
- Evaluate
x + 1
in an environment extended with[x := 10]
Let’s extend our eval
function!
eval :: Env -> Expr -> Value
Num n) = ???
eval env (Bin op e1 e2) = ???
eval env (Var x) = ???
eval env (Let x e1 e2) = ???
eval env (Lam x e) = ???
eval env (App e1 e2) = ??? eval env (
eval :: Env -> Expr -> Value
Num n) = VNum n
eval env (Var x) = lookup x env
eval env (Bin op e1 e2) = VNum (evalOp op v1 v2)
eval env (where
VNum v1) = eval env e1
(VNum v2) = eval env e2
(Let x e1 e2) = eval env' e2
eval env (where
= eval env e1
v = (x, v) : env
env' Lam x body) = VFun x body
eval env (App fun arg) = eval env' body
eval env (where
VFun x body = eval env fun -- DO NOT DO THIS in HW!
-- introduce a helper instead
-- to match different value patterns
= eval env arg
vArg = (x, vArg) : env env'
QUIZ
What should this evaluate to?
let c = 1
in
let inc = \x -> x + c
in
10 inc
(A) Undefined variable x
(B) Undefined variable c
(C) 1
(D) 10
(E) 11
Answer: E
QUIZ
And what should this evaluate to?
let c = 1
in
let inc = \x -> x + c
in
let c = 100
in
10 inc
(A) Error: multiple definitions of c
(B) 11
(C) 110
Answer: B
Reminder: Referential Transparency
The same expression must always evaluate to the same value
- In particular: a function must always return the same output for a given input
Why?
> myFunc 10
11
> myFunc 10
110
Oh no! How do I find the bug???
- Is it in
myFunc
? - Is it in a global variable?
- Is it in a library somewhere else?
My worst debugging nightmare!
Static vs Dynamic Scoping
What we want:
let c = 1 -- <-------------------
in -- \
let inc = \x -> x + c -- refers to this def \
in
let c = 100
in
10
inc
==> 11
Lexical (or static) scoping:
- each occurrence of a variable refers to the most recent binding in the program text
- definition of each variable is unique and known statically
- guarantees referential transparency:
let c = 1 -- <-------------------
in -- \
let inc = \x -> x + c -- refers to this def \
in
let c = 100
in
let res1 = inc 10 -- ==> 11
in
let c = 200
in
let res2 = inc 10 -- ==> 11
in res1 == res2 -- ==> True
What we don’t want:
let c = 1
in
let inc = \x -> x + c -- refers to this def \
in -- \
let c = 100 -- <-------------------
in
10
inc
==> 110
Dynamic scoping:
- each occurrence of a variable refers to the most recent binding during program execution
- can’t tell where a variable is defined just by looking at the function body
- violates referential transparency:
let c = 1
in
let inc = \x -> x + c -- refers to this def \ \
in -- \ \
let c = 100 -- <------------------- \
in -- \
let res1 = inc 10 -- ==> 110 \
in -- \
let c = 200 -- <----------------------
in
let res2 = inc 10 -- ==> 210!!!
in res1 == res2 -- ==> False
QUIZ
Which scoping does our eval
function implement?
...
Lam x body) = VFun x body
eval env (App fun arg) = eval env' body
eval env (where
VFun x body = eval env fun
= eval env arg
vArg = (x, vArg) : env env'
(A) Static
(B) Dynamic
(C) Neither
Answer: B
Let’s find out!
-- env:
let c = 1 -- []
in -- ["c" := 1]
let inc = \x -> x + c
in -- ["inc" := <x, x + c>, "c" := 1]
let c = 100
in -- ["c" := 100, "inc" := <x, x + c>, "c" := 1]
10
inc
-- 1. ==> <x, x + c>
-- 2. ==> 10
-- 3. x + c ["x" := 10, "c" := 100, "inc" := <x, x + c>, "c" := 1]
-- ==> 110
Ouch.
What went wrong?
let c = 1
in -- ["c" := 1]
let inc = \x -> x + c -- we want this "c" to ALWAYS mean 1!
in -- ["inc" := <x, x + c>, "c" := 1]
let c = 100
in -- ["c" := 100, "inc" := <x, x + c>, "c" := 1]
10 -- but now it means 100 because we are in a new env! inc
Lesson learned: need to remember what c
was bound to when inc
was defined!
- i.e. “freeze” the environment at the point of function definition
Implementing Static Scoping
Key ideas:
- At definition: Freeze the environment in the function’s value
- At call: Use the frozen environment to evaluate the body
- instead of the current environment
-- env:
let c = 1 -- []
in -- ["c" := 1]
let inc = \x -> x + c
in -- ["inc" := <fro, x, x + c>, "c" := 1]
-- where fro = ["c" := 1]
let c = 100
in -- ["c" := 100, "inc" := <fro, x, x + c>, ...]
10
inc
-- 1. ==> <fro, x, x + c>
-- 2. ==> 10
-- add "x" to fro instead of env:
-- 3. x + c ["x" := 10, "c" := 1]
-- ==> 11
Tada!
Function Values as Closures
To implement lexical scoping, we will represent function values as closures
Closure = lambda abstraction (formal + body) + environment at function definition
Updated grammar for values:
::= n
v | <env, x, e> -- NEW: frozen env + formal + body
::= []
env | (x := v) : env
Updated Haskell representation:
data Value = VNum Int
| VClos Env Id Expr -- frozen env + formal + body
Evaluating function definitions
How should we modify our eval
for Lam
?
data Value = VNum Int
| VClos Env Id Expr -- env + formal + body
eval :: Env -> Expr -> Value
Lam x body) = ??? -- construct a closure eval env (
Recall: At definition: Freeze the environment in the function’s value
Exact code for you to figure out in HW4
Evaluating function calls
How should we modify our eval
for App
?
data Value = VNum Int
| VClos Env Id Expr -- env + formal + body
eval :: Env -> Expr -> Value
App e1 e2) = ??? -- apply the closure eval env (
Recall: At call: Use the frozen environment to evaluate the body
Exact code for you to figure out in HW4
Hint: Recall evaluating inc 10
:
- Evaluate
inc
to get<fro, x, x + c>
- Evaluate
10
to get10
- Evaluate
x + c
in(x := 10) : fro
Let’s generalize to e1 e2
:
- Evaluate
e1
to get<fro, param, body>
- Evaluate
e2
to getv2
- Evaluate
body
in(param := v2) : fro
Advanced Features of Functions
- Functions returning functions
- aka partial applications
- Functions taking functions as arguments
- aka higher-order functions
- Recursion
Does our eval
support this?
QUIZ
What should the following evaluate to?
let add = \x y -> x + y
in
let add1 = add 1
in
let add10 = add 10
in
100 + add10 1000 add1
(A) Runtime error
(B) 1102
(C) 1120
(D) 1111
Answer: D
Partial Applications Achieved!
Closures support functions returning functions!
let add = \x -> (\y -> x + y) -- env0 = []
in -- env1 = ["add" := <[], x, \y -> x + y>]
let add1 =
1 -- eval ("x" := 1 : env0) (\y -> x + y)
add -- ==> <["x" := 1], y, x + y>
in -- env2 = ["add1" := <["x" := 1], y, x + y>, "add" := ...]
let add10 =
10 -- eval ("x" := 10 : env0) (\y -> x + y)
add -- ==> <["x" := 10], y, x + y>
in -- env3 = ["add10" := <["x" := 10], y, x + y>, "add1" := ...]
100 -- eval ["y" := 100, "x" := 1] (x + y)
add1 -- ==> 101
+
1000 -- eval ["y" := 1000, "x" := 10] (x + y)
add10 -- ==> 1010
==> 1111
QUIZ
What should the following evaluate to?
let inc = \x -> x + 1
in
let doTwice = \f -> (\x -> f (f x))
in
10 doTwice inc
(A) Runtime error
(B) 11
(C) 12
Answer: C
Higher-order Functions Achieved
Closures support functions taking functions as arguments!
let inc = \x -> x + 1 -- env0 = []
in -- env1 = [inc := <[], x, x + 1>]
let doTwice = \f -> (\x -> f (f x))
in -- env2 = [doTwice := <env1, f, \x -> f (f x)>, inc := ...]
-- eval ("f" := <[],x,x + 1> : env1) (\x -> f (f x))
((doTwice inc) -- ==> <("f" := <[],x,x + 1> : env1), x, f (f x)>
10) -- eval ["x" := 10, "f" := <[],x,x + 1>, ...] f (f x)
-- f ==> <[], x, x + 1>
-- x ==> 10
-- <[], x, x + 1> 10 ==> eval ["x" := 10] x + 1 ==> 11
-- <[], x, x + 1> 11 ==> eval ["x" := 11] x + 1 ==> 12
==> 12
QUIZ
What does this evaluate to?
let f = \n -> n * f (n - 1)
in
5 f
(A) 120
(B) Evaluation does not terminate
(C) Error: unbound variable f
Answer: C
let f = \n -> n * f (n - 1)
in -- [f := <[], n, n * f (n - 1)>]
5 -- eval [n := 5] (n * f (n - 1))
f -- ==> unbound variable f!!!
Lesson learned: to support recursion, you need to figure out a way to put the function itself back into its closure environment before the body gets evaluated!
The Nano Language
Features of Nano:
- Arithmetic [done]
- Variables [done]
- Let bindings [done]
- Functions [done]
- Recursion [you figure it out in HW4]
That’s all folks!


§445-2 Treasurer to issue. The treasurer, upon the application of any person, shall issue to the applicant any license in this chapter upon the terms and conditions in this chapter set forth, provided that the county shall have the option to license those businesses enumerated in section 445-15(1). [L 1896, c 64, pt of §1; RL 1925, §1956; RL 1935, §2401; RL 1945, §7002; RL 1955, §155-2; HRS §445-2; am L 1992, c 232, §3]
Case Notes
No discretion to refuse license conforming to chapter. 11 H. 57 (1897).


| Version |
Research |
What was new |
| v6 |
Research to be planned |
Adding account recovery management |
| v7 |
Research to be planned |
A.C - enabling patients to update PDS data independently to NHS login data
(Diverging from the 'Account management' work) |
| v8 |
Research to be planned |
NHS login credentials as default contact details |
| v9 |
Research to be planned |
Scope reduced to collecting and updating patient phone and email |
| v10 |
Popup research on 02/03/2020 & lab research on 11/03/2020 |
Changes following design crit on 20/02/2020 |
| v11 |
Remote research on 02/04/2020 |
Changes following previous research on 11/03/2020 |
| v11hc |
Help centre project |
|
V12
Manage contact details section
Interruption card v4
|
Remote research on 21/05/2020 |
Changes following previous research on 02/04/2020 |


0% 年化收益
0% 阿尔法
0 贝塔
0 夏普比率
0% 最大回撤
还没登录，请登录或注册！
${strategy_name!""}
Interactively grow cross-media customer service through B2C paradigms. Continually monetize magnetic sources rather than ...
Objectively disseminate customer directed e-commerce with prospective partnerships. Collaboratively actualize ...
Continually monetize magnetic sources rather than leveraged outsourcing ...
Proactively reinvent team building customer service with ethical e-markets. Professionally utilize mission-critical ...
600181
5.43


Creating Plugins
Discord BOT Dashboard allows for custom plugins to be installed within your application, this documentation section will hopefully help you understand how you can create your own plugins.
📁 Code Structure
Having a basic understand of Discord BOT Command Development will allow you to understand this easier. Below is the code all Plugins have to follow, very simular to most BOT's which use a command handler.
// Requirements
const discord = require ("discord.js");
// Required display prefix
const prefix = require('../config/config.json')
// All the code for you Plugin goes inside here
module.exports.run = (client, message, args) =>{
message.channel.send ('pong!')
}
// IMPORTANT Allows DBD to know details about your Plugin
module.exports.details = {
name:'Ping',
author:'LachlanDev#8014',
icon:'URL',
description:'ping command description',
usage:`${prefix.prefix}ping`
}
Want to learn more about Discord BOT Development you can check out my guide here.


Limitless - Form Plugins
Overview
This library allows you to create editable elements on your page. It can be used with any engine (bootstrap, jquery-ui, jquery only) and includes both popup and inline modes. This is a brief documentation, some kind of getting started section. Please refer to a complete documentation for a complete list of options and configuration parameters.
Usage
To use editable plugin, include path to the minified plugin file. Also include necessary plugins if you want to use them with editable plugin. In demo page, for demo purpose, also included mockjax.min.js
extension for simulating AJAX requests. Include these files after jQuery
library. Ordering matters:

1. Markup elements that should be editable. Usually it is
element with additional data-*
attributes:

superuser

Main attributes you should define are:
type
- type of input (text, textarea, select, etc)url
- url to server-side script to process submitted value (/post
,post.php
etc)pk
- primary key of record to be updated (ID in db)id
orname
- name of field to be updated (column in db). Taken fromid
ordata-name
attributevalue
- initial value. Usefull for select, where value is integer key of text to be shown. If empty - will be taken from element html contents
2. Setup editable mode: inline or popup (default):
// Turn on popup mode
$.fn.editable.defaults.mode = 'popup';
3. Apply editable() method to these elements:
// Initialize
$(document).ready(function() {
$('#username').editable(options);
})
Alternatively, you can set all options via javascript

superuser
// Initialize with options
$('#username').editable({
type: 'text',
pk: 1,
url: '/post',
title: 'Enter username'
});
Default supported inputs
There are several input types supported by library. Each type may have additional configuration options. Input options are defined as well as other parameters of $().editable() method. Currently supported:
- text
- textarea
- select
- date
- datetime
- dateui
- combodate
- html5types
- checklist
- typeahead
- typeaheadjs
- select2
Options
| Option | Default | Description |
|---|---|---|
ajaxOptions |
null | Additional options for submit ajax request. List of values: http://api.jquery.com/jQuery.ajax |
anim |
false | Animation speed (inline mode only) |
autotext |
'auto' | Allows to automatically set element's text based on it's value. Can be auto|always|never |
defaultValue |
null | Value that will be displayed in input if original field value is empty (null|undefined|'' ) |
disabled |
false | Sets disabled state of editable |
display |
null |
Callback to perform custom displaying of value in element's text.
Runs under element's scope. Parameters:
For inputs with source (select, checklist) parameters are different:
$.fn.editableutils.itemsByValue(value, sourceData)
|
emptyclass |
'editable-empty' | Css class applied when editable text is empty |
emptytext |
'Empty' | Text shown when element is empty |
error |
null | Error callback. Called when request failed (response status != 200). Useful when you want to parse error response and display a custom message. Must return string - the message to be displayed in the error block |
highlight |
'#FFFF80' | Color used to highlight element after update. Implemented via CSS3 transition, works in modern browsers |
mode |
'popup' | Mode of editable, can be popup or inline |
name |
null | Name of field. Will be submitted on server. Can be taken from id attribute |
onblur |
'cancel' | Action when user clicks outside the container. Can be cancel|submit|ignore . Setting ignore allows to have several containers open |
params |
null | Additional params for submit. If defined as object - it is appended to original ajax data (pk, name and value). If defined as function - returned object overwrites original ajax data |
pk |
null | Primary key of editable object (e.g. record id in database). For composite keys use object, e.g. {id: 1, lang: 'en'} . Can be calculated dynamically via function |
placement |
'top' | Placement of container relative to element. Can be top|right|bottom|left . Not used for inline container |
savenochange |
false | Whether to save or cancel value when it was not changed but form was submitted |
selector |
null |
If selector is provided, editable will be delegated to the specified targets. Usefull for dynamically generated DOM elements. Please note, that delegated targets can't be initialized with editable-click to these elements |
send |
'auto' | Strategy for sending data on server. Can be auto|always|never . When 'auto' data will be sent on server only if pk and url defined, otherwise new value will be stored locally |
showbuttons |
true | Where to show buttons: left(true)|bottom|false . Form without buttons is auto-submitted |
success |
null |
Success callback. Called when value successfully sent on server and response status = 200. Usefull to work with json response. For example, if your backend response can be
|
toggle |
'click' |
How to toggle editable. Can be show or toggle inside click handler of some DOM element, you need to apply e.stopPropagation() because containers are being closed on any click on document |
type |
'text' | Type of input. Can be text|textarea|select|date|checklist and more |
unsavedclass |
'editable-unsaved' | Css class applied when value was stored but not sent to server (pk is empty or send = 'never' ). You may set it to null if you work with editables locally and submit them together |
url |
null | Url for submit, e.g. '/post' . If function - it will be called instead of ajax. Function should return deferred object to run fail/done callbacks |
validate |
null | Function for client-side validation. If returns string - means validation not passed and string showed as error. Since 1.5.1 you can modify submitted value by returning object from validate: {newValue: '...'} or {newValue: '...', msg: '...'} |
value |
element's text |
Initial value of input. If not set, taken from element's text. Note: if element's text is empty - text is automatically generated from value and can be customized (see autotext option) |
Plugin info
| Property | Description |
|---|---|
| File name | editable.min.js, address.js |
| Location | assets/js/plugins/forms/editable/ |
| Updates | 0 |
| Links | Github project page |
Overview
Autosize is a small, stand-alone script to automatically adjust textarea height to fit text. Use CSS to specify a min-height
and max-height
for the textarea element. Once the height exceeds the max-height
, autosize will re-enable the vertical scrollbar.
The rows attribute can also be used to specify a minimum height. The rows attribute has a default value of 2, so to make the textarea smaller than that you'll need to set the value to 1. Example: <textarea rows='1'></textarea>
.
Usage
The autosize function accepts a single textarea element, or an array or array-like object (such as a NodeList or jQuery collection) of textarea elements:
// From a NodeList
autosize(document.querySelectorAll('textarea'));
// from a single Node
autosize(document.querySelector('textarea'));
// from a jQuery collection
autosize($('textarea'));
Life-cycle events
| Event | Description |
|---|---|
autosize:update |
Once you've assigned autosize to an element, you can manually trigger the resize event by using the 'autosize:update' event. Autosize has no way of knowing when a script has changed the value of a textarea element, or when the textarea element styles have changed, so this event would be used instruct autosize to resize the textarea
|
autosize:autosize:destroy |
|
autosize:resized |
This event is fired every time autosize adjusts the textarea height.
If you are using jQuery, you can use the on/off methods to listen to this event:
|
Methods
These methods are provided as an alternative to using the life-cycle events
| Method | Description |
|---|---|
autosize.update(elements) |
For manually recalculating the height for a textarea element, array, or array-like object
|
autosize.destroy(elements) |
Removes autosize and reverts it's changes from a textarea element, array, or array-like object
|
Plugin info
| Property | Description |
|---|---|
| File name | autosize.min.js |
| Location | assets/js/plugins/forms/inputs/ |
| Updates | 0 |
| Links | Github project page |
Overview
Bootstrap Dual Listbox is a responsive dual listbox widget optimized for Twitter Bootstrap. It works on all modern browsers and on touch devices. The dual listbox is created from a select multiple by calling .bootstrapDualListbox(settings);
on a selector. The selector can be any element, not just selects. When the method is called on a selector other than a select, then all select childrens are converted into dual list boxes.
Usage
First you need to load jQuery library as Dual listbox plugin is jQuery dependent. Then add a path to the plugin file:

Then initialize via JavaScript:
// Multiple selection
$('.listbox-no-selection').bootstrapDualListbox({
preserveSelectionOnMove: 'moved',
moveOnSelect: false
});
Options
When calling $("#element").bootstrapDualListbox()
you can pass a parameters object with zero or more of the following:
| Option | Default | Description |
|---|---|---|
bootstrap2Compatible |
false | Set this to true if you want graphic compatibility with Bootstrap 2 |
filterTextClear |
'show all' | The text for the "Show All" button |
filterPlaceHolder |
'Filter' | The placeholder for the input element for filtering elements |
moveSelectedLabel |
'Move selected' | The label for the "Move Selected" button |
moveAllLabel |
'Move all' | The label for the "Move All" button |
removeSelectedLabel |
'Remove selected' | The label for the "Remove Selected" button |
removeAllLabel |
'Remove all' | The label for the "Remove All" button |
moveOnSelect |
true | Determines whether to move options upon selection. This option is forced to true on the Android browser |
preserveSelectionOnMove |
false | Can be 'all' (for selecting both moved elements and the already selected ones in the target list) or 'moved' (for selecting moved elements only) |
selectedListLabel |
false | Can be a string specifying the name of the selected list |
nonSelectedListLabel |
false | Can be a string specifying the name of the non selected list |
helperSelectNamePostfix |
'_helper' | The added selects will have the same name as the original one, concatenated with this string and 1 (for the non selected list, e.g. element_helper1) or 2 (for the selected list, e.g. element_helper2) |
selectorMinimalHeight |
100 | Represents the minimal height of the generated dual listbox |
showFilterInputs |
true | Whether to show filter inputs |
nonSelectedFilter |
'' | Initializes the dual listbox with a filter for the non selected elements. This is applied only if showFilterInputs is set to true |
selectedFilter |
'' | Initializes the dual listbox with a filter for the selected elements. This is applied only if showFilterInputs is set to true |
infoText |
'Showing all {0}' | Determines which string format to use when all options are visible. Set this to false to hide this information. Remember to insert the {0} placeholder. |
infoTextFiltered |
'Filtered {0} from {1}' | Determines which element format to use when some element is filtered. Remember to insert the {0} and {1} placeholders |
infoTextEmpty |
'Empty list' | Determines the string to use when there are no options in the list |
filterOnValues |
false | Set this to true to filter the options according to their values and not their HTML contents |
Methods
You can modify the behavior and aspect of the dual listbox by calling its methods, all of which accept a value
and a refresh
option. The value
determines the new parameter value, while refresh
(optional, defaults to false
) tells whether to update the plugin UI or not.
Note: when making multiple chained calls to the plugin, set refresh
to true
to the last call only, in order to make a unique UI change; alternatively, you can also call the refresh
method as your last one.
To call methods on the dual listbox instance, use the following syntax:
// Syntax
$(selector).bootstrapDualListbox(methodName, parameter);
Here are the available methods:
| Method | Description |
|---|---|
refresh() |
Update the plugin element UI |
destroy() |
Restore the original select element and delete the plugin element |
getContainer() |
Get the container element |
setBootstrap2Compatible(value, refresh) |
Change the bootstrap2Compatible parameter |
setFilterTextClear(value, refresh) |
Change the filterTextClear parameter |
setFilterPlaceHolder(value, refresh) |
Change the filterPlaceHolder parameter |
setMoveSelectedLabel(value, refresh) |
Change the moveSelectedLabel parameter |
setMoveAllLabel(value, refresh) |
Change the moveAllLabel parameter |
setRemoveSelectedLabel(value, refresh) |
Change the removeSelectedLabel parameter |
setRemoveAllLabel(value, refresh) |
Change the removeAllLabel parameter |
setMoveOnSelect(value, refresh) |
Change the moveOnSelect parameter |
setPreserveSelectionOnMove(value, refresh) |
Change the preserveSelectionOnMove parameter |
setSelectedListLabel(value, refresh) |
Change the selectedListLabel parameter |
setNonSelectedListLabel(value, refresh) |
Change the nonSelectedListLabel parameter |
setHelperSelectNamePostfix(value, refresh) |
Change the helperSelectNamePostfix parameter |
setSelectOrMinimalHeight(value, refresh) |
Change the selectOrMinimalHeight parameter |
setShowFilterInputs(value, refresh) |
Change the showFilterInputs parameter |
setNonSelectedFilter(value, refresh) |
Change the nonSelectedFilter parameter |
setSelectedFilter(value, refresh) |
Change the selectedFilter parameter |
setInfoText(value, refresh) |
Change the infoText parameter |
setInfoTextFiltered(value, refresh) |
Change the infoTextFiltered parameter |
setInfoTextEmpty(value, refresh) |
Change the infoTextEmpty parameter |
setFilterOnValues(value, refresh) |
Change the filterOnValues parameter |
Plugin info
| Property | Description |
|---|---|
| File name | duallistbox.min.js |
| Location | assets/js/plugins/forms/inputs/ |
| Updates | 0 |
| Links | Github project page |
Overview
Sometimes it is useful to format user input as they type. Existing libraries lacked proper functionality / flexibility. Formatter was built from the ground up with no dependencies. There is however a jquery wrapper version for quick use.
Usage
First you need to load jQuery library as Input formatter plugin is jQuery dependent. Then add a path to the plugin file:

Then initialize via JavaScript:
// Initialize
$('#credit-input').formatter({
'pattern': '{{999}}-{{999}}-{{999}}-{{9999}}',
'persistent': true
});
Options
| Option | Value | Description |
|---|---|---|
pattern |
'' |
Required. String representing the pattern of your formatted input. User input areas begin with
|
persistent |
false | Boolean representing if the formatted characters are always visible (persistent), or if they appear as you type |
patterns |
'Filter' | The placeholder for the input element for filtering elements |
moveSelectedLabel |
'' |
Optional, replaces
|
Methods
| Method | Description | |
|---|---|---|
| Class methods | ||
addInptType(char, regexp) |
Add regular expressions for different input types.
|
|
| Instance methods | ||
resetPattern(pattern) |
Fairly self explanatory here :) reset the pattern on an existing Formatter instance. Assuming you already initiated formatter on
|
Plugin info
| Property | Description |
|---|---|
| File name | formatter.min.js |
| Location | assets/js/plugins/forms/inputs/ |
| Updates | 0 |
| Links | Github project page |
Overview
This plugin integrates by default with Twitter bootstrap using badges to display the maximum length of the field where the user is inserting text. This plugin uses the HTML5 attribute maxlength
to work. The indicator badge shows up on focusing on the element, and disappears when the focus is lost.
Usage
First you need to load jQuery library as Bootstrap maxlength plugin is jQuery dependent. Then add a path to the plugin file:

Then initialize via JavaScript:
// Initialize
$('input[maxlength]').maxlength({
// options
});
Options
| Option | Default | Description |
|---|---|---|
alwaysShow |
false | If true the threshold will be ignored and the remaining length indication will be always showing up while typing or on focus on the input |
threshold |
10 | This is a number indicating how many chars are left to start displaying the indications |
warningClass |
label label-success | It's the class of the element with the indicator. By default is the bootstrap label label-success but can be changed to anything you'd like |
limitReachedClass |
label label-danger | It's the class the element gets when the limit is reached |
separator |
'/' | Represents the separator between the number of typed chars and total number of available chars |
preText |
'' | String of text that can be outputted in front of the indicator |
postText |
'' | String outputted after the indicator |
showMaxLength |
true | If false , will display just the number of typed characters, e.g. will not display the max length |
showCharsTyped |
true | If false , will display just the remaining length, e.g. will display remaining lenght instead of number of typed characters |
placement |
'bottom' | String, define where to output the counter. Possible values are: bottom, left, top, right, bottom-right, top-right, top-left, bottom-left and centered-right |
appendToParent |
'' | Appends the maxlength indicator badge to the parent of the input rather than to the body |
message |
'' | An alternative way to provide the message text, i.e. 'You have typed %charsTyped% chars, %charsRemaining% of %charsTotal% remaining'. %charsTyped%, %charsRemaining% and %charsTotal% will be replaced by the actual values. This overrides the options separator , preText , postText and showMaxLength . Alternatively you may supply a function that the current text and max length and returns the string to be displayed |
utf8 |
false | If true the input will count using utf8 bytesize/encoding. For example: the '£' character is counted as two characters |
twoCharLinebreak |
'' | Count linebreak as 2 characters to match IE/Chrome textarea validation |
customMaxAttribute |
'' | Allows a custom attribute to display indicator without triggering native maxlength behaviour. Ignored if value greater than a native maxlength attribute. 'overmax' class gets added when exceeded to allow user to implement form validation |
placement |
this |
String, object, or function, to define where to output the counter.
|
Events
| Event | Description |
|---|---|
maxlength.reposition |
On an input element triggers re-placing of its indicator. Useful if textareas are resized by an external trigger |
maxlength.shown |
Triggered when the indicator is displayed |
maxlength.hidden |
Triggered when the indicator is removed from view |
Plugin info
| Property | Description |
|---|---|
| File name | maxlength.min.js |
| Location | assets/js/plugins/forms/inputs/ |
| Updates | 0 |
| Links | Github project page |
Overview
You cant emphasize the importance of good passwords. Passy plugin was created to make it easier for developers to give good feedback on a password. Passy is a jQuery plugin to rate and generate passwords.
Usage
First you need to load jQuery library as Passy plugin is jQuery dependent. Then add a path to the plugin file:

Then initialize via JavaScript:
// Initialization example
$('input').passy(function( strength, valid ) {
// Set color based on validness and strength
if(valid) {
if( strength < $.passy.strength.HIGH) {
color = 'orange';
} else {
color = 'green';
}
} else {
color = 'red';
}
$(this).css('background-color', color);
});
Configuration
Before calling .passy(), you can alter these settings:
// Requirements a inserted password should meet
$.passy.requirements = {
// Character types a password should contain
characters: [
$.passy.character.DIGIT,
$.passy.character.LOWERCASE,
$.passy.character.UPPERCASE,
$.passy.character.PUNCTUATION
],
// A minimum and maximum length
length: {
min: 8,
max: Infinity
}
};
// Thresholds are numeric values representing
// the estimated amount of days for a single computer
// to brute force the password, assuming it processes
// about 1,000,000 passwords per second
$.passy.threshold = {
medium: 365,
high: Math.pow( 365, 2 ),
extreme: Math.pow( 365, 5 )
};
Methods
Generate a password of a specific length:
// 'Generate method'
$('input').passy('generate', 16);
Check if a field’s content is valid:
// 'Valid' method
if (
$('input').passy('valid')
)
{ ... }
Plugin info
| Property | Description |
|---|---|
| File name | passy.js |
| Location | assets/js/plugins/forms/inputs/ |
| Updates | 0 |
| Links | Github project page |
Overview
A mobile and touch friendly input spinner component for Bootstrap 3. It supports the mousewheel and the up/down keys.
Usage
First you need to load jQuery library as Touchspin plugin is jQuery dependent. Then add a path to the plugin file:

Create element:

<input id="demo1" type="text" value="55" name="demo1">
Then initialize via JavaScript:
// Initialization example
$("input[name='demo1']").TouchSpin({
min: 0,
max: 100,
step: 0.1,
decimals: 2,
boostat: 5,
maxboostedstep: 10,
postfix: '%'
});
Touchspin options
| Option | Default | Description |
|---|---|---|
initval |
"" | Applied when no explicit value is set on the input with the value attribute. Empty string means that the value remains empty on initialization. |
min |
0 | Minimum value. |
max |
100 | Maximum value. |
step |
1 | Incremental/decremental step on up/down change. |
forcestepdivisibility |
'round' | How to force the value to be divisible by step value: 'none' | 'round' | 'floor' | 'ceil' |
decimals |
0 | Number of decimal points. |
stepinterval |
100 | Refresh rate of the spinner in milliseconds. |
stepintervaldelay |
500 | Time in milliseconds before the spinner starts to spin. |
verticalbuttons |
false | Enables the traditional up/down buttons. |
verticalupclass |
'glyphicon glyphicon-chevron-up' | Class of the up button with vertical buttons mode enabled. |
verticaldownclass |
'glyphicon glyphicon-chevron-down' | Class of the down button with vertical buttons mode enabled. |
prefix |
"" | Text before the input. |
postfix |
"" | Text after the input. |
prefix_extraclass |
"" | Extra class(es) for prefix. |
postfix_extraclass |
"" | Extra class(es) for postfix. |
booster |
true | If enabled, the the spinner is continually becoming faster as holding the button. |
boostat |
10 | Boost at every nth step. |
maxboostedstep |
false | Maximum step when boosted. |
mousewheel |
true | Enables the mouse wheel to change the value of the input. |
buttondown_class |
'btn btn-default' | Class(es) of down button. |
buttonup_class |
'btn btn-default' | Class(es) of up button. |
Touchspin events
Triggered events
The following events are triggered on the original input by the plugin and can be listened on.
| Event | Description |
|---|---|
change |
Triggered when the value is changed with one of the buttons (but not triggered when the spinner hits the limit set by settings.min or settings.max . |
touchspin.on.startspin |
Triggered when the spinner starts spinning upwards or downwards. |
touchspin.on.startupspin |
Triggered when the spinner starts spinning upwards. |
touchspin.on.startdownspin |
Triggered when the spinner starts spinning downwards. |
touchspin.on.stopspin |
Triggered when the spinner stops spinning. |
touchspin.on.stopupspin |
Triggered when the spinner stops upspinning. |
touchspin.on.stopdownspin |
Triggered when the spinner stops downspinning. |
touchspin.on.min |
Triggered when the spinner hits the limit set by settings.min . |
touchspin.on.max |
Triggered when the spinner hits the limit set by settings.max . |
Callable events
The following events can be triggered on the original input. Example usage:
// 'upOnce' event
$("input").trigger("touchspin.uponce");
// 'updateSettings' event
$("input").trigger("touchspin.updatesettings", {
max: 1000
});
| Event | Description |
|---|---|
change |
Triggered when the value is changed with one of the buttons (but not triggered when the spinner hits the limit set by settings.min or settings.max . |
touchspin.on.startspin |
Triggered when the spinner starts spinning upwards or downwards. |
touchspin.on.startupspin |
Triggered when the spinner starts spinning upwards. |
touchspin.on.startdownspin |
Triggered when the spinner starts spinning downwards. |
touchspin.on.stopspin |
Triggered when the spinner stops spinning. |
touchspin.on.stopupspin |
Triggered when the spinner stops upspinning. |
touchspin.on.stopdownspin |
Triggered when the spinner stops downspinning. |
touchspin.on.min |
Triggered when the spinner hits the limit set by settings.min . |
touchspin.on.max |
Triggered when the spinner hits the limit set by settings.max . |
Plugin info
| Property | Description |
|---|---|
| File name | touchspin.min.js |
| Location | assets/js/plugins/forms/inputs/ |
| Updates | 0 |
| Links | Github project page |
Overview
Typeahead is a flexible JavaScript library that provides a strong foundation for building robust typeaheads. The typeahead.js
library consists of 2 components: the suggestion engine - Bloodhound, and the UI view - Typeahead. The suggestion engine is responsible for computing suggestions for a given query. The UI view is responsible for rendering suggestions and handling DOM interactions. Both components can be used separately, but when used together, they can provide a rich typeahead experience.
Main Typeahead features:
- Displays suggestions to end-users as they type
- Shows top suggestion as a hint (i.e. background text)
- Supports custom templates to allow for UI flexibility
- Works well with RTL languages and input method editors
- Highlights query matches within the suggestion
- Triggers custom events to encourage extensibility
Usage
Load library itself, Bloodhound engine is already integrated to the main file:

Create element:

<input class="typeahead" type="text" placeholder="States of USA">

Then initialize via JavaScript:
// Initialization example
$('.typeahead').typeahead({
minLength: 3,
highlight: true
},
{
name: 'my-dataset',
source: mySource
});
Typeahead options
| Option | Default | Description |
|---|---|---|
highlight |
false | If true , when suggestions are rendered, pattern matches for the current query in text nodes will be wrapped in a strong element with its class set to {{classNames.highlight}} |
hint |
true | If false , the typeahead will not show a hint |
minLength |
1 | The minimum character length needed before suggestions start getting rendered |
classNames |
'' | For overriding the default class names used |
Typeahead datasets
A typeahead is composed of one or more datasets. When an end-user modifies the value of a typeahead, each dataset will attempt to render suggestions for the new value.
For most use cases, one dataset should suffice. It's only in the scenario where you want rendered suggestions to be grouped based on some sort of categorical relationship that you'd need to use multiple datasets. For example, on twitter.com, the search typeahead groups results into recent searches, trends, and accounts – that would be a great use case for using multiple datasets.
Datasets can be configured using the following options:
| Option | Description |
|---|---|
source |
[Required]. The backing data source for suggestions. Expected to be a function with the signature (query , syncResults , asyncResults ). syncResults should be called with suggestions computed synchronously and asyncResults should be called with suggestions computed asynchronously (e.g. suggestions that come for an AJAX request). source can also be a Bloodhound instance |
async |
Lets the dataset know if async suggestions should be expected. If not set, this information is inferred from the signature of source i.e. if the source function expects 3 arguments, async will be set to true |
name |
The name of the dataset. This will be appended to {{classNames.dataset}} - to form the class name of the containing DOM element. Must only consist of underscores, dashes, letters (a-z ), and numbers. Defaults to a random number |
limit |
The max number of suggestions to be displayed. Defaults to 5 |
display |
For a given suggestion, determines the string representation of it. This will be used when setting the value of the input control after a suggestion is selected. Can be either a key string or a function that transforms a suggestion object into a string. Defaults to stringifying the suggestion |
templates |
A hash of templates to be used when rendering the dataset. Note a precompiled template is a function that takes a JavaScript object as its first argument and returns a HTML string |
[templates] notFound |
Rendered when 0 suggestions are available for the given query. Can be either a HTML string or a precompiled template. If it's a precompiled template, the passed in context will contain query |
[template] pending |
Rendered when 0 synchronous suggestions are available but asynchronous suggestions are expected. Can be either a HTML string or a precompiled template. If it's a precompiled template, the passed in context will contain query |
[template] header |
Rendered at the top of the dataset when suggestions are present. Can be either a HTML string or a precompiled template. If it's a precompiled template, the passed in context will contain query and suggestions |
[template] footer |
Rendered at the bottom of the dataset when suggestions are present. Can be either a HTML string or a precompiled template. If it's a precompiled template, the passed in context will contain query and suggestions |
[template] suggestion |
Used to render a single suggestion. If set, this has to be a precompiled template. The associated suggestion object will serve as the context. Defaults to the value of display wrapped in a div tag i.e.
{{value}}
 |
Custom events
The following events get triggered on the input element during the life-cycle of a typeahead. Note: Every event does not supply the same arguments. See the event descriptions below for details on each event's argument list.
| Event | Description |
|---|---|
typeahead:active |
Fired when the typeahead moves to active state |
typeahead:idle |
Fired when the typeahead moves to idle state |
typeahead:open |
Fired when the results container is opened |
typeahead:close |
Fired when the results container is closed |
typeahead:change |
Normalized version of the native change event. Fired when input loses focus and the value has changed since it originally received focus |
typeahead:render |
Fired when suggestions are rendered for a dataset. The event handler will be invoked with 4 arguments: the jQuery event object, the suggestions that were rendered, a flag indicating whether the suggestions were fetched asynchronously, and the name of the dataset the rendering occurred in |
typeahead:select |
Fired when a suggestion is selected. The event handler will be invoked with 2 arguments: the jQuery event object and the suggestion object that was selected |
typeahead:autocomplete |
Fired when a autocompletion occurs. The event handler will be invoked with 2 arguments: the jQuery event object and the suggestion object that was used for autocompletion |
typeahead:cursorchange |
Fired when the results container cursor moves. The event handler will be invoked with 2 arguments: the jQuery event object and the suggestion object that was moved to |
typeahead:asyncrequest |
Fired when an async request for suggestions is sent. The event handler will be invoked with 3 arguments: the jQuery event object, the current query, and the name of the dataset the async request belongs to |
typeahead:asynccancel |
Fired when an async request is cancelled. The event handler will be invoked with 3 arguments: the jQuery event object, the current query, and the name of the dataset the async request belonged to |
typeahead:asyncreceive |
Fired when an async request completes. The event handler will be invoked with 3 arguments: the jQuery event object, the current query, and the name of the dataset the async request belongs to |
Example usage:
// Events usage
$('.typeahead').bind('typeahead:select', function(ev, suggestion) {
console.log('Selection: ' + suggestion);
});
Class Names
| Class | Defaults | Description |
|---|---|---|
input |
.tt-input | Added to input that's initialized into a typeahead |
hint |
.tt-hint | Added to hint input |
menu |
.tt-menu | Added to menu element |
dataset |
tt-dataset | Added to dataset elements |
suggestion |
tt-suggestion | Added to suggestion elements |
empty |
.tt-empty | Added to menu element when it contains no content |
open |
.tt-open | Added to menu element when it is opened |
cursor |
.tt-cursor | Added to suggestion element when menu cursor moves to said suggestion |
highlight |
.tt-highlight | Added to the element that wraps highlighted text |
To override any of these defaults, you can use the classNames
option:
// Override class names
$('.typeahead').typeahead({
classNames: {
input: 'Typeahead-input',
hint: 'Typeahead-hint',
selectable: 'Typeahead-selectable'
}
});
Plugin info
| Property | Description |
|---|---|
| File name | typeahead.bundle.min.js, handlebars.js |
| Location | assets/js/plugins/forms/inputs/typeahead/ |
| Updates | 0 |
| Links | Github project page |
Overview
This jQuery plugin makes simple clientside form validation easy, whilst still offering plenty of customization options. It makes a good choice if you’re building something new from scratch, but also when you’re trying to integrate something into an existing application with lots of existing markup.
The plugin comes bundled with a useful set of validation methods, including URL and email validation, while providing an API to write your own methods. All bundled methods come with default error messages in english and translations into 37 other languages
Usage
Include the following lines of code in the
section of your HTML:

Select a form to validate and call the validate method:

<form class="validate" id="commentForm" method="get" action="">
<fieldset>
<legend>Please provide your name, email address (won't be published) and a comment</legend>

Name (required, at least 2 characters)
<input id="cname" name="name" minlength="2" type="text" required="required'">

</fieldset>
</form>
Finally call the plugin via JavaScript:
// Basic initialization
$("#commentForm").validate({
// options
});
Validate options
| Name | Default | Description |
|---|---|---|
debug |
false | Enables debug mode. If true, the form is not submitted and certain errors are displayed on the console (will check if a window.console property exists). Try to enable when a form is just submitted instead of validation stopping the submit |
submitHandler |
native form submit | Callback for handling the actual submit when the form is valid. Gets the form as the only argument. Replaces the default submit. The right place to submit a form via Ajax after it is validated |
invalidHandler |
{} | Callback for custom code when an invalid form is submitted. Called with an event object as the first argument, and the validator as the second |
ignore |
":hidden" | Elements to ignore when validating, simply filtering them out. jQuery's not-method is used, therefore everything that is accepted by not() can be passed as this option. Inputs of type submit and reset are always ignored, so are disabled elements |
rules |
read from markup (classes, attributes, data) | Key/value pairs defining custom rules. Key is the name of an element (or a group of checkboxes/radio buttons), value is an object consisting of rule/parameter pairs or a plain String . Can be combined with class/attribute/data rules. Each rule can be specified as having a depends-property to apply the rule only in certain conditions |
messages |
Default message for the method used | Key/value pairs defining custom messages. Key is the name of an element, value the message to display for that element. Instead of a plain message, another map with specific messages for each rule can be used. Overrides the title attribute of an element or the default message for the method (in that order). Each message can be a String or a Callback . The callback is called in the scope of the validator, with the rule's parameters as the first argument and the element as the second, and must return a String to display as the message |
groups |
[] | Specify grouping of error messages. A group consists of an arbitrary group name as the key and a space separated list of element names as the value. Use errorPlacement to control where the group message is placed |
onsubmit |
true | Validate the form on submit. Set to false to use only other events for validation. Set to a Function to decide for yourself when to run validation. A boolean true is not a valid value |
onfocusout |
{} | Validate elements (except checkboxes/radio buttons) on blur . If nothing is entered, all rules are skipped, except when the field was already marked as invalid. Set to a Function to decide for yourself when to run validation. A boolean true is not a valid value |
onkeyup |
{} | Validate elements on keyup . As long as the field is not marked as invalid, nothing happens. Otherwise, all rules are checked on each key up event. Set to false to disable. Set to a Function to decide for yourself when to run validation. A boolean true is not a valid value |
onclick |
{} | Validate checkboxes and radio buttons on click . Set to false to disable. Set to a Function to decide for yourself when to run validation. A boolean true is not a valid value |
focusInvalid |
true | Focus the last active or first invalid element on submit via validator.focusInvalid() . The last active element is the one that had focus when the form was submitted, avoiding stealing its focus. If there was no element focused, the first one in the form gets it, unless this option is turned off |
focusCleanup |
false | If enabled, removes the errorClass from the invalid elements and hides all error messages whenever the element is focused. Avoid combination with focusInvalid |
errorClass |
'error' | Use this class to create error labels, to look for existing error labels and to add it to invalid elements |
validClass |
'valid' | This class is added to an element after it was validated and considered valid |
errorElement |
'label' | Use this element type to create error messages and to look for existing error messages. The default, "label" , has the advantage of creating a meaningful link between error message and invalid field using the for attribute (which is always used, regardless of element type) |
wrapper |
'window' | Wrap error labels with the specified element. Useful in combination with errorLabelContainer to create a list of error messages |
errorLabelContainer |
- | Hide and show this container when validating |
errorContainer |
- | Hide and show this container when validating |
showErrors |
{} | A custom message display handler. Gets the map of errors as the first argument and an array of errors as the second, called in the context of the validator object. The arguments contain only those elements currently validated, which can be a single element when doing validation onblur/keyup. You can trigger (in addition to your own messages) the default behaviour by calling this.defaultShowErrors() |
errorPlacement |
After the invalid element | Customize placement of created error labels. First argument: The created error label as a jQuery object. Second argument: The invalid element as a jQuery object |
success |
- | If specified, the error label is displayed to show a valid element. If a String is given, it is added as a class to the label. If a Function is given, it is called with the label (as a jQuery object) and the validated input (as a DOM element). The label can be used to add a text like "ok!" |
highlight |
Adds errorClass to the element | How to highlight invalid fields. Override to decide which fields and how to highlight |
unhighlight |
Removes the errorClass | Called to revert changes made by option highlight , same arguments as highlight |
ignoreTitle |
false | Set to skip reading messages from the title attribute, helps to avoid issues with Google Toolbar; default is false for compability, the message-from-title is likely to be completely removed in a future release |
Plugin methods
This library adds three jQuery plugin methods, the main entry point being the validate
method:
| Method | Description |
|---|---|
validate() |
Validates the selected form |
valid() |
Checks whether the selected form or selected elements are valid |
rules() |
Read, add and remove rules for an element |
Custom selectors
This library also extends jQuery with three custom selectors:
| Method | Description |
|---|---|
:blank |
Selects all elements with a blank value |
:filled |
Selects all elements with a filled value |
:unchecked |
Selects all elements that are unchecked |
Validator
The validate method returns a Validator object that has a few public methods that you can use to trigger validation programmatically or change the contents of the form. The validator object has more methods, but only those documented here are intended for usage.
| Method | Description |
|---|---|
Validator.form() |
Validates the form |
Validator.element() |
Validates a single element |
Validator.resetForm() |
Resets the controlled form |
Validator.showErrors() |
Show the specified messages |
Validator.numberOfInvalids() |
Returns the number of invalid fields |
jQuery.validator.addMethod() |
Add a custom validation method |
jQuery.validator.format() |
Replaces {n} placeholders with arguments |
jQuery.validator.setDefaults() |
Modify default settings for validation |
jQuery.validator.addClassRules() |
Add a compound class method |
Built-in Validation methods
A set of standard validation methods is provided:
| Method | Description |
|---|---|
required |
Makes the element required |
remote |
Requests a resource to check the element for validity |
minlength |
Makes the element require a given minimum length |
maxlength |
Makes the element require a given maxmimum length |
rangelength |
Makes the element require a given value range |
min |
Makes the element require a given minimum |
max |
Makes the element require a given maximum |
range |
Makes the element require a given value range |
email |
Makes the element require a valid email |
url |
Makes the element require a valid url |
date |
Makes the element require a date |
dateISO |
Makes the element require an ISO date |
number |
Makes the element require a decimal number |
digits |
Makes the element require digits only |
creditcard |
Makes the element require a credit card number |
equalTo |
Requires the element to be the same as another one |
Some more methods are provided as add-ons, and are currently included in additional-methods.js in the download package. Not all of them are documented here:
| Method | Description |
|---|---|
accept |
Makes a file upload accept only specified mime-types |
extension |
Makes the element require a certain file extension |
phoneUS |
Validate for valid US phone number |
require_from_group |
Ensures a given number of fields in a group are complete |
Plugin info
| Property | Description |
|---|---|
| File name | validate.min.js |
| Location | assets/js/plugins/forms/validation/ |
| Updates | 0 |
| Links | Github project page |
Overview
Bootstrap Tags Input is a jQuery plugin providing a Twitter Bootstrap user interface for managing tags. Integrates with Twitter Bootstraps' 2.3.2 typeahead, or use custom typeahead when using Bootstrap 3.
Main features:
- Objects as tags
- True multi value
- Typeahead
- Designed for Bootstrap 2.3.2 and 3
Usage
The plugin is jQuery and Bootstrap dependent. Include the following lines of code in the
section of your HTML:

Create an HTML element with id
, class
, or name
attributes:

<input type="text" value="Amsterdam, Washington, Sydney, Beijing" class="tags-input">
Finally call the plugin via JavaScript:
// Basic initialization
$('.tags-input').tagsinput({
// options
});
Plugin options
| Name | Description |
|---|---|
tagClass |
Classname for the tags, or a function returning a classname |
itemValue |
When adding objects as tags, itemValue must be set to the name of the property containing the item's value, or a function returning an item's value |
itemText |
When adding objects as tags, you can set itemText to the name of the property of item to use for a its tag's text. You may also provide a function which returns an item's value. When this options is not set, the value of itemValue will be used |
confirmKeys |
Array of keycodes which will add a tag when typing in the input. (default: [13, 188] , which are ENTER and comma) |
maxTags |
When set, no more than the given number of tags are allowed to add (default: undefined ). When maxTags is reached, a class 'bootstrap-tagsinput-max' is placed on the tagsinput element |
maxChars |
Defines the maximum length of a single tag. (default: undefined ) |
trimValue |
When true , automatically removes all whitespace around tags. (default: false ) |
allowDuplicates |
When true , the same tag can be added multiple times. (default: false ) |
freeInput |
Allow creating tags which are not returned by typeahead's source (default: true ). This is only possible when using string as tags. When itemValue option is set, this option will be ignored |
typeahead |
Object containing typeahead specific options |
[typeahead] source |
An array (or function returning a promise or array), which will be used as source for a typeahead |
onTagExists |
Function invoked when trying to add an item which allready exists. By default, the existing tag hides and fades in |
Plugin methods
Example usage:
// Method usage example
$('input').tagsinput('add', 'some tag');
Available methods
| Method | Description |
|---|---|
add |
Adds a tag |
remove |
Removes a tag |
removeAll |
Removes all tags |
focus |
Sets focus in the tagsinput |
input |
Returns the tagsinput's internal <input /> , which is used for adding tags. You could use this to add your own typeahead behaviour for example |
refresh |
Refreshes the tags input UI. This might be usefull when you're adding objects as tags. When an object's text changes, you'll have to refresh to update the matching tag's text |
destroy |
Removes tagsinput behaviour |
Plugin events
Example usage:
// Event usage example
$('input').on('beforeItemAdd', function(event) {
// event.item: contains the item
// event.cancel: set to true to prevent the item getting added
});
Available events
| Method | Description |
|---|---|
beforeItemAdd |
Triggered just before an item gets added |
itemAdded |
Triggered just after an item got added |
beforeItemRemove |
Triggered just before an item gets removed |
itemRemoved |
Triggered just after an item got removed |
Plugin info
| Property | Description |
|---|---|
| File name | tagsinput.min.js |
| Location | assets/js/plugins/forms/tags/ |
| Updates | 0 |
| Links | Github project page |
Overview
Advanced tagging/tokenizing plugin for jQuery and Twitter Bootstrap with a focus on keyboard and copy-paste support. Also supports validation states, typeahead implementation, different sizes and states, form layouts, directions, copy and paste, width options and other features.
Core features:
- Copy & paste tokens with Ctrl+C and Ctrl+V
- Keyboard navigation, delete tokens with keyboard (arrow keys, Shift + arrow keys)
- Select specific tokens with Ctrl + click and Shift + click
- Twitter Typeahead and jQuery UI Autocomplete support
Usage
The plugin is jQuery and Bootstrap (CSS only) dependent. Include the following lines of code in the
section of your HTML:

Create an HTML element:

<input type="text" class="form-control" id="tokenfield-typeahead" value="red,green,blue">
Finally call the plugin via JavaScript:
// Basic initialization
$('.tokenfield').tokenfield({
// options
});
Plugin options
Options for individual tokenfields can alternatively be specified through the use of data attributes, as explained below:
| Name | Default | Description |
|---|---|---|
tokens |
[] | Tokens (or tags). Can be a string with comma-separated values, an array of strings or an array of objects |
limit |
0 | Maximum number of tokens allowed. 0 = unlimited |
minLength |
0 | Minimum length required for token value |
minWidth |
60 | Minimum input field width. In pixels |
autocomplete |
{} | jQuery UI Autocomplete options |
showAutocompleteOnFocus |
false | Whether to show autocomplete suggestions menu on focus or not. Works only for jQuery UI Autocomplete, as Typeahead has no support for this kind of behavior |
typeahead |
[] | Arguments for Twitter Typeahead. The first argument should be an options hash (or null if you want to use the defaults). The second argument should be a dataset . Multiple datasets are also supported |
createTokensOnBlur |
false | Whether to turn input into tokens when tokenfield loses focus or not |
delimiter |
',' | A character or an array of characters that will trigger token creation on keypress event. Defaults to ',' (comma). Note - this does not affect Enter or Tab keys, as they are handled in the keydown event. The first delimiter will be used as a separator when getting the list of tokens or copy-pasting tokens |
beautify |
true | Whether to insert spaces after each token when getting a comma-separated list of tokens |
inputType |
'text' | HTML type attribute for the token input. This is useful for specifying an HTML5 input type like 'email' , 'url' or 'tel' which allows mobile browsers to show a specialized virtual keyboard optimized for different types of input. This only sets the type of the visible token input, but does not touch the original input field. So you may set the original input to have type="text" but set this inputType option to 'email' if you only want to take advantage of the email style keyboard on mobile, but don't want to enable HTML5 native email validation on the original hidden input |
Plugin methods
Example usage:
// Method usage example
$('#myField').tokenfield('createToken', {
value: 'violet',
label: 'Violet'
});
Available methods
| Method | Description |
|---|---|
.tokenfield(options) |
Initializes an input with a tokenfield |
.tokenfield('setTokens', tokens) |
Manually set the tokenfield content (replacing the old content) |
.tokenfield('createToken', token) |
Manually create a token and append it to the input |
.tokenfield('getTokens', active) |
Get an array of tokens from the input. Set active to true to return only selected tokens |
.tokenfield('getTokensList', delimiter, beautify, active) |
Get a comma-separated list of the tokens from the input. You can use an alternative separator by supplying also a delimiter argument. Setting beautify to false will prevent adding a space after each token. Set active to true to return only selected tokens |
.tokenfield('disable') |
Disable tokenfield (just like a normal input field) |
.tokenfield('enable') |
Enable tokenfield (just like a normal input field) |
.tokenfield('readonly') |
Make tokenfield a readonly field (just like a normal input field) |
.tokenfield('writeable') |
Make tokenfield writeable (just like a normal input field) |
.tokenfield('destroy') |
Destroy tokenfield and restore original input |
Plugin events
Tokenfield exposes a few events for hooking into it's functionality. Example usage:
// Event usage example
$('#tokenfield').on('tokenfield:createtoken', function (e) {
var data = e.attrs.value.split('|')
e.attrs.value = data[1] || data[0]
e.attrs.label = data[1] ? data[0] + ' (' + data[1] + ')' : data[0]
});
Available events
| Method | Description |
|---|---|
tokenfield:initialize |
Fires after Tokenfield has been initialized |
tokenfield:createtoken |
This event fires when a token is all set up to be created, but before it is inserted into the DOM and event listeners are attached. You can use this event to manipulate token value and label by changing the appropriate values of attrs property of the event. Calling event.preventDefault() or doing return false in the event handler will prevent the token from being created |
tokenfield:createdtoken |
This event is fired after the token has been created. Here, attrs property of the event is also available, but is basically read-only. You can also get a direct reference to the token DOM object via e.relatedTarget |
tokenfield:edittoken |
This event is fired just before a token is about to be edited. This allows you to manipluate the input field value before it is created. Again, to do this, manipluate the attrs property of the event. Here you can also access the token DOM object with e.relatedTarget . Calling event.preventDefault() or doing return false in the event handler will prevent the token from being edited |
tokenfield:editedtoken |
This event is fired when a token is ready for being edited. It means that the token has been replaced by an input field |
tokenfield:removetoken |
This event is fired right before a token is removed. Here you can also access the token DOM object with e.relatedTarget . Calling event.preventDefault() or doing return false in the event handler will prevent the token from being removed. You can access token label and value by checking the attrs property of the event. Also, e.relatedTarget is a reference to the token DOM object |
tokenfield:removedtoken |
This event is fired right after a token is removed from the DOM. You can access token label and value by checking the attrs property of the event |
Plugin info
| Property | Description |
|---|---|
| File name | tokenfield.min.js |
| Location | assets/js/plugins/forms/tags/ |
| Updates | 0 |
| Links | Github project page |


WITNESS LIST
Criminal Justice
September 22, 2015 10:00 AM
Jail Safety Standards
FOR:
Esparza, Maria Anna (Self), Spring Branch, TX
ON:
Brown, Veda (Self), Prairie View, TX
Claitor, Diana Director (Texas Jail Project), Austin, TX
Deitch, Michele Senior Lecturer (also providing written testimony) (Self), Austin, TX
Fabelo, Tony Dr. (also providing written testimony) (Council on State Governments,
Justice Center), Austin, TX
Gann, Laura (also providing written testimony) (Montgomery County Jail Advocates),
Humble, TX
Gray III, John F (Daughter Victoria Gray), Lake Jackson, TX
Gutierrez, David Chair (Board of Pardons and Parole), Gatesville, TX
Lacefield-Lewis, Lauren Assistant Commissioner for Mental health and Substance abuse
(Department of State health Service), Austin, TX
McClelland, Charles Chief (Houston Police Department), Houston, TX
Richardson, Kent Assistant attorney General (also providing written testimony) (Office of
the Attorney General), Austin, TX
Rowe, Kelly Sheriff (Sheriff's Association of Texas), Lubbock, TX
Thompson, Sandra Professor (also providing written testimony) (Self; U of H Law),
Houston, TX
Vickers, Kim Executive Director (Texas Commission on Law Enforcement), Austin, TX
White, Gloria (Self), Bay City, TX
Wood, Brandon Executive Director (Texas Commission on Jail Standards), Austin, TX


One of the goals of MPI was to allow for layered libraries. In order for a library to do this cleanly, it needs to know if MPI is active. In MPI the function MPI_INITIALIZED was provided to tell if MPI had been initialized. The problem arises in knowing if MPI has been finalized. Once MPI has been finalized it is no longer active and cannot be restarted. A library needs to be able to determine this to act accordingly. To achieve this the following function is needed:
| MPI_FINALIZED(flag) | |
| OUT flag | true if MPI was finalized (logical) |
int MPI_Finalized(int *flag)
MPI_FINALIZED(FLAG, IERROR)
LOGICAL FLAG
INTEGER IERROR
{ bool MPI::Is_finalized() (binding deprecated, see Section Deprecated since MPI-2.2
) }
This routine returns true if MPI_FINALIZE has completed.
It is legal to call MPI_FINALIZED
before MPI_INIT and after MPI_FINALIZE.
MPI is ``active'' and it is thus safe to call MPI functions if
MPI_INIT has completed and MPI_FINALIZE
has not completed. If a library has no other way of knowing whether
MPI is active or not, then it can use MPI_INITIALIZED and
MPI_FINALIZED to determine this. For example, MPI is ``active''
in callback functions that are invoked during MPI_FINALIZE.
( End of advice to users.)
Advice to users.
Up: Startup
Next: Portable MPI Process Startup
Previous: Allowing User Functions at Process Termination
Return to MPI-2.2 Standard Index
Return to MPI Forum Home Page
(Unofficial) MPI-2.2 of September 4, 2009
HTML Generated on September 10, 2009


ASN1Collection
public class ASN1Collection : ASN1
Superclass for ASN1Sequence and ASN1Set
-
Get collection
Declaration
Swift
public func getValue() -> [ASN1]
Return Value
Value of self
-
Add a value to a collection
Declaration
Swift
public func add(_ asn1: ASN1) -> ASN1Collection
Parameters
asn1
Value to add
Return Value
self
-
Get a value from a collection
Declaration
Swift
public func get(_ i: Int) -> ASN1
Parameters
i
Index of value to get
Return Value
Value at index
-
Remove a value from a collection - a set or a sequence. Note that a set is sorted by its element’s tags, so a set element’s index may not match the order in which it was inserted
Declaration
Swift
public func remove(_ i: Int)
Parameters
i
Index of value to remove


Select an option below to take or create a quiz:
Quiz-O-Matic allows you to create a quiz or "would you rather" which you can share with your friends and the internet.
Browse through and take different quizes others have create.


All Classes
-
All Classes Interface Summary Class Summary Enum Summary Exception Summary Class Description AlphaNumGridView AlphaNumGridView.ConstraintType AlphaNumKeys AlphaNumKeysController This controller gives the operating elements of an instance ofAlphaNumKeys
a function and links the simulation of the keyboard to the encapsulated scene.ArrayUtils BaseSpinner Spinner for choosing the base of a numeral system.BasicMenuBar Basic MenuBar containing the MenuItems that are generally required.BasicMenuController BitchangerLauncher This class contains the main method that is the entry point for the application.BitchangerLauncher.ErrorLevel BitLength BitoperationController BitoperationMenuBar BitoperationMenuController BitoperationView CalcPathView CalcPathViewController Calculation<T extends Number> CalculationControllerBase<T extends CalculationViewBase> CalculationControllerBase.Operation CalculationViewBase CalculatorController CalculatorView ChangeableNumber Interface that defines methods to convert numbers from any numeral system into another numeral systemComma Enumeration of the wrapper class, that represents the character for a comma.Controllable Interface that defines methods to connect a controllable with a controller.ControllableApplication Interface that defines methods to connect a Application with a controller.Controller Interface for defining a controller.ControllerBase<T extends Controllable> ConversionStep ConverterController Controller that provides the function for a ConverterView.ConverterMenuBar ConverterMenuController ConverterView ConvertingNumbers TheConvertingNumbers
class contains methods for performing conversions of numbers with different numeral systems.FXUtils Utility class to handle objects whose belong to the user interface.HornersMethod IconFactory IEEEController IEEEMenuBar IEEEMenuController IEEEStandard IEEEView InformationDialog InformationDialog.InformationType LongDivision Multiplication NumberOverflowException Preferences Preferences is the global collection for all possible settings that can be selected for the bitchanger.PrimaryFXApp Main window of the application with javaFXResources SimpleChangeableNumber The class SimpleChangeableNumber offers a complete implementation ofChangeableNumber
.Style Enum of different styles that are available as CSS files for javaFXStyleableLabel SVGIcon TablePane TablePane.StackCell TriConsumer<T,U,V> Represents an operation that accepts three input arguments and returns no result.TwosComplement UnfocusedButton Button that does not get focus by clicking and has a rectangle without rounded corners as basic form.ValueButton UnfocusedButton with an extra Property to adjust the base.ValueField Text field in which a number of a certain numeral system can be entered.Viewable The interfaceViewable
defines the base for a view.ViewBase<T extends javafx.scene.Parent> WritableBooleanProperty WritableClassProperty<T> WritableDoubleProperty WritableEnumProperty<E extends Enum<E>> WritableIntegerProperty WritableObjectPropertyBase<T> WritableStringProperty XMLWritable


Legal Notice
Registered Office
Munster Rugby
Musgrave Park
Cork
Ireland
Privacy Policy
At the MUNSTER RUGBY we are committed to protecting your privacy & security. Please read our Privacy Policy carefully so that you are aware of the steps we take to protect you privacy, what information we collect and how we use it now or may use it in the future.
Controllers of Information
Any personal information provided to or gathered by irishrugby.ie or Munster Rugby.ie is controlled by MUNSTER RUGBY, Registered Office 10 Munster Rugby, Musgrave Park, Cork, Ireland.
What Information do we collect? How do we use it?
When you order over our website we need to know your name, e-mail address, delivery address, credit or debit card number, expiry date (and valid from date and issue number for Switch cards). This allows us to process and fulfil your orders and to notify you of the status of your order. You will find that it is not compulsory to provide us with any additional information we request which is not necessary or reasonable in order to complete your transaction.
We also ask for your telephone number which enables us to contact you urgently if there is a problem with your order. We will give your name and address to our couriers and we may also give them your telephone number to aid the delivery of your order.
When you register on the website or, during the process of purchasing goods from the website and choose to receive further information from us, we may use the information you provide us with for the following purposes:
• We monitor customer traffic patterns and site usage to help us to develop the design and layout of the website.
• Personal details may be for purposes such as notifying you of MUNSTER RUGBY news, events, fixture, ticket, merchandising and player information which we think may be of interest to you.
• The MUNSTER RUGBY will not put any information about you on general release nor will it sell such information to organisations not associated with the MUNSTER RUGBY. Personal data will not be transferred outside of the European Economic Area.
We employ other companies and individuals to perform functions on our behalf such as delivering packages, analysing data, providing marketing assistance, processing credit card payments and designing and operating our website. Such companies and individuals have access to your personal information for the purpose of carrying out this work only. These enterprises will not use your data for any other purpose. Under no circumstances will these enterprises use any additional data about you to which they are party for any other purposes.
Cookies
EU Cookie directive
From 26 May 2011 a new European Union directive requires us to gain the consent of our users to download cookies on to their machines. There are various methods we could use to gain users consent. For example, we could use pop-ups; prompting users to tick a box to confirm they give permission for us to download cookies on their machine.
Alternatively, we could use an online form that all users must complete before using the website.
We consider both of these solutions as obtrusive. We want our users find information and services quickly.
Therefore, we have taken the decision to promote how we use cookies on our website instead. This will enable users to make an informed decision whether they want to disable this feature.
There are links on our terms and conditions and disclaimer pages which are in the footer of every web page pointing to this information.
What is a Cookie
Information may be sent to your computer in the form of an Internet “cookie” to allow our servers to monitor your requirements. The cookie is stored on your computer. Our server may request that your computer return a cookie to it.
These return cookies do not contain any information supplied by you or any personally identifiable information about you. However, we use cookies to keep track of your shopping cart when you are using the Munster Rugby Store Online.
Such measures are necessary to allow Munster Rugby to measure the usability of the systems, which will help to continually improve user experience of our websites. Your browser software should however enable you to block cookies if you wish to. For more information about cookies, please visit http://www.allaboutcookies.org/.
Strictly Necessary Cookies
These cookies are essential in order to enable you to move around the website and use its features, such as accessing secure areas of the website. Without these cookies services you have asked for, like shopping baskets or e-billing, cannot be provided.
Performance Cookies
These cookies collect information about how visitors use a website, for instance which pages visitors go to most often, and if they get error messages from web pages. These cookies don’t collect information that identifies a visitor. All information these cookies collect is aggregated and therefore anonymous. It is only used to improve how a website works.
Functionality Cookies
These cookies allow the website to remember choices you make (such as your user name, language or the region you are in) and provide enhanced, more personal features. For instance, a website may be able to provide you with local weather reports or traffic news by storing in a cookie the region in which you are currently located.
These cookies can also be used to remember changes you have made to text size, fonts and other parts of web pages that you can customise. They may also be used to provide services you have asked for such as watching a video or commenting on a blog. The information these cookies collect may be anonymised and they cannot track your browsing activity on other websites.
Targeting or Advertising Cookies
These cookies are used to deliver adverts more relevant to you and your interests They are also used to limit the number of times you see an advertisement as well as help measure the effectiveness of the advertising campaign. They are usually placed by advertising networks with the website operator’s permission. They remember that you have visited a website and this information is shared with other organisations such as advertisers. Quite often targeting or advertising cookies will be linked to site functionality provided by the other organisation.
Google Analytics
Munster Rugby uses Google Analytics, a web analytics service provided by Google. Google Analytics collects first party cookies, which are text files placed on your computer to collect standard internet log information and visitor behaviour. This information is sent to Google and is used to evaluate how our website is being used. This enables Munster Rugby to compile statistical reports. A full list of cookies used by Google Analytics and explanations on how these work are available on the Google code website.
Munster Rugby does not collect (nor allow any third party to collect) personally identifiable information of visitors to our site. We will not associate any data gathered with any personally identifying information. We will not link or seek to link an IP address with the identity of a computer user. In short, Google Analytics doesn’t identify who you are, but it does track your movements on our websites.
How to disable cookies
You can stop cookies being downloaded on to your computer by selecting the appropriate settings on your browser. However please note that if you do this you may not be able to use the full functionality of this website.
There is more information about cookies, including how to delete them on the website aboutcookies.org. You may also opt out of being tracked by Google Analytics.
Consent
By using our website you consent to collection and use of any information you provide to us by Munster Rugby Limited for the purposes described above. If we amend our privacy policy, any changes will be published on this web site. If at any time you wish to update the information which we hold about you, or if you wish to stop receiving information from Munster Rugby, please contact us.
Disclaimer
The MUNSTER RUGBY recognise that we have legal obligations in terms of the collection and use of personal data made available to us. This website is provided on an “AS IS” basis and the MUNSTER RUGBY excludes all warranties or representations of any kind with respect to this website or its contents. In particular, the MUNSTER RUGBY does not warrant or represent that the information contained on this website is accurate or up to date.
The contents of this website are designed to comply with Irish law. You may be viewing the website in a market in which we do not commonly sell our goods. The MUNSTER RUGBY cannot be held responsible for non-compliance with any local advertising or other laws in relation to this website or its contents.
Your Consent
By using our website you consent to collection and use of any information you provide to us bythe MUNSTER RUGBY for the purposes described above. If we decide to change our privacy policy, we will post those changes on this page. We recommend you re-visit this page periodically to check for changes. We endeavour to take all reasonable steps to protect your personal data including the use of encryption technology, but cannot guarantee the security of any data you disclose online. You accept the inherent security implications of sending information over the Internet and will not hold us responsible for any breach of security unless we have been negligent.
If you are under the age of 18 you may register on the website to receive newsletters and other information but only with parental or guardian consent. You may only make purchases on this website if you are aged 18 or over or, if under 18, have received parental or guardian consent.


{% extends 'core.html' %} {% load i18n %} {% load ahmia_custom %} {% block title %}{% trans "Hidden Service Blacklist" %} — Ahmia{% endblock %} {% block extra_js %} {% endblock %} {% block body %} {% include 'partial/nav_tor.html' with nav_type='maxi' %}
{% blocktrans %} Ahmia blacklists sites containing child abuse material from its index. This list contains a masked version of all hidden service .onion addresses that have been added to the Ahmia blacklist, and is updated whenever Ahmia blacklists a new .onion site for abuse material. {% endblocktrans %}
{% blocktrans %}
Hidden service names are masked by creating an MD5 sum of the onion name plus a new line.
For example, if
the onion is abcdefghijk.onion
, the resulting hash would be
6a69b60bdbd7675002b65440ca3c0818
.
This way it is possible for researchers and administrators to check if a site has been
blacklisted from the index without making the .onion hostnames easily accessible.
{% endblocktrans %}
{% blocktrans %} Blacklist hash data is available for raw text download here. You may use this in your own search indexes to remove abusive content. {% endblocktrans %}
info
warn
error
{{ onion.md5 }}


--- date: 2011-02-27T00:00:00Z published: true title: Cats Quote Charlie Sheen | lolcats with Sheenisms - somebody's had a little too much coke. url: /2011/02/27/cats-quote-charlie-sheen-lolcats-with-sheenisms-somebody-s-had-a-little-too-much-coke-/ ---


Details of level 1 are:
1.Solve this fragment by answering the one word solution
2. rule no 2
Details of level 2 are:
Get that code to activate the weapons
Details of level 3 are:
Can you decrypt this one?
Details of level 4 are:
Can you decrypt this one?


Hello, user! Not you?
Expense Reimbursements
Reimbursement Id
Type
Amount
Description
Status
Submitted
Resolved
Update Reimbursement Claim
Submit Reimbursement Claim


The left part of this page shows the location of oil tankers on a specific day on a map. The arrows are oriented in the average course of a tankers. The opacity is determined by the average speed (higher opacity = faster). Clicking on an arrow will open a dialog with information about the ship.
On the right two graphs are shown. The upper graph shows the number of slow moving tankers (slow count) and the number of fast moving tankers (fast count) as well as a day ahead forecast along with its 95% confidence interval. The bottom graph shows the Brent oil price for each day in USD/barrel.
One can increment the time by pressing the "Next week" or "Next day" button. The vertical orange line in the graphs corresponds to the currently selected day.