Copyright © 2010 W3C® (MIT, ERCIM, Keio), All Rights Reserved. W3C liability, trademark and document use rules apply.
This specification defines an API for storing data in databases that can be queried using a variant of SQL.
Beware. This specification is no longer in active maintenance and the Web Applications Working Group does not intend to maintain it further.
This section describes the status of this document at the time of its publication. Other documents may supersede this document. A list of current W3C publications and the most recently formally published revision of this technical report can be found in the W3C technical reports index at http://www.w3.org/TR/.
This document is the 18 November 2010 Working Group Note of Web SQL Database. Publication as a Working Group Note does not imply endorsement by the W3C Membership. This is a draft document and may be updated, replaced or obsoleted by other documents at any time. It is inappropriate to cite this document as other than work in progress. The W3C Web Applications Working Group is the W3C working group responsible for this document.
This document was on the W3C Recommendation track but specification work has stopped. The specification reached an impasse: all interested implementors have used the same SQL backend (Sqlite), but we need multiple independent implementations to proceed along a standardisation path.
The Web Applications Working Group continues work on two other storage-related specifications: Web Storage and Indexed Database API.
Implementors should be aware that this specification is not stable. Implementors who are not taking part in the discussions are likely to find the specification changing out from under them in incompatible ways. Vendors interested in implementing this specification should join the aforementioned mailing lists and take part in the discussions.
If you wish to make comments regarding this document, please send them to<EMAIL_ADDRESS>(subscribe, archives) or<EMAIL_ADDRESS>(subscribe, archives), or submit them using our public bug database. All feedback is welcome.
The latest stable version of the editor's draft of this specification is always available on the W3C CVS server. Change tracking for this document is available at the following location:
This specification is automatically generated from the corresponding section in the HTML5 specification's source document, as hosted in the WHATWG Subversion repository. Detailed change history for all of HTML5, including the parts that form this specification, can be found at the following locations:
This document was produced by a group operating under the 5 February 2004 W3C Patent Policy. W3C maintains a public list of any patent disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent which the individual believes contains Essential Claim(s) must disclose the information in accordance with section 6 of the W3C Patent Policy.
This section is non-normative.
This specification introduces a set of APIs to manipulate client-side databases using SQL.
The API is asynchronous, so authors are likely to find anonymous functions (lambdas) very useful in using this API.
Here is an example of a script using this API. First, a function
prepareDatabase()
is defined. This function
returns a handle to the database, first creating the database if
necessary. The example then calls the function to do the actual
work, in this case showDocCount()
.
function prepareDatabase(ready, error) { return openDatabase('documents', '1.0', 'Offline document storage', 5*1024*1024, function (db) { db.changeVersion('', '1.0', function (t) { t.executeSql('CREATE TABLE docids (id, name)'); }, error); }); } function showDocCount(db, span) { db.readTransaction(function (t) { t.executeSql('SELECT COUNT(*) AS c FROM docids', [], function (t, r) { span.textContent = r.rows[0].c; }, function (t, e) { // couldn't read database span.textContent = '(unknown: ' + e.message + ')'; }); }); } prepareDatabase(function(db) { // got database var span = document.getElementById('doc-count'); showDocCount(db, span); }, function (e) { // error getting database alert(e.message); });
The executeSql()
method has
an argument intended to allow variables to be substituted into
statements without risking SQL injection vulnerabilities:
db.readTransaction(function (t) { t.executeSql('SELECT title, author FROM docs WHERE id=?', [id], function (t, data) { report(data.rows[0].title, data.rows[0].author); }); });
Sometimes, there might be an arbitrary number of variables to substitute in. Even in these case, the right solution is to construct the query using only "?" characters, and then to pass the variables in as the second argument:
function findDocs(db, resultCallback) { var q = ""; for each (var i in labels) q += (q == "" ? "" : ", ") + "?"; db.readTransaction(function (t) { t.executeSql('SELECT id FROM docs WHERE label IN (' + q + ')', labels, function (t, data) { resultCallback(data); }); }); }
All diagrams, examples, and notes in this specification are non-normative, as are all sections explicitly marked non-normative. Everything else in this specification is normative.
The key words "MUST", "MUST NOT", "REQUIRED", "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", and "OPTIONAL" in the normative parts of this document are to be interpreted as described in RFC2119. For readability, these words do not appear in all uppercase letters in this specification. [RFC2119]
Requirements phrased in the imperative as part of algorithms (such as "strip any leading space characters" or "return false and abort these steps") are to be interpreted with the meaning of the key word ("must", "should", "may", etc) used in introducing the algorithm.
Some conformance requirements are phrased as requirements on attributes, methods or objects. Such requirements are to be interpreted as requirements on user agents.
Conformance requirements phrased as algorithms or specific steps may be implemented in any manner, so long as the end result is equivalent. (In particular, the algorithms defined in this specification are intended to be easy to follow, and not intended to be performant.)
The only conformance class defined by this specification is user agents.
User agents may impose implementation-specific limits on otherwise unconstrained inputs, e.g. to prevent denial of service attacks, to guard against running out of memory, or to work around platform-specific limitations.
When support for a feature is disabled (e.g. as an emergency measure to mitigate a security problem, or to aid in development, or for performance reasons), user agents must act as if they had no support for the feature whatsoever, and as if the feature was not mentioned in this specification. For example, if a particular feature is accessed via an attribute in a Web IDL interface, the attribute itself would be omitted from the objects that implement that interface — leaving the attribute on the object but making it return null or throw an exception is insufficient.
This specification relies on several other underlying specifications.
Many fundamental concepts from HTML are used by this specification. [HTML]
The IDL blocks in this specification use the semantics of the WebIDL specification. [WEBIDL]
The construction "a Foo
object", where
Foo
is actually an interface, is sometimes
used instead of the more accurate "an object implementing the
interface Foo
".
The term DOM is used to refer to the API set made available to
scripts in Web applications, and does not necessarily imply the
existence of an actual Document
object or of any other
Node
objects as defined in the DOM Core
specifications. [DOMCORE]
An IDL attribute is said to be getting when its value is being retrieved (e.g. by author script), and is said to be setting when a new value is assigned to it.
The term "JavaScript" is used to refer to ECMA262, rather than the official term ECMAScript, since the term JavaScript is more widely known. [ECMA262]
Each origin has an associated set of databases. Each database has a name and a current version. There is no way to enumerate or delete the databases available for an origin from this API.
Each database has one version at a time; a database can't exist in multiple versions at once. Versions are intended to allow authors to manage schema changes incrementally and non-destructively, and without running the risk of old code (e.g. in another browser window) trying to write to a database with incorrect assumptions.
[Supplemental, NoInterfaceObject] interface WindowDatabase { Database openDatabase(in DOMString name, in DOMString version, in DOMString displayName, in unsigned long estimatedSize, in optional DatabaseCallback creationCallback); }; Window implements WindowDatabase; [Supplemental, NoInterfaceObject] interface WorkerUtilsDatabase { Database openDatabase(in DOMString name, in DOMString version, in DOMString displayName, in unsigned long estimatedSize, in optional DatabaseCallback creationCallback); DatabaseSync openDatabaseSync(in DOMString name, in DOMString version, in DOMString displayName, in unsigned long estimatedSize, in optional DatabaseCallback creationCallback); }; WorkerUtils implements WorkerUtilsDatabase; [Callback=FunctionOnly, NoInterfaceObject] interface DatabaseCallback { void handleEvent(in Database database); };
The openDatabase()
method on
the Window
and WorkerUtils
interfaces and
the openDatabaseSync()
method on the WorkerUtils
interface take the following
arguments: a database name, a database version, a display name, an
estimated size — in bytes — of the data that will be
stored in the database, and optionally a callback to be invoked if
the database has not yet been created. The callback, if provided, is
intended to be used to call changeVersion()
; the
callback is invoked with the database having the empty string as its
version regardless of the given database version. If the callback is
not provided, the database is created with the given database
version as its version.
When invoked, these methods must run the following steps, with all but the last two steps being run atomically:
The user agent may raise a SECURITY_ERR
exception
instead of returning a Database
object if the request
violates a policy decision (e.g. if the user agent is configured
to not allow the page to open databases).
For the method on the Window
object: let origin be the origin of the
active document of the browsing context
of the Window
object on which the method was
invoked.
For the methods on the WorkerUtils
object: let
origin be the origin of the
scripts in the worker.
If origin is not a scheme/host/port
tuple, then throw a SECURITY_ERR
exception and abort
these steps.
If the database version provided is not the empty string,
and there is already a database with the given name from the origin
origin, but the database has a different
version than the version provided, then throw an
INVALID_STATE_ERR
exception and abort these
steps.
If no database with the given name from the origin origin exists, then create the database and let created be true. If a callback was passed to the method, then set the new database's version to the empty string. Otherwise, set the new database's version to the given database version.
Otherwise, if a database with the given name already exists, let created be false.
For the openDatabase()
methods: let result be a newly constructed
Database
object representing the database with the
given database name from the origin origin.
For the openDatabaseSync()
method:
let result be a newly constructed
DatabaseSync
object representing the database with
the given database name from the origin origin.
If created is false or if no callback was passed to the method, skip this step. Otherwise:
For the openDatabase()
methods: queue a task to to invoke the callback with
result as its only argument.
For the openDatabaseSync()
method:
invoke the callback with result as its only
argument. If the callback throws an exception, rethrow that
exception and abort these steps.
Return result.
All strings including the empty string are valid database names. Database names must be compared in a case-sensitive manner.
Implementations can support this even in environments that only support a subset of all strings as database names by mapping database names (e.g. using a hashing algorithm) to the supported set of names.
The version that the database was opened with is the expected version of
this Database
or DatabaseSync
object. It
can be the empty string, in which case there is no expected version
— any version is fine.
User agents are expected to use the display name and the estimated database size to optimize the user experience. For example, a user agent could use the estimated size to suggest an initial quota to the user. This allows a site that is aware that it will try to use hundreds of megabytes to declare this upfront, instead of the user agent prompting the user for permission to increase the quota every five megabytes.
When the user agent is to preprocess a SQL statement sqlStatement with an array of arguments arguments, it must run the following steps:
Parse sqlStatement as a SQL statement, with the exception that U+003F QUESTION MARK characters (?) can be used in place of SQL literals in the statement. [SQL]
Bind each ?
placeholder with the value of
the argument in the arguments array with the
same position. (So the first ?
placeholder
gets bound to the first value in the arguments
array, and generally the nth ?
placeholder gets bound to the nth value in the arguments
array.)
Binding the ?
placeholders
is done at the literal level, not as string concatenations, so
this provides a way to dynamically insert parameters into a
statement without risk of a SQL injection attack.
The result is the statement.
If the Database
object that the
SQLTransaction
or SQLTransactionSync
object was created from has an expected version
that is neither the empty string nor the actual version of the
database, then mark the statement as
bogus. (Error code
2.)
Otherwise, if the syntax of sqlStatement is
not valid (except for the use of ?
characters in the place of literals), or the statement uses
features that are not supported (e.g. due to security reasons), or
the number of items in the arguments array is
not equal to the number of ?
placeholders in
the statement, or the statement cannot be parsed for some other
reason, then mark the statement as
bogus. (Error code
5.)
User agents must consider statements that use the BEGIN
, COMMIT
, and ROLLBACK
SQL features as being unsupported (and thus
will mark them as bogus), so as to not let these statements
interfere with the explicit transactions managed by the database API
itself.
Otherwise, if the mode that was used to create the
SQLTransaction
or SQLTransactionSync
object is read-only but the statement's main verb can modify the
database, mark the statement as bogus. (Error code 5.)
Only the statement's main verb (e.g. UPDATE
, SELECT
, DROP
) is considered here. Thus, a statement like
"UPDATE test SET id=0 WHERE 0=1
" would be
treated as potentially modifying the database for the purposes
of this step, even though it could never in fact have any
side-effects.
Return the statement.
The user agent must act as if the database was hosted in an otherwise completely empty environment with no resources. For example, attempts to read from or write to the file system will fail.
A future version of this specification will probably define the exact SQL subset required in more detail.
interface Database { void transaction(in SQLTransactionCallback callback, in optional SQLTransactionErrorCallback errorCallback, in optional SQLVoidCallback successCallback); void readTransaction(in SQLTransactionCallback callback, in optional SQLTransactionErrorCallback errorCallback, in optional SQLVoidCallback successCallback); readonly attribute DOMString version; void changeVersion(in DOMString oldVersion, in DOMString newVersion, in optional SQLTransactionCallback callback, in optional SQLTransactionErrorCallback errorCallback, in optional SQLVoidCallback successCallback); }; [Callback=FunctionOnly, NoInterfaceObject] interface SQLVoidCallback { void handleEvent(); }; [Callback=FunctionOnly, NoInterfaceObject] interface SQLTransactionCallback { void handleEvent(in SQLTransaction transaction); }; [Callback=FunctionOnly, NoInterfaceObject] interface SQLTransactionErrorCallback { void handleEvent(in SQLError error); };
The transaction()
and readTransaction()
methods takes one to three arguments. When called, these methods must
immediately return and then asynchronously run the transaction
steps with the transaction callback being the first
argument, the error callback being the second argument, if
any, the success callback being the third argument, if any,
and with no preflight operation or postflight
operation.
For the transaction()
method, the
mode must be read/write. For the readTransaction()
method, the mode must be read-only.
On getting, the version
attribute
must return the current version of the database (as opposed to the
expected
version of the Database
object).
The changeVersion()
method allows scripts to atomically verify the version number and
change it at the same time as doing a schema update. When the method
is invoked, it must immediately return, and then asynchronously run
the transaction steps with the transaction
callback being the third argument, the error callback
being the fourth argument, the success callback being the
fifth argument, the preflight operation being the
following:
Check that the value of the first argument to the changeVersion()
method
exactly matches the database's actual version. If it does not, then
the preflight operation fails.
...the postflight operation being the following:
changeVersion()
method.Database
object's expected version to
the value of the second argument to the changeVersion()
method....and the mode being read/write.
If any of the optional arguments are omitted, then they must be treated as if they were null.
The transaction()
,
readTransaction()
,
and changeVersion()
methods invoke callbacks with SQLTransaction
objects.
typedef sequence<any> ObjectArray; interface SQLTransaction { void executeSql(in DOMString sqlStatement, in optional ObjectArray arguments, in optional SQLStatementCallback callback, in optional SQLStatementErrorCallback errorCallback); }; [Callback=FunctionOnly, NoInterfaceObject] interface SQLStatementCallback { void handleEvent(in SQLTransaction transaction, in SQLResultSet resultSet); }; [Callback=FunctionOnly, NoInterfaceObject] interface SQLStatementErrorCallback { boolean handleEvent(in SQLTransaction transaction, in SQLError error); };
When the executeSql(sqlStatement, arguments, callback, errorCallback)
method is invoked, the
user agent must run the following algorithm. (This algorithm is
relatively simple in that it doesn't actually execute any SQL
— the bulk of the work is actually done as part of the
transaction steps.)
If the method was not invoked during the execution of a
SQLTransactionCallback
,
SQLStatementCallback
, or
SQLStatementErrorCallback
then raise an
INVALID_STATE_ERR
exception. (Calls from inside a
SQLTransactionErrorCallback
thus raise an
exception. The SQLTransactionErrorCallback
handler is
only called once a transaction has failed, and no SQL statements
can be added to a failed transaction.)
Preprocess the SQL statement given as the first argument to the method (sqlStatement), using the second argument to the method as the arguments array, to obtain the statement.
If the second argument is omitted or null, then treat the arguments array as empty.
Queue up the statement in the transaction, along with the third argument (if any) as the statement's result set callback and the fourth argument (if any) as the error callback.
The transaction steps are as follows. These steps must be run asynchronously. These steps are invoked with a transaction callback, optionally an error callback, optionally a success callback, optionally a preflight operation, optionally a postflight operation, and with a mode that is either read/write or read-only.
Open a new SQL transaction to the database, and create a
SQLTransaction
object that represents that
transaction. If the mode is read/write, the transaction must
have an exclusive write lock over the entire database. If the
mode is read-only, the transaction must have a shared read
lock over the entire database. The user agent should wait for an
appropriate lock to be available.
If an error occurred in the opening of the transaction (e.g. if the user agent failed to obtain an appropriate lock after an appropriate delay), jump to the last step.
If a preflight operation was defined for this
instance of the transaction steps, run that. If it fails, then jump
to the last step. (This is basically a hook for the changeVersion()
method.)
If the transaction callback is not null, queue
a task to invoke the transaction callback with the
aforementioned SQLTransaction
object as its only
argument, and wait for that task to be run.
If the callback raised an exception, jump to the last step.
While there are any statements queued up in the transaction, perform the following steps for each queued up statement in the transaction, oldest first. Each statement has a statement, optionally a result set callback, and optionally an error callback.
If the statement is marked as bogus, jump to the "in case of error" steps below.
Execute the statement in the context of the transaction. [SQL]
If the statement failed, jump to the "in case of error" steps below.
Create a SQLResultSet
object that represents
the result of the statement.
If the statement has a result set callback that is not
null, queue a task to invoke it with the
SQLTransaction
object as its first argument and the
new SQLResultSet
object as its second argument, and
wait for that task to be run.
If the callback was invoked and raised an exception, jump to the last step in the overall steps.
Move on to the next statement, if any, or onto the next overall step otherwise.
In case of error (or more specifically, if the above substeps say to jump to the "in case of error" steps), run the following substeps:
If the statement had an associated error callback that is
not null, then queue a task to invoke that error
callback with the SQLTransaction
object and a newly
constructed SQLError
object that represents the
error that caused these substeps to be run as the two arguments,
respectively, and wait for the task to be run.
If the error callback returns false, then move on to the next statement, if any, or onto the next overall step otherwise.
Otherwise, the error callback did not return false, or there was no error callback. Jump to the last step in the overall steps.
If a postflight operation was defined for this instance
of the transaction steps, then: as one atomic operation, commit
the transaction and, if that succeeds, run the postflight
operation. If the commit fails, then instead jump to the last
step. (This is basically a hook for the changeVersion()
method.)
Otherwise: commit the transaction. If an error occurred in the committing of the transaction, jump to the last step.
Queue a task to invoke the success callback, if it is not null.
End these steps. The next step is only used when something goes wrong.
Queue a task to invoke the transaction's
error callback, if it is not null, with a newly constructed
SQLError
object that represents the last error to have
occurred in this transaction. Rollback the transaction. Any
still-pending statements in the transaction are discarded.
The task source for these tasks is the database access task source.
interface DatabaseSync {
void transaction(in SQLTransactionSyncCallback callback);
void readTransaction(in SQLTransactionSyncCallback callback);
readonly attribute DOMString version;
void changeVersion(in DOMString oldVersion, in DOMString newVersion, in optional SQLTransactionSyncCallback callback);
};
[Callback=FunctionOnly, NoInterfaceObject]
interface SQLTransactionSyncCallback {
void handleEvent(in SQLTransactionSync transaction);
};
The transaction()
and readTransaction()
methods must run the following steps:
If the method was the transaction()
method,
create a SQLTransactionSync
object for a
read/write transaction. Otherwise, create a
SQLTransactionSync
object for a read-only
transaction. In either case, if this throws an exception, then
rethrow it and abort these steps. Otherwise, let transaction be the newly created
SQLTransactionSync
object.
If the first argument is null, rollback the transaction,
throw a SQLException
exception, and abort these
steps. (Error code
0.)
Invoke the callback given by the first argument, passing it the transaction object as its only argument.
Mark the SQLTransactionSync
object as stale.
If the callback was terminated by an exception, then rollback the transaction, rethrow that exception, and abort these steps.
Commit the transaction.
If an error occurred in the committing of the transaction,
rollback the transaction, throw a SQLException
exception, and abort these steps.
On getting, the version
attribute must return the current version of the database (as
opposed to the expected version of
the DatabaseSync
object).
The changeVersion()
method allows scripts to atomically verify the version number and
change it at the same time as doing a schema update. When the method
is invoked, it must run the following steps:
Create a SQLTransactionSync
object
for a read/write transaction. If this throws an exception, then
rethrow it and abort these steps. Otherwise, let transaction be the newly created
SQLTransactionSync
object.
Check that the value of the first argument to the changeVersion()
method exactly matches the database's actual version. If it does
not, then throw a SQLException
exception and abort
these steps. (Error code
2.)
If the third argument is not null, invoke the callback given by the third argument, passing it the transaction object as its only argument.
Mark the SQLTransactionSync
object as stale.
If the callback was terminated by an exception, then rollback the transaction, rethrow the exception, and abort these steps.
Commit the transaction.
If an error occurred in the committing of the transaction,
rollback the transaction, throw a SQLException
exception, and abort these steps.
changeVersion()
method.Database
object's expected version to
the value of the second argument to the changeVersion()
method.When the user agent is to create a
SQLTransactionSync
object for a transaction that
is either read/write or read-only, it must run the following
steps:
Open a new SQL transaction to the database, and create a
SQLTransactionSync
object that represents that
transaction. If the mode is read/write, the transaction must
have an exclusive write lock over the entire database. If the
mode is read-only, the transaction must have a shared read
lock over the entire database. The user agent should wait for an
appropriate lock to be available.
If an error occurred in the opening of the transaction
(e.g. if the user agent failed to obtain an appropriate lock after
an appropriate delay), throw a SQLException
exception
and abort these steps.
Return the newly created SQLTransactionSync
object.
The transaction()
, readTransaction()
,
and changeVersion()
methods invoke callbacks that are passed
SQLTransactionSync
objects.
// typedef sequence<any> ObjectArray; interface SQLTransactionSync { SQLResultSet executeSql(in DOMString sqlStatement, in optional ObjectArray arguments); };
A SQLTransactionSync
object is initially fresh, but it will be marked as stale
once it has been committed or rolled back.
When the executeSql(sqlStatement, arguments)
method is invoked, the user
agent must run the following algorithm:
If the SQLTransactionSync
object is stale, then throw an INVALID_STATE_ERR
exception.
Preprocess the SQL statement given as the first argument to the method (sqlStatement), using the second argument to the method as the arguments array, to obtain the statement.
If the second argument is omitted or null, then treat the arguments array as empty.
If the statement is marked as bogus, throw a
SQLException
exception.
Execute the statement in the context of the transaction. [SQL]
If the statement failed, throw a SQLException
exception.
Create a SQLResultSet
object that represents
the result of the statement.
Return the newly created SQLResultSet
object.
The executeSql()
method invokes its callback with a SQLResultSet
object
as an argument.
interface SQLResultSet { readonly attribute long insertId; readonly attribute long rowsAffected; readonly attribute SQLResultSetRowList rows; };
The insertId
attribute must return the row ID of the row that the
SQLResultSet
object's SQL statement inserted into the
database, if the statement inserted a row. If the statement inserted
multiple rows, the ID of the last row must be the one returned. If
the statement did not insert a row, then the attribute must instead
raise an INVALID_ACCESS_ERR
exception.
The rowsAffected
attribute must return the number of rows that were changed by the
SQL statement. If the statement did not affected any rows, then the
attribute must return zero. For "SELECT" statements, this returns
zero (querying the database doesn't affect any rows).
The rows
attribute must return a SQLResultSetRowList
representing the rows returned, in the order returned by the
database. The same object must be returned each time. If no rows
were returned, then the object will be empty (its length
will be
zero).
interface SQLResultSetRowList {
readonly attribute unsigned long length;
getter any item(in unsigned long index);
};
For the asynchronous API, implementors are
encouraged to prefetch all the data for
SQLResultSetRowList
objects when the object is
constructed (before the result set callback is invoked), rather than
on-demand, for better responsiveness. For the synchronous API, an
on-demand lazy evaluation implementation strategy is encouraged
instead, for better performance.
SQLResultSetRowList
objects have a length
attribute that must return the number of rows it represents (the
number of rows returned by the database). This is the length.
Fetching the length
might be
expensive, and authors are thus encouraged to avoid using it (or
enumerating over the object, which implicitly uses it) where
possible.
The object's supported property indices are the numbers in the range zero to length-1, unless the length is zero, in which case there are no supported property indices.
The item(index)
attribute must return the row
with the given index index. If there is no such
row, then the method must return null.
Each row must be represented by a native ordered dictionary data
type. In the JavaScript binding, this must be Object
.
Each row object must have one property (or dictionary entry) per
column, with those properties enumerating in the order that these
columns were returned by the database. Each property must have the
name of the column and the value of the cell, as they were returned
by the database.
Errors in the asynchronous database API are reported using
callbacks that have a SQLError
object as one of their
arguments.
interface SQLError { const unsigned short UNKNOWN_ERR = 0; const unsigned short DATABASE_ERR = 1; const unsigned short VERSION_ERR = 2; const unsigned short TOO_LARGE_ERR = 3; const unsigned short QUOTA_ERR = 4; const unsigned short SYNTAX_ERR = 5; const unsigned short CONSTRAINT_ERR = 6; const unsigned short TIMEOUT_ERR = 7; readonly attribute unsigned short code; readonly attribute DOMString message; };
The code
IDL
attribute must return the most appropriate code from the table
below.
The message
IDL attribute must return an error message describing the error
encountered. The message should be localized to the user's
language.
Errors in the synchronous database API are reported using
SQLException
exceptions:
exception SQLException { const unsigned short UNKNOWN_ERR = 0; const unsigned short DATABASE_ERR = 1; const unsigned short VERSION_ERR = 2; const unsigned short TOO_LARGE_ERR = 3; const unsigned short QUOTA_ERR = 4; const unsigned short SYNTAX_ERR = 5; const unsigned short CONSTRAINT_ERR = 6; const unsigned short TIMEOUT_ERR = 7; unsigned short code; DOMString message; };
The code
IDL attribute must return the most appropriate code from the table
below.
The message
IDL
attribute must return an error message describing the error
encountered. The message should be localized to the user's
language.
The error codes are as follows:
| Constant | Code | Situation |
|---|---|---|
UNKNOWN_ERR
| 0 | The transaction failed for reasons unrelated to the database itself and not covered by any other error code. |
DATABASE_ERR
| 1 | The statement failed for database reasons not covered by any other error code. |
VERSION_ERR
| 2 | The operation failed because the actual database version was
not what it should be. For example, a statement found that the
actual database version no longer matched the expected version
of the Database or DatabaseSync object,
or the Database.changeVersion()
or DatabaseSync.changeVersion()
methods were passed a version that doesn't match the actual
database version.
|
TOO_LARGE_ERR
| 3 | The statement failed because the data returned from the database was too large. The SQL "LIMIT" modifier might be useful to reduce the size of the result set. |
QUOTA_ERR
| 4 | The statement failed because there was not enough remaining storage space, or the storage quota was reached and the user declined to give more space to the database. |
SYNTAX_ERR
| 5 | The statement failed because of a syntax error, or the number
of arguments did not match the number of ?
placeholders in the statement, or the statement tried to use a
statement that is not allowed, such as BEGIN , COMMIT , or ROLLBACK , or the statement tried to use a verb
that could modify the database but the transaction was read-only.
|
CONSTRAINT_ERR
| 6 | An INSERT , UPDATE , or REPLACE
statement failed due to a constraint failure. For example,
because a row was being inserted and the value given for the
primary key column duplicated the value of an existing row.
|
TIMEOUT_ERR
| 7 | A lock for the transaction could not be obtained in a reasonable time. |
User agents must implement the SQL dialect supported by Sqlite 3.6.19.
When converting bound arguments to SQL data types, the JavaScript ToPrimitive abstract operation must be applied to obtain the raw value to be processed. [ECMA262].
User agents should limit the total amount of space allowed for databases.
User agents should guard against sites storing data under the origins other affiliated sites, e.g. storing up to the limit in a1.example.com, a2.example.com, a3.example.com, etc, circumventing the main example.com storage limit.
User agents may prompt the user when quotas are reached, allowing the user to grant a site more space. This enables sites to store many user-created documents on the user's computer, for instance.
User agents should allow users to see how much space each domain is using.
A mostly arbitrary limit of five megabytes per origin is recommended. Implementation feedback is welcome and will be used to update this suggestion in the future.
A third-party advertiser (or any entity capable of getting content distributed to multiple sites) could use a unique identifier stored in its client-side databases to track a user across multiple sessions, building a profile of the user's interests to allow for highly targeted advertising. In conjunction with a site that is aware of the user's real identity (for example an e-commerce site that requires authenticated credentials), this could allow oppressive groups to target individuals with greater accuracy than in a world with purely anonymous Web usage.
There are a number of techniques that can be used to mitigate the risk of user tracking:
User agents may restrict access to
the database objects
to scripts originating at the domain of the top-level document of
the browsing context, for instance denying access to
the API for pages from other domains running in
iframe
s.
User agents may, if so configured by the user, automatically delete stored data after a period of time.
This can restrict the ability of a site to track a user, as the site would then only be able to track the user across multiple sessions when he authenticates with the site itself (e.g. by making a purchase or logging in to a service).
However, this also reduces the usefulness of the API as a long-term storage mechanism. It can also put the user's data at risk, if the user does not fully understand the implications of data expiration.
If users attempt to protect their privacy by clearing cookies without also clearing data stored in the relevant databases, sites can defeat those attempts by using the two features as redundant backup for each other. User agents should present the interfaces for clearing these in a way that helps users to understand this possibility and enables them to delete data in all persistent storage features simultaneously. [COOKIES]
User agents may require the user to authorize access to databases before a site can use the feature.
User agents may record the origins of sites that contained content from third-party origins that caused data to be stored.
If this information is then used to present the view of data currently in persistent storage, it would allow the user to make informed decisions about which parts of the persistent storage to prune. Combined with a blacklist ("delete this data and prevent this domain from ever storing data again"), the user can restrict the use of persistent storage to sites that he trusts.
User agents may allow users to share their persistent storage domain blacklists.
This would allow communities to act together to protect their privacy.
While these suggestions prevent trivial use of this API for user tracking, they do not block it altogether. Within a single domain, a site can continue to track the user during a session, and can then pass all this information to the third party along with any identifying information (names, credit card numbers, addresses) obtained by the site. If a third party cooperates with multiple sites to obtain such information, a profile can still be created.
However, user tracking is to some extent possible even with no cooperation from the user agent whatsoever, for instance by using session identifiers in URLs, a technique already commonly used for innocuous purposes but easily repurposed for user tracking (even retroactively). This information can then be shared with other sites, using using visitors' IP addresses and other user-specific data (e.g. user-agent headers and configuration settings) to combine separate sessions into coherent user profiles.
User agents should treat persistently stored data as potentially sensitive; it's quite possible for e-mails, calendar appointments, health records, or other confidential documents to be stored in this mechanism.
To this end, user agents should ensure that when deleting data, it is promptly deleted from the underlying storage.
Because of the potential for DNS spoofing attacks, one cannot guarantee that a host claiming to be in a certain domain really is from that domain. To mitigate this, pages can use TLS. Pages using TLS can be sure that only pages using TLS that have certificates identifying them as being from the same domain can access their databases.
Different authors sharing one host name, for example users
hosting content on geocities.com
, all share one
set of databases.
There is no feature to restrict the access by pathname. Authors on
shared hosts are therefore recommended to avoid using these
features, as it would be trivial for other authors to read the data
and overwrite it.
Even if a path-restriction feature was made available, the usual DOM scripting security model would make it trivial to bypass this protection and access the data from any path.
The two primary risks when implementing these persistent storage features are letting hostile sites read information from other domains, and letting hostile sites write information that is then read from other domains.
Letting third-party sites read data that is not supposed to be read from their domain causes information leakage, For example, a user's shopping wishlist on one domain could be used by another domain for targeted advertising; or a user's work-in-progress confidential documents stored by a word-processing site could be examined by the site of a competing company.
Letting third-party sites write data to the persistent storage of other domains can result in information spoofing, which is equally dangerous. For example, a hostile site could add items to a user's wishlist; or a hostile site could set a user's session identifier to a known ID that the hostile site can then use to track the user's actions on the victim site.
Thus, strictly following the origin model described in this specification is important for user security.
User agent implementors are strongly encouraged to audit all
their supported SQL statements for security implications. For
example, LOAD DATA INFILE
is likely to pose
security risks and there is little reason to support it.
In general, it is recommended that user agents not support features that control how databases are stored on disk. For example, there is little reason to allow Web authors to control the character encoding used in the disk representation of the data, as all data in JavaScript is implicitly UTF-16.
Authors are strongly recommended to make use of the ?
placeholder feature of the executeSql()
method,
and to never construct SQL statements on the fly.
All references are normative unless marked "Non-normative".


| File | Statements | Branches | Functions | Lines | |||||
|---|---|---|---|---|---|---|---|---|---|
| bin/ | 89.31% | 234/262 | 87.88% | 58/66 | 100% | 14/14 | 89.31% | 234/262 | |
| lib/alexa/ | 99.79% | 469/470 | 95.92% | 188/196 | 100% | 116/116 | 99.79% | 465/466 | |
| lib/client/ | 94.93% | 693/730 | 75.82% | 207/273 | 98.11% | 156/159 | 94.9% | 689/726 | |
| lib/core/ | 100% | 411/411 | 92.57% | 162/175 | 100% | 96/96 | 100% | 409/409 | |
| lib/server/ | 98.5% | 197/200 | 91.67% | 55/60 | 97.62% | 41/42 | 98.48% | 195/198 |


Below the flavortext are two main items:
Eventually, by traveling around and mapping the sounds, the solver will realize that the giant chamber is basically a 13x8 grid. (The START square is where the solver begins whenever they start or restart the app.) Below are locations and descriptions of all the sounds that we’d hear.
| 1 | 2 | 3 @ | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 * | 12 | 13 ^ |
| 14 * | 15 | 16 | 17 | 18 | 19 | 20 | 21 | 22 | 23 | 24 % | 25 # | 26 |
| 27 + | 28 - | 29 | 30 | 31 | 32 | 33 | 34 | 35 > | 36 | 37 * | 38 | 39 * |
| 40 | 41 | 42 | 43 | 44 | 45 | 46 | 47 | 48 * | 49 | 50 | 51 ? | 52 = |
| 53 * | 54 | 55 | 56 | 57 * | 58 | START | 60 | 61 | 62 < | 63 | 64 | 65 |
| 66 | 67 | 68 | 69 | 70 $ | 71 | 72 | 73 | 74 | 75 | 76 | 77 * | 78 |
| 79 | 80 | 81 | 82 * | 83 | 84 | 85 | 86 \ | 87 | 88 | 89 | 90 | 91 |
| 92 | 93 | 94 | 95 | 96 | 97 | 98 | 99 | 100 | 101 | 102 | 103 | 104 |
| NOISE | |
|---|---|
| * | A small bell ringing |
| + | “I before e, except after c.” |
| @ | “A man, a plan, a canal, Panama!” |
| ^ | Echo-y “Hello!... Hello… hello…” |
| - | A group of people yelling “Surprise!” |
| = | A clock ticking |
| > | A chorus singing “Alleluia!” |
| # | Crickets chirping in the evening |
| % | A hunting bugle with hounds barking |
| ? | An officer barking marching orders |
| < | A car horn honking |
| $ | A chicken clucking |
| \ | A growl, as if from a bear |
WAYS FOR THE SOLVER TO GET TO THE BIG “AHA”
THE BIG “AHA”
FROM THERE…
Now one can fill in the blanks with the proper symphony nicknames (the blanks will also help weed out any discrepancies in the correct names). To help with solving, the symphonies are listed in increasing numerical order:
The numbered spaces, in order, spell out the instruction DO NUMBERLINK.
The rooms are numbered 1 through 104. Thus, each sound has two clear positions connected to it: its actual location, and the location of its corresponding symphony number’s room. However, if we naively connect the locations in traditional numberlink style, there’s no unique solution.
The solver may notice that for symphonies with shorter names, the two locations are pretty close to each other. In fact, many (ECHO, LE SOIR, etc.) are exactly as many rooms away from each other as the symphony’s word length. Are we supposed to connect the two endpoints using each symphony’s name? Totalling the letters in all the symphony names gives us 104, suggesting that yes we should do that, and that will perfectly fill up the grid.
It turns out there is only one way to make all the connections in the grid such that each line takes up exactly the same number of squares as its symphony name.
Once all the connections are made, one can then fill in the grid using the symphony nicknames. Each symphony name starts at the proper number for its symphony and then winds its way to its endpoint, where the sound was found in the grid. (The final sentence of the flavortext helps clue this direction for us.)
The only thing we haven’t yet used are the spaces that have a bell ringing. Each symphony, it turns out, has either 0 squares or 1 square with a bell in it. Below are those highlighted spaces and letters. Reading the letters in numerical order of the symphonies (as given on the puzzle page) gives us the solution, ORCHESTRA.
| NOISE | SYMPH. TITLE | SYMPH. # | TITLE LEN. | BELL | |
|---|---|---|---|---|---|
| # | Crickets chirping in the evening | LE SOIR | 8 | 6 | O |
| > | A chorus singing “Alleluia!” | ALLELUIA | 30 | 8 | |
| < | A car horn honking | HORNSIGNAL | 31 | 10 | R |
| ^ | Echo-y “Hello!... Hello… hello…” | ECHO | 38 | 4 | C |
| @ | “A man, a plan, a canal, Panama!” | THE PALINDROME | 47 | 13 | H |
| + | “I before e, except after c.” | THE SCHOOLMASTER | 55 | 15 | E |
| % | A hunting bugle with hounds barking | LA CHASSE | 73 | 8 | S |
| \ | A growl, as if from a bear | THE BEAR | 82 | 7 | T |
| $ | A chicken clucking | THE HEN | 83 | 6 | |
| - | A group of people yelling “Surprise!” | THE SURPRISE | 94 | 11 | R |
| ? | An officer barking marching orders | MILITARY | 100 | 8 | A |
| = | A clock ticking | THE CLOCK | 101 | 8 |


Did you find this page useful? Do you have a suggestion? Give us feedback or send us a pull request on GitHub.
First time using the AWS CLI? See the User Guide for help getting started.
[ aws . storagegateway ]
Updates a file share.
Note
To leave a file share field unchanged, set the corresponding input field to null.
See also: AWS API Documentation
update-nfs-file-share
--file-share-arn <value>
[--kms-encrypted | --no-kms-encrypted]
[--kms-key <value>]
[--nfs-file-share-defaults <value>]
[--default-storage-class <value>]
[--client-list <value>]
[--cli-input-json <value>]
[--generate-cli-skeleton <value>]
The Amazon Resource Name (ARN) of the file share to be updated.
--kms-encrypted | --no-kms-encrypted (boolean)
True to use Amazon S3 server side encryption with your own AWS KMS key, or false to use a key managed by Amazon S3. Optional.
The KMS key used for Amazon S3 server side encryption. This value can only be set when KmsEncrypted is true. Optional.
--nfs-file-share-defaults (structure)
The default values for the file share. Optional.
Shorthand Syntax:
FileMode=string,DirectoryMode=string,GroupId=long,OwnerId=long
JSON Syntax:
{
"FileMode": "string",
"DirectoryMode": "string",
"GroupId": long,
"OwnerId": long
}
--default-storage-class (string)
The default storage class for objects put into an Amazon S3 bucket by a file gateway. Possible values are S3_STANDARD or S3_STANDARD_IA. If this field is not populated, the default value S3_STANDARD is used. Optional.
The list of clients that are allowed to access the file gateway. The list must contain either valid IP addresses or valid CIDR blocks.
Syntax:
"string" "string" ...
--cli-input-json (string) Performs service operation based on the JSON string provided. The JSON string follows the format provided by --generate-cli-skeleton. If other arguments are provided on the command line, the CLI values will override the JSON-provided values.
--generate-cli-skeleton (string) Prints a JSON skeleton to standard output without sending an API request. If provided with no value or the value input, prints a sample input JSON that can be used as an argument for --cli-input-json. If provided with the value output, it validates the command inputs and returns a sample output JSON for that command.


This chapter describes how to create and run JavaFX applications using scripts interpreted by the Nashorn engine. It is assumed that you are familiar with JavaFX. For more information, see the JavaFX documentation at http://docs.oracle.com/javase/8/javafx/
You can interpret a JavaFX script application with Nashorn using the jjs
command with the -fx
option. For example, the following command invokes Nashorn to interpret the JavaFXscript.js
file:
jjs -fx JavaFXscript.js
For more information about jjs
, see the tool's reference page at http://docs.oracle.com/javase/8/docs/technotes/tools/windows/jjs.html
A JavaFX script application is similar to the Java equivalent, but Nashorn enables you to simplify many of the JavaFX constructs. Typically, a JavaFX script application contains only the start()
function, which is equivalent to the start()
method in its Java counterpart. It can also contain the init()
and stop()
functions.
Example 3-1 contains the source code for a simple JavaFX application that displays a button, which when clicked prints "Hello World!"
to standard output.
Example 3-1 JavaFX Application (HelloWorld.java)
import javafx.application.Application; import javafx.event.ActionEvent; import javafx.event.EventHandler; import javafx.scene.Scene; import javafx.scene.control.Button; import javafx.scene.layout.StackPane; import javafx.stage.Stage; public class HelloWorld extends Application { public static void main(String[] args) { launch(args); } @Override public void start(Stage primaryStage) { primaryStage.setTitle("Hello World!"); Button btn = new Button(); btn.setText("Say 'Hello World'"); btn.setOnAction(new EventHandler<ActionEvent>() { @Override public void handle(ActionEvent event) { System.out.println("Hello World!"); } }); StackPane root = new StackPane(); root.getChildren().add(btn); primaryStage.setScene(new Scene(root, 300, 250)); primaryStage.show(); } }
Example 3-2 contains the source code for a JavaFX script application that corresponds to the Java code in Example 3-1.
Example 3-2 JavaFX Script Application (HelloWorld.js)
var Button = javafx.scene.control.Button; var StackPane = javafx.scene.layout.StackPane; var Scene = javafx.scene.Scene; function start(primaryStage) { primaryStage.title = "Hello World!"; var button = new Button(); button.text = "Say 'Hello World'"; button.onAction = function() print("Hello World!"); var root = new StackPane(); root.children.add(button); primaryStage.scene = new Scene(root, 300, 250); primaryStage.show(); }
Both Example 3-1 and Example 3-2 produce the same result: a window titled Hello World! with a button labeled Say 'Hello World'.
Analyzing the two preceding examples, you can see how Nashorn enables you to simplify Java code when you write a JavaFX application as a script:
There is no need to declare variable types, import packages, use annotations, specify the class name, and implement its main()
method.
Only the JavaFX classes that are instantiated must be declared.
JavaBeans do not require the get
and set
prefixes, and are treated as JavaScript properties instead of as Java methods. For more information, see Using JavaBeans.
Implementing the javafx.event.EventHandler
interface does not require you to specify the implemented method explicitly. Because handle()
is the only method, Nashorn automatically applies the provided function to the method. For more information, see Extending Java Classes.
The JavaFX primary stage is available to Nashorn as a global property $STAGE
. This global property enables you to treat the whole script as one start()
function (you can still add the init()
and stop()
functions). Example 3-3 contains the source code for a simplified version of the JavaFX script application from Example 3-2.
Example 3-3 Simpler Version of the JavaFX Script Application (HelloWorldSimple.js)
var Button = javafx.scene.control.Button; var StackPane = javafx.scene.layout.StackPane; var Scene = javafx.scene.Scene; $STAGE.title = "Hello World!"; var button = new Button(); button.text = "Say 'Hello World'"; button.onAction = function() print("Hello World!"); var root = new StackPane(); root.children.add(button); $STAGE.scene = new Scene(root, 300, 250); $STAGE.show();
In most cases, you should only add the classes that you instantiate or use to access static fields. However, for prototyping purposes, Nashorn predefines a set of scripts that can be loaded to import groups of JavaFX packages and classes. You can load a script using the load()
function that takes a string with the name of the script. The following table lists the predefined script objects that are available for inclusion:
| This script ... | Imports ... |
|---|---|
| fx:base.js | javafx.stage.Stage javafx.scene.Scene javafx.scene.Group javafx/beans javafx/collections javafx/events javafx/util |
| fx:graphics.js | javafx/animation javafx/application javafx/concurrent javafx/css javafx/geometry javafx/print javafx/scene javafx/stage |
| fx:controls.js | javafx/scene/chart javafx/scene/control |
| fx:fxml.js | javafx/fxml |
| fx:web.js | javafx/scene/web |
| fx:media.js | javafx/scene/media |
| fx:swing.js | javafx/embed/swing |
| fx:swt.js | javafx/embed/swt |
Example 3-4 contains the source code of the simplified JavaFX script application from Example 3-3 with load()
functions used to import the necessary packages and classes.
Example 3-4 JavaFX Script Application with Loaded Scripts
load("fx:base.js"); load("fx:controls.js"); load("fx:graphics.js"); $STAGE.title = "Hello World!"; var button = new Button(); button.text = "Say 'Hello World'"; button.onAction = function() print("Hello World!"); var root = new StackPane(); root.children.add(button); $STAGE.scene = new Scene(root, 300, 250); $STAGE.show();
For more examples of JavaFX script applications, see Appendix A, "JavaFX Script Application Examples".


Shower Loop vs Normal Shower
90% reduction in water usage and 70-90% in energy reduction for a 10 minute shower with a flow rate of 10 l/min. Savings are dependant on user behaviour and can vary. Use Just one bucket of water for a shower of any length. See the savings section for more information.
Save Water
Capture, Filter, Reuse
Saving Energy
By reusing warm water.
Save The Planet
Save Money
Open Hardware
Copy, improve, adapt, share
Assemble It Yourself
With manufactured and off-shell components
Enjoy Better Showers
The single pump provides stable water pressure and the thermostat and heater keep water nice and warm
Off - Grid Ready
The entire system can run on a 12V DC
No Plumber Needed
Shower Loop is like a standalone appliance without connecting to water mains
How It Works
Showers are great, but pouring hot and almost drinkable water down the drain is not. Besides the obvious costs to the environment and your bills, there is also a conscious on unconscious psychological cost any time you create waste. To solve this problem we created Showerloop. It's a shower that collects, cleans and reuses the water in real time while you are showering. So now you can shower for as long as you like but with a reduced ecological impact.


| ./app/controllers/booking/ |
|
93.83% |
(76 / 81) |
100% |
(0 / 0) |
83.33% |
(20 / 24) |
93.83% |
(76 / 81) |
| ./app/controllers/customer/ |
|
89.63% |
(268 / 299) |
100% |
(21 / 21) |
80.65% |
(75 / 93) |
89.63% |
(268 / 299) |
| ./app/controllers/furnituring/ |
|
88.89% |
(264 / 297) |
100% |
(21 / 21) |
78.49% |
(73 / 93) |
88.89% |
(264 / 297) |
| ./app/controllers/location/ |
|
58.5% |
(241 / 412) |
29.73% |
(11 / 37) |
50.35% |
(71 / 141) |
58.5% |
(241 / 412) |
| ./app/controllers/resource/ |
|
88.89% |
(264 / 297) |
100% |
(21 / 21) |
78.49% |
(73 / 93) |
88.89% |
(264 / 297) |
| ./app/controllers/start/ |
|
66.67% |
(2 / 3) |
100% |
(0 / 0) |
66.67% |
(2 / 3) |
66.67% |
(2 / 3) |
| ./app/shared/controllers/ |
|
82.41% |
(89 / 108) |
63.16% |
(12 / 19) |
85.19% |
(23 / 27) |
82.41% |
(89 / 108) |
| ./app/shared/directives/ |
|
62.35% |
(154 / 247) |
42.5% |
(17 / 40) |
48.19% |
(40 / 83) |
62.35% |
(154 / 247) |
| ./app/shared/filters/ |
|
96.49% |
(55 / 57) |
90% |
(9 / 10) |
90.48% |
(19 / 21) |
96.49% |
(55 / 57) |
| ./app/shared/services/ |
|
15.97% |
(19 / 119) |
0% |
(0 / 10) |
22.86% |
(8 / 35) |
16.1% |
(19 / 118) |


Swiss-Army chainsaw
`Prev `__
S
`Next `__
--------------
**Swiss-Army chainsaw**
In early Unix days, a well-known technical paper analogized the lexical
analyzer generator lex(1) to a Swiss-army knife; this was a comment on
the remarkable variety of more general uses discovered for a program
originally designed as a special-purpose code generator for writing
compilers. Two decades later, well-known hacker Henry Spencer described
the `*Perl* <../P/Perl.html>`__ scripting language as a “Swiss-Army
chainsaw”, intending to convey his evaluation of the language as
exceedingly powerful but ugly and noisy and prone to belch noxious
fumes. This had two results: (1) Perl fans adopted the epithet as a
badge of pride, and (2) it entered more general usage to describe
software that is highly versatile but distressingly inelegant.
--------------
+--------------------------------+----------------------------+----------------------------+
| `Prev `__ | `Up <../S.html>`__ | `Next `__ |
+--------------------------------+----------------------------+----------------------------+
| swapped out | `Home <../index.html>`__ | swizzle |
+--------------------------------+----------------------------+----------------------------+


Toggle navigation
Trader Rater
Login.
You must be registered to submit a job. Not Registered, register
here
Search.
Find a tradesman near you.
Tradesman Type
-- Select --
Builder
Joiner
Job Type
-- Select A Job Type--
Bathroom fitting
Kitchen fitting
Job Description
Please provide a description.
Postcode
Please
Post


If asked about my favorite restaurant, it is none other than the Dusty Scarole.
The restaurant has a assortment of authentic Italian dishes, made with the utmost precision. The cuisine, is pasta served with a dash of tomato puree, and sprinkled oregano, known as the Special Scarole. Diving deep into this is truly, an experience of a lifetime, one that can never be forgotten. Click here to view the menu
If you would like to leave a comment, suggestion or make a reservation. Please contact us here.
About The Site


An object to be passed to the underlying function call (Create, Update, Delete, Read)
Return type
Boolean
iot.agile.Protocol
A Protocol object abstract operations over a specific protocol implementation.
Every Device has one Protocol used to establish and use a communication exchange.
The Storage component offer an abstraction for Devices to store and fetch data
in a generic way.
Write operations happens on all the enabled Drivers;
Failure of a single Driver doesn't make faile the whole write but only reported
Read operations work on a default driver, if specified, which acts as preferred source.
In case default is not available or fails, read will be executed in cascade on
the enabled Driver. If none replies the operation fails.
A stream contains a set of measurement values for a sensor
String
name
Array[DeviceStreamChannel]
channels
Object
DeviceDefinition
A device definition that contains informations describing the current device
String
id
String
name
String
description
Object*
properties
Array[DeviceStream]
streams
Array[Object]
ProtocolDevice
List all devices a Protocol knows about.
The list is updated by the Discover method.
Devices may be provisioned programmatically during the initialization phase.
Object
String
name
String
id
Enum
status
CONNECTED
DISCONNECTED
Enum
ProtocolStatus
Identify a status of the Protocol, indicating if operational (AVAILABLE) or
if for some reason further user-side checks are required.
AVAILABLE
NOT_CONFIGURED
UNAVAILABLE
DISABLED
FATAL
Object*
ProtocolProfile
A Protocol set of settings that translate human readable properties
to actual Protocol implementation details.
For example, the user request the temperature value over a BLE connected
device and the Protocol receive all the specific informations (like
services and characteristics ids) to enable the data reading.


RFC1918
RFC 1918 defines a set of 3 IP ranges that are not routed across the Internet and can only be used on local networks. You will sometimes see these used on ISP networks, where the devices can only be accessed from within the ISP’s network, not from the rest of the Internet.
There are 3 IP ranges defined in RFC 1918. Your home network should be in one of these ranges:
<IP_ADDRESS>/8 (<IP_ADDRESS>-<IP_ADDRESS>)
<IP_ADDRESS>/12 (<IP_ADDRESS>-<IP_ADDRESS>)
<IP_ADDRESS>/16 (<IP_ADDRESS>-<IP_ADDRESS>)
There are also the RFC 6598 addresses for Carrier-Grade NAT:
<IP_ADDRESS>/10 (<IP_ADDRESS>-<IP_ADDRESS>)
If you ISP or provider allocates one of these IP ranges as your WAN IP then your device can only be reached from within your ISP at best. They are very commonly seen where the provider is part of an academic environment (school, college, hall of residence etc), is part of an apartment complex or a mobile phone network. They are also normally seen where the ISP connected device is an ADSL device and you are connecting a router to that device.
The problem is that if you visit any of the web pages that claim to tell you your IP address they will tell you the IP address your ISP is NATing you behind. The only way to know is to look at the management pages of your ISP connected device (or if you are connecting with a USB connected modem looking at the IP assigned to that interface - using ipconfig
on Windows, ifconfig
on Linux and BSD, or ip addr show
on Linux).
For over a decade those IP ranges (and the link-local subnet) have been routed to AS112, which is a black hole designed to minimise the impact of people trying to reach those IP addresses across the Internet.
There are also a few other special case IP ranges that you may also see, covered in RFC 5735:
<IP_ADDRESS>/8
<IP_ADDRESS>/8
<IP_ADDRESS>/16
<IP_ADDRESS>/24
<IP_ADDRESS>/24
<IP_ADDRESS>/24
<IP_ADDRESS>/15
<IP_ADDRESS>/24
<IP_ADDRESS>/24
These IP addresses also cannot be routed across the Internet, some (<IP_ADDRESS>/8
) cannot be routed beyond the local host and the others beyond the local network.


A recent addition to the restaurant galores of Philadelphia, Chocolate by the Bald Man is a neat little outlet with an absolutely amazing chocolate feel. That’s right. Chocolate lovers, the time has finally arrived!

You get a 10% discount for correctly guessing the number of times I’ve said the word ‘Chocolate’ in this post, by the way.
We started off with a milkshake and a hot chocolate. I’m mentioning these in particular because I loved the mugs it came in. The hot chocolate came in a ‘hug mug’ ??? no handles ??? so you literally had to hug it with your hands to drink, which is perfect for hot chocolate! The milkshake arrived in a nice tall glass with Drink Me written all over. What was really cool is the spurts of chocolate all around the glass.
Overall, the food was quite delicious. Since we went as a group, we attempted a pizza, a burger and a panini. They all came out delicious, and considering their specialty is chocolate, that’s rather amazing. Oh, and that first picture ??? none of us had that, so I’m not really sure what it is. But it looked so good, we snapped it off someone’s plate 0:)
The money for life, chocolate for the soul box was what they served the bill in. Very nice touch.
Definitely recommend a visit to anyone that’s in town. And don’t forget to walk around and see their chocolate selection, particularly their chocolate syringes. As Barney Stinson would say, Dee-lightful!
PS I was kidding about the discount.


--- layout: post title: PDC tomorrow, WeHo tonight date: '2008-10-26T01:06:00.000Z' tags: [conferences, pdc] modified_time: '2008-10-26T01:06:00.118Z' blogger_id: tag:blogger.com,1999:blog-4015568221071268916.post-1554926174336806580 comments: true blogger_orig_url: http://serialseb.blogspot.com/2008/10/pdc-tomorrow-weho-tonight.html ---
Anyone wanting to come for dinner / drinks in WeHo (gaying PDC up a bit), or meet from tomorrow, phone number is +44 7789 00 8282 :)


Coding Guidelines
The Mercado Pago .NET is a collaborative effort from the start. The SDK team thinks that contributions from different developer will enrich it's feature set and make it more relevant to the community.
However; absorbing all contributions as-is, while expedient, might lead to difficulties in maintenance of the codebase is left unchecked. Collaborative codebases often establish guidelines for contributors to ensure code remains maintainable over time. The effort to maintain the SDK is no different in this regard so a bit of guidance is in order.
The purpose of this guide is to set a baseline for contributions. These guidelines are not intended to limit the tools at your disposal nor to rewire the way you think but rather to encourage good neighbor behavior.
Language Guidelines
We use english language. This is to be consistent everywhere, and to be considerate with developers that do not speak our native language.
Therefore: source code, comments, documentation, commit messages, review comments, and any other kind of contribution MUST use english language.
Typos are unavoidable, but try to reduce them by using a spellchecker. Most IDEs can be configured to run one automatically.
Code Guidelines
- Set your IDE to follow the
.editorconfig
in each repository. - Follow the C# Coding Convention.
Generally speaking, be conscious when contributing and try following the same style that the code in the SDK already has. If you have any doubts, just ask us!
This rules will be enforced automatically when making a pull requests, and checks will fail if you do not follow them, resulting in your contribution being automatically rejected until fixed.
Comment Guidelines
Comments in code are a hard thing to write, not because the words are difficult to produce but because it is hard to make relevant comments. Too much of it and people do not read comments (and it obfuscates code reading) and too little of it gives you no recourse but to read large portions of codebase to get insight as to what a feature/codeblock is doing. Both situations are undesirable and efforts should be made at all time to have a please comment reading experience
As a general rule you would have to comment on decisions you made while coding that are not part of any specification.
In particular you should always comment any decision that:
- Departs from common wisdom or convention (The why's are necessary).
- Takes a significant amount of time to produce. A good rule of thumb here is that if you spent more than 1 hour thinking on how to produce a fragment of code that took 2 minutes of wrist time to write you should document your thinking to aid reader and allow for validation.
- Need to preserve properties of the implementation. This is the case of performance sensitive portions of the codebase, goroutines synchronization, implementations of security primitives, congestion control algorithms, etc.
As a general rule of what not to comment you should avoid:
- Commenting on structure of programs that is already part of a convention, specified or otherwise.
- Having pedantic explanations of behavior that can be found by immediate examination of the surrounding code artifacts.
- Commenting on behavior you cannot attest.
Branching Guidelines
Currently master
is our only long term branch, below a few suggestions of short term branches naming:
hotfix/something-needs-fix
: Small routine patches in code to features already there.feature/something-new
: A new feature or a change in a existent feature. Beware of breaking changes that would require a major version bump.doc/improves-documentation-for-this-feature
: If you add or change documentation with no impact to the source code.
Git Guidelines
All commits SHOULD follow the seven rules of a great Git commit message:
- Separate subject from body with a blank line.
- Limit the subject line to 72 characters.
- Capitalize the subject line.
- Do not end the subject line with a period.
- Use the imperative mood in the subject line.
- Wrap the body at 72 characters.
- Use the body to explain what and why vs. how.
Commits such as "fix tests", "now it's working" and many other common messages we find usually in code WON'T be accepted.
Ideally we would like to enforce these rules, but we are realistic and understand that it might be a big change for some people. So unless deviating heavily from what was stated we might accept your commits even if not following these rules perfectly.
Please avoid taking to much time to deliver code, and always rebase your code to avoid reverse merge commits.
When reviewing, check if the PR adheres to C# Coding Convention.


Posted by Tony Vidler on June 08, 1996 at 18:01:23:
One of our contacts has posed the question as towhether it is possible to create and simulate a StewartPlatform using Workspace.
Follow Ups:
Post a Followup
Subject:
Comments: : One of our contacts has posed the question as to : whether it is possible to create and simulate a Stewart : Platform using Workspace.
Optional Link URL: Link Title: Optional Image URL:


| 1 (29 Dec–4 Jan) |
31 Dec 2019, cluster of cases of pneumonia with unknown cause in Wuhan, Hubei province of China was reported. |
- |
49.1 |
| 2 (5 Jan–11 Jan) |
8 Jan 2020, first patient under investigation (PUI) |
- |
47.8 |
| 3 (12 Jan–18 Jan) |
13 Jan 2020, development of diagnostics for 2019-nCoV was launched by KCDC. |
- |
42.4 |
| 4 (19 Jan–25 Jan) |
20 Jan 2020, first case of COVID-19 |
2 |
40.9 |
| 5 (26 Jan–1 Feb) |
30 Jan 2020, WHO declared a Public Health Emergency of International Concern (PHEIC). |
12 |
28.0 |
| 6 (2 Feb–8 Feb) |
4 Feb 2020, immigration of all foreigners who have been to Hubei province, China, in past 2 weeks was banned. |
24 |
16.4 |


Test purpose
- Check that we can load the Delaunator JS library into a module from a remote CMS.
- Use a set of static coordinates, alongside the mouse cursor, as the source points for the Delaunay triangulation calculations.
- Use the calculated Voronoi edges to create a mosaic scene to an image
- Give the scene a 3d effect using a filter
- Animate the scene, updating the Voronoi edges as the user moves the mouse cursor over the canvas.
Touch test: canvas should be resizable
Annotated code


title = "Галерея" url = "/students/gallery/:id" layout = "static-llight" is_hidden = 0 [Project] [SingleProject] alias = "{{:id}}" ==


{% extends "layout.html" %} {% block page_title %} GOV.UK prototype kit {% endblock %} {% block content %} Home Account menu Back Sign out BLYTHE ACADEMY UKPRN:12345678 Funding statements View your statements Download documents 1 new document to download Upload documents 1 new document to upload Contracts Sign your contract Apprenticeship grant for employers View your AGE reports Funding claims View your claims {% endblock %}
UKPRN:12345678


CW WEB RUNNER
Click or press enter key to play the Morse code.
After entering the code you heard, please click or press enter key to confirm your answer.
Right
Wrong
Signal Type
World
Japan
Basic
Rubber Stamp
Speed (wpm)
Random
Fixed
Freq (Hz)
Random
Fixed
Add De
repeat wrong signal
History of Training in the time.


The Ghost And The Darkness (1996) A film review by James Berardinelli Copyright 1996 James Berardinelli
RATING (0 TO 10): 5.5 Alternative Scale: ** out of ****
United States, 1996 U.S. Release Date: 10/11/96 (wide) Running Length: 1:50 MPAA Classification: R (Violence, profanity) Theatrical Aspect Ratio: 2.35:1
Cast: Val Kilmer, Michael Douglas, John Kani, Tom Wilkinson, Bernard Hill, Brian McCardi, Om Puri, Emily Mortimer Director: Stephen Hopkins Producers: Gale Ann Hurd, Paul Radin, and A. Kitman Ho Screenplay: William Goldman Cinematography: Vilmos Zsigmond Music: Jerry Goldsmith U.S. Distributor: Paramount Pictures
If it does nothing else, THE GHOST AND THE DARKNESS will make you realize just how brilliant Steven Spielberg's execution of JAWS is. Using a similar (albeit land-bound) premise -- hunting down bloodthirsty predators -- this movie devolves into a silly series of animal attacks and chases. The camerawork is frenetic and confusing, and the big confrontations are as likely to provoke unintentional laughter as edge- of-the-seat excitement.
"Evil lions terrorize workers building a turn-of-the-century railroad in Africa" doesn't sound all that promising, but, then again, neither does "Giant shark terrorizes vacationers at a quiet seaside resort." In his 1975 thriller, Spielberg proved that the man-against- beast struggle, if done properly, can make for a compelling motion picture. With THE GHOST AND THE DARKNESS, director Stephen Hopkins tries unsuccessfully to generate the same level of tension. While Hopkins' film making skills aren't of the same caliber as Spielberg's (one man made A NIGHTMARE ON ELM STREET 5; the other, SCHINDLER'S LIST), the lion's share of the blame for this movie's failure can be laid squarely on the shoulders of veteran screenwriter William Goldman, whose script is contrived and inadequate. In JAWS, it was thrilling to watch the failed attempts to kill the enemy; here, it's just frustrating.
THE GHOST AND THE DARKNESS takes place during the waning years of the nineteenth century, when England, France, and Germany were racing to complete the first cross-Africa railroad to facilitate the ivory trade. Colonel John Patterson (Val Kilmer), an Irishman with an inconsistent accent, is the engineer employed to build England's bridge across Uganda's Tsavo River. As if he doesn't have enough problems with feuding, stereotyped workers and a bombastic boss named Beaumont (Tom Wilkinson), two man-eating lions begin stalking Patterson's camp. More than one-hundred die, often horribly, including the camp's resident evangelist (Brian McCardi), and when Patterson's attempts to kill the lions fail, Beaumont calls in an expert hunter, Charles Remington (Michael Douglas), to resolve the situation.
Actually, taken as high camp, it's possible to enjoy THE GHOST AND THE DARKNESS on a reasonably consistent basis. In addition to giving Kilmer and Douglas some wonderfully loony lines of dialogue, the script spends a lot of time on unnecessarily convoluted schemes to kill the beasts. Then there's Patterson's "ultimate solution" -- take his gun, climb on top of a rickety platform, wait for the lion, then, when the beast is charging, get knocked off the platform by an aggressive bird. Somehow, I don't think Hopkins intended this scene to be as funny as it is.
There is a promising, although largely unexplored, story buried within THE GHOST AND THE DARKNESS. Building a railroad bridge across the Tsavo River has the potential to generate some potent drama. Of course, THE GHOST AND THE DARKNESS is only interested in this material as background, so no attempt is made to examine the pressures and difficulties of railroad construction. We're told that the Africans don't get along with the Indians, and the Muslims fight with the Hindus, but the ramifications of these internal struggles are left unexplored. And, man-eating animals aside, what about the inherent difficulties of raising such an imposing structure under stringent time and environmental constraints?
The lions in THE GHOST AND THE DARKNESS, like the shark in JAWS, are invested with near-mythical powers. At first, I thought the film makers' reluctance to give us a good, clear view of them was to build suspense. Unfortunately, it becomes clear that the real reason has more to do with poor special effects than a desire to tease the audience. The animatronic lions look terrible. (Remember the apes in CONGO?) One wonders why, with all the impressive twisters and spaceships that were zipping around on screens this summer, THE GHOST AND THE DARKNESS can't come up with a pair of credible lions.
Val Kilmer is either badly miscast, bored, or a combination of the two. His Patterson is dull and largely unsympathetic. As a hero, he leaves a lot to be desired. Michael Douglas is the exact opposite, drawing the camera like a magnet with his over-the-top portrayal of the big game hunter, THE GHOST IN THE DARKNESS' answer to Robert Shaw's JAWS character. Unfortunately, Douglas doesn't show up until the film is half over, so it's necessary to struggle through the first forty-five minutes without his energetic boost.
For those who are interested in observing the habits of real lions and viewing genuine life-and-death struggles in Africa, I direct your attention to THE LEOPARD SON, which is still in theatrical release. That well-constructed documentary has stronger drama, tension, and cinematography than the supposedly-real story told in THE GHOST AND THE DARKNESS. True, it's missing Tom Wilkinson sneering, Michael Douglas smirking, and Val Kilmer looking bored, but no movie can boast everything.
- James Berardinelli e-mail<EMAIL_ADDRESS>ReelViews web site: http://www.cybernex.net/~berardin
"We go away from our parents in youth and then we gradually come back to them; and in that moment, we have grown up." -- Ingmar Bergman
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


The installed Terraform version you wish to use for this build.
To install Terraform, in Configure system, select Terraform and then select install automatically from bintray.com


barney
`Prev `__
B
`Next `__
--------------
**barney**: n.
In Commonwealth hackish, barney is to `*fred* <../F/fred.html>`__ (sense
#1) as `*bar* `__ is to `*foo* <../F/foo.html>`__. That is,
people who commonly use fred as their first metasyntactic variable will
often use barney second. The reference is, of course, to Fred Flintstone
and Barney Rubble in the Flintstones cartoons.
--------------
+-------------------------+----------------------------+----------------------------+
| `Prev `__ | `Up <../B.html>`__ | `Next `__ |
+-------------------------+----------------------------+----------------------------+
| barn | `Home <../index.html>`__ | baroque |
+-------------------------+----------------------------+----------------------------+


Blockchain for Business
WITH IBM BLOCKCHAIN
Home
Signout
Schneider
Schneider
chief Supplying Officer
Create
Purchase Order
Goods Receipt
Consumption
Payment
Search
Purchase Order
Self Invoice
Notification
Report
Payment failed
Invoice ID
Batch Id
PO Number
Amount to be paid
SE materialCode
Total Quantity
{{transactionId}}
Invoice generation faied
Invoice ID


In addition surrounding XHTML with a template, you can also embed a template at the current point in the page rendering with the <lift:embed/> tag.
The above paragraph was embedded using this code:
<lift:embed what="/templating/_sample_embed"/>
Templates that start with the underscore ('_') or period ('.') characters will not be served directly by Lift, but may be accessed using the surround and embed tags.
Lift will select templates based on the current localization
setting for the session. Lift uses the function in
LiftRules.localeCalculator
to determine the
current locale for template selection. By default the
function is:
def defaultLocaleCalculator(request: Box[HttpServletRequest]) = request.flatMap(_.getLocale() match {case null => Empty case l: Locale => Full(l)}).openOr(Locale.getDefault())But you can customize the function to return the locale of the currently logged in user, detect the IP address of the request, etc.
Based on the locale, Lift will look for templates based on
the base template name, in this case
'/templating/_sample_embed'
and
then append an underscore ('_') followed by the complete locale, for
example 'en_US'. So, Lift will look for
'/templating/_sample_embed_en_US.html'
. If that resource
is not available, Lift will look for
'/templating/_sample_embed_en.html'
and finally
'/templating/_sample_embed.html'
.


I am really glad you took the responsibility to save your nation or company or you personal data from the bad guys(You know who!).  But before we dive in I wanna clear that:
With great powers comes the great responsibility -Uncle BenSo be ready for that because there is a huge difference between reel life hacking and real life hacking. We don't randomly press any key and a cool green text animation start playing on our screen. So if you ready to take the responsibility we can start or you can leave this post and explore other domains on our websites.
What is Ethical Hacking?
I am glad you still reading this and ready to take the responsibilty.
So before starting give youself a Cheer!Ok, So let's understand what is Ethical Hacking in a way a hacker will understand i.e. break it into smaller parts and then learn. Ethical means with correct/good morals and hacking in easy words means controlling something. So, if we merge these two findings we get to know that Ethical hacking is a job given to good people by big giant companies(not necessarily) to protect their assets(say it applications like mobile apps of amazon etc or data of users). They got paid for the security service they provide to you.
Let's Understand it with an example: Suppose you are an undercover cop and want to save your locality from a group of thieves So you planned to join the group of thieves pretending that you wanna be a burglar and you learned all their tactics And suddenly one day you left and now you know all different methods these thieves use so you made precautionary measures accordingly and thus avoiding the burglary for some time. Wooo! you saved the assets.
The same is what an ethical hacker does. He learns! What ways an application or a machine can be compromised by bad guys? and does the precautionary measures accordingly. But here the good guy i.e. you need to learn constantly to keep your machines secure all the time. As we all know that time and tide wait for none and bad guys keep developing new ways to break into your systems.
The demand for ethical hackers in INDIA?
Let me ask you: Do you hear phrases like
“Oh god! My Facebook account has been hacked”or something like
“Someone withdrew $10000 from my bank_account”.Most probably yes and here is your answer who's gonna make a strong system for the noob users like your friends(not mocking you better know) it's the Ethical Hacker(i.e. you). According to a survey by World_Economic_Forum INDIA is standing at 11th position in cyberattack response and hence the job opening is increasing at a rate of 3.5 times each year. The average salary ranges from $10,000-$15,000 + BugBounty if you manage to find the bugs
Ethical Hacking Vs Cybersecurity
So in simple terms Cybersecurity is an umbrella/domain under which ethical hacking is a part. Kind of different branches under computer science departments(say). As shown in the graph below we have various subdomains in the ethical hacking field like risk_assessment, Security_operation, etc. So an ethical hacker can have knowledge of one or two domains in the graph and not all. I hope you understood the concept.
Who are the hackers?
As the term #hackerr" strikes our mind, the 1st thing that comes in our mind is cybercrime. We witness news flashing every day on #cybercrimes – through the mail, social networking sites, phone numbers, and more.
- White_Hat_hackers(legal): A white-hat hacker is a person who #breaks into systems ethically. The purpose is not to steal info. but to enhance or test the security. They are legally permitted to do the same and are often called as ethical hackers. In fact, there are professional certifications that certify one as a Certified Ethical Hacker.
- Black_Hat_hackers(illegal): Not all hackers are crackers. Now, opposite of white hat hackers, they break into systems due to #malicious intent. They use private information of people for causing crimes like #robbery, #fraud, #vandalism, and more which is punishable by law.
- Grey_Hat_hackers(both): They belong to the grey area and exhibits traits of both white and black hat hackers. These types of hackers usually dig into other systems #unethically while causing no such malicious harm.


|
RayTracer
|
Files | |
| file | BinaryVolumeHierarchy.cpp |
| file | BinaryVolumeHierarchy.h [code] |
| file | BoundedVolume.cpp |
| file | BoundedVolume.h [code] |
| file | BoundingBox.cpp |
| file | BoundingBox.h [code] |
| file | CSG.cpp |
| file | CSG.h [code] |
| file | ImplicitSurface.cpp |
| file | ImplicitSurface.h [code] |
| file | RenderObject.cpp |
| file | RenderObject.h [code] |
| file | SDFBox.cpp |
| file | SDFBox.h [code] |
| file | SDFCylinder.cpp |
| file | SDFCylinder.h [code] |
| file | SDFObject.cpp |
| file | SDFObject.h [code] |
| file | SDFSphere.cpp |
| file | SDFSphere.h [code] |
| file | SimplePlane.cpp |
| file | SimplePlane.h [code] |
| file | SimpleSphere.cpp |
| file | SimpleSphere.h [code] |
| file | Triangle.cpp |
| file | Triangle.h [code] |


@* * Copyright 2010-2023 Artima, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import controllers.Application.scaladocsPageUrl @import controllers.Application.milestoneScaladoc @combinedReleaseNotesPage("Scalactic/ScalaTest 3.2.16 Release Notes") {
ScalaTest/Scalactic 3.2.16 (for Scala 2.10, 2.11, 2.12, 2.13, 3.1; on the JVM, JavaScript, and native) includes the enhancements listed below.
For information on how to include ScalaTest in your project, see the install page. For information on how to use Scalactic in your production code, see its install page.
ScalaTest 3.2.16 is a minor release of ScalaTest that makes bug fixes, few enhancements, and supports Scala.js 1.8.x, Scala.native 0.4.9 and Scala 3.1.x.
Recognize -S as a valid argument in checkArgsForValidity, used by Runner. (PR #2222)
Fixed "SuiteAborted.this.message was null". (PR #2236)
Fixed compiler warning in expanded code when the size or length method call contains empty bracket. (PR #2230)
Deprecated NoArg as scala.DelayedInit is dropped from Scala 3, updated ScalaDoc. (PR #2228)
Scalactic 3.2.16 contains no new bug fixes.
Added overridable differ to Prettifier trait, and added functions to create prettifier instance with supplied Differ. (PR #2221)
Scalactic 3.2.16 contains no new deprecations.
Visit ScalaTest Release Notes for links to the release notes of all previous versions, or step back in time by visiting the release notes for the previous version.


Ip Routing General
21 Apr 2017 |layout: post title: IP Routing General category: General Routing tag: knowledge date: 2017-04-21 19:56:45 — Static routes that point to an interface are advertised via RIP (and EIGRP) regardless of whether redistribute static router configuration commands are specified for those routing protocols. This is because these routes are considered “connected” routes and lose their static nature. However, if there is no network command defined for that interface, then the default route will not be advertised unless a redistribute static command is configured.
There are 3 ways (outside of dynamic routing protocols) to generate a default route.
- ip default-gateway
- ip default-network
- ip route <IP_ADDRESS> <IP_ADDRESS>
ip default-gateway is used to define a default gateway when ip routing is not enabled on the device. This can be handy to transfer a Cisco software image to a device when the device is in boot mode.
ip default-network is used to define a default gateway when ip routing is enabled on the router. Default routes configured this way are propagated differently depending on which routing protocol is propagating the default route. For EIGRP to propagate the default route, the network specified by ip default-network must be known to EIGRP. The network must be an EIGRP derived network in the routing table, or the static route used to generate the route to the network must be redistributed into EIGRP.
RIP advertises a route to network <IP_ADDRESS> if a gateway of last resort is configured using the ip default-network command.
When using ip route <IP_ADDRESS> <IP_ADDRESS> to create a default route, EIGRP will propagate a route to network <IP_ADDRESS>, but the static route must be redistributed into the routing protocol. With RIP, on most versions of IOS the default route created by ip route <IP_ADDRESS> <IP_ADDRESS> is automatically advertised by RIP. Not only are these routes not automatically propagated by OSPF, you cannot redistribute a default route into OSPF - you must use the default-information originate command.


SPTAudioStreamingPlaybackDelegate Protocol Reference
| Conforms to | NSObject |
|---|---|
| Declared in | SPTAudioStreamingController.h |
– audioStreaming:didReceivePlaybackEvent:
Called for each received low-level event
- (void)audioStreaming:(SPTAudioStreamingController *)audioStreaming didReceivePlaybackEvent:(SpPlaybackEvent)event
Parameters
audioStreaming |
The object that sent the message. |
|---|---|
event |
The event code |
Declared In
SPTAudioStreamingController.h
– audioStreaming:didChangePosition:
Called when playback has progressed
- (void)audioStreaming:(SPTAudioStreamingController *)audioStreaming didChangePosition:(NSTimeInterval)position
Parameters
audioStreaming |
The object that sent the message. |
|---|---|
position |
The new playback location in sec. |
Declared In
SPTAudioStreamingController.h
– audioStreaming:didChangePlaybackStatus:
Called when playback status changes.
- (void)audioStreaming:(SPTAudioStreamingController *)audioStreaming didChangePlaybackStatus:(BOOL)isPlaying
Parameters
audioStreaming |
The object that sent the message. |
|---|---|
isPlaying |
Set to |
Declared In
SPTAudioStreamingController.h
– audioStreaming:didSeekToPosition:
Called when playback is seeked “unaturally” to a new location.
- (void)audioStreaming:(SPTAudioStreamingController *)audioStreaming didSeekToPosition:(NSTimeInterval)position
Parameters
audioStreaming |
The object that sent the message. |
|---|---|
position |
The new playback location in sec. |
Declared In
SPTAudioStreamingController.h
– audioStreaming:didChangeVolume:
Called when playback volume changes.
- (void)audioStreaming:(SPTAudioStreamingController *)audioStreaming didChangeVolume:(SPTVolume)volume
Parameters
audioStreaming |
The object that sent the message. |
|---|---|
volume |
The new volume. |
Declared In
SPTAudioStreamingController.h
– audioStreaming:didChangeShuffleStatus:
Called when shuffle status changes.
- (void)audioStreaming:(SPTAudioStreamingController *)audioStreaming didChangeShuffleStatus:(BOOL)enabled
Parameters
audioStreaming |
The object that sent the message. |
|---|---|
enabled |
Set to |
Declared In
SPTAudioStreamingController.h
– audioStreaming:didChangeRepeatStatus:
Called when repeat status changes.
- (void)audioStreaming:(SPTAudioStreamingController *)audioStreaming didChangeRepeatStatus:(SPTRepeatMode)repeateMode
Parameters
audioStreaming |
The object that sent the message. |
|---|---|
repeateMode |
Set to |
Declared In
SPTAudioStreamingController.h
– audioStreaming:didChangeMetadata:
Called when metadata for current, previous, or next track is changed. * * This event occurs when playback starts or changes to a different context, * when a track switch occurs, etc. This is an informational event that does * not require action, but should be used to keep the UI display updated with * the latest metadata information. *
- (void)audioStreaming:(SPTAudioStreamingController *)audioStreaming didChangeMetadata:(SPTPlaybackMetadata *)metadata
Parameters
audioStreaming |
The object that sent the message. |
|---|---|
metadata |
for previous, current, and next tracks |
Declared In
SPTAudioStreamingController.h
– audioStreaming:didStartPlayingTrack:
Called when the streaming controller begins playing a new track.
- (void)audioStreaming:(SPTAudioStreamingController *)audioStreaming didStartPlayingTrack:(NSString *)trackUri
Parameters
audioStreaming |
The object that sent the message. |
|---|---|
trackUri |
The Spotify URI of the track that started to play. |
Declared In
SPTAudioStreamingController.h
– audioStreaming:didStopPlayingTrack:
Called before the streaming controller begins playing another track.
- (void)audioStreaming:(SPTAudioStreamingController *)audioStreaming didStopPlayingTrack:(NSString *)trackUri
Parameters
audioStreaming |
The object that sent the message. |
|---|---|
trackUri |
The Spotify URI of the track that stopped. |
Declared In
SPTAudioStreamingController.h
– audioStreamingDidSkipToNextTrack:
Called when the audio streaming object requests playback skips to the next track.
- (void)audioStreamingDidSkipToNextTrack:(SPTAudioStreamingController *)audioStreaming
Parameters
audioStreaming |
The object that sent the message. |
|---|
Declared In
SPTAudioStreamingController.h
– audioStreamingDidSkipToPreviousTrack:
Called when the audio streaming object requests playback skips to the previous track.
- (void)audioStreamingDidSkipToPreviousTrack:(SPTAudioStreamingController *)audioStreaming
Parameters
audioStreaming |
The object that sent the message. |
|---|
Declared In
SPTAudioStreamingController.h
– audioStreamingDidBecomeActivePlaybackDevice:
Called when the audio streaming object becomes the active playback device on the user’s account.
- (void)audioStreamingDidBecomeActivePlaybackDevice:(SPTAudioStreamingController *)audioStreaming
Parameters
audioStreaming |
The object that sent the message. |
|---|
Declared In
SPTAudioStreamingController.h
– audioStreamingDidBecomeInactivePlaybackDevice:
Called when the audio streaming object becomes an inactive playback device on the user’s account.
- (void)audioStreamingDidBecomeInactivePlaybackDevice:(SPTAudioStreamingController *)audioStreaming
Parameters
audioStreaming |
The object that sent the message. |
|---|
Declared In
SPTAudioStreamingController.h
– audioStreamingDidLosePermissionForPlayback:
Called when the streaming controller lost permission to play audio.
- (void)audioStreamingDidLosePermissionForPlayback:(SPTAudioStreamingController *)audioStreaming
Parameters
audioStreaming |
The object that sent the message. |
|---|
Discussion
This typically happens when the user plays audio from their account on another device.
Declared In
SPTAudioStreamingController.h
– audioStreamingDidPopQueue:
Called when the streaming controller popped a new item from the playqueue.
- (void)audioStreamingDidPopQueue:(SPTAudioStreamingController *)audioStreaming
Parameters
audioStreaming |
The object that sent the message. |
|---|
Declared In
SPTAudioStreamingController.h


Type something below, close your browser, restart your computer, and come back. Your text will still be there.


Easy And Fast Way To Healthy Life
Live Confidently
Good Life Just A CLick Away
Dead bodies move on their own after death, likely due to procccesses of decomposition
Testing for circulating tumor cells in the blood alongside PSA can increase accuracy of prostate cancer
Using a mini organ modal, laxane chemotherapy can permanently damage follicles
Reseaches reveals the structure and function of a molecule that may help cancer develop and become treatment resistant
Eating Iron-rich foods may counter the the cancer fighting properties of latter
Many new cancer drugs may not work the way their developers think they do, which may have implication for this effectiveness
Delivering a flu vaccine using a new type of skin patch can stimulate an appropriate immune response
People with Alheimer's biomakers in the brain who frequently exercise experience slower deterioration.
Over 70% Of US Adults Unaware Of HPV-related Cancer Risk
How Do Supersitions Affects Our Phycology And Well-being
Hearing Aids Lower The Chance Of DEMENTIA, DEPRESSION AND FALLING
Why Do Female Bonobos Have Sex With Each Other Than With Males?
Physical Fitness Linked To Better Brain Function


You can access a specific character in a string by using the square brackets syntax [].
You have to provide the index of the character that you'd like to access, starting from 0.
Let's take an example where the variable language has the value: "JavaScript". Here's how you access the 1st character, the 2nd, and the 3rd:
You can debug it in the console as:
You can also combine the character access with the .length property. So using the same language variable, here's how you get the second to last character from it:
Note that language[ language.length ] will be undefined because character
access starts at 0.
So for a string of 9 characters, 8 is the position of the last character.
Substring signature
A function signature gives you an explanation of the parameters that you
need to pass for that method. Let's take a look at the signature of
substring:
//Signature:
substring(indexStart, indexEnd)
This means that when you call substring, you can give it 2 parameters, the
first one for the indexStart and the second one for indexEnd.
indexStart:
the position of the first
character you'd like to include
indexEnd:
the position of the first
character you'd like to ignore
This means an indexEnd of 5, will only include up to character 4.
The combination of these 2 will give you a substring.
The indexEnd parameter is optional, which means you can simply pass the indexStart and it'll assume the indexEnd to be the same as the string length. Here's an example: