Introduction
LPeg is a new pattern-matching library for Lua, based on Parsing Expression Grammars (PEGs). In this text, I assume you are familiar with PEGs. If you are not, you can get a quick start reading the Wikipedia Entry for PEGs or Section 2 of Parsing Expression Grammars: A Recognition-Based Syntactic Foundation (the section has only one page). The nice thing about PEGs is that it has a formal basis (instead of being an ad-hoc set of features), allows an efficient and simple implementation, and does most things we expect from a pattern-matching library (and more, as we can define entire grammars).
Following the Snobol tradition, LPeg defines patterns as first-class objects. That is, patterns are regular Lua values (represented by userdata). The library offers several functions to create and compose patterns. With the use of metamethods, several of these functions are provided as infix or prefix operators. On the one hand, the result is usually much more verbose than the typical encoding of patterns using the so called regular expressions (which typically are not regular expressions in the formal sense). On the other hand, first-class patterns allow much better documentation (as it is easy to comment the code, to use auxiliary variables to break complex definitions, etc.) and are extensible, as we can define new functions to create and compose patterns.
For a quick glance of the library, the following table summarizes its basic operations for creating patterns:
| Operator | Description |
lpeg.P(string) |
Matches string literally |
lpeg.P(number) |
Matches exactly number characters |
lpeg.S(string) |
Matches any character in string (set) |
lpeg.R("xy") |
Matches any character between x and y (range) |
patt^n |
Matches at least n repetitions of patt |
patt^-n |
Matches at most n repetitions of patt |
patt1 * patt2 |
Matches patt1 followed by patt2 |
patt1 + patt2 |
Matches patt1 or patt2
(ordered choice) |
patt1 - patt2 |
Matches patt1 if patt2 does not match |
-patt |
Equivalent to "" - patt |
As a very simple example, lpeg.R("09")^1
matches
a non-empty sequence of digits.
As a not so simple example,
-lpeg.P(1)
(which can be written as lpeg.P(-1)
or simply -1
for operations expecting a pattern)
matches an empty string only if it cannot match a single character;
so, it succeeds only at the subject's end.
Those not convinced by the previous syntax
can try the re
module,
which implements patterns following a regular-expression style
(e.g., [09]+
).
(This module is less than 100 lines of Lua code,
and of course uses LPeg to parse regular expressions.)
This library currently supports only very basic captures.
But it provides a good source for those looking for
extended examples of LPeg definitions.
Basic Constructions
Most of the following operations build patterns.
All operations that expect a pattern as an argument
may receive also strings, tables, numbers, booleans, or functions,
which are translated to patterns according to
the rules of function lpeg.P
.
lpeg.match (pattern, subject [, init])
The matching function. It attempts to match the given pattern against the subject string. If the match succeeds, returns the index in the subject of the first character after the match, or the values of captured values (if the pattern captured any value).
An optional numeric argument init
makes the match
starts at that position in the subject string.
As usual in Lua libraries,
a negative value counts from the end.
Unlike typical pattern-matching functions,
match
works only in anchored mode;
that is, it tries to match the pattern with a prefix of
the given subject string (at position init
),
not with an arbitrary substring of the subject.
So, if we want to find a pattern anywhere in a string,
we must either write a loop in Lua or write a pattern that
matches anywhere.
This second approach is easy and quite efficient;
see examples.
lpeg.P (value)
Converts the given value into a proper pattern, according to the following rules:
If the argument is a pattern, it is returned unmodified.
If the argument is a string, it is translated to a pattern that matches literally the string.
If the argument is a number, it is translated as follows. A non-negative number n gives a pattern that matches exactly n characters; a negative number -n gives a pattern that succeeds only if the input string does not have n characters. It is (as expected) equivalent to the unary minus operation (see below) applied over the absolute value of n.
If the argument is a boolean, the result is a pattern that always succeeds or always fails (according to the boolean value), without consuming any input.
If the argument is a table, it is interpreted as a grammar (see Grammars).
If the argument is a function, returns a pattern that matches as follows. Each time there is an attempt for a match against this pattern, the function is called, always with two arguments: the original subject string, and the current position in the subject. If the call returns a valid number, the match succeeds and the returned number becomes the new current position. If the call returns false, nil, or an invalid number, the match fails.
If the function is called with parameters s and i, its result is valid if it is in the range [i, len(s) + 1].
lpeg.R ({range})
Returns a pattern that matches any single character
belonging to one of the given ranges.
Each range
is a string xy of length 2,
representing all characters with code
between the codes of x and y
(both inclusive).
As an example, the pattern
lpeg.R("09")
matches any digit,
and lpeg.R("az", "AZ")
matches any ASCII letter.
lpeg.S (string)
Returns a pattern that matches any single character that
appears in the given string.
(The S
stands for Set.)
As an example, the pattern
lpeg.S("+-*/")
matches any arithmetic operator.
Note that, if s
is a character
(that is, a string of length 1),
then lpeg.P(s)
is equivalent to lpeg.S(s)
which is equivalent to lpeg.R(s..s)
.
Note also that both lpeg.S("")
and lpeg.R()
are patterns that always fail.
lpeg.V (v)
This operation creates a non-terminal (a variable)
for a grammar.
The created non-terminal refers to the rule indexed by v
in the enclosing grammar.
(See Grammars for details.)
#patt
Returns a pattern equivalent to &patt in the original
PEG notation.
This is a pattern that matches only if the input string
does match patt
,
but without consuming any input,
independently of success or failure.
-patt
Returns a pattern equivalent to !patt in the original
PEG notation.
This pattern matches only if the input string
does not match patt
.
It does not consume any input,
independently of success or failure.
As an example, the pattern
-1
matches only the end of string.
patt1 + patt2
Returns a pattern equivalent to an ordered choice
of patt1
and patt2
.
(This is denoted by patt1 / patt2 in the original PEG notation,
not to be confused with the /
operation in LPeg.)
It matches either patt1
or patt2
(with no backtracking once one of them succeeds).
The identity element for this operation is the pattern
lpeg.P(false)
,
which always fails.
If both patt1
and patt2
are
character sets,
this operation is equivalent to set union:
lower = lpeg.R("az") upper = lpeg.R("AZ") letter = lower + upper
patt1 - patt2
Returns a pattern equivalent to !patt2 patt1.
This pattern asserts that the input does not match
patt2
and then matches patt1
.
If both patt1
and patt2
are
character sets,
this operation is equivalent to set difference.
Note that -patt
is equivalent to "" - patt
(or 0 - patt
).
If patt
is a character set,
1 - patt
is its complement.
patt1 * patt2
Returns a pattern that matches patt1
and then matches patt2
,
starting where patt1
finished.
The identity element for this operation is the
pattern lpeg.P(true)
,
which always succeeds.
(LPeg uses the *
operator
[instead of the more obvious ..
]
both because it has
the right priority and because in formal languages it is
common to use a dot for denoting concatenation.)
patt^n
If n
is nonnegative,
this pattern is
equivalent to pattn patt*.
It matches at least n
occurrences of patt
.
Otherwise, when n
is negative,
this pattern is equivalent to (patt?)-n.
That is, it matches at most -n
occurrences of patt
.
In particular, patt^0
is equivalent to patt*,
patt^1
is equivalent to patt+,
and patt^-1
is equivalent to patt?
in the original PEG notation.
In all cases,
the resulting pattern is greedy with no backtracking.
That is, it matches only the longest possible sequence
of matches for patt
.
Grammars
With the use of Lua variables, it is possible to define patterns incrementally, with each new pattern using previously defined ones. However, this technique does not allow the definition of recursive patterns. For recursive patterns, we need real grammars.
LPeg represents grammars with tables, where each entry is a rule.
The call lpeg.V(v)
creates a pattern that represents the nonterminal
(or variable) with index v
in a grammar.
Because the grammar still does not exist when
this function is evaluated,
the result is an open reference to the respective rule.
A table is fixed when it is converted to a pattern
(either by calling lpeg.P
or by using it wherein a
pattern is expected).
Then every open reference created by lpeg.V(v)
is corrected to refer to the rule indexed by v
in the table.
When a table is fixed, the result is a pattern that matches its initial rule. The entry with index 1 in the table defines its initial rule. If that entry is a string, it is assumed to be the name of the initial rule. Otherwise, LPeg assumes that the entry 1 itself is the initial rule.
As an example, the following grammar matches strings of a's and b's that have the same number of a's and b's:
equalcount = lpeg.P{ "S"; -- initial rule name S = "a" * lpeg.V"B" + "b" * lpeg.V"A" + "", A = "a" * lpeg.V"S" + "b" * lpeg.V"A" * lpeg.V"A", B = "b" * lpeg.V"S" + "a" * lpeg.V"B" * lpeg.V"B", } * -1
Captures
Captures specify what a match operation should return (the so called semantic information). LPeg offers several kinds of captures, which build values based on matches and combine them to create new values.
The following table summarizes the basic captures:
| Operation | What is Captured |
lpeg.C(patt) |
the match for patt |
lpeg.Cc(values) |
the given values (matches the empty string) |
lpeg.Cp() |
the current position (matches the empty string) |
lpeg.Cs(patt) |
the match for patt
with nested captures replacing their matches |
lpeg.Ct(patt) |
a table with all captures from patt |
lpeg.Ca(patt) |
an accumulation (or folding) of the
captures from patt |
patt / function |
the returns of function applied to the captures
of patt |
patt / table |
table[c] , where c is the (first)
capture of patt |
patt / string |
string , with some marks replaced by captures
of patt |
A capture pattern captures a value every time it succeeds.
For instance,
a capture inside a loop generates as many values as matched by the loop.
A capture generates a value only when it succeeds.
For instance,
the pattern lpeg.C(lpeg.P'a'^-1)
captures the empty string when there is no 'a'
(because the pattern 'a'?
succeeds),
while the pattern lpeg.C('a')^-1
does not capture any value when there is no 'a'
(because the pattern 'a'
fails).
lpeg.C (patt)
Creates a simple capture,
which captures the substring of the subject that matches patt
.
The captured value is a string.
If patt
has other captures,
their values are returned after this one.
lpeg.Ca (patt)
Creates an accumulator capture.
This capture assumes that patt
should produce
at least one captured value of any kind,
which becomes the initial value of an accumulator.
Pattern patt
then may produce
zero or more function captures.
Each of these functions in these captures is called having the
accumulator as its first argument
(followed by any other arguments provided by its own pattern),
and the value returned by the function becomes the new value
of the accumulator.
The final value of this accumulator is the sole result of
the whole capture.
As an example, the following pattern matches a list of numbers separated by commas and returns their addition:
-- matches a numeral and captures its value local number = lpeg.R"09"^1 / tonumber -- auxiliary function to add two numbers local function add (acc, newvalue) return acc + newvalue end list = lpeg.Ca(number * ("," * number / add)^0) -- example of use print(list:match("10,30,43")) --> 83
lpeg.Cc ({value})
Creates a constant capture. This pattern matches the empty string and produces all given values as its captured values.
lpeg.Cs (patt)
Creates a substitution capture,
which captures the substring of the subject that matches patt
,
with substitutions.
For any capture inside patt
,
the substring that matched the capture is replaced by the capture value
(which should be a string).
The capture values from patt
are not returned independently
(only as substrings in the resulting string).
lpeg.Cp ()
Creates a position capture. It matches the empty string and captures the position in the subject where the match occurs. The captured value is a number.
lpeg.Ct (patt)
Creates a table capture.
This capture creates a table and puts all captures made by
patt
inside this table in successive integer keys,
starting at 1.
The captured value is only this table.
The captures made by patt
are not
returned independently (only as table elements).
patt / function
Creates a function capture.
It calls the given function passing all captures made by
patt
as arguments,
or the whole match if patt
made no capture.
The values returned by the function
are the final values of the capture.
(This capture may create multiple values.)
In particular,
if function
returns no value,
there is no captured value;
everything works as if there was no capture.
patt / string
Creates a string capture.
It creates a capture string based on string
.
The captured value is a copy of string
,
except that the character %
works as an escape character:
any sequence in string
of the form %n
,
with n between 1 and 9,
stands for the match of the n-th capture in patt
.
(Currently these nested captures can be only simple captures.)
The sequence %0
stands for the whole match.
The sequence %%
stands for a single %
.
patt / table
Creates a query capture.
It indexes the given table using as key the value of the first capture
of patt
,
or the whole match if patt
made no capture.
The value at that index is the final value of the capture.
If the table does not have that key, there is no captured value. Everything works as if there was no capture.
Some Examples
Splitting a String
The following code splits a string using a given pattern
sep
as a separator:
function split (s, sep) sep = lpeg.P(sep) local elem = lpeg.C((1 - sep)^0) local p = elem * (sep * elem)^0 return lpeg.match(p, s) end
First the function ensures that sep
is a proper pattern.
The pattern elem
is a repetition of zero of more
arbitrary characters as long as there is not a match against
the separator. It also captures its result.
The pattern p
matches a list of elements separated
by sep
.
If the split results in too many values, it may overflow the maximum number of values that can be returned by a Lua function. In this case, we should collect these values in a table:
function split (s, sep) sep = lpeg.P(sep) local elem = lpeg.C((1 - sep)^0) local p = lpeg.Ct(elem * (sep * elem)^0) -- make a table capture return lpeg.match(p, s) end
Searching for a Pattern
The primitive match
works only in anchored mode.
If we want to find a pattern anywhere in a string,
we must write a pattern that matches anywhere.
Because patterns are composable,
we can write a function that,
given any arbitrary pattern p
,
returns a new pattern that searches for p
anywhere in a string.
There are several ways to do the search.
One way is like this:
function anywhere (p) return lpeg.P{ p + 1 * lpeg.V(1) } end
This grammar has a straight reading:
it matches p
or skips one character and tries again.
If we want to know where the pattern is in the string (instead of knowing only that it is there somewhere), we can add position captures to the pattern:
local I = lpeg.Cp() function anywhere (p) return lpeg.P{ I * p * I + 1 * lpeg.V(1) } end
Another option for the search is like this:
local I = lpeg.Cp() function anywhere (p) return (1 - lpeg.P(p))^0 * I * p * I end
Again the pattern has a straight reading:
it skips as many characters as possible while not matching p
,
and then matches p
(plus appropriate captures).
If we want to look for a pattern only at word boundaries, we can use the following transformer:
local wordletter = lpeg.R("AZ", "az") function atwordboundary (p) return lpeg.P{ [1] = p + wordletter^0 * (1 - wordletter)^1 * lpeg.V(1) } end
Balanced Parentheses
The following pattern matches only strings with balanced parentheses:
b = lpeg.P{ "(" * ((1 - lpeg.S"()") + lpeg.V(1))^0 * ")" }
Reading the first (and only) rule of the given grammar,
we have that a balanced string is
an open parenthesis,
followed by zero or more repetitions of either
a non-parenthesis character or
a balanced string (lpeg.V(1)
),
followed by a closing parenthesis.
Global Substitution
The next example does a job somewhat similar to string.gsub
.
It receives a pattern and a replacement value,
and substitutes the replacement value for all occurrences of the pattern
in a given string:
function gsub (s, patt, repl) patt = lpeg.P(patt) patt = lpeg.Cs((patt / repl + 1)^0) return lpeg.match(patt, s) end
As in string.gsub
,
the replacement value can be a string,
a function, or a table.
Comma-Separated Values (CSV)
This example breaks a string into comma-separated values, returning all fields:
local field = '"' * lpeg.Cs(((lpeg.P(1) - '"') + lpeg.P'""' / '"')^0) * '"' + lpeg.C((1 - lpeg.S',\n"')^0) local record = field * (',' * field)^0 * (lpeg.P'\n' + -1) function csv (s) return lpeg.match(record, s) end
A field is either a quoted field (which may contain any character except an individual quote, which may be written as two quotes that are replaced by one) or an unquoted field (which cannot contain commas, newlines, or quotes). A record is a list of fields separated by commas, ending with a newline or the string end (-1).
Lua's Long Strings
This example matches long strings in Lua. Probably there is no pure PEG grammar that matches that syntax (as there is no Context-Free Grammar for it), so we resort to Lua:
local start = "[" * lpeg.P"="^0 * "[" longstring = lpeg.P(function (s, i) local l = lpeg.match(start, s, i) if not l then return nil end local p = lpeg.P("]" .. string.rep("=", l - i - 2) .. "]") p = (1 - p)^0 * p return lpeg.match(p, s, l) end)
The function first checks whether there is a long string starting
at position i
, using the start
pattern.
If so, it builds a pattern p
that matches an ending bracket with the correct number of equal signs
and then looks for this pattern.
Lua-function patterns are not efficient. So, it may be worth the use of an and-predicate to pre-analyze the subject before calling Lua:
longstring = #("[" * lpeg.S"[=") * longstring
In this example, the pattern only calls Lua if the current position matches an open bracket followed by either another open bracket or an equal sign (so that the only valid token there is a long string).
UTF-8 and Latin 1
It is not difficult to use LPeg to convert a string from utf-8 encoding to Latin 1 (ISO 8859-1):
-- convert a two-byte utf8 sequence to a Latin 1 character local function f2 (s) local c1, c2 = string.byte(s, 1, 2) return string.char(c1 * 64 + c2 - 12416) end local utf8 = lpeg.R("\0\127") + lpeg.R("\194\195") * lpeg.R("\128\191") / f2 local decode_pattern = lpeg.Cs(utf8^0) * -1
In this code, the definition of utf-8 is already restricted to the Latin 1 range (from 0 to 255). Any encoding outside this range (as well as any invalid encoding) will not match that pattern.
As the definition of decode_pattern
demands that
the pattern matches the whole input (because of the -1 at its end),
any invalid string will simply fail to match,
without any useful information about the problem.
We can improve this situation redefining decode_pattern
as follows:
local function er (_, i) error("invalid encoding at position " .. i) end local decode_pattern = lpeg.Cs(utf8^0) * (-1 + lpeg.P(er))
Now, if the pattern utf8^0
stops
before the end of the string,
an appropriate error function is called.
UTF-8 and Unicode
We can extend the previous patterns to handle all Unicode code points. Of course, we cannot translate them to Latin 1 or any other one-byte encoding. Instead, our translation results in a array with the code points represented as numbers. The full code is here:
-- decode a two-byte utf8 sequence local function f2 (s) local c1, c2 = string.byte(s, 1, 2) return c1 * 64 + c2 - 12416 end -- decode a three-byte utf8 sequence local function f3 (s) local c1, c2, c3 = string.byte(s, 1, 3) return (c1 * 64 + c2) * 64 + c3 - 925824 end -- decode a four-byte utf8 sequence local function f4 (s) local c1, c2, c3, c4 = string.byte(s, 1, 4) return ((c1 * 64 + c2) * 64 + c3) * 64 + c4 - 63447168 end local cont = lpeg.R("\128\191") -- continuation byte local utf8 = lpeg.R("\0\127") / string.byte + lpeg.R("\194\223") * cont / f2 + lpeg.R("\224\239") * cont * cont / f3 + lpeg.R("\240\244") * cont * cont * cont / f4 local decode_pattern = lpeg.Ct(utf8^0) * -1
Arithmetic Expressions
This example is a complete parser and evaluator for simple arithmetic expressions. We write it in two styles. The first approach first builds a syntax tree and then traverses this tree to compute the expression value:
-- Lexical Elements local Space = lpeg.S(" \n\t")^0 local Number = lpeg.C(lpeg.P"-"^-1 * lpeg.R("09")^1) * Space local FactorOp = lpeg.C(lpeg.S("+-")) * Space local TermOp = lpeg.C(lpeg.S("*/")) * Space local Open = "(" * Space local Close = ")" * Space -- Grammar local Exp, Term, Factor = lpeg.V"Exp", lpeg.V"Term", lpeg.V"Factor" G = lpeg.P{ Exp, Exp = lpeg.Ct(Factor * (FactorOp * Factor)^0); Factor = lpeg.Ct(Term * (TermOp * Term)^0); Term = Number + Open * Exp * Close; } G = Space * G * -1 -- Evaluator function eval (x) if type(x) == "string" then return tonumber(x) else local op1 = eval(x[1]) for i = 2, #x, 2 do local op = x[i] local op2 = eval(x[i + 1]) if (op == "+") then op1 = op1 + op2 elseif (op == "-") then op1 = op1 - op2 elseif (op == "*") then op1 = op1 * op2 elseif (op == "/") then op1 = op1 / op2 end end return op1 end end -- Parser/Evaluator function evalExp (s) local t = lpeg.match(G, s) if not t then error("syntax error", 2) end return eval(t) end -- small example print(evalExp"3 + 5*9 / (1+1) - 12")
The second style computes the expression value on the fly, without building the syntax tree. The following grammar takes this approach. (It assumes the same lexical elements as before.)
-- Auxiliary function function eval (v1, op, v2) if (op == "+") then return v1 + v2 elseif (op == "-") then return v1 - v2 elseif (op == "*") then return v1 * v2 elseif (op == "/") then return v1 / v2 end end -- Grammar local V = lpeg.V G = lpeg.P{ "Exp", Exp = lpeg.Ca(V"Factor" * (FactorOp * V"Factor" / eval)^0); Factor = lpeg.Ca(V"Term" * (TermOp * V"Term" / eval)^0); Term = Number / tonumber + Open * V"Exp" * Close; } -- small example print(lpeg.match(G, "3 + 5*9 / (1+1) - 12"))
Note the use of the accumulator capture.
To compute the value of an expression,
the accumulator starts with the value of the first factor,
and then applies eval
over
the accumulator, the operator,
and the new factor for each repetition.
The re
Module
The re
Module
(provided by file re.lua
in the distribution)
supports a somewhat conventional regular-expression syntax
for pattern construction.
If offers two functions:
re.compile(string, [, defs])
compiles the given string and returns an equivalent LPeg pattern. The given string may define either an expression or a grammar. The optionaldefs
table provides extra Lua values to be used by the pattern.re.match(subject,pattern)
compiles the given pattern (a string) and matches it against the given subject. (It memoizes its results, so that there is no penalty in calling it multiple times with the same string.)
Like traditional regular expressions (but unlike original PEG),
a character class may start with a ^
to complement
its meaning.
The next table summarizes re
's syntax.
A p
represents an arbitrary pattern.
| Syntax | Description |
( p ) | grouping |
'string' | literal string |
"string" | literal string |
[class] | character class |
. | any character |
name | pattern defs[name]
(if defined) or a non terminal defined by the current grammar |
{} | position capture |
{ p } | simple capture |
{~ p ~} | substitution capture |
p? | optional match |
p* | zero or more repetitions |
p+ | one or more repetitions |
p{n} | exactly n repetitions |
p{n,} |
at least n repetitions |
p{n,m} |
between n and m repetitions |
p -> 'string' | string capture |
p -> "string" | string capture |
p -> {} | table capture |
p -> name | function/query/string capture
equivalent to p / defs[name] |
&p | and predicate |
!p | not predicate |
p1 p2 | concatenation |
p1 / p2 | ordered choice |
name <- p | grammar rule |
Any space appearing in a syntax description can be
replaced by zero or more space characters and comments
(--
until end of line).
Character classes define sets of characters.
An initial ^
complements the resulting set.
A range x-
y includes in the set
all characters with codes between the codes of x and y.
A simple character includes itself in the set.
The only special characters inside a class are ^
(special only if it is the first character);
]
(can be included in the set as the first character,
after the optional ^
);
and -
(can be included in the set as the first or the last character).
As a simple example, the following call will produce the same pattern produced by the Lua expression in the balanced parentheses example:
b = re.compile[[ balanced <- '(' ([^()] / balanced)* ')' ]]
The next example replicates the CSV decoder:
record = re.compile[[ record <- ( field (',' field)* ) -> {} ('\n' / !.) field <- escaped / nonescaped nonescaped <- { [^,"\n]* } escaped <- '"' {~ ([^"] / '""' -> '"')* ~} '"' ]]
Download
LPeg source code.
License
Copyright © 2007 Lua.org, PUC-Rio.
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
 IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


 By /han≠kass’o (L VIII.-27. 8399 rev. and 8400 rev., note). |han≠kass'o was told by his elders that dead people (who come out of the ground) are those who 'rode the Rain' (when living) and thus do so again (they are rain-sorcerers).
Comments
1) |han≠kass'o heard this from his maternal grandfather (Tsatsi), as well as from his maternal grandmother (≠kammi) and another person (called Tuai-an), 2) This story is found in Book VIII-27
Contributors
|han≠kass'o (Klein Jantje) (VIII)
Date
May 1879
Categories
The Rain and Rain's water, Custom and daily life
Keywords
rain (people who have 'got the Rain') , rain (dead people are those who rode the Rain) , rain (its leg) , rain (and dead sorcerers) , rain (and dead people who come out of the ground) , rain (the Rain is ridden by sorcerers) , rain (the riding of) , rain (is possessed by rain-sorcerers) , rain (its liquid) , rain (rain-water) , rain (when the rain-sorcerer unloosens his thong) , rain (and the sorcerer's thong) , rain (comes out of the clouds) , rain (-clouds) , rain (heavy) , rain (that is 'great') , sorcerers (rain-sorcerers) , sorcerers (who possess the rain) , sorcerers (dead, are those who 'rode the Rain') , sorcerers (who 'have got the Rain') , death (dead sorcerers rode and possess the Rain) , thong (with which the dead people rode the Rain) , thong (used by rain-sorcerers to ride the Rain) , thong (when 'unloosened' it brings heavy rain) , dead people (rain-sorcerers) , dead people (are those who rode the Rain) , rain-sorcerers (dead people are those who rode the Rain) , rain-sorcerers (Rain is possessed by) , rain-sorcerers (unloosen their thong and bring heavy rain)
Story Pages
8399v-8400v


SVG 2 user agent support
View on GitHub
Hide 'at risk' features?
Indicated priorities: high [++], medium [+], low [-]
Feature
Tests
References
SVG 2 new features
Inkscape SVG 2 Status (including CSS 3)
SVG 2 support in Mozilla


IMF to continue new-loan talks with Ukraine in coming weeks
KIEV (Reuters) - The International Monetary Fund said on Saturday it will continue talks with Ukraine about a new support program in coming weeks following significant progress in discussions so far with Kiev.
An IMF mission has been in Ukraine for a week as part of talks between Kiev and the fund to replace a $3.9 billion stand-by arrangement that expires in January.
“The IMF staff team had constructive and productive discussions with the Ukrainian authorities and commended them on the considerable progress made during the last few months in advancing reforms and continuing with sound economic policies,” it said in a statement.
Ukraine wants to secure an IMF deal worth around $5 billion-6 billion over three years to support its economy and signal to investors that the new government of President Volodymyr Zelenskiy is committed to reform.
“Discussions will continue in the coming weeks,” the IMF said.


Transportation
Kindly make tavel arrangements with your travel agencies. Access to Limau Resort is by:
Road
Air - Nanyuki airstripe
Rail


XCTestHTMLReport
Tests
Logs
Design Review
Devices
[[DEVICES]]
Report an issue
[[RUNS]]
No Selected Attachment


--- layout: default --- Machine Learning @ Brocade: Current Events, December, 2016.
Random (and largely incomplete) musings on various machine learning topics, WIP. Last update: 25 May 2016.
Machine Intelligence and Networking: Challenges, Opportunities and Realities, IETF 97 (nmlrg), 13-18 Nov 2016, Seoul, Republic of Korea (pdf).
Anomaly Detection for the IDEAS Mapping System: A Machine Learning Approach, IETF 97 (IDEAS), 13-18 Nov 2016, Seoul, Republic of Korea (pdf).


User Info
Email
Password
Firstname
Lastname
Telephone
Billing Address
Street
City
Country
should be shortcode
State
can be integer id or string name of state
Postcode
Shipping Address
Firstname
Lastname
Email
Telephone
Street
City
Country
should be shortcode
State
can be integer id or string name of state
Postcode
Payment Info
Owner Name
Card Number
Card Type
Visa
Master Card
Exp. Month
Exp. Year
CVV
Sponsored by:


Search
Preparing search index...
 Documentation generated by
TypeDoc.


Full stack web developer with extensive background in film and television. Trained as a Moving Image Preservation Specialist for digital and Time-Based Media artworks. Focus on coding to develop tools and technologies that expand information and access of media and art to new sectors and communities.
🇵🇾 | 🇨🇱 | 🇺🇸


{% extends "layout.html" %} {% block body %}
Enniskillen Castle, situated beside the River Erne in County Fermanagh, was built almost 600 years ago by the ruling Gaelic Maguires. Guarding one of the few passes into Ulster, it has been strategically important throughout its history. Today, the historic site houses two museums, Fermanagh County Museum and The Inniskillings Museum. Fermanagh County Museum at Enniskillen Castle has reopened after undergoing a major redevelopment.
All Information is from Enniskillen Castle


| AbstractQueueWithResources (27%) |
| FileBasedSPSCQueue (78%) |
| FileBasedSPSCQueueMemoryMapped (0%) |
| FileBasedSPSCQueueMemoryMappedReaderWriter (0%) |
| NullSentinel (60%) |
| ObservableServerSocket (91%) |
| OnSubscribeCacheResetable (100%) |
| OnSubscribeDoOnEmpty (100%) |
| OnSubscribeFromQueue (0%) |
| OnSubscribeInputStream (88%) |
| OnSubscribeMapLast (98%) |
| OnSubscribeReader (86%) |
| OnSubscribeRepeating (95%) |
| OperatorBufferPredicateBoundary (86%) |
| OperatorBufferToFile (88%) |
| OperatorDoOnNth (88%) |
| OperatorFromTransformer (93%) |
| OperatorSampleFirst (100%) |
| OperatorUnsubscribeEagerly (100%) |
| OperatorWindowMinMax (100%) |
| OrderedMerge (85%) |
| Permutations (89%) |
| QueueWithResources (N/A) |
| QueueWithResourcesNonBlockingUnsubscribe (84%) |
| QueueWithSubscription (N/A) |
| RollingSPSCQueue (62%) |
| TransformerDecode (93%) |
| TransformerDelayFinalUnsubscribe (86%) |
| TransformerLimitSubscribers (100%) |
| TransformerOnBackpressureBufferRequestLimiting (0%) |
| TransformerOnTerminateResume (86%) |
| TransformerStateMachine (91%) |
| TransformerStringSplit (90%) |


Akan (Twi, Asante) names are the names used by the Akan people of Ghana and the Ivory Coast, who are frequently naming their baby boys and baby girls after the day of the week in which they were born and the order of birth for each of them. More on Akan names can be found on Wikipedia
Here we will try to get own Akan names. Kindly provide the information as needed below so that we can calculate and get you your akan name


| PUBLIC MEMBERS: |
CLASSES
| STRUCTS
| UNIONS
| ENUMS
| TYPEDEFS
| METHODS
| STATIC METHODS
| DATA
| STATIC DATA |
:: rtl ::
template< typename T, typename InitAggregate >
class StaticAggregate
- Base Classes
- None.

- Template Parameters
| T |
aggregate's element type
|
| InitAggregate |
initializer functor class
|
- File
- instance.hxx
Public Members
-
Static Methods
|
static T *
get( ); |
Gets the static aggregate, late-initializing.
Mutual exclusion is performed using the osl global mutex.
|
Top of Page
Copyright © 2012, The Apache Software Foundation, Licensed under the Apache License, Version 2.0. Apache, the Apache feather logo, Apache OpenOffice and OpenOffice.org are trademarks of The Apache Software Foundation. Other names may be trademarks of their respective owners.


Survey Form
Let us know how we can improve freecodecamp
*Name
*Email
*Age
Which option best describes your current role?
Student
Full Time Job
Full time learner
How likely is that you would recommend freeCodeCamp to a friend?
Definietly
Maybe
Not sure
What do you like most in FCC:
Challenges
Proejcts
Community
Things that should be improved in the future (Check all that apply):
Any Comments or Suggestions?


Spin up a download request for GBIF occurrence data.
occ_download(..., body = NULL, type = "and", format = "DWCA", user = NULL, pwd = NULL, email = NULL, curlopts = list()) occ_download_prep(..., body = NULL, type = "and", format = "DWCA", user = NULL, pwd = NULL, email = NULL, curlopts = list())
| ... | One or more of query arguments to kick of a download job.
If you use this, don't use |
|---|---|
| body | if you prefer to pass in the payload yourself, use this parameter. if use this, don't pass anythig to the dots. accepts either an R list, or JSON. JSON is likely easier, since the JSON library jsonlite requires that you unbox strings that shouldn't be auto-converted to arrays, which is a bit tedious for large queries. optional |
| type | (character) One of equals (=), and (&), or (|), lessThan (<), lessThanOrEquals (<=), greaterThan (>), greaterThanOrEquals (>=), in, within, not (!), like |
| format | (character) The download format. One of DWCA (default), SIMPLE_CSV, or SPECIES_LIST |
| user | (character) User name within GBIF's website. Required. See Details. |
| pwd | (character) User password within GBIF's website. Required. See Details. |
(character) Email address to recieve download notice done email. Required. See Details. |
|
| curlopts | list of named curl options passed on to
|
Argument passed have to be passed as character (e.g.,
'country = US'), with a space between key ('country'), operator ('='),
and value ('US'). See the type
parameter for possible options for
the operator. This character string is parsed internally.
The value can be comma separated, in which case we'll turn that into a
predicate combined with the OR operator, for example,
"taxonKey = 2480946,5229208"
will turn into
'{ "type": "or", "predicates": [ { "type": "equals", "key": "TAXON_KEY", "value": "2480946" }, { "type": "equals", "key": "TAXON_KEY", "value": "5229208" } ] }'
Acceptable arguments to ...
are:
taxonKey = 'TAXON_KEY'
scientificName = 'SCIENTIFIC_NAME'
country = 'COUNTRY'
publishingCountry = 'PUBLISHING_COUNTRY'
hasCoordinate = 'HAS_COORDINATE'
hasGeospatialIssue = 'HAS_GEOSPATIAL_ISSUE'
typeStatus = 'TYPE_STATUS'
recordNumber = 'RECORD_NUMBER'
lastInterpreted = 'LAST_INTERPRETED'
continent = 'CONTINENT'
geometry = 'GEOMETRY'
basisOfRecord = 'BASIS_OF_RECORD'
datasetKey = 'DATASET_KEY'
eventDate = 'EVENT_DATE'
catalogNumber = 'CATALOG_NUMBER'
year = 'YEAR'
month = 'MONTH'
decimalLatitude = 'DECIMAL_LATITUDE'
decimalLongitude = 'DECIMAL_LONGITUDE'
elevation = 'ELEVATION'
depth = 'DEPTH'
institutionCode = 'INSTITUTION_CODE'
collectionCode = 'COLLECTION_CODE'
issue = 'ISSUE'
mediatype = 'MEDIA_TYPE'
recordedBy = 'RECORDED_BY'
see downloads for an overview of GBIF downloads methods
When using the geometry parameter, make sure that your well known text
(WKT) is formatted as GBIF expects it. They expect WKT to have a
counter-clockwise winding order. For example, the following is clockwise
POLYGON((-19.5 34.1, -25.3 68.1, 35.9 68.1, 27.8 34.1, -19.5 34.1))
,
whereas they expect the other order:
POLYGON((-19.5 34.1, 27.8 34.1, 35.9 68.1, -25.3 68.1, -19.5 34.1))
note that coordinate pairs are longitude latitude
, longitude first, then
latitude
you should not get any results if you supply WKT that has clockwise winding order.
also note that occ_search()
/occ_data()
behave differently with
respect to WKT in that you can supply counter-clockwise WKT to those
functions but they treat it as an exclusion, so get all data not
inside the WKT area.
occ_download_prep
: prepares a download request, but DOES NOT execute it.
meant for use with occ_download_queue()
occ_download
: prepares a download request and DOES execute it
For user
, pwd
, and email
parameters, you can set them in one of
three ways:
Set them in your .Rprofile
file with the names gbif_user
,
gbif_pwd
, and gbif_email
Set them in your .Renviron
/.bash_profile
(or similar) file with the
names GBIF_USER
, GBIF_PWD
, and GBIF_EMAIL
Simply pass strings to each of the parameters in the function call
We strongly recommend the second option - storing your details as environment variables as it's the most widely used way to store secrets.
See ?Startup
for help.
GBIF has a limit of 12,000 characters for a download query. This means that you can have a pretty long query, but at some point it may lead to an error on GBIF's side and you'll have to split your query into a few.
See the API docs http://www.gbif.org/developer/occurrence#download for more info, and the predicates docs http://www.gbif.org/developer/occurrence#predicates
# NOT RUN { # occ_download("basisOfRecord = LITERATURE") # occ_download('taxonKey = 3119195') # occ_download('decimalLatitude > 50') # occ_download('elevation >= 9000') # occ_download('decimalLatitude >= 65') # occ_download("country = US") # occ_download("institutionCode = TLMF") # occ_download("catalogNumber = Bird.27847588") # download format # z <- occ_download('decimalLatitude >= 75', format = "SPECIES_LIST") # res <- occ_download('taxonKey = 7264332', 'hasCoordinate = TRUE') # pass output directly, or later, to occ_download_meta for more information # occ_download('decimalLatitude > 75') %>% occ_download_meta # Multiple queries # occ_download('decimalLatitude >= 65', 'decimalLatitude <= -65', type="or") # gg <- occ_download('depth = 80', 'taxonKey = 2343454', type="or") # complex example with many predicates # shows example of how to do date ranges for both year and month # res <- occ_download( # "taxonKey = 2480946,5229208", # "basisOfRecord = HUMAN_OBSERVATION,OBSERVATION,MACHINE_OBSERVATION", # "country = US", # "hasCoordinate = true", # "hasGeospatialIssue = false", # "year >= 1999", # "year <= 2011", # "month >= 3", # "month <= 8" # ) # Using body parameter - pass in your own complete query ## as JSON query1 <- '{"creator":"sckott"<EMAIL_ADDRESS>"predicate":{"type":"and","predicates":[ {"type":"equals","key":"TAXON_KEY","value":"7264332"}, {"type":"equals","key":"HAS_COORDINATE","value":"TRUE"}]} }' # res <- occ_download(body = query1, curlopts=list(verbose=TRUE)) ## as a list library(jsonlite) query <- list( creator = unbox("sckott"), notification_address =<EMAIL_ADDRESS>predicate = list( type = unbox("and"), predicates = list( list(type = unbox("equals"), key = unbox("TAXON_KEY"), value = unbox("7264332")), list(type = unbox("equals"), key = unbox("HAS_COORDINATE"), value = unbox("TRUE")) ) ) ) # res <- occ_download(body = query, curlopts = list(verbose = TRUE)) # Prepared query occ_download_prep("basisOfRecord = LITERATURE") occ_download_prep("basisOfRecord = LITERATURE", format = "SIMPLE_CSV") occ_download_prep("basisOfRecord = LITERATURE", format = "SPECIES_LIST") # }


Library of Sages Director Sophia:
Did you find the book you were looking for? If you're finished, I will lead you back to Library of Sages..
Go to Library of Sages
"I'm not ready yet."


National Defense Days Prove Effectiveness
by Luz Marina Reyes CaballeroThe National Defense Days, held over the weekend, began in Las Tunas with the activation of the Provincial Defense Council and the municipal ones, with the aim of preparing the governing and command bodies for its complete combative disposition.
Las Tunas, Cuba.- In addition to the preparation of the Provincial Defense Council, the missions of the working groups and subgroups, as well as the updating of the objectives and tasks of the factors that integrate the territorial defense system were pointed out on Saturday.
During Sunday, all the structures of the territorial defense system and the population participated, when the activities of each group to be fulfilled, along with the companies and entities that have precise missions in case that an exceptional situation is decreed, were carried out.
The realization of these exercises guarantee the continuity of the services to the population in the territory, in addition to show the organization, direction, preparation and command of the State administration agencies and other structures of the territorial defense system.
On these National Days, the tactical exercises of the defense zones and the actions of the production and defense brigades for protection and security of the objectives of the companies constituted key factors.
The president of the Provincial Defense Council, Manuel Pérez Gallego, and its Vice President, Jaime Chiang Vega, discussed with the working groups issues that are also in the strategic objectives of the country, such as food production, the development of the sugar harvest and the supply of water to hard-to-reach areas.


What I have learned
- Create asynchronous connection to a JSON file
- How to use the 'then' method to retrieve a Promise
- Using try...catch
Choose Your Hotel
Hotel
Where:
Number of Rooms:
Pool Available:
Type of Room:
Number of Rooms:
Pool Available:
Type of Room:


Enumerators Information
See Enumerators status here
| Name | Job Position | Active Area | View Profile |
|---|---|---|---|
| Tanvir Hayder | Welfare Officer | Gazipur | |
| Fahmidul Hasan | Welfare Officer | Gazipur | |
| Tahmid Alam | Welfare Officer | Gazipur | |
| Sakib Shadman | Welfare Officer | Gaibandha | |
| Maqsud Ul Anwar | Welfare Officer | Kurigram | |
| Navan Tanjeem | Welfare Officer | Shirajgonj |
| PHONE : | +880<PHONE_NUMBER> |
|---|---|
| NID : |<PHONE_NUMBER>64827 |
| ADDRESS : | Basundha RA, Dhaka, Bangladesh |
| Doing Date : | 05 April 2017 |
| Active Area: | Dhaka |
$13500
Loan Dispatched
$58467
Loan Collected
$1247
Loan Due
| PHONE : | +880<PHONE_NUMBER> |
|---|---|
| NID : |<PHONE_NUMBER>64827 |
| ADDRESS : | Basundha RA, Dhaka, Bangladesh |
| Doing Date : | 05 April 2017 |
| Active Area: | Dhaka |
$16500
Loan Dispatched
$68467
Loan Collected
$1257
Loan Due
| PHONE : | +880<PHONE_NUMBER> |
|---|---|
| NID : |<PHONE_NUMBER>64827 |
| ADDRESS : | Basundha RA, Dhaka, Bangladesh |
| Doing Date : | 05 April 2017 |
| Active Area: | Dhaka |


Bloodhound
STAGE - II
Seek and you shall find
Seive through the TEXT, be an EDITOR and you shall pass
Download


Netflix’s chilling ‘The Confession Killer’ trailer digs into the truth of Henry Lee Lucas
by Tricia CrimminsFor its latest true-crime docuseries, The Confession Killer, Netflix is tackling the case of Henry Lee Lucas, a serial killer who confessed to the murder of hundreds of people — and not only did Lucas confess, he made a show of sketching out victims and describing their deaths in detail to investigators.
However, Lucas's copious confessions proved implausible when lawyers, journalists, and forensic DNA analysis poked holes in his seemingly endless killing spree. Such implausibilities forced investigators to open cases that Lucas's confessions had closed, and upended the closure grieving families had found in those confessions.
Dubbed "The Deadly Drifter" in the 1980s, the entire ordeal surrounding the plausibility of Lucas's confessions earned him a new nickname: The Confession Killer. The five-part docuseries explores the truth behind Henry Lee Lucas and how his story revealed inadequacies in the United States justice system.
The Confession Killer debuts on Netflix on Dec. 6.


# install.packages("remotes")
remotes::install_github("devOpifex/g2r")
Easy to use
An intuitive, familiar
API, and easy to pick up API.
Crosstalk
Support for
crosstalk selection and filtering.
Shiny
Integration with
shiny events and proxies.
Rmd
Integration for dynamic charts in
Rmarkdown.
Limitations
g2r currently does not work well with large datasets (performance drop), and some features are still under development, namely rmarkdown actions, shiny proxies, and maps. Theming is not currently rather unwieldy.


--- title: Shape Parameters - Basic Properties sidebar: documentation_sidebar permalink: ShapeParameters.html folder: documentation toc: false ---
In this section we discuss basic geometric properties of grains. Due to the huge amount of shape parameters we split them into different categories: basic properties (this page), properties based on fitted ellipses, convex hull bases properties, projection bases properties. The table below summarizes the shape parameters discussed on this page.
|
grainSize |
number of pixels per grain |
grain area in µm² |
|
|
number of boundary segments |
perimeter in µm |
||
|
number of inner boundaries |
length of inner boundaries in µm |
||
|
diameter in µm |
caliper or Feret diameter |
||
|
perimeter of a circle with the same area |
radius of a circle with the same area |
||
|
perimeter / equivalent perimeter |
is it a boundary grain |
||
|
irregularity of grain boundary |
|
|
|
|
has inclusions |
is an inclusions |
||
|
number neighboring grains |
list of triple points |
||
|
list of boundary segments |
subgrain boundaries |
||
|
x, y |
coordinates of the vertices |
x,y coordinates of the barycenter |
We start our discussion by reconstructing the grain structure from a sample EBSD data set.
{% highlight matlab %} % load sample EBSD data set mtexdata forsterite silent % restrict it to a subregion of interest. ebsd = ebsd(inpolygon(ebsd,[5 2 10 5]*10^3)); % remove all not indexed pixels ebsd = ebsd('indexed'); % reconstruct grains [grains, ebsd.grainId] = calcGrains(ebsd,'angle',5*degree); % smooth them grains = smooth(grains,5); % plot the orientation data of the Forsterite phase plot(ebsd('fo'),ebsd('fo').orientations) % plot the grain boundary on top of it hold on plot(grains.boundary,'lineWidth',2) hold off {% endhighlight %}The most basic properties are grainSize and grain area. Those can be computed by
{% highlight matlab %} grains(9).grainSize grains(9).area {% endhighlight %} {% highlight plaintext %} ans = 1 ans = 1.9540e+03 {% endhighlight %}Hereby grainSize
referes to the number of pixels that belong to a certain grain while area
represents the actual area measured in (µm)^2
. We may analyze the distribution of grains by grain area using a histogram.
Note the large amount of very small grains. A more realistic histogram we obtain if we do not plot the number of grains at the y-axis but its total area. This can be achieved with the command histogram(grains)
or hist(grains)
Simarly as grainSize
and area
, the one-dimensional meassures boundarySize
and perimeter
give the length of the grain boundary as number of segments and in µm
, respectively.
We may compute these quantities also explicitely from the grain boundary segents. In the following code the first command returns simply the number of boundary segments while the second one gives the total length of the boundary by summing up the length of each individual boundary segment
{% highlight matlab %} length(grains(9).boundary) sum(grains(9).boundary.segLength) {% endhighlight %} {% highlight plaintext %} ans = 4 ans = 233.1561 {% endhighlight %}Another, one dimensional measure is the diameter
which refers to the longest distance between any two boundary points and is given im µm
as well
The diameter is a special case of the caliper or Feret diameter of a grain that is explained in detail in the section Projection based parameters.
In contrast the equivalent radius is the radius of a circle with the same area as the grain. Naturally, the equivalent radius is always smaller than the actual radius of the grains. Similarly, the equivalent perimeter is defined as the perimeter of the circle the same area and is always smaller then the actual perimeter.
{% highlight matlab %} 2*grains(9).equivalentRadius grains(9).equivalentPerimeter {% endhighlight %} {% highlight plaintext %} ans = 49.8787 ans = 156.6986 {% endhighlight %}As a consequence, the ratio between between actual grain perimeter and the equivalent perimeter, the so called shape factor, is always larger then 1. The shapeFactor
amd measures how different a certain shape is from a circle.
A second measure for the discrepancy between the actual shape and a circle is the relative difference between the perimeter
and the equivalentPerimeter
In this plot round shapes will have values close to zero while concave shapes will get values up to \(0.5\).
A third measure is the paris
which stands for Percentile Average Relative Indented Surface and gives the relative difference between the actual perimeter and the perimeter of the convex hull. It is explained in more detail in the section convex hull parameters.
The fractal dimension of grain boundaries has been used to characterize the conditions of dynamical recrystallization. One way to define the fractal dimension of grain boundaries is to look at the slope of the perimeter as a function of the equivalent radius of the grains. More precisely, we consider this relationship in a log log plot and fit a linear model.
{% highlight matlab %} % consider the entire data set mtexdata forsterite silent % reconstruct grains grains = calcGrains(ebsd('indexed')); % smooth them grains = smooth(grains,5); close all scatter(grains.equivalentRadius,grains.perimeter) xlabel('equivalent radius') ylabel('perimeter') % set axes to logarithmic logAxis(gca, [10,10^4],[10^2,10^5]) % fit a linear function in log space ab = polyfit(log(grains.equivalentRadius),log(grains.perimeter),1); % plot it hold on plot([10,10^4],exp(ab(2) + ab(1) * log([10,10^4])),'LineWidth',3) hold off {% endhighlight %}The slope of the linear function is the fractal dimension.
{% highlight matlab %} fractalDimension = ab(1) {% endhighlight %} {% highlight plaintext %} fractalDimension = 1.0338 {% endhighlight %}It is important to understand that the fractal dimension computed this way heavily depends on the smoothing applied to the grain boundaries.


Simplified scheme of common stages of viral life cycle targeted by antiviral drugs. These stages including: 1) attachment and entry, 2) uncoating, 3) genome replication, 4) genome packaging and assembly of viral particle and 5) virus release and maturation.


This tutorial is going to show you how to startup D365-UI-Test.
Below snippet can be used in an init function of your test framework (e.g. "beforeAll" in jest):
// When saving the settings file with the credentials directly in this directory, be sure to exclude it using .gitignore
const config = fs.readFileSync(path.resolve(__dirname, "settings.txt"), {encoding: "utf-8"});
// Easiest way to store credentials is to just separate url, username and password by comma in the file
const [url, user, password] = config.split(",");
// Pass headless: true for DevOps and when you don't want to see what puppeteer is doing.
// For debugging, setting headless: false is easier as you see what's happening
const browser = await xrmTest.launch({
headless: false,
args: [
"--start-fullscreen"
]
});
// You will probably want to declare the page variable in outer scope as you might need to access it for implementing your own interactions with puppeteer.
const page = await xrmTest.open(url, { userName: user, password: password });
Authentication with the default Microsoft D365 authentication provider is implemented by default. Nothing to take care of.
When having a custom authentication page that you get redirected to on login, you have to provide D365-UI-Test with some additional information.
In some cases these authentication pages need the user name and the password, in some cases only the password is needed. The password is of course always needed.
The xrmTest.open
function is able to use this information:
const page = await xrmTest.open(url, { userName: user, password: password, passwordFieldSelector: "#password_input", userNameFieldSelector: "#userName_input" });
The values for passwordFieldSelector and userNameFieldSelector need to be valid CSS selectors that help D365-UI-Test finding the correct inputs for logging you in. You can find them out using your browser's DOM developer tools. Usually they will have an ID set as above.
For sending this information the enter button will be pressed, no need to specify a login button selector.
Generated using TypeDoc


Upload one or more spatial files or .zip files
containing any number of spatial files.
When uploading .shp files, remember to include .prj, .dbx, and .shx files.
or
| Space required: | {{ fileSize | bytesize }} |
| Space available: | {{ diskSize | bytesize }} |


16 August 2002
Disease Outbreak Reported
As of 2 August 2002, the Ministry of Health has reported 5 833 suspected cases of dengue fever of which 344 have been laboratory confirmed. Dengue haemorrhagic fever is suspected in 158 cases of which 11 have been laboratory confirmed. Dengue 3 has been the predominant circulating strain although 2 districts have reported the presence of dengue 2 in January.
In the Galapagos Islands, 4 cases have now been confirmed by laboratory tests. This is the first reported detection of dengue fever in the Galapagos Islands. The Ministry of Health have sent a team to investigate the outbreak and carry out entomological studies.


Valencia
I left Barcelona early morning around 7 AM while it was still dark. I was now leaving Catalonia and making my journey towards the south.
I took the subway to the train station and was surprised to see that people were already commuting to their work places during early morning.
The central train station in Barcelona is housed in a grand building reminiscent of the Renaissance architecture.
My train was scheduled to depart at 9:30 AM, and it arrived right on time.
The train ticket cost me €28, which I had bought online. The ticketing station was quite crowded when I visited it the previous day which led me to purchase the ticket online. I was surprised to see that other people weren’t doing the same, and were waiting in long queues to buy the ticket. (In hindsight, the online ticket purchase wasn’t very trivial.)
The train arrived right on time and was very clean and equipped with all the essentials. They even provided us with earphones.
This was my first time taking a coastal train and it turned out to be a very enjoyable experience. The journey was very scenic and there were many beautiful sights along the way.
The train stopped numerous times along the way, with the first one being at Salou, a small resort town with many beaches. I was amazed to see how uniform the structural development was throughout Spain. Even some of the smaller towns had good biking lanes.
As the train made its way towards Valencia, I kept noting down the name of each town we passed through. The environment in Spain was quite different compared to France or Switzerland where I currently lived. The scenery was beautiful all along the way.
It took around 4 hours for the train to arrive in Valencia. My first goal after getting out from the train station was to find a rental bicycle. I was able to find a shop fairly easily given that it was lunch time when I arrived.
It cost me €9 to rent a bike for one day (with a €50 security deposit). The bike itself was very comfortable and was equipped with a front basket where I could put my jacket and a small bag.
I then set out to find the Airbnb I had booked out for the night. As I made my way towards the coast I noticed that the streets became quite narrow at some junctions, and it had more apartment blocks than houses. My Airbnb was close to the beach and was very comfortable. The host also had a nice white dog which kept licking my hands (sadly, I didn’t take his picture).
After leaving my luggage I set out to find some food (it was already quite late, around 3 PM). I had some delicious prawns from this small restaurant along the coast. I speculate that during summer time this beach must be very crowded.
The beach was very calming and the sand was quite peculiar looking. It contained different types of pebbles and broken sea shells.
Throughout my journey in Spain I came across a lot of beautiful street art. Valencia was no different. I first saw this building which had an antique feel to it.
Another noticeable difference in Spain, compared to other western European countries, was the abundance of Orange trees. In Valencia these trees were scattered all across the city in almost every street, and were filled with hundreds of Oranges! (I don’t know whether if these Oranges were edible or not. At least I didn’t see anyone plucking them, although it was very tempting.)
The bike lanes in Valencia were plenty and well-built. I travelled throughout the city on my bike.
In the city outskirts there were some exceptionally large buildings. One of them was an aquarium which housed dolphins and other marine species.
Another stunning piece of architecture was the arts theatre. I also found it very fascinating how some construction workers were performing the repairs. The safety procedures looked very robust.
There’s probably a lot of thought put into designing the major cities in Europe. This part was located just outside the city and could house a large crowd. Just alongside these buildings was a large lush green park.
I now made my way back to the city centre. There was a lot to see in Valencia, but sadly I only stayed there for one night and could only see a limited number of places.
Unlike Barcelona, this city wasn’t very crowded.
Like Barcelona, the streets were decorated with Christmas lights.
For some reason I took pictures of every telephone booth I came across. They looked very vintage and cool.
It was now getting dark but there was a lot of activity in the city centre.
It is quite common to come across road musicians throughout Europe, mostly in city centres. This guy was playing a harp.
I walked the streets on foot and then visited a church.
The ceiling was particularly fascinating.
I then walked around the Christmas market, which had numerous items for sale including clothes, antiques, books, etc.
I really wanted to enter this university but it didn’t seem to be open to the public (I did visit the main campus afterwards).
Almost each street was decorated with different lights. I wondered how much time and effort was put into this and if they changed the design each year.
Some random bikes on the road.
There was a protest going on here of some sorts.
I then visited the University of Valencia. Its campus was completely accessible for the public.
I walked across the various department blocks. In the medicine section, they had showcased numerous medical instruments, similar to how it’s done in a museum.
I then went to a Mexican restaurant and had Tacos for dinner.
I again came across some beautiful artwork and couldn’t resist taking its pictures.


With @Chainzillaio, Customers have the possibility to launch their own #blockchain on 4 different networks. Currently we offer our clients services for @NEMofficial , @KomodoPlatform , @QtumOfficial, @Ethereum and we plan on adding more as we test different #blockchains.


Colorado ex-Gov. Hickenlooper’s travel ethics probe released
by NICHOLAS RICCARDIDENVER (AP) - The Colorado Ethics Commission is releasing an investigation into John Hickenlooper’s use of private planes while governor.
A Republican critic filed a complaint alleging Hickenlooper had improperly traveled on private flights during his administration. Hickenlooper is a Democrat who is challenging Republican Sen. Cory Gardner.
The commission’s investigation comes to no conclusions about the ethics of the former governor’s plane travel. It shows that he paid for some of the flights he took such as on a private plane to officiate at the Texas wedding of the brother of entrepreneur Elon Musk. Hickenlooper did not pay for a flight to Connecticut on a plane owned by the company of a billionaire supporters.
The commission will later decide whether Hickenlooper violated the state’s ban on elected officials accepting gifts.
Sign up for Daily Newsletters
Copyright © 2019 The Washington Times, LLC.
Please read our comment policy before commenting.


Planner Update
Long Island Iced Tea
You can make 5 servings, at a cost of $3.00 per drink. Don't forget an extra one for me, I'm definitely coming over!
How many would you like to make?


QAbstract3DAxis Class
The QAbstract3DAxis class is a base class for the axes of a graph. More...
| Header: | #include <QAbstract3DAxis> |
| Since: | QtDataVisualization 1.0 |
| Instantiated By: | AbstractAxis3D |
| Inherits: | QObject |
| Inherited By: |
Public Types
| enum | AxisOrientation { AxisOrientationNone, AxisOrientationX, AxisOrientationY, AxisOrientationZ } |
| enum | AxisType { AxisTypeNone, AxisTypeCategory, AxisTypeValue } |
Properties
|
|
- 1 property inherited from QObject
Public Functions
| virtual | ~QAbstract3DAxis() |
| bool | isAutoAdjustRange() const |
| bool | isTitleFixed() const |
| bool | isTitleVisible() const |
| float | labelAutoRotation() const |
| QStringList | labels() const |
| float | max() const |
| float | min() const |
| AxisOrientation | orientation() const |
| void | setAutoAdjustRange(bool autoAdjust) |
| void | setLabelAutoRotation(float angle) |
| void | setLabels(const QStringList &labels) |
| void | setMax(float max) |
| void | setMin(float min) |
| void | setRange(float min, float max) |
| void | setTitle(const QString &title) |
| void | setTitleFixed(bool fixed) |
| void | setTitleVisible(bool visible) |
| QString | title() const |
| AxisType | type() const |
- 32 public functions inherited from QObject
Signals
| void | autoAdjustRangeChanged(bool autoAdjust) |
| void | labelAutoRotationChanged(float angle) |
| void | labelsChanged() |
| void | maxChanged(float value) |
| void | minChanged(float value) |
| void | orientationChanged(QAbstract3DAxis::AxisOrientation orientation) |
| void | rangeChanged(float min, float max) |
| void | titleChanged(const QString &newTitle) |
| void | titleFixedChanged(bool fixed) |
| void | titleVisibilityChanged(bool visible) |
- 2 signals inherited from QObject
Additional Inherited Members
- 1 public slot inherited from QObject
- 1 public variable inherited from QObject
- 10 static public members inherited from QObject
- 9 protected functions inherited from QObject
- 2 protected variables inherited from QObject
Detailed Description
The QAbstract3DAxis class is a base class for the axes of a graph.
This class specifies the enumerations, properties, and functions shared by graph axes. It should not be used directly, but one of its subclasses should be used instead.
See also QCategory3DAxis and QValue3DAxis.
Member Type Documentation
enum QAbstract3DAxis::AxisOrientation
The orientation of the axis object.
| Constant | Value |
|---|---|
QAbstract3DAxis::AxisOrientationNone | 0 |
QAbstract3DAxis::AxisOrientationX | 1 |
QAbstract3DAxis::AxisOrientationY | 2 |
QAbstract3DAxis::AxisOrientationZ | 4 |
enum QAbstract3DAxis::AxisType
The type of the axis object.
| Constant | Value |
|---|---|
QAbstract3DAxis::AxisTypeNone | 0 |
QAbstract3DAxis::AxisTypeCategory | 1 |
QAbstract3DAxis::AxisTypeValue | 2 |
Property Documentation
autoAdjustRange : bool
This property holds whether the axis will automatically adjust the range so that all data fits in it.
Access functions:
| bool | isAutoAdjustRange() const |
| void | setAutoAdjustRange(bool autoAdjust) |
Notifier signal:
| void | autoAdjustRangeChanged(bool autoAdjust) |
See also setRange(), setMin(), and setMax().
labelAutoRotation : float
This property holds the maximum angle the labels can autorotate when the camera angle changes.
The angle can be between 0 and 90, inclusive. The default value is 0. If the value is 0, axis labels do not automatically rotate. If the value is greater than zero, labels attempt to orient themselves toward the camera, up to the specified angle.
Access functions:
| float | labelAutoRotation() const |
| void | setLabelAutoRotation(float angle) |
Notifier signal:
| void | labelAutoRotationChanged(float angle) |
labels : QStringList
This property holds the labels for the axis.
Note: Setting this property for QValue3DAxis does nothing, as it generates labels automatically.
Access functions:
| QStringList | labels() const |
| void | setLabels(const QStringList &labels) |
Notifier signal:
| void | labelsChanged() |
max : float
This property holds the maximum value on the axis.
When setting this property, the minimum value is adjusted if necessary, to ensure that the range remains valid.
Note: For QCategory3DAxis, specifies the index of the last row or column to show.
Access functions:
| float | max() const |
| void | setMax(float max) |
Notifier signal:
| void | maxChanged(float value) |
min : float
This property holds the minimum value on the axis.
When setting this property, the maximum value is adjusted if necessary, to ensure that the range remains valid.
Note: For QCategory3DAxis, specifies the index of the first row or column to show.
Access functions:
| float | min() const |
| void | setMin(float min) |
Notifier signal:
| void | minChanged(float value) |
orientation : const AxisOrientation
This property holds the orientation of the axis.
The value is one of AxisOrientation values.
Access functions:
| AxisOrientation | orientation() const |
Notifier signal:
| void | orientationChanged(QAbstract3DAxis::AxisOrientation orientation) |
title : QString
This property holds the title for the axis.
Access functions:
| QString | title() const |
| void | setTitle(const QString &title) |
Notifier signal:
| void | titleChanged(const QString &newTitle) |
See also titleVisible and titleFixed.
titleFixed : bool
This property holds the rotation of the axis titles.
If true
, axis titles in the primary graph view will be rotated towards the camera similarly to the axis labels. If false
, axis titles are only rotated around their axis but are not otherwise oriented towards the camera. This property does not have any effect if the labelAutoRotation property value is zero. Default value is true
.
Access functions:
| bool | isTitleFixed() const |
| void | setTitleFixed(bool fixed) |
Notifier signal:
| void | titleFixedChanged(bool fixed) |
See also labelAutoRotation, title, and titleVisible.
titleVisible : bool
This property holds whether the axis title is visible in the primary graph view.
The default value is false
.
Access functions:
| bool | isTitleVisible() const |
| void | setTitleVisible(bool visible) |
Notifier signal:
| void | titleVisibilityChanged(bool visible) |
See also title and titleFixed.
type : const AxisType
This property holds the type of the axis.
The value is one of AxisType values.
Access functions:
| AxisType | type() const |
Member Function Documentation
[virtual]
QAbstract3DAxis::~QAbstract3DAxis()
Destroys QAbstract3DAxis.
[signal]
void QAbstract3DAxis::rangeChanged(float min, float max)
Emits the minimum and maximum values of the range, min and max, when the range changes.
void QAbstract3DAxis::setRange(float min, float max)
Sets the value range of the axis from min to max. When setting the range, the maximum value is adjusted if necessary, to ensure that the range remains valid.
Note: For QCategory3DAxis, specifies the index range of rows or columns to show.


Accordions
Section 1
A paragraph (from the Greek paragraphos, "to write beside" or "written beside") is a self-contained unit of a discourse in writing dealing with a particular point or idea. A paragraph consists of one or more sentences. Though not required by the syntax of any language, paragraphs are usually an expected part of formal writing, used to organize longer prose.
Section 2
A paragraph (from the Greek paragraphos, "to write beside" or "written beside") is a self-contained unit of a discourse in writing dealing with a particular point or idea. A paragraph consists of one or more sentences. Though not required by the syntax of any language, paragraphs are usually an expected part of formal writing, used to organize longer prose.
Section 3
A paragraph (from the Greek paragraphos, "to write beside" or "written beside") is a self-contained unit of a discourse in writing dealing with a particular point or idea. A paragraph consists of one or more sentences. Though not required by the syntax of any language, paragraphs are usually an expected part of formal writing, used to organize longer prose.
Section 1
A paragraph (from the Greek paragraphos, "to write beside" or "written beside") is a self-contained unit of a discourse in writing dealing with a particular point or idea. A paragraph consists of one or more sentences. Though not required by the syntax of any language, paragraphs are usually an expected part of formal writing, used to organize longer prose.
Section 2
A paragraph (from the Greek paragraphos, "to write beside" or "written beside") is a self-contained unit of a discourse in writing dealing with a particular point or idea. A paragraph consists of one or more sentences. Though not required by the syntax of any language, paragraphs are usually an expected part of formal writing, used to organize longer prose.
Section 3
A paragraph (from the Greek paragraphos, "to write beside" or "written beside") is a self-contained unit of a discourse in writing dealing with a particular point or idea. A paragraph consists of one or more sentences. Though not required by the syntax of any language, paragraphs are usually an expected part of formal writing, used to organize longer prose.


|
Picasso is the new review and recommendation site for extracurricular teachers and classes.
|
|
|
|
|
|
|
{% block content %}
{% endblock %}
Copyright © 2014 Picasso, All rights
reserved.
You are receiving this email because you are
an extracurricular teacher listed on Picasso.
Our mailing address is:
|
|
|
|
|
|


There are only two kinds of redeclarations that do not require the modified element to be declared replaceable: restricting the variability of a declared variable, e.g. from parameter to constant or restricting array dimension sizes, e.g. from (:) to a specified size. The following examples demonstrates these kinds of redeclarations.
C4 is equivalent to C4expanded below.


Connect to LATIN AMERICAN AND LATINO STUDIES-LPS in the Course Register.
LATIN AMERICAN AND LATINO STUDIES
LALS-155 AFRO-LATINOS IN THE U.S. 1 CU 601 LEC MW 5-6:30PM JAFF 104 ANDINO S CROSS LISTED: AFRC-155 SOCI-154 SECTION MAX: 8 MAX W/CROSS LIST: 16 LALS-425 LATIN@ CULTURAL HISTORY 1 CU 601 SEM T 5:30-8:30PM WILL 306 IRIZARRY J CROSS LISTED: SOCI-425 SECTION MAX: 8 MAX W/CROSS LIST: 16
Return to Course & Room Roster
Comments to:
Office of the University Registrar
University of Pennsylvania
Room 221 Franklin Building
3451 Walnut Street
Philadelphia, PA 19104-6291
Phone:<PHONE_NUMBER> Fax:<PHONE_NUMBER>
<EMAIL_ADDRESS>Updated: Sat Jan 17 08:30:02 2015


The 2018 R Package Calendar
These are 24 of my favorite R things.
xaringan
- Day One
- Stars 852
- Forks 172
Mountains of examples and excellent documentation makes
xaringan
a pleasure to work with.
readr
- Day Two
- Stars 739
- Forks 232
The readr
package allows for an easy and fast way to
read rectangular data.
xaringan
- Day Three
- Stars 431
- Forks 111
If manual tweetering isn't enough for you, you can use the
rtweet
package to accelerate your work! Collect,
analyze and summarize tweets with rtweet
.


Schools asked to ensure safety of children
Collector seeks MGNREGS help to clean school compounds
by Special CorrespondentAn emergency meeting of Education Department officials convened by District Collector S. Shanawas, against the backdrop of the Batheri incident, asked the head teachers of government, aided, and unaided schools to take stock of the safety and security of students at their respective institutions.
They were asked to give an affidavit to the Deputy Director of Education within a week that there is no threat to the students in their schools.
The head teachers should inform the authorities about the dilapidated school buildings and other lack of facilities. Distance education institutions, anganwadis, vocational and higher secondary institutions, and colleges should also take stock of their facilities, the Collector said.
Schools should be able to provide safe and secure atmosphere for the students, he added.
The District Collector gave instruction to the joint coordinator of the Mahatma Gandhi National Rural Employment Guarantee Scheme (MGNREGS) to utilise the project to clean compounds of government schools and to prepare them for projects such as vegetable farming.
Repair work
The funds of panchayats should be utilised for repairing government schools and anganwadis.
As part of the mission to make schools safe and secure for students, the District Collector visited Kuttoor on Friday.
BJP march
Meanwhile, alleging negligence of the Education Department in the death of a girl student at a Sultan Batheri School following snake bite, Bharatiya Janata Party activists on Friday took a protest march to the office of Education Minister C. Ravindranath at Puthukkad.


{% filter markdown %}
Dear Competition Organizer,
a competition entry by user **{{ user.username }}** has been published on
{{ entry.published_on.strftime('%Y-%m-%d %H:%M') }} and is waiting for approval.
**Title:** *{{ entry.title }}*
**Artist:** *{{ entry.artist }}*
**URL:** [{{ entry.url }}]({{ entry.url }})
Please go to [{{ approve_url }}]({{ approve_url }}) to review the entry.
The Open Source Music FM Synthesizer Challenge
{% endfilter %}


- Data is 3-Dimensional (USER, ITEMS, INTERACTIONS)
- 2 Dimensions (USER and ITEMS) shall vary with time
- Dimension of Interaction is Fixed (4 D)
Papers
- Original Paper
- Matrix Factorization Techniques
- Scalable Techniques
- Online Learning
- Demographical Info Usage
- Neural Network based Hybrid Technique
- Large Scale Parallel technique for Collaborative Filtering
- Scalable Inference for latent variable models
- latent source modelfor online collab filtering
- high frequency collab filtering
- multi-task CF for on-the-fly recommender system
- online learning for CF
Previous Implementations
- Factorizer
- Tensorrec
- NVIDIA Autoencoders
Timeline
- Algorithm to handle variability in the first 2 dimensions
- Ways to handle 3 dimensional data:
- Some form of averaging of the interactions
- Consider 4 different matrices and append results at the end
- Prediction method speed testing
- Matrix Factorization
- Deep Learning with Auto Encoders


| Interface | Description |
|---|---|
| AfterBeanDiscovery |
The event type of the second event fired by the container when it has fully completed the bean discovery process, validated
that there are no definition errors relating to the discovered beans, and registered
Bean
and ObserverMethod objects for the discovered beans, but before detecting deployment
problems. |
| AfterDeploymentValidation |
The event type of the third event fired by the container after it has validated that there are no deployment problems and
before creating contexts or processing requests.
|
| AfterTypeDiscovery |
This event type is thrown by the container after type discovery is complete.
|
| Annotated |
Represents a Java program element that can be annotated.
|
| AnnotatedCallable<X> |
Represents a callable member of a Java type.
|
| AnnotatedConstructor<X> |
Represents a constructor of a Java class.
|
| AnnotatedField<X> |
Represents a field of a Java class.
|
| AnnotatedMember<X> |
Represents a member of a Java type.
|
| AnnotatedMethod<X> |
Represents a method of a Java type.
|
| AnnotatedParameter<X> |
Represents a parameter of a method or constructor.
|
| AnnotatedType<X> |
Represents a Java class or interface.
|
| Bean<T> |
Represents an enabled bean.
|
| BeanAttributes<T> |
The BeanAttributes interface exposes the basic attributes of a bean.
|
| BeanContainer |
BeanContainer is a superclass of BeanManager containing capabilities that are portable across
all CDI environments. |
| BeanManager |
Allows a portable extension to interact directly with the container.
|
| BeforeBeanDiscovery |
This event type is thrown by the container before the bean discovery process begins.
|
| BeforeShutdown |
The type of the final event the container fires after it has finished processing requests and destroyed all contexts.
|
| CDIProvider |
Interface implemented by a CDI provider to provide access to the current container
|
| Decorator<T> |
Represents an enabled decorator.
|
| EventContext<T> |
Represents a context of a fired event.
|
| EventMetadata |
Provides access to metadata about an observed event payload.
|
| Extension |
Service interface implemented by extensions.
|
| InjectionPoint |
Provides access to metadata about an injection point.
|
| InjectionTarget<T> |
Provides operations for performing dependency injection and lifecycle callbacks on an
instance of a type.
|
| InjectionTargetFactory<T> |
An
InjectionTargetFactory can create an InjectionTarget for a given bean. |
| InterceptionFactory<T> |
InterceptionFactory allows to create a wrapper instance whose method invocations are intercepted by method
interceptors and forwarded to a provided instance. |
| Interceptor<T> |
Represents an enabled interceptor.
|
| ObserverMethod<T> |
Represents an observer method of an enabled
bean.
|
| PassivationCapable |
Indicates that a custom implementation of
Bean or
Contextual is passivation capable. |
| Prioritized |
This interface allows some SPI implementation to change their priority programmatically.
|
| ProcessAnnotatedType<X> |
The container fires an event of this type for each Java class or interface it discovers in a bean archive, before it reads
the declared annotations.
|
| ProcessBean<X> |
The container fires an event of this type for each enabled bean, interceptor or decorator deployed in a bean archive, before
registering the
Bean object. |
| ProcessBeanAttributes<T> |
The container fires an event of this type for each enabled bean, interceptor or decorator deployed in a bean archive before
registering the
Bean object. |
| ProcessInjectionPoint<T,X> |
The container fires an event of this type for every injection point of every Java EE component class supporting injection
that may be instantiated by the container at runtime, including every managed bean declared using
jakarta.annotation.ManagedBean , EJB session or message-driven bean, enabled bean, enabled interceptor or enabled
decorator. |
| ProcessInjectionTarget<X> |
The container fires an event of this type for every Java EE component class supporting injection that may be instantiated by
the container at runtime, including every managed bean declared using
jakarta.annotation.ManagedBean , EJB session or
message-driven bean, enabled bean, enabled interceptor or enabled decorator. |
| ProcessManagedBean<X> |
The container fires an event of this type for each enabled managed bean, before registering the
Bean object. |
| ProcessObserverMethod<T,X> |
The container fires an event of this type for each observer method of each
enabled bean, before registering the
ObserverMethod object. |
| ProcessProducer<T,X> |
The container fires an event of this type for each producer method or field of
each enabled bean, including resources.
|
| ProcessProducerField<T,X> |
The container fires an event of this type for each enabled producer field, before registering the
Bean object. |
| ProcessProducerMethod<T,X> |
The container fires an event of this type for each enabled producer method, before registering the
Bean object. |
| ProcessSessionBean<X> |
The container fires an event of this type for each enabled session bean, before registering the
Bean object. |
| ProcessSyntheticAnnotatedType<X> |
The container fires an event of this type for each Java class or interface added by
BeforeBeanDiscovery.addAnnotatedType(AnnotatedType, String) or
AfterTypeDiscovery.addAnnotatedType(AnnotatedType, String) |
| ProcessSyntheticBean<X> |
The container fires an event of this type for each custom bean implementation added through
AfterBeanDiscovery.addBean() or AfterBeanDiscovery.addBean(Bean) , before registering the
Bean object. |
| ProcessSyntheticObserverMethod<T,X> |
The container fires an event of this type for each custom implementation of
ObserverMethod added through
AfterBeanDiscovery.addObserverMethod(ObserverMethod) or AfterBeanDiscovery.addObserverMethod() , before
registering the ObserverMethod object. |
| Producer<T> |
Provides a generic operation for producing an instance of a type.
|
| ProducerFactory<X> |
An
ProducerFactory can create an Producer for a given bean. |
| Class | Description |
|---|---|
| CDI<T> |
Provides access to the current container.
|
| Unmanaged<T> |
Helper class for injecting and calling lifecycle callbacks unmanaged instances for use by framework and library integrators.
|
| Unmanaged.UnmanagedInstance<T> |
Represents a non-contextual instance.
|
| Enum | Description |
|---|---|
| InterceptionType |
Identifies the kind of lifecycle callback, EJB timeout method or business method interception.
|
| SessionBeanType |
Identifies the kind of EJB session bean.
|
| Exception | Description |
|---|---|
| DefinitionException |
Thrown when a definition error occurs.
|
| DeploymentException |
Thrown when a deployment problem occurs.
|
| Annotation Type | Description |
|---|---|
| WithAnnotations |
WithAnnotations may be applied to any portable extension observer method with an event parameter type of
ProcessAnnotatedType to filter the events delivered. |
The portable extension integration SPI.
A portable extension may integrate with the container by:
BeanManager
objectPortable extensions sometimes interact directly with the container
via programmatic API call. The interface
BeanManager
provides operations
for obtaining contextual references for beans, along with many other
operations of use to portable extensions.
During the application initialization process, the container fires
a series of events, allowing
portable extensions to integrate with the container initialization
process. Observer methods of these events must belong to
extensions declared
in META-INF/services
.
Lifecycle events include
BeforeBeanDiscovery
,
AfterBeanDiscovery
,
AfterDeploymentValidation
and
BeforeShutdown
.
The interfaces
Bean
,
Decorator
,
Interceptor
and
ObserverMethod
define everything the container needs to manage instances of
a bean, interceptor, decorator or observer method.
An instance of Bean
exists for every
enabled bean. A portable
extension may add support for new kinds of beans by implementing
Bean
, observing the event
AfterBeanDiscovery
event
registering beans with the container. An instance of
ObserverMethod
exists for every
observer method of every
enabled bean. A portable extension may add observers by implementing
ObserverMethod
and
registering an instance with the container.
A portable extension may be notified of the existence of an
enabled bean by observing the container lifecycle event type
ProcessBean
or one of its
subtypes,
or of the existence of an observer method of an enabled bean by
observing the event type
ProcessObserverMethod
.
A portable extension may provide an alternative metadata source, such as configuration by XML.
Annotated
and its subtypes allow a portable extension to specify
metadata that overrides the annotations that exist on a
bean class. The portable extension is responsible for
implementing the interfaces, thereby exposing the metadata
to the container. The container must use the operations of
Annotated
and its subinterfaces to discover program
element types and annotations, instead of directly calling the
Java Reflection API.
A portable extension provides its metadata to the
container by observing the event
ProcessAnnotatedType
and
wrapping the AnnotatedType
.
Producer
and InjectionTarget
The interfaces Producer
and
InjectionTarget
abstract the
basic lifecycle of (contextual or non-contextual) container managed
objects, including instantiation and destruction, dependency injection
and lifecycle callbacks.
An instance of InjectionTarget
may be product of
BeanManager.getInjectionTargetFactory(AnnotatedType)
obtained from the BeanManager
,
allowing a portable extension to request these container services for
objects under the control of the portable extension.
Furthermore, a portable extension may replace the implementation
of InjectionTarget
or
Producer
used by the container
with its own implementation by observing the events
ProcessInjectionTarget
or
ProcessProducer
.


This document outlines the API changes that have been done to AWT and Swing to accomodate the new focus model. For a general overview of the changes, you may want to first read this.
Modifications to existing classes:
New classes:
Add the following to
java.awt.AWTEvent
:
public void setSource(Object newSource)
Changes to java.awt.Component
:
public boolean isFocusTraversable() public boolean isFocusable() public void setFocusable(boolean focusable) public void setFocusTraversalKeys(int id, Set keystroke) public Set getFocusTraversalKeys(int id) public void setFocusTraversalKeysEnabled(boolean focusTraversalKeysEnabled) public boolean getFocusTraversalKeysEnabled() public void requestFocus() protected boolean requestFocus(boolean temporary) public boolean requestFocusInWindow() protected boolean requestFocusInWindow(boolean temporary) public void transferFocus() public void transferFocusBackward() public void transferFocusUpCycle() public Container getFocusCycleRootAncestor() public boolean isFocusCycleRoot(Container container) public boolean hasFocus() public boolean isFocusOwner() public void addPropertyChangeListener(PropertyChangeListener listener) public void removePropertyChangeListener(PropertyChangeListener listener) public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) public void removePropertyChangeListener(String propertyName, PropertyChangeListener listener) public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) public void firePropertyChange(String propertyName, int oldValue, int newValue) public boolean isFontSet() public boolean isBackgroundSet() public boolean isForegroundSet() public boolean isCursorSet() public boolean areFocusTraversalKeysSet(int id)
Changes to java.awt.Container
:
public void setFocusTraversalKeys(int id, Set keystroke) public Set getFocusTraversalKeys(int id) public void setFocusTraversalPolicy(FocusTraversalPolicy policy) public FocusTraversalPolicy getFocusTraversalPolicy() public void setFocusCycleRoot(boolean focusCycleRoot) public boolean isFocusCycleRoot() public boolean isFocusCycleRoot(Container container) public void transferFocusDownCycle() public void addPropertyChangeListener(PropertyChangeListener listener) public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener) public boolean areFocusTraversalKeysSet(int id) public boolean isFocusTraversalPolicySet()
public void toFront() public void toBack() public Component getFocusOwner() public Component getMostRecentFocusOwner() public boolean isActive() public boolean isFocused() public final void setFocusCycleRoot(boolean focusCycleRoot) public final boolean isFocusCycleRoot() public final Container getFocusCycleRootAncestor() public boolean isFocusableWindow() public void setFocusableWindowState(boolean focusableWindowState) public void addPropertyChangeListener(PropertyChangeListener listener) public void addPropertyChangeListener(String propertyName, PropertyChangeListener listener)
Add the following to the javadoc
of java.awt.Frame
:
/** * Frames are capable of generating the following types of WindowEvents: * WindowOpened, WindowClosing, WindowClosed, WindowIconified, * WindowDeiconified, WindowActivated, WindowDeactivated, WindowGainedFocus, * WindowLostFocus. */
Add the following to the javadoc
of java.awt.Dialog
:
/** * Dialogs are capable of generating the following WindowEvents: * WindowOpened, WindowClosing, WindowClosed, WindowActivated, * WindowDeactivated, WindowGainedFocus, WindowLostFocus. */
Add the following to
java.awt.event.FocusEvent
:
public FocusEvent(Component source, int id, boolean temporary, Component opposite) public Component getOppositeComponent()
Add the following to
the javadoc of java.awt.event.WindowEvent
:
/** * A low-level event that indicates that a window has changed its status. This * low-level event is generated by a Window object when it is opened, closed, * activated, deactivated, iconified, or deiconified, or when focus is * transfered into or out of the Window. */
Add the following to java.awt.event.WindowEvent
:
public static final int WINDOW_ACTIVATED public static final int WINDOW_DEACTIVATED public static final int WINDOW_GAINED_FOCUS public static final int WINDOW_LOST_FOCUS public WindowEvent(Window source, int id, Window opposite) public Window getOppositeWindow()
Add the following to java.awt.event.WindowListener:
public void windowActivated(WindowEvent e) public void windowDeactivated(WindowEvent e)
Add the following
to java.awt.event.WindowAdapter
:
public void windowGainedFocus(WindowEvent e) public void windowLostFocus(WindowEvent e)
Add
the following to java.awt.AWTEventMulticaster
:
public void windowGainedFocus(WindowEvent e) public void windowLostFocus(WindowEvent e)
Modifications to
javax.swing.FocusManager
This class has been obsoleted. New applications should use
java.awt.KeyboardFocusManager
exclusively. Nevertheless, we have preserved backward compatibility
for existing applications (but not applets) which define their own
FocusManager
.
The Swing FocusManager
has been changed to be a
subclass of the new, AWT KeyboardFocusManager
.
FocusManager.setCurrentManager(FocusManager)
and
FocusManager.getCurrentManager()
have been changed to
wrappers around
KeyboardFocusManager.setCurrentKeyboardFocusManager(KeyboardFocusManager)
and
KeyboardFocusManager.getCurrentKeyboardFocusManager()
,
respectively.
There was much discussion over these changes because
KeyboardFocusManager.setCurrentKeyboardFocusManager(KeyboardFocusManager)
will throw a SecurityException
if the calling thread
was not granted the "replaceKeyboardFocusManager"
permission. Previously,
FocusManager.setCurrentManager(FocusManager)
would
never throw a SecurityException
. Although we were able
to design a convoluted class organization which avoided this
problem, we felt that the elegance and simplicity of the proposed
design outweighed the rather small backward compatibility
concern.
disableSwingFocusManager()
and
isFocusManagerEnabled()
should not be used. Disabling
the Swing FocusManager
now has the semantics of
reverting the default FocusTraversalPolicy
from the
Swing default of
javax.swing.LayoutFocusTraversalPolicy
to the AWT
default of java.awt.DefaultFocusTraversalPolicy
.
Modifications to javax.swing.DefaultFocusManager
This class has been obsoleted. New applications should use
java.awt.KeyboardFocusManager
exclusively. Nevertheless, we have preserved backward compatibility
for existing applications (but not applets) which define their own
DefaultFocusManager
.
If client code installs a legacy
DefaultFocusManager
, we provide backward compatibility
by installing a non-public
LegacyGlueFocusTraversalPolicy
which routes
FocusTraversalPolicy
method invocations to the
corresponding methods on DefaultFocusManager
.
Modifications to
javax.swing.JComponent
isManagingFocus
: This method has been obsoleted. It
changed a JComponent
's focus traversal keys from TAB
and SHIFT-TAB to CTRL-TAB and CTRL-SHIFT-TAB. It also marked the
JComponent
in such a way that focus traversal would
not automatically enter the JComponent
. This was
similar to, but different from, marking a JComponent
as a focus cycle root. Its functionality is superseded by the
FocusTraversalPolicy
class, per-Component
focus traversal keys, and the
ability to disable a Component
's focus traversal keys
en masse.
setNextFocusableComponent/getNextFocusableComponents
:
These methods have been obsoleted
FocusTraversalPolicies
are more reliable because they
allow an algorithmic expression of focus traversal. These methods
force applications to hard-code focus traversal
Component
by Component
.
The spec for
setRequestFocusEnabled/isRequestFocusEnabled
has changed, such that the requestFocusEnabled
property is now a hint to the current look and feel.
requestDefaultFocus
: This method has been
obsoleted. Its functionality is superseded by
FocusTraversalPolicy.getDefaultComponent(Container).requestFocus()
.
Modifications
to javax.swing.JInternalFrame
getMostRecentFocusOwner
: Like
java.awt.Window
, JInternalFrame
has a
getFocusOwner()
method left over from before
centralization of focus management in
java.awt.KeyboardFocusManager
. To round out the API,
and to remain consistent with Window,
getMostRecentFocusOwner()
has been added to
JInternalFrame
with the same specification as the
corresponding method on Window
.
setFocusCycleRoot/isFocusCycleRoot
:
These methods give JInternalFrames
similar semantics
to top-level Windows
in AWT. Since a
JInternalFrame
must always be a focus cycle root,
these methods are overridden and declared final to enforce that
restriction. However, unlike an AWT Window
, a
JInternalFrame
can have a focus-cycle-root ancestor,
such as a JDesktopPane
. Thus,
Component.getFocusCycleRootAncestor()
is not declared
final in JInternalFrame
as it is in
Window
.
Modifications to
javax.swing.KeyStroke
Because the existing KeyStroke
class was useful for
designing per-Component
focus traversal key APIs, this
class was promoted with minor modifications to AWT as java.awt.AWTKeyStroke
.
The Swing class is now a subclass of the AWT class.
The one deprecated method in KeyStroke
,
getKeyStroke(char, boolean)
, was not promoted to AWT.
Because of this, there is no simple way for this method to
participate in the standard AWTKeyStroke
caching
scheme. The specification of this method has been changed to note
that implementations need not cache the instances returned by this
method.
Modifications
to javax.swing.SwingUtilities
findFocusOwner:
This method has been obsoleted. Its
functionality is superseded by
KeyboardFocusManager.getFocusOwner()
.


In this week's podcast, we talk with our guest Pakratt about GTA V sales surpassing $1 billion within 3 days, PS4 allowing capture over HDMI, Dark Souls 2 being available for PS3 and Xbox 360 in March 2014, and PS4 being sold at a $60 loss per $399 console.


In order to support event-driven application frameworks and so as not to burden the kernel with POSIX primitives (such as signals), a fully generic event handling and dispatching system has been built into Pedigree.
Events are sent asynchronously with no return value or indication that they
have been received or handled. Event subclasses provide serialize
and
unserialize
functions that allow the passing of Events over address space
boundaries (see below). Events may be nested - one event may be being handled
when another is fired. This can continue up to a hard limit, which is
implementation defined.
All events must subclass class Event
;
class Event
{
public:
Event(uintptr_t handlerAddress, bool isDeletable, size_t specificNestingLevel=~0UL);
virtual ~Event();
virtual bool isDeletable();
virtual size_t serialize(uint8_t *pBuffer) = 0;
static bool unserialize(uint8_t *pBuffer, Event &event);
static size_t getEventType(uint8_t *pBuffer);
uintptr_t getHandlerAddress();
size_t getSpecificNestingLevel();
virtual size_t getNumber();
};
Note that the important functions that require overriding are serialize
,
unserialize
and getNumber
. For a full description of each function, see
the doxygen documentation.
Each Event
object can have only one handler address. This cannot be changed at
runtime; the value is not thread-reentrant. An Event
can be deletable - if this
is true, when the Event
is fired it will be immediately deleted. This is useful
for creating 'fire-and-forget' type events, so you don't have to worry about
memory leaks.
So, hypothetically, what if you had an Event that when fired, did a kind of longjmp
(Probably using the Processor::saveState
and Processor::restoreState
functions) to some code in the original thread? This could be used as a hard timeout
(in fact, this exact mechanism is implemented in TimeoutGuard
). There is a problem here - Events can be nested, and you may be inadvertently longjmp'ing over another Event that is partially executed (and possibly preempted).
It is for this reason that the specificNestingLevel
constructor parameter is implemented. Using this (as opposed to the default value of ~0UL
) constrains the kernel to only run this Event when it is currently at that event nesting level.
TODO.


Ever get frustrated that a problem in your town or neighborhood goes ages without being resolved? You might have road issues (potholes, dangerous areas..), overgrown plant issues, or anything else that makes living where you live a little less pleasant. With Co-make you can make your voice heard on the issues you would like to see resolved in your community. 3 simple steps:
Neighborhood Projects
Massive Pot Hole
A massive pot hole has been reported 23rd street near the cross street Park Ave. In the situation where you have to take this street be officials arrive, please becareful and exercise extreme caution as we do not want you or your vehicle to fall inside. Please upvote this issue so that it can be taken care of as soona s possible.