Raw TCP/IP networking is dangerous for two reasons:
Transport Layer Security (TLS) and its predecessor Secure Socket Layer (SSL), which are both often collectively called SSL, solve both problems. SSL uses:
SSL allows agents to talk in private and create secure web services.
The SWI-Prolog library(ssl)
library provides an API to
turn a pair of arbitrary Prolog wire streams into SSL powered
encrypted streams. Note that secure protocols such as secure HTTP simply
run the plain protocol over (SSL) encrypted streams.
The library(crypto)
library provides additional
predicates related to cryptography and authentication, secure hashes and
elliptic curves.
Cryptography is a difficult topic. If you just want to download documents from an HTTPS server without worrying much about security, http_open/3 will do the job for you. As soon as you have higher security demands we strongly recommend you to read enough background material to understand what you are doing. See section 5 for some remarks regarding this implementation. This http://www.tldp.org/HOWTO/SSL-Certificates-HOWTO/index.htmlThe Linux Documentation Project page provides some additional background and tips for managing certificates and keys.
An SSL server and client can be built with the (abstracted) predicate
calls from the table below. The tcp_
predicates are
provided by library(socket)
. The predicate ssl_context/3
defines properties of the SSL connection, while ssl_negotiate/5
establishes the SSL connection based on the wire streams created by the
TCP predicates and the context.
The SSL Server The SSL Client ssl_context/3 ssl_context/3 tcp_socket/1 tcp_accept/3 tcp_connect/3 tcp_open_socket/3 stream_pair/3 ssl_negotiate/5 ssl_negotiate/5
The library is abstracted to communication over streams, and is not
reliant on those streams being directly attached to sockets. The tcp_
calls here are simply the most common way to use the library. Other
two-way communication channels such as (named), pipes can just as easily
be used.
client
.
Otherwise, certificate verification may fail when negotiating a secure
connection.
key_file(+FileName)
option. A server must have
at least one certificate before clients can connect. A client
must have a certificate only if the server demands the client to
identify itself with a client certificate using the
peer_cert(true)
option. If a certificate is provided, it is
necessary to also provide a matching private key via the
key_file/1 option. To configure multiple
certificates, use the option certificate_key_pairs/1
instead. Alternatively, use
ssl_add_certificate_key/4
to add certificates and keys to an existing context.
password(+Text)
or
pem_password_hook(:Goal)
option.
call(Goal, +SSL, -Password)
and typically unifies
Password with a string containing the password.
require_crl(true)
and provide neither of these options, verification will necessarily fail
require_crl(true)
if you want
CRLs to actually be checked by OpenSSL.
system(root_certificates)
uses a list of trusted root certificates as provided by the OS. See
system_root_certificates/1
for details.
Additional verification of the peer certificate as well as accepting certificates that are not trusted by the given set can be realised using the hook cert_verify_hook(:Goal).
call(Goal, +SSL, +ProblemCertificate, +AllCertificates, +FirstCertificate, +Error)
In case the certificate was verified by one of the provided
certifications from the cacert_file
option, Error is
unified with the atom verified
. Otherwise it contains the
error string passed from OpenSSL. Access will be granted iff the
predicate succeeds. See load_certificate/2
for a description of the certificate terms. See cert_accept_any/5
for a dummy implementation that accepts any certificate.
prime256v1
is used by default.
true
, close the raw streams if the SSL
streams are closed. Default is false
.
true
(default is false
), the server sends
TLS
close_notify
when closing the connection. In addition, this
mitigates truncation attacks for both client and server role: If
EOF is encountered without having received a TLS shutdown, an exception
is raised. Well-designed protocols are self-terminating, and this attack
is therefore very rarely a concern.
sslv3
, tlsv1
, tlsv1_1
and tlsv1_2
. This option is available with OpenSSL 1.1.0
and later, and should be used instead of disable_ssl_methods/1
.
sslv3
, tlsv1
, tlsv1_1
and tlsv1_2
. This option is available with OpenSSL 1.1.0
and later, and should be used instead of disable_ssl_methods/1
.
sslv2
, sslv3
, sslv23
,
tlsv1
, tlsv1_1
and tlsv1_2
. This
option is deprecated starting with OpenSSL 1.1.0. Use min_protocol_version/1
and
max_protocol_version/1 instead.
disable_ssl_methods
above.
Using this option is discouraged. When using OpenSSL 1.1.0 or later,
this option is ignored, and a version-flexible method is used to
negotiate the connection. Using version-specific methods is deprecated
in recent OpenSSL versions, and this option will become obsolete and
ignored in the future.
call(Goal, +SSL0, +HostName, -SSL)
Given the current context SSL0, and the host name of the client request, the predicate computes SSL which is used as the context for negotiating the connection. The first solution is used. If the predicate fails, the default options are used, which are those of the encompassing ssl_context/3 call. In that case, if no default certificate and key are specified, the client connection is rejected.
| Role | is one of server
or client and denotes whether the
SSL instance will have a server or client role in the
established connection. |
| SSL | is a SWI-Prolog blob
of type ssl_context , i.e., the type-test for an SSL
context is blob(SSL, ssl_context) . |
This predicate allows dual-stack RSA and ECDSA servers (for example),
and is an alternative for using the
certificate_key_pairs/1
option. As of OpenSSL 1.0.2,
multiple certificate types with completely independent certificate
chains are supported. If a certificate of the same type is added
repeatedly to a context, the result is undefined. Currently, up to 12
additional certificates of different types are admissible.
After a successful handshake and finishing the communication the user
must close SSLRead and SSLWrite, for example using
call_cleanup(close(SSLWrite), close(SSLRead))
. If the SSL
context (created with ssl_context/3
has the option
close_parent(true)
(default false
), closing SSLRead
and
SSLWrite also closes the original PlainRead and PlainWrite
streams. Otherwise these must be closed explicitly by the user.
http_open(HTTPS_url, In, []), ssl_peer_certificate(In, Cert), memberchk(subject(Subject), Cert), memberchk('CN' = CommonName), Subject)
Note that the OpenSSL CA.pl
utility creates certificates
that have a human readable textual representation in front of the PEM
representation. You can use the following to skip to the certificate if
you know it is a PEM certificate:
skip_to_pem_cert(In) :- repeat, ( peek_char(In, '-') -> ! ; skip(In, 0'\n), at_end_of_stream(In), ! ).
revoked(+Serial, DateOfRevocation)
system(root_certificates)
. The list is obtained using an OS
specific process. The current implementation is as follows:
"ROOT"
certificates from the OS.
system_cacert_filename
. The initial value of this flag
is operating system dependent. For security reasons, the flag can only
be set prior to using the SSL library. For example:
:- use_module(library(ssl)). :- set_prolog_flag(system_cacert_filename, '/home/jan/ssl/ca-bundle.crt').
private_key(KeyTerm)
where KeyTerm is an rsa/8 term
representing an RSA key, or ec/3 for EC
keys.public_key(KeyTerm)
where KeyTerm is an rsa/8
term representing an RSA key, or ec/3 for
EC keys.http_open('https:/...', In, [ cert_verify_hook(cert_accept_any) ])
Note that obsolete ciphers must be disabled to reliably prevent protocol downgrade attacks.
The Ciphers list is read from the setting ssl:secure_ciphers
and can be controlled using set_setting/2
and other predicates from
library(settings)
.
BEWARE: This list must be changed when attacks on these ciphers become known! Keep an eye on this setting and adapt it as necessary in the future.
This library provides bindings to functionality of OpenSSL that is related to cryptography and authentication, not necessarily involving connections, sockets or streams.
A basic design principle of this library is that its default algorithms are cryptographically secure at the time of this writing. We will change the default algorithms if an attack on them becomes known, and replace them by new defaults that are deemed appropriate at that time.
This may mean, for example, that where sha256
is
currently the default algorithm, blake2s256
or some other
algorithm may become the default in the future.
To preserve interoperability and compatibility and at the same time allow us to transparently update default algorithms of this library, the following conventions are used:
This allows application programmers to inspect which algorithm was actually used, and store it for later reference.
For example:
?- crypto_data_hash(test, Hash, [algorithm(A)]). Hash = '9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08', A = sha256.
This shows that at the time of this writing, sha256
was
deemed sufficiently secure, and was used as default algorithm for
hashing.
You therefore must not rely on which concrete algorithm is being used by default. However, you can rely on the fact that the default algorithms are secure. In other words, if they are not secure, then this is a mistake in this library, and we ask you to please report such a situation as an urgent security issue.
In the context of this library, bytes can be represented as lists of integers between 0 and 255. Such lists can be converted to and from hexadecimal notation with the following bidirectional relation:
Example:
?- hex_bytes('501ACE', Bs). Bs = [80, 26, 206].
Almost all cryptographic applications require the availability of numbers that are sufficiently unpredictable. Examples are the creation of keys, nonces and salts. With this library, you can generate cryptographically strong pseudo-random numbers for such use cases:
One way to relate such a list of bytes to an integer is to use CLP(FD) constraints as follows:
:- use_module(library(clpfd)). bytes_integer(Bs, N) :- foldl(pow, Bs, 0-0, N-_). pow(B, N0-I0, N-I) :- B in 0..255, N #= N0 + B*256^I0, I #= I0 + 1.
With this definition, you can generate a random 256-bit integer from a list of 32 random bytes:
?- crypto_n_random_bytes(32, Bs), bytes_integer(Bs, I). Bs = [98, 9, 35, 100, 126, 174, 48, 176, 246|...], I =<PHONE_NUMBER>62338328820827...(53 digits omitted).
The above relation also works in the other direction, letting you translate an integer to a list of bytes. In addition, you can use hex_bytes/2 to convert bytes to tokens that can be easily exchanged in your applications. This also works if you have compiled SWI-Prolog without support for large integers.
A hash, also called digest, is a way to verify the integrity of data. In typical cases, a hash is significantly shorter than the data itself, and already miniscule changes in the data lead to different hashes.
The hash functionality of this library subsumes and extends that of
library(sha)
, library(hash_stream)
and library(md5)
by providing a unified interface to all available digest algorithms.
The underlying OpenSSL library (libcrypto
) is
dynamically loaded if
either library(crypto)
or library(ssl)
are loaded. Therefore, if your application uses library(ssl)
,
you can use library(crypto)
for hashing without increasing
the memory footprint of your application. In other cases, the
specialised hashing libraries are more lightweight but less general
alternatives to library(crypto)
.
The most important predicates to compute hashes are:
md5
(insecure), sha1
(insecure), ripemd160
,
sha224
, sha256
, sha384
, sha512
, sha3_224
, sha3_256
,
sha3_384
, sha3_512
, blake2s256
or blake2b512
.
The BLAKE digest algorithms require OpenSSL 1.1.0 or greater, and the
SHA-3 algorithms require OpenSSL 1.1.1 or greater. The default is a
cryptographically secure algorithm. If you specify a variable, then that
variable is unified with the algorithm that was used.
utf8
. The other
meaningful value is octet
, claiming that Data
contains raw bytes.
| Data | is either an atom, string or code-list |
| Hash | is an atom that represents the hash in hexadecimal encoding. |
For the important case of deriving hashes from passwords, the following specialised predicates are provided:
crypto_password_hash(Password, Hash, [])
and computes a
password-based hash using the default options.Another important distinction is that equal passwords must yield, with very high probability, different hashes. For this reason, cryptographically strong random numbers are automatically added to the password before a hash is derived.
Hash is unified with an atom that contains the computed hash and all parameters that were used, except for the password. Instead of storing passwords, store these hashes. Later, you can verify the validity of a password with crypto_password_hash/2, comparing the then entered password to the stored hash. If you need to export this atom, you should treat it as opaque ASCII data with up to 255 bytes of length. The maximal length may increase in the future.
Admissible options are:
pbkdf2-sha512
,
which is therefore also the default.
^
C.
Currently, the default is 17, and thus more than one hundred thousand
iterations. You should set this option as high as your server and users
can tolerate. The default is subject to change and will likely increase
in the future or adapt to new algorithms.
Currently, PBKDF2 with SHA-512 is used as the hash derivation function, using 128 bits of salt. All default parameters, including the algorithm, are subject to change, and other algorithms will also become available in the future. Since computed hashes store all parameters that were used during their derivation, such changes will not affect the operation of existing deployments. Note though that new hashes will then be computed with the new default parameters.
The following predicate implements the Hashed Message Authentication Code (HMAC)-based key derivation function, abbreviated as HKDF. It supports a wide range of applications and requirements by concentrating possibly dispersed entropy of the input keying material and then expanding it to the desired length. The number and lengths of the output keys depend on the specific cryptographic algorithms for which the keys are needed.
Admissible options are:
utf8
(default) or octet
, denoting the
representation of Data as in crypto_data_hash/3.
The info/1
option can be used to generate multiple keys
from a single master key, using for example values such as key
and
iv
, or the name of a file that is to be encrypted.
This predicate requires OpenSSL 1.1.0 or greater.
The following predicates are provided for building hashes incrementally. This works by first creating a context with crypto_context_new/2, then using this context with crypto_data_context/3 to incrementally obtain further contexts, and finally extract the resulting hash with crypto_context_hash/2.
| Context | is an opaque pure Prolog term that is subject to garbage collection. |
This predicate allows a hash to be computed in chunks, which may be important while working with Metalink (RFC 5854), BitTorrent or similar technologies, or simply with big files.
The following hashing predicates work over streams:
true
(default), closing the filter stream also closes
the original (parent) stream.
A digital signature is a relation between a key and data that only someone who knows the key can compute.
Signing uses a private key, and verifying a signature uses the corresponding public key of the signing entity. This library supports both RSA and ECDSA signatures. You can use load_private_key/3 and load_public_key/2 to load keys from files and streams.
In typical cases, we use this mechanism to sign the hash of data. See hashing (section 3.5). For this reason, the following predicates work on the hexadecimal representation of hashes that is also used by crypto_data_hash/3 and related predicates.
Signatures are also represented in hexadecimal notation, and you can use hex_bytes/2 to convert them to and from lists of bytes (integers).
hex
) assumes that Data is an atom,
string, character list or code list representing the data in hexadecimal
notation. See rsa_sign/4 for an
example.
Options:
hex
.
Alternatives are octet
, utf8
and text
.
Options:
hex
.
Alternatives are octet
, utf8
and text
.
sha1
, sha224
, sha256
, sha384
or sha512
. The default is a cryptographically secure
algorithm. If you specify a variable, then it is unified with the
algorithm that was used.
hex
.
Alternatives are octet
, utf8
and text
.
This predicate can be used to compute a sha256WithRSAEncryption
signature as follows:
sha256_with_rsa(PemKeyFile, Password, Data, Signature) :- Algorithm = sha256, read_key(PemKeyFile, Password, Key), crypto_data_hash(Data, Hash, [algorithm(Algorithm), encoding(octet)]), rsa_sign(Key, Hash, Signature, [type(Algorithm)]). read_key(File, Password, Key) :- setup_call_cleanup( open(File, read, In, [type(binary)]), load_private_key(In, Password, Key), close(In)).
Note that a hash that is computed by crypto_data_hash/3 can be directly used in rsa_sign/4 as well as ecdsa_sign/4.
Options:
sha1
,
sha224
, sha256
, sha384
or sha512
.
The default is the same as for rsa_sign/4.
This option must match the algorithm that was used for signing. When
operating with different parties, the used algorithm must be
communicated over an authenticated channel.
hex
.
Alternatives are octet
, utf8
and text
.
The following predicates provide asymmetric RSA encryption and decryption. This means that the key that is used for encryption is different from the one used to decrypt the data:
Options:
utf8
.
Alternatives are utf8
and octet
.
pkcs1
. Alternatives are pkcs1_oaep
, sslv23
and none
. Note that none
should only be used
if you implement cryptographically sound padding modes in your
application code as encrypting unpadded data with RSA is insecure
The following predicates provide symmetric encryption and decryption. This means that the same key is used in both cases.
PlainText must be a string, atom or list of codes or characters, and CipherText is created as a string. Key and IV are typically lists of bytes, though atoms and strings are also permitted. Algorithm must be an algorithm which your copy of OpenSSL knows about.
Keys and IVs can be chosen at random (using for example crypto_n_random_bytes/2) or derived from input keying material (IKM) using for example crypto_data_hkdf/4. This input is often a shared secret, such as a negotiated point on an elliptic curve, or the hash that was computed from a password via crypto_password_hash/3 with a freshly generated and specified salt.
Reusing the same combination of Key and IV
typically leaks at least
some information about the plaintext. For example, identical
plaintexts will then correspond to identical ciphertexts. For some
algorithms, reusing an IV with the same Key has
disastrous results and can cause the loss of all properties that are
otherwise guaranteed. Especially in such cases, an IV is also
called a
nonce (number used once). If an IV is not needed for
your algorithm (such as 'aes-128-ecb'
) then any value can
be provided as it will be ignored by the underlying implementation. Note
that such algorithms do not provide semantic security and are
thus insecure. You should use stronger algorithms instead.
It is safe to store and transfer the used initialization vector (or nonce) in plain text, but the key must be kept secret.
Commonly used algorithms include:
'chacha20-poly1305'
'aes-128-gcm'
'aes-128-cbc'
Options:
utf8
.
Alternatives are utf8
and octet
.
block
. You can disable padding by supplying none
here. If padding is disabled for block ciphers, then the length of the
ciphertext must be a multiple of the block size.
For example, with OpenSSL 1.1.0 and greater, we can use the ChaCha20 stream cipher with the Poly1305 authenticator. This cipher uses a 256-bit key and a 96-bit nonce, i.e., 32 and 12 bytes, respectively:
?- Algorithm = 'chacha20-poly1305', crypto_n_random_bytes(32, Key), crypto_n_random_bytes(12, IV), crypto_data_encrypt("this is some input", Algorithm, Key, IV, CipherText, [tag(Tag)]), crypto_data_decrypt(CipherText, Algorithm, Key, IV, RecoveredText, [tag(Tag)]). Algorithm = 'chacha20-poly1305', Key = [65, 147, 140, 197, 27, 60, 198, 50, 218|...], IV = [253, 232, 174, 84, 168, 208, 218, 168, 228|...], CipherText = <binary string>, Tag = [248, 220, 46, 62, 255, 9, 178, 130, 250|...], RecoveredText = "this is some input".
In this example, we use crypto_n_random_bytes/2 to generate a key and nonce from cryptographically secure random numbers. For repeated applications, you must ensure that a nonce is only used once together with the same key. Note that for authenticated encryption schemes, the tag that was computed during encryption is necessary for decryption. It is safe to store and transfer the tag in plain text.
utf8
.
Alternatives are utf8
and octet
.
block
. You can disable padding by supplying none
here.
This library provides operations from number theory that frequently arise in cryptographic applications, complementing the existing built-ins and GMP bindings:
true
(default is false
),
then a safe prime is generated. This means that P is
of the form 2*Q + 1 where Q is also prime.
^
(-80).
This library provides functionality for reasoning over elliptic curves. Elliptic curves are represented as opaque objects. You acquire a handle for an elliptic curve via crypto_name_curve/2.
A point on a curve is represented by the Prolog term point(X, Y)
,
where X and Y are integers that represent the
point's affine coordinates.
The following predicates are provided for reasoning over elliptic curves:
prime256v1
and
secp256k1
.
If you have OpenSSL installed, you can get a list of supported curves via:
$ openssl ecparam -list_curves
As one example that involves most predicates of this library, we explain a way to establish a shared secret over an insecure channel. We shall use elliptic curves for this purpose.
Suppose Alice wants to establish an encrypted connection with Bob. To achieve this even over a channel that may be subject to eavesdrooping and man-in-the-middle attacks, Bob performs the following steps:
This mechanism hinges on a way for Alice to establish the authenticity of the signed message (using predicates like rsa_verify/4 and ecdsa_verify/4), for example by means of a public key that was previously exchanged or is signed by a trusted party in such a way that Alice can be sufficiently certain that it belongs to Bob. However, none of these steps require any encryption!
Alice in turn performs the following steps:
Bob receives j*G in plain text and can arrive at the same shared secret by performing the calculation k*(j*G), which is - by associativity and commutativity of scalar multiplication - identical to the point j*(k*G), which is again Q from which the shared secret can be derived, and the message can be decrypted with crypto_data_decrypt/6.
This method is known as Diffie-Hellman-Merkle key exchange over elliptic curves, abbreviated as ECDH. It provides forward secrecy (FS): Even if the private key that was used to establish the authenticity of Bob is later compromised, the encrypted messages cannot be decrypted with it.
A major attraction of using elliptic curves for this purpose is found in the comparatively small key size that suffices to make any attacks unrealistic as far as we currently know. In particular, given any point on the curve, we currently have no efficient way to determine by which scalar the generator was multiplied to obtain that point. The method described above relies on the hardness of this so-called elliptic curve discrete logarithm problem (ECDLP). On the other hand, some of the named curves have been suspected to be chosen in such a way that they could be prone to attacks that are not publicly known.
As an alternative to ECDH, you can use the original DH key exchange scheme, where the prime field GF(p) is used instead of an elliptic curve, and exponentiation of a suitable generator is used instead of scalar multiplication. You can use crypto_generate_prime/3 to generate a sufficiently large prime for this purpose.
The SSL package provides several libraries dealing with cryptographic
operations of XML documents. These libraries depend on the sgml
package. These libraries are part of this package because the
sgml
package has no external dependencies and will thus be
available in any SWI-Prolog installation while configuring and building
this ssl
package is much more involved.
This library uses SAML to exchange messages with an Identity Provider to establish assertions about the current user's session. It operates only as the service end, not the identity provider end.
This library is a partial implementation of the XML encryption standard. It implements the decryption part, which is needed by SAML clients.
| KeyCallback | may be called as
follows:
|
This library deals with XMLDSIG, RSA signed XML documents.
The SignedDOM must be emitted using xml_write/3
or
xml_write_canonical/3. If xml_write/3
is used, the option
layout(false)
is needed to avoid changing the layout of the
SignedInfo
element and the signed DOM, which
will cause the signature to be invalid.
ds:Signature
element contains a valid
signature. Certificate is bound to the certificate that
appears in the element if the signature is valid. It is up to the caller
to determine if the certificate is trusted or not.
Note: The DOM and SignatureDOM must have
been obtained using the load_structure/3
option keep_prefix(true)
otherwise it is impossible to
generate an identical document for checking the signature. See also xml_write_canonical/3.
Using SSL (in this particular case based on the OpenSSL
implementation) to connect to SSL services (e.g., an https://
address) easily gives a false sense of security. This section explains
some of the pitfalls.1We do not
claim to be complete, just to start warning you if security is important
to you. Please make sure you understand (Open)SSL before relying on it..
As stated in the introduction, SSL aims at solving two issues: tapping
information from the wire by means of encryption and make sure that you
are talking to the right address.
Encryption is generally well arranged as long as you ensure that the
underlying SSL library has all known security patches installed and you
use an encryption that is not known to be weak. The Windows version and
MacOS binaries of SWI-Prolog ships with its own binary of the OpenSSL
library. Ensure this is up-to-date. On systems that ship with the
OpenSSL library SWI-Prolog uses the system version. This applies notably
for all Linux packages. Check the origin and version of the OpenSSL
libraries and verify there are no more recent security patches regularly
if security is important to you. The OpenSSL library version as reported
by SSLeay_version() is available in the Prolog flag
ssl_library_version
as illustrated below on Ubuntu 14.04.
?- [library(ssl)]. ?- current_prolog_flag(ssl_library_version, X). X = 'OpenSSL 1.0.1f 6 Jan 2014'.
Whether you are talking to the right address is a complicated issue. The core of the validation is that the server provides a certificate that identifies the server. This certificate is digitally signed by another certificate, and ultimately by a root certificate. (There may be additional links in this chain as well, or there may just be one certificate signed by itself) Verifying the peer implies:
The default https client plugin (library(http/http_ssl_plugin)
)
registers the system trusted root certificate with OpenSSL. This is
achieved using the option
cacert_file(system(root_certificates))
of ssl_context/3.
The verification is left to OpenSSL. To the best of our knowledge, the
current (1.0) version of OpenSSL only implements step (1) of the
verification process outlined above. This implies that an attacker that
can control DNS mapping (host name to IP) or routing (IP to physical
machine) can fake to be a secure host as long as they manage to obtain a
certificate that is signed from a recognised authority. Version 1.0.2
supports hostname checking, and will not validate a certificate chain if
the leaf certificate does not match the hostname. 'Match' here is not a
simple string comparison; certificates are allowed (subject to many
rules) to have wildcards in their SubjectAltName field. Care must also
be taken to ensure that the name we are checking against does not
contain embedded NULLs. If SWI-Prolog is compiled against a version of
OpenSSL that does NOT have hostname checking (ie 1.0.0 or earlier), it
will attempt to do the validation itself. This is not guaranteed to be
perfect, and it only supports a small subset of allowed wildcards. If
security is important, use OpenSSL 1.0.2 or higher.
After validation, the predicate ssl_peer_certificate/2 can be used to obtain the peer certificate and inspect its properties.
To do CRL checking, pass require_crl(true) as an option to the ssl_context/3 (or http_open/3) option list. If you do this, a certificate will not be validated unless it can be checked for on a revocation list. There are two options for this:
First, you can pass a list of filenames in as the option crl/1. If the CRL corresponds to an issuer in the chain, and the issued certificate is not on the CRL, then it is assumed to not be revoked. Note that this does NOT prove the certificate is actually trustworthy - the CRL you pass may be out of date! This is quite awkward to get right, since you do not necessarily know in advance what the chain of certificates the other party will present are, so you cannot reasonably be expected to know which CRLs to pass in.
Secondly, you can handle the CRL checking in the cert_verify_hook when the Error is bound to unknown_crl. At this point you can obtain the issuer certificate (also given in the hook), find the CRL distribution point on it (the crl/1 argument), try downloading the CRL (the URL can have literally any protocol, most commonly HTTP and LDAP, but theoretically anything else, too, including the possibility that the certificate has no CRL distribution point given, and you are expected to obtain the CRL by email, fax, or telegraph. Therefore how to actually obtain a CRL is out of scope of this document), load it using load_crl/2, then check to see whether the certificate currently under scrutiny appears in the list of revocations. It is up to the application to determine what to do if the CRL cannot be obtained - either because the protocol to obtain it is not supported or because the place you are obtaining it from is not responding. Just because the CRL server is not responding does not mean that your certificate is safe, of course - it has been suggested that an ideal way to extend the life of a stolen certificate key would be to force a denial of service of the CRL server.
In some cases clients are not really interested in host validation of
the peer and whether or not the certificate can be trusted. In these
cases the client can pass cert_verify_hook(cert_accept_any)
,
calling cert_accept_any/5
which accepts any certificate. Note that this will accept literally ANY
certificate presented - including ones which have expired, have been
revoked, and have forged signatures. This is probably not a good idea!
Applications that exchange sensitive data with e.g., a backend server
typically need to ensure they have a secure connection to their peer. To
do this, first obtain a non-secure connection to the peer (eg via a TCP
socket connection). Then create an SSL context via
ssl_context/3.
For the client initiating the connection, the role is 'client', and you
should pass options host/1
and cacert_file/1
at the very least. If you expect the peer to have a certificate which
would be accepted by your host system, you can pass
cacert_file(system(root_certificates))
, otherwise you will
need a copy of the CA certificate which was used to sign the peer's
certificate. Alternatively, you can pass cert_verify_hook/1
to write your own custom validation for the peer's certificate.
Depending on the requirements, you may also have to provide your /own/
certificate if the peer demands mutual authentication. This is done via
the
certificate_file/1, key_file/1
and either password/1
or
pem_password_hook/1.
Once you have the SSL context and the non-secure stream, you can call ssl_negotiate/5 to obtain a secure stream. ssl_negotiate/5 will raise an exception if there were any certificate errors that could not be resolved.
The peer behaves in a symmetric fashion: First, a non-secure connection is obtained, and a context is created using ssl_context/3 with the role set to server. In the server case, you must provide certificate_file/1 and key_file/1, and then either password/1 or pem_password_hook/1. If you require the other party to present a certificate as well, then peer_cert(true) should be provided. If the peer does not present a certificate, or the certificate cannot be validated as trusted, the connection will be rejected.
By default, revocation is not checked. To enable certificate revocation checking, pass require_crl(true) when creating the SSL context. See section 6 for more information about revocations.
Examples of a simple server and client (server.pl
and
client.pl
as well as a simple HTTPS server (https.pl
)
can be found in the example directory which is located in
doc/packages/examples/ssl
relative to the SWI-Prolog
installation directory. The etc
directory contains example
certificate files as well as a README
on the creation of
certificates using OpenSSL tools.
Accessing an https://
server can be achieved using the
code skeleton below. The line :- use_module(library(http/http_ssl_plugin)).
can actually be omitted because the plugin is dynamically loaded by
http_open/3
if the https
scheme is detected. See section
5 for more information about security aspects.
:- use_module(library(http/http_open)). :- use_module(library(http/http_ssl_plugin)). ..., http_open(HTTPS_url, In, []), ...
The SWI-Prolog infrastructure provides two main ways to launch an HTTPS server:
library(http/thread_httpd)
, the server is started
in HTTPS mode by adding an option ssl/1
to
http_server/2.
The argument of ssl/1
is an option list that is passed as
the third argument to ssl_context/3.
library(http/http_unix_daemon)
, an HTTPS server
is started by using the command line argument --https
.
Two items are typically specified as, respectively, options or additional command line arguments:
password
option, the pem_password_hook
callback or, in case of the Unix daemon, via the --pwfile
or
--password
command line options.
Here is an example that uses the self-signed demo certificates distributed with the SSL package. As is typical for publicly accessible HTTPS servers, this version does not require a certificate from the client:
:- use_module(library(http/thread_httpd)). :- use_module(library(http/http_ssl_plugin)). https_server(Port, Options) :- http_server(reply, [ port(Port), ssl([ certificate_file('etc/server/server-cert.pem'), key_file('etc/server/server-key.pem'), password("apenoot1") ]) | Options ]).
There are two hooks that let you extend HTTPS servers with custom definitions:
http:ssl_server_create_hook(+SSL0, -SSL, +Options)
:
This extensible predicate is called exactly once, after creating
an HTTPS server with Options. If this predicate succeeds,
SSL
is the context that is used for negotiating all
new connections. Otherwise, SSL0
is used, which is the
context that was created with the given options.
http:ssl_server_open_client_hook(+SSL0, -SSL, +Options)
:
This predicate is called before each connection that the server
negotiates with a client. If this predicate succeeds, SSL
is the context that is used for the new connection. Otherwise, SSL0
is used, which is the context that was created when launching the server.
Important use cases of these hooks are running dual-stack RSA/ECDSA servers, updating certificates while the server keeps running, and tweaking SSL parameters for connections. Use ssl_set_options/3 to create and configure copies of existing contexts in these hooks.
The example file https.pl
also provides a server that
does require the client to show its certificate. This provides an
additional level of security, often used to allow a selected set of
clients to perform sensitive tasks.
Note that a single Prolog program can call http_server/2
with different parameters to provide services at several security levels
as described below. These servers can either use their own dispatching
or commonly use http_dispatch/1
and check the port
property of the request to verify they
are called with the desired security level. If a service is approached
at a too low level of security, the handler can deny access or use HTTP
redirect to send the client to to appropriate interface.
The above expects Prolog to be accessible directly from the internet. This is becoming more popular now that services are often deployed using virtualization. If the Prolog services are placed behind a reverse proxy, HTTPS implementation is the task of the proxy server (e.g., Apache or Nginx). The communication from the proxy server to the Prolog server can use either plain HTTP or HTTPS. As plain HTTP is easier to setup and faster, this is typically preferred if the network between the proxy server and Prolog server can be trusted.
Note that the proxy server must decrypt the HTTPS traffic because it must decide on the destination based on the encrypted HTTP header. Port forwarding provides another option to make a server running on a machine that is not directly connected to the internet visible. It is not needed to decrypt the traffic using port forwarding, but it is also not possible to realise virtual hosts or path-based proxy rules.
Virtual hosts for HTTPS are available via Server Name Indication (SNI). This is a TLS extension that allows servers to host different domains from the same IP address. See the sni_hook/1 option of ssl_context/3 for more information.
The development of the SWI-Prolog SSL interface has been sponsored by http://www.sss.co.nzScientific Software and Systems Limited . The current version contains contributions from many people. Besides the mentioned authors, https://www.metalevel.atMarkus Triska has submitted several patches, and improved and documented the integration of this package with the HTTP infrastructure.


{% extends base %} {% block postamble %} {% endblock %} {% block contents %}
This demo uses a callback to size a DataTable
row height to the data in a column.
Use the selector on the left to see the resizing in action. If the salary range you select includes salaries of $59,000 or more, heights are resized for a long error message, if you select a range that's less than $59,000 the row heights will resize to the shorter error messages.
There is no way I have found of dynamically resizing each individual row. It's all or nothing.


|
Online:
|
|
%online%
|
|
Title:
|
|
%title%
|
|
PvP Points:
|
|
%pvpPoints%
|
|
Pk Points:
|
|
%pkPoints%
|
|
Online Time:
|
|
%onlineTime%
|
|
Leader:
|
|
%leader%
|
|
Subpledge:
|
|
%subpledge%
|
|
Nobless:
|
|
%nobless%
|
|
Hero:
|
|
%hero%
|
|
|
Adena:
|
|
%adena%
|
|
Recs:
|
|
%recs%
|
|
Seven Signs:
|
|
%sevenSigns%
|
|
Fame:
|
|
%fame%
|
|
Main Class:
|
|
%mainClass%
|
|
1st Sub:
|
|
%firstSub%
|
|
2nd Sub:
|
|
%secondSub%
|
|
3rd Sub:
|
|
%thirdSub%
|
|
|


–
http://banshee-project.org/Main_Page
I recently tried out this open source music management application as an alternative to iTunes on my Gentoo PPC box. My initial impression is quite favorable. One of the features I found most compelling was its ability to connect to iTunes shares via DAAP and Bonjour. The only problem I experienced with this feature at present is the lack of support for iTunes 7 shares, as Apple has altered the DAAP protocol in 7. This is currently being worked on and an update is expected soon.
Anyway, as I said, I’m very impressed with this app. Not only does it have some great features, it’s written in C# for Mono! How cool is that? Another real app written for Mono!
Read More ›–
I just ran across this useful hint in answer to a problem I was experiencing with my Gentoo/PPC installation on my PowerBook G3.
http://www.macosxhints.com/article.php?story=20060814075952448
Read More ›–
The talented and creative team at OmniGroup have done it again and released a new application I’m really excited about. The new app is called OmniPlan, and it is their answer to project management.
So far, OmniPlan is only available as a Beta, but so far, it’s been a solid performer for me. I’ve been a user of PMX for some time now, and it appears that the developer of PMX has been working with OmniGroup to provide an upgrade path for PMX users. I couldn’t be more pleased to see OmniGroup filling this need. I hope their efforts on OmniPlan only continue to prove that you don’t need to run Windows to run all your necessary office applications.
Read More ›–
I just thought I’d take the opportunity to brag about my dog, Tennyson, making the top ten list on puppywar.com. He was up to #4 yesterday. Here’s a screenshot:
</p>
Oh, and “Rabbit, Rabbit.
Read More ›–
I recently corresponded with a visitor to my site who was interested in my use of my Cisco Aironet 350 card with my PowerBook G3 Lombard. He was having some difficulty with his 350. In the process of troubleshooting, he discovered that he had an older Ralink card that was supported under OS X.
So, if you have an Ralink card, or are considering getting one, they appear to have fairly decent Mac OS X support.
One point I want to make is that the Cisco card is supported under both OS X and Mac OS 9, whereas the Ralink drivers appear to be OS X only.
Simon, thanks for the info and I hope it helps some other Mac users out there.
Read More ›


Hi, I’m a 3L at Harvard Law School. I used to be a front-end web developer at Recombine, a genetic testing company.
My previous jobs include management consulting and microfinance. I went to Haverford College, where I studied Latin and Ancient Greek and minored in physics.
<EMAIL_ADDRESS>or tcarroll at jd18.law.harvard.edu


return f"Tiff image builder: {message}"
for file_path in path.iterdir():
pk = uuid4()
dzi_output = None
tiff_file = None
gc_file = GrandChallengeTiffFile(file_path)
for gc_file in loaded_files:
dzi_output = None
error = ""
if gc_file.path in errors:
error = errors[gc_file.path]
// try and load image with tiff file
try:
gc_file = _load_with_tiff(gc_file=gc_file)
except Exception as e:
error += f"Load error: {e}. "


Every scatter series point in LiveCharts contains 3 properties, X, Y and weight, the size of every point will vary according to the point's weight, in this case all points have the same weight, see Bubbles example to watch how the weight property is applied.
From your tool box, drag a new CartesianChart control and a button


Polls give your web audiences a quick and easy way to voice their opinion on concise topics and then immediately see feedback from their vote, automatically.The Adxstudio Portals Polls provide single question or multiple choice response polls on simple topics of interest. Either way, responses are instantly stored and associated with the applicable CRM Contact record for immediate review or aggregate reporting. You can use them as simple market research tools and, if you refresh or rotate the polls dynamically, you'll keep your website looking current and topical.
Polls may placed on the portal via the PollPlacement control. This control works very similarily to the AdPlacement control. If there are any polls associated with the Poll Placement entity that is being rendered by the PollPlacement control, then those polls will be rendered. If there is more than one poll for a given placement, the placement will randomly present one of the specified polls.


Anika is a rising sophomore at Denmark High School. This page will display the diverse qualifications she has.
As stated at the top, Anika is a rising sophomore at Denmark High School. She has diverse experiences from her first year of high school. She played on two varsity teams, the swim team and tennis team. From this, she gained skills on how to work with others and how to contribute to a team. In addition, she has learned how to overcome challenges and deal with emotion.
Adding on to her skills, Anika particpated in her schools theatre department. She did the spring show playing Mabel in the show Fame Jr. Through this experience, she gained public speaking skills that can help in the workplace.
Anika is a member of her Girls Who Code and Future Business Leaders of America (FBLA) chapter at her school. At the state leadership conference, she and her team competed in Website Design and placed first. Doing this has given her the skills to make a website for a business.
Call to Action »Competed in Website Design
Usually swims butterfly
Played Mabel in Fame Jr.


Volume
-
speaker_fill volume_mutespeaker_3_fill volume_up
Brightness
-
sun_min brightness_lowsun_max_fill brightness_high
Price Filter ${{priceMin}} - ${{priceMax}}
-
money_dollar_circle attach_moneymoney_dollar_circle_fill monetization_on
With Scale
Vertical
Vertical Reversed


It was a sunny morning.I prepared my self to go to Mombasa with my father,Brother Malli and my cousin Sharon.My Father called a taxi to drop us at Jomo Kenyata International Airport.When we reached the Airport,we saw many aeroplanes in the Airport.We bought our tickets and went to the Aeroplane.The Aeroplane was called Jambo Jet.
Then we took of.The plane was very comfortable.Then I felt hungry.Lukily my mother had brought some fruits.I ate some bananas and an apple.We landed after 48 minutes.Then my Father called another taxi to come to pick us from the Airport to the hotel.
After we reached the hotel, we waited for our key to the room.Then I and found the beach and the swimming pool.I was happyy as a king.I went to tell my father.In a drop of a hat, we wore our swimming costume and then we went to the swimming pool.
Then we went to the ocean.In the ocean some waves were small while others were huge.We like the big ones becoause we went underwater and the wave would push you rearward to the shore.
In the Afternoon you can it lunch at lunch time,playing or swimming inthe sswimming pool .You can go to play in the beach and relax.Many children play in the swimming pool.When it reaches 4 oclock.You can go to the ocean because it was starting to become high tide.There was also a watching point were you could enjoy watching the waves or go to the waves.You can stay in the swimming pool or go to have a snack.
When we reached home we were shocked to see our bags were there.Our Dad told us the people of the hotel took the bags in the room.We went to shower,change and went to eat supper.There were so many things to choose from.I choose so many things.When everyone was full, we all went home to watch TV.


{{ character.get_status_display }} {{ character.name }} {# {{ character.class }} #}
You have no characters right now.


We exchange metrics!
- seize extensible vortals
- facilitate vertical bandwidth
- synthesize global communities
- recontextualize value-added methodologies
- cultivate holistic relationships
- strategize clicks-and-mortar infrastructures
- streamline compelling technologies
- matrix sexy content
- revolutionize out-of-the-box e-business
- visualize revolutionary e-tailers
- engineer dot-com channels
- incubate dynamic e-services
- harness seamless e-tailers
- optimize world-class web-readiness


Default Style
Separators are automatically added in CSS through :before
and content.
Arrow Style
Add modifier class .breadcrumb-arrow
to switch slash
or arrow style.
Items With Icon
An icon used in breadcrumb to convey that it’s an home page,
with additional .wb-home
class.
Responsive
jquery-asBreadcrumbs allows you to hide the overflowing crumbs and then makes them available to your visitor via a dropdown menu.
Accessibility
Use this snippet to make breadcrumbs more accessible. Adding
the role attribute gives context to a screen reader. The aria-label
attribute will allow a screen reader to call out what the component
is to the user.


--- layout: post title: The Burj Dubai of character date: '2013-08-19T20:59:00.001-06:00' author: Jacob . tags: - front-page - progress modified_time: '2013-08-23T21:51:52.791-06:00' blogger_id: tag:blogger.com,1999:blog-6400085873105072120.post-1270922753981345329 blogger_orig_url: http://www.svlark.com/2013/08/the-burj-dubai-of-character.html --- You build an awful lot of character rolling around in a sea of fiberglass in a 110-degree unventilated attic for 7 hours. So now we're ready for our inspections and I have an extraordinarily tall pile of, um, character.


Some programming code:
Computer science is the study of algorithmic processes, computational machines and computation itself. As a discipline, computer science spans a range of topics from theoretical studies of algorithms, computation and information to the practical issues of implementing computational systems in hardware and software.
Information systems are combinations of hardware, software, and telecommunications networks that people build and use to collect, create, and distribute useful data, typically in organizational settings.


movieBuff.io
Type in the name of your favourite actor and hit 'search' to see their best films!
Search


@() @main("Nine men's morris") {
Nine Men’s Morris is an ancient game, popular in Ancient Rome and the medieval period.
No one really knows where and when the game originated.
The oldest building that has a Nine Men’s Morris board carved into its stones is an Egyptian temple at Kurna, Egypt, which dates to roughly 1400 BCE.
However, it is not known when the game board itself was carved into the Kurna temple’s roofing slabs; was it at the time of the construction or much later in history.
There are many Nine Men’s Morris carved into various buildings’ stones through out the Roman Empire and in the seats of many medieval cathedrals.
This game is known by many names, such as Mill or Windmill, most probably, because the shape of the board looks like a windmill, and Merrels, from the Latin word merellus, which means “gaming piece”.
The name Nine Men’s Morris seems to have been originated by Shakespeare in his play, A Midsummer Night’s Dream (Act II, Scene I), in which Titania refers to such a board by saying, “The nine men’s morris is filled up with mud”.
The rules of the game are well known, mostly because the game has been played continuously in Europe since the Roman period.


AnnOtaria v.0.1 "Eumetopias"
© 2014 Ciro Mattia Gonano.
This software is released under ISC license. You can find the latest version of this software on GitHub.


An array of images is viewed sequentially, but loaded in a different order. The Carousel's size parameter is set to 17. This demonstrates that by setting a bounded size, the carousel handles the situation of items being loaded in a non-sequential manner.


We mitigate gender disparity in text generation while performing knowledge distillation by exploiting counterfactual role-reversed texts for training.
We illustrate that allowing access to model parameters can leak private information about the training set. We observed strong correlations between privacy leakage and overfitting, indicating that reducing overfitting may ensure privacy.
We show that limiting the mutual information between the representations limits any classifier's statistical parity. To this end, we propose a novel method for controlling fairness through mutual information based on contrastive information estimators.
We propose a new architecture for making predictions over 3D-MRIs prediction, which works by encoding a single 2D slice in an MRI with a deep 2D-CNN model and integrating the information from these 2D-slice encodings with permutation invariant layers.
We propose an approximate extension of fictitious play in continuous action spaces by modeling best responses with implicit density models.
Deriving inspiration from human complementary learning systems (hippocampus and neocortex), we develop a dual generative memory architecture that consolidates memory via generative replay and is capable of learning continuously from sequentially incoming tasks while averting catastrophic forgetting.


NVAPI Reference Documentation
|
|
Release 343: September 30
|
#include <nvapi.h>
Data Fields | |
| NV_GPU_PUBLIC_CLOCK_ID | domainId |
| NV_GPU_PERF_PSTATE20_CLOCK_TYPE_ID | typeId |
| NvU32 | bIsEditable:1 |
| NvU32 | reserved:31 |
| NV_GPU_PERF_PSTATES20_PARAM_DELTA | freqDelta_kHz |
| union { | |
| struct { | |
| NvU32 freq_kHz | |
| } single | |
| struct { | |
| NvU32 minFreq_kHz | |
| NvU32 maxFreq_kHz | |
| NV_GPU_PERF_VOLTAGE_INFO_DOMAIN_ID domainId | |
| NvU32 minVoltage_uV | |
| NvU32 maxVoltage_uV | |
| } range | |
| } | data |
Used to describe single clock entry.
| union { ... } NV_GPU_PSTATE20_CLOCK_ENTRY_V1::data |
Clock domain type dependant information.
ID of the clock domain.
Voltage domain ID and value range in (uV) required for this clock.
Clock frequency within given pstate in (kHz)
Current frequency delta from nominal settings in (kHz)
Max clock frequency within given pstate in (kHz)
Min clock frequency within given pstate in (kHz)
| struct { ... } NV_GPU_PSTATE20_CLOCK_ENTRY_V1::range |
These bits are reserved for future use (must be always 0)
| struct { ... } NV_GPU_PSTATE20_CLOCK_ENTRY_V1::single |


You will be randomly and anonymously grouped with 4 other participants. Each of you will be asked to pick a number between 0 and 100. The winner will be the participant whose number is closest to two-third of the average of all chosen numbers.
The winner will receive 100 points, while other participants will receive nothing. In case of a tie, the 100 points will be equally divided between winners.
For your convenience, these instructions will remain available to you on all subsequent screens of this study.


WORKFORCE APP - TRACKING YOUR PATIENTS
Login Form
Username
Password
Forgot your password?
Remember me
Log in


Triggers any button of a given ID.
If the button ID does not exist, sends an extension trigger instead.
| Box Name | Type | Description |
|---|---|---|
| Button ID | Any | ID of a button you want to activate. |
| Queue-Able | boolean | If set to true and the button is already activated, it will wait for it to finish and trigger the button again. Will get queued as many times as you execute the command. If set to false and the button is already activated, nothing will happen. |
| Hidden Delay | Int | This exists to make a button happen without greying it out in case the button is showing valuable info. The delay is hidden and cannot be cancelled (unless you use Reset or press Done in your Receiver). |


Check your details are correct
Property details
Contact information
Now sign up for flood alerts
What we will do
We will try to send the flood warning you have asked for. When we do that, we'll do what is reasonable, but we can't guarantee it will be sent or arrive. Warnings may be sent at any time of the day or night.
We do not:
- accept responsibility if you fail to receive a warning
- guarantee that our website or the phone lines will be available
- accept responsibility for any loss, damage or costs incurred by you caused by flooding, or by issuing or failing to issue warnings - except where the law says we must
You are responsible for:
- making sure that the contact details you give us are correct
- telling us about any changes
We may use the personal information you give us to:
- send you the warnings you have signed up for
- send you a small number of service announcements or administrative messages
- help emergency services and local councils respond to flooding
- help with our work on flood warning and flood risk management
- respond to freedom of information requests (if data protection law allows it)
We may give your information to our agents or representatives, so they can do any of these things for us. And we may share your information with other organisations if the law says we must.
The Environment Agency manages the flood warning systems. Their personal information charter (opens new window) explains how they deal with your information. Natural Resources Wales use the same systems and will have access to your personal information if you ask for a service in Wales. Read how Natural Resources Wales uses your personal information (opens new window).


Documentation / Query / Aggregation
Aggregation
SQL has the aggregation functions of SUM
, MIN
, MAX
, COUNT
and AVG
.
We can use these functions in Ebean as dynamic formula or as properties via @Aggregation and @Sum.
Dynamic formula
Single attribute
LocalDate maxDate =
new QOrder()
.select("max(orderDate)")
.customer.name.equalTo("Rob")
.findSingleAttribute();
select max(t0.order_date)
from orders t0
join customer t1 on t1.id = t0.customer_id
where t1.name = ? ; --bind(Rob)
With aggregation queries that select only a single attribute the returned type
matches the property type. In the above case the orderDate is a LocalDate
and so that is the type returned.
Multiple attributes
When we specify non-aggregate properties (status in the example below) then
a GROUP BY
clause is generated that includes all the non-aggregate properties.
List<Order> orders =
new QOrder()
.select("status, max(orderDate)") // status is non-aggregate
.customer.name.equalTo("Rob")
.findList();
select t0.status, max(t0.order_date)
from orders t0
join customer t1 on t1.id = t0.customer_id
where t1.name = ?
group by t0.status -- group by non-aggregate properties
The beans returned by aggregation queries are partially populated. They don't contain the @Id property and thus do not support lazy loading or persisting.
The order beans in the example above will only have their status and orderDate properties loaded.
Fetch
Aggregation queries can include fetch
or fetchQuery
to load related beans.
List<Order> orders
= new QOrder()
.select("status, max(orderDate)")
.customer.fetch("name") // (1) fetch
.status.notEqualTo(Order.Status.NEW)
.findList();
select t0.status, max(t0.order_date), t1.id, t1.name -- (1) has customer id and name
from orders t0
join customer t1 on t1.id = t0.customer_id
where t0.status <> ?
group by t0.status, t1.id, t1.name -- (1) has customer id and name
When we use fetchQuery
the ORM query is executed as 2 sql queries.
List<Order> orders
= new QOrder()
.select("status, max(orderDate)")
.customer.fetchQuery("name") // (2) fetchQuery ...
.status.notEqualTo(Order.Status.NEW)
.findList();
-- Primary query
select t0.status, max(t0.order_date), t0.customer_id -- (2) has customer id only
from orders t0
where t0.status <> ?
group by t0.status, t0.customer_id
-- Secondary query
select t0.id, t0.name -- (2) customer id and name
from customer t0
where t0.id in (?, ?, ?, ?, ? )
Using fetchQuery() can be good when there are many properties on customer that we want to load (as these all go into the secondary sql query rather than the primary query and therefore are not part of the GROUP BY.
@Aggregation
We can model aggregations with properties annotated with @Aggregation
.
This is an alternative to using dynamic formula.
Properties with @Aggregation must be explicitly included in a query (they are considered Transient).
Example:
@Entity
@Table(name = "orders")
public class Order extends BaseModel {
...
LocalDate orderDate;
@Aggregation("max(orderDate)") // aggregation property
LocalDate maxOrderDate;
@Aggregation("count(*)") // aggregation property
Long totalCount;
Having added the maxOrderDate and totalCount properties we can use
them in select
and having
clauses in our queries.
QOrder o = QOrder.alias();
List<Order> orders = new QOrder()
.select(o.status, o.maxOrderDate, o.totalCount)
.findList();
select t0.status, max(t0.order_date), count(*)
from orders t0
group by t0.status
Having
Predicates on aggregation properties should be added to the Having
clause.
List<Order> orders = new QOrder()
.select(o.status, o.maxOrderDate, o.totalCount)
.status.notEqualTo(Order.Status.COMPLETE) // (1) where clause - non aggregate properties
.having()
.totalCount.greaterThan(1) // (2) having clause - aggregate properties
.findList();
select t0.status, max(t0.order_date), count(*)
from orders t0
where t0.status <> ? // (1)
group by t0.status
having count(*) > ? // (2)
Aggregation beans
If we only want 1 or 2 aggregation properties we feel ok adding these to the existing entity beans. However, if instead we have many properties we want to aggregate this approach is messing with our model and it starts to look ugly.
We can create aggregation beans to model the properties - model the sum/group by/aggregation view.
- Use @View rather than @Table
- Does not extend Model as we don't save() or delete() these
- Does not have @Id or @Version properties
- Has properties we want to Aggregate on (sum, max etc)
- Has properties we want to group by on (date, status, ManyToOne)
Example
Say we have an entity bean called MachineUse with:
@Entity
@Table(name = "machine_use")
public class MachineUse extends Model {
@Id
private long id;
@ManyToOne(optional = false)
private DMachine machine;
private LocalDate date;
private long distanceKms; // we want to sum() this ...
private long timeSecs; // we want to sum() this ...
private BigDecimal fuel; // we want to sum() this ...
@Version
private long version;
...
We can create the aggregate bean for this as:
@Entity
@View(name = "machine_use")
public class MachineUseAggregate {
@ManyToOne(optional = false)
private DMachine machine; // group by, fetch, fetchQuery on ...
private LocalDate date; // group by on ...
@Aggregation("sum(distanceKms)")
private Long distanceKms;
@Aggregation("sum(timeSecs)")
private Long timeSecs;
@Aggregation("sum(fuel)")
private BigDecimal fuel;
@Aggregation("count(*)")
private Long count;
...
@Sum
When we create aggregation beans we very often see the pattern where we sum a property like:
@Aggregation("sum(<property name>)")
Type <property name>;
For example, we see beans like:
@Aggregation("sum(distanceKms)")
BigDecimal distanceKms;
@Aggregation("sum(useSeconds)")
Long useSeconds;
@Aggregation("sum(cost)")
BigDecimal cost;
@Sum
is syntatic sugar for this pattern and the above becomes:
@Sum
BigDecimal distanceKms;
@Sum
Long useSeconds;
@Sum
BigDecimal cost;


Server-Side Rendering
Note: Spartacus 2.x is no longer maintained. Please upgrade to the latest version.
In Spartacus, server-side rendering allows you to render static versions of pages on the server side. This speeds up response times, assists with SEO, and allows the application to render more quickly. After Angular has bootstrapped, users of your site will have the full experience.
Adding SSR Support Using Schematics (Recommended)
The recommended way to add SSR support to your Spartacus application is to use schematics. With a single command, all required files are added automatically, and all modifications for SSR support are done automatically as well. To add SSR support to your Spartacus application, run the following command:
ng add @spartacus/schematics --ssr
The steps executed by this command are described in more detail in the following sections.
Adding SSR Support Manually
The following steps describe how to manually add SSR support so that your Spartacus shell app includes the Spartacus libraries running in SSR mode.
-
Add the following dependencies to
package.json
:"@angular/platform-server": "~8.2.14", "@nguniversal/express-engine": "^8.1.1", "@nguniversal/module-map-ngfactory-loader": "^8.2.6", "express": "^4.15.2"
-
Add the following developer dependencies to
package.json
:"ts-loader": "^5.3.2", "webpack-cli": "^3.3.2"
-
For convenience, add the following scripts to
package.json
:"compile:server": "webpack --config webpack.server.config.js --progress --colors", "serve:ssr": "node dist/server", "build:ssr": "npm run build:client-and-server-bundles && npm run compile:server", "build:client-and-server-bundles": "ng build --prod && ng run spartacus:server"
-
Update the
src/main.ts
file, as follows://from platformBrowserDynamic().bootstrapModule(AppModule); //to document.addEventListener("DOMContentLoaded", () => { platformBrowserDynamic().bootstrapModule(AppModule); });
-
Replace the following lines in
app.module.ts
://from: BrowserModule, //to BrowserModule.withServerTransition({ appId: 'spartacus-app' }),
-
In the
src/index.html
file, add the following meta attribute, and replaceOCC_BASE_URL
with the URL of your back end instance, as follows:<meta name="occ-backend-base-url" content="OCC_BASE_URL" />
-
In
projects.<your-project-name>.architect
, add the following configuration to your existingangular.json
file:"server": { "builder": "@angular-devkit/build-angular:server", "options": { "outputPath": "dist/<your-project-name>-server", "main": "src/main.server.ts", "tsConfig": "tsconfig.server.json", "fileReplacements": [ { "replace": "src/environments/environment.ts", "with": "src/environments/environment.prod.ts" } ] } }
Note: In the above example, remember to replace the string
"<your-project-name>"
with your project name (such asmystore
, for example). -
Add the
tsconfig.server.json
file to your existing shell app. The following is an example:{ "extends": "./tsconfig.json", "compilerOptions": { "outDir": "../out-tsc/app", "baseUrl": "./", "module": "commonjs", "types": [] }, "exclude": ["test.ts", "e2e/src/app.e2e-spec.ts", "**/*.spec.ts"], "angularCompilerOptions": { "entryModule": "src/app/app.server.module#AppServerModule" } }
-
Add the
src/main.server.ts
file to your existing shell app. The following is an example:import { enableProdMode } from "@angular/core"; import { environment } from "./environments/environment"; if (environment.production) { enableProdMode(); } export { AppServerModule } from "./app/app.server.module"; export { provideModuleMap } from "@nguniversal/module-map-ngfactory-loader"; import { ngExpressEngine as engine } from "@nguniversal/express-engine"; import { NgExpressEngineDecorator } from "@spartacus/core"; export const ngExpressEngine = NgExpressEngineDecorator.get(engine);
-
Add the
src/app/app.server.module
file to your existing shell app. The following is an example:import { NgModule } from "@angular/core"; import { ServerModule, ServerTransferStateModule, } from "@angular/platform-server"; import { AppModule } from "./app.module"; import { AppComponent } from "./app.component"; import { ModuleMapLoaderModule } from "@nguniversal/module-map-ngfactory-loader"; @NgModule({ imports: [ // The AppServerModule should import your AppModule followed // by the ServerModule from @angular/platform-server. AppModule, ServerModule, ModuleMapLoaderModule, ServerTransferStateModule, ], bootstrap: [AppComponent], }) export class AppServerModule {}
For more information about caching and transfer state, see Caching the Site Context with Server-Side Rendering
-
Add the
webpack.server.config.js
file to your existing shell app. The following is an example:const path = require("path"); const webpack = require("webpack"); module.exports = { mode: "none", entry: { // This is our Express server for Dynamic universal server: "./server.ts", }, externals: { "./dist/server/main": 'require("./server/main")', }, target: "node", resolve: { extensions: [".ts", ".js"] }, optimization: { minimize: false, }, output: { // Puts the output at the root of the dist folder path: path.join(__dirname, "dist"), filename: "[name].js", }, module: { noParse: /polyfills-.*\.js/, rules: [ { test: /\.ts$/, loader: "ts-loader" }, { // Mark files inside `@angular/core` as using SystemJS style dynamic imports. // Removing this will cause deprecation warnings to appear. test: /(\\|\/)@angular(\\|\/)core(\\|\/).+\.js$/, parser: { system: true }, }, ], }, plugins: [ new webpack.ContextReplacementPlugin( // fixes WARNING Critical dependency: the request of a dependency is an expression /(.+)?angular(\\|\/)core(.+)?/, path.join(__dirname, "src"), // location of your src {} // a map of your routes ), new webpack.ContextReplacementPlugin( // fixes WARNING Critical dependency: the request of a dependency is an expression /(.+)?express(\\|\/)(.+)?/, path.join(__dirname, "src"), {} ), ], };
-
Add the
server.ts
file to your existing shell app. The following is an example:import "zone.js/dist/zone-node"; import * as express from "express"; import { join } from "path"; // Express server const app = express(); const PORT = process.env.PORT || 4200; const DIST_FOLDER = join(process.cwd(), "dist/<your-project-name>"); // * NOTE :: leave this as require() since this file is built Dynamically from webpack const { AppServerModuleNgFactory, LAZY_MODULE_MAP, ngExpressEngine, provideModuleMap, } = require("./dist/<your-project-name>-server/main"); app.engine( "html", ngExpressEngine({ bootstrap: AppServerModuleNgFactory, providers: [provideModuleMap(LAZY_MODULE_MAP)], }) ); app.set("view engine", "html"); app.set("views", DIST_FOLDER); app.get( "*.*", express.static(DIST_FOLDER, { maxAge: "1y", }) ); // All regular routes use the Universal engine app.get("*", (req, res) => { res.render("index", { req }); }); // Start up the Node server app.listen(PORT, () => { console.log(`Node server listening on http://localhost:${PORT}`); });
Note: In the above example, remember to replace the string
"<your-project-name>"
with your project name (such asmystore
, for example). -
Add the following scripts to your
package.json
. Remember to replace<your-project-name>
with your project name (such asmystore
, for example)."compile:server": "webpack --config webpack.server.config.js --progress --colors", "serve:ssr": "node dist/server", "build:ssr": "npm run build:client-and-server-bundles && npm run compile:server", "build:client-and-server-bundles": "ng build --prod && ng run <your-project-name>:server"
Note: For the
build:client-and-server-bundles
script, replace<your-project-name>
with the name of your Angular application. -
Build the SSR version of your Spartacus shell app by running the following command:
npm run build:ssr && npm run serve:ssr
Installation Steps for Spartacus Development
If you are involved in Spartacus internal development, or wish to submit a pull request, you can perform the following steps, which describe how to run Spartacus in SSR mode using the Spartacus storefront app.
-
Set the production server endpoint in your
environment.prod.ts
(dev mode) orapp.module.ts
(shell app mode), as follows:environment = { occBaseUrl: 'https://[your_occ_endpoint]', };
-
Turn PWA off.
As soon as Spartacus is installed in PWA mode, a service worker is installed, and it serves a cached version of
index.html
, along with thejs
files. This results in SSR being completely skipped. The following steps describe how to turn off PWA:-
Check that there are no service workers registered in your app. If you do find any service workers, remove them.
-
Turn PWA off in your app module configuration, as follows:
StorefrontModule.withConfig({ backend: { occ: { baseUrl: 'https://[your_enpdoint], }, }, pwa: { enabled: false, }, };
-
-
Rebuild your local Spartacus libraries by running the following command:
yarn build:core:lib
-
Build your local Spartacus shell app by running the following command:
yarn build --prod
-
Build the SSR version of your shell app by running the following command:
yarn build:ssr
-
Start Spartacus with the SSR server by running the following command:
yarn serve:ssr


[gecode-users] new C++ library database
Oliver Kullmann
O.Kullmann at swansea.ac.uk
Mon Feb 16 21:10:33 CET 2009
Hello,
hopefully the link
http://c-plusplus.org/
is useful: This aims at providing
the much needed links to all those C++
libraries out there.
I propose Gecode also puts a link there
(yet there are topics "Algorithms, Bioinformatics, Cryptography, Mathematics";
one could have links for Gecode in Algorithms and Mathematics, but
likely a new category like "Constraint Processing" would be good).
Oliver
--
Dr. Oliver Kullmann
Computer Science Department
Swansea University
Faraday Building, Singleton Park
Swansea SA2 8PP, UK
http://cs.swan.ac.uk/~csoliver/
More information about the gecode-users
mailing list


new ObjCanvas(divEle, bMouseControlOutsideopt)
Load and draw *.obj file on canvas, and save as image.
*.obj file can be loaded as contour or depth map.
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
divEle |
object | div element to draw | |
bMouseControlOutside |
boolean |
<optional> |
Flag to control object by mouse operations. Default value is false. |
- Source:
Methods
animate()
Request to animate and redraw.
- Source:
autoSave(distRatioopt)
Save multiple images seen from different 26 angles automatically.
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
distRatio |
number |
<optional> |
Ratio multiplied to distance from camera to object. The default value is 1.0. |
- Source:
clear()
Clear the object drawn on canvas.
- Source:
getCameraPositionZ() → {Number}
Returns z coordinate of camera.
- Source:
Returns:
z coordinate of camera
- Type
- Number
getObjectName() → {string}
Returns name of object.
When object was loaded from *.obj file, this function will return file name of it.
When object was loaded from *.obj file, this function will return file name of it.
- Source:
Returns:
Name of object
- Type
- string
loadObjFile(filePath, options)
load *.obj file.
Parameters:
| Name | Type | Description |
|---|---|---|
filePath |
string | file path |
options |
object | option settings options.bDepthMap {boolean} true if you want to draw as depth map. options.thresholdAngle {number} Threshold angle(degree) for edges to be drawn as contour. Default value is 15.0. |
- Source:
loadUint8Array(array)
Load Uint8Array as 3D-Object.
Parameters:
| Name | Type | Description |
|---|---|---|
array |
Uint8Array | Array obtained from depth map image. Size of the array should be width * height of div element specified by argument of constructor. |
- Deprecated:
- This method is under development.
- Source:
onDocumentMouseMove()
Event handler for mouse move.
- Source:
render()
Conduct rendering.
- Source:
save(fileNameopt)
Save what is shown on canvas as image.
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
fileName |
string |
<optional> |
File name of saved image. Default value is object name with extension "png". |
- Source:
setAmbientLightColor(rgb)
Set color of ambient light.
Parameters:
| Name | Type | Description |
|---|---|---|
rgb |
number | RGB color value to set. (e.g. ffffff for white.) |
- Source:
setCameraPositionZ(z, isKeepSceneopt)
Set z coordinate of camera.
Parameters:
| Name | Type | Attributes | Description |
|---|---|---|---|
z |
Number | z coordinate of camera | |
isKeepScene |
boolean |
<optional> |
Set z coordinate without updating scene. Default value is false. |
- Source:
setDirectionalLightColor(rgb)
Set color of directional light.
Parameters:
| Name | Type | Description |
|---|---|---|
rgb |
number | RGB color value to set. (e.g. ffffff for white.) |
- Source:


Copyright © 1999 - 2008 David Johnson, All Rights Reserved.
Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.

This product contains software written by Abe Kabakoff<EMAIL_ADDRESS>and Michal Palczewski <michalp@gmail.com>


Stacy M. Carter and Miles Little
Unread
Outlines epistemology, methodology and method in the context of qualitative research (although with a health bent).
"when we speak about “qualitative”
research, we mean social research in which the
researcher relies on text data rather than numerical data,
analyzes those data in their textual form rather than
converting them to numbers for analysis, aims to under-
stand the meaning of human action (Schwandt, 2001)"
"Method, methodology, and epistemology are defined in conflicting ways in the research literature. For the purposes of this article, we will define them as follows. Epistemology is “the study of the nature of knowledge and justification” (Schwandt, 2001, p. 71), and epistemological issues are “issues about an adequate theory of knowledge or justificatory strategy” (Harding, 1987, p. 2). As shorthand, epistemology can be thought of as justification of knowledge. A methodology is defined as “a theory and analysis of how research should proceed” (Harding, 1987, p. 2), “analysis of the assumptions, principles, and procedures in a particular approach to inquiry” (Schwandt, 2001, p. 161), or “the study—the description, the explanation, and the justification—of methods, and not the methods themselves” (Kaplan, 1964, p. 18). In short, methodology provides justification for the methods of a research project. Methods are “techniques for gathering evidence” (Harding, 1987, p. 2) or “procedures, tools and techniques” of research (Schwandt, 2001, p. 158). Methods can be thought of as research action. In the simplest terms, methodology justifies method, which produces data and analyses. Knowledge is created from data and analyses. Epistemology modifies methodology and justifies the knowledge produced"
"Accordingly, we will discuss epistemic questions, questions regarding research practice as knowledge creation and the status of the knowledge created, as academic researchers informed by the qualitative research literature."


Back
Find an energy assessor
Contact an assessor listed below to book an energy assessment.
Who accredits assessors
Accreditation schemes check that all the assessors listed below are qualified to carry out energy assessments on residential properties,
and to issue Energy Performance Certificates.
1 - 10 of 30 results near SW1A 2AA:
{%
set assessors = [
{
"name": "William Desai",
"distance": 0.2,
"phone": "0792 102 1368",
"email_address"<EMAIL_ADDRESS>"website": "epbassessments.com",
"accreditation_scheme": "CIBSIE",
"assessor_ID": "1234"
},
{
"name": "Amanda Sellen",
"distance": 0.6,
"phone": "0792 102 1368",
"email_address"<EMAIL_ADDRESS>"website": "epbassessments.com",
"accreditation_scheme": "Sterling",
"assessor_ID": "1234"
},
{
"name": "Juliet Tague",
"distance": 0.6,
"phone": "0792 102 1368",
"email_address"<EMAIL_ADDRESS>"website": "epbassessments.com",
"accreditation_scheme": "ECMK",
"assessor_ID": "1234"
},
{
"name": "Wallace Romney",
"distance": 0.6,
"phone": "0792 102 1368",
"email_address"<EMAIL_ADDRESS>"website": "epbassessments.com",
"accreditation_scheme": "ECMK",
"assessor_ID": "1234"
},
{
"name": "Mohammed Stewart",
"distance": 0.9,
"phone": "0792 102 1368",
"email_address"<EMAIL_ADDRESS>"website": "epbassessments.com",
"accreditation_scheme": "CIBSIE",
"assessor_ID": "1234"
},
{
"name": "Sandeep Sing",
"distance": 1,
"phone": "0792 102 1368",
"email_address"<EMAIL_ADDRESS>"website": "epbassessments.com",
"accreditation_scheme": "ECMK",
"assessor_ID": "1234"
},
{
"name": "Simon Doe",
"distance": 2,
"phone": "0792 102 1368",
"email_address"<EMAIL_ADDRESS>"website": "epbassessments.com",
"accreditation_scheme": "CIBSIE",
"assessor_ID": "1234"
},
{
"name": "Harald Anderson",
"distance": 2,
"phone": "0792 102 1368",
"email_address"<EMAIL_ADDRESS>"website": "epbassessments.com",
"accreditation_scheme": "Elmhurst Energy",
"assessor_ID": "1234"
},
{
"name": "Daniel Adams",
"distance": 4,
"phone": "0792 102 1368",
"email_address"<EMAIL_ADDRESS>"website": "epbassessments.com",
"accreditation_scheme": "Elmhurst Energy",
"assessor_ID": "1234"
},
{
"name": "Abul Minster",
"distance": 5,
"phone": "0792 102 1368",
"email_address"<EMAIL_ADDRESS>"website": "epbassessments.com",
"accreditation_scheme": "ECMK",
"assessor_ID": "1234"
}
]
%}
{% for assessor in assessors %}
-
{{assessor.name}}
- Distance
-
{% if assessor.distance<1 %}
Less than 1 mile away
{% else %}
{{assessor.distance}} miles away
{% endif %}
- Accredited by
- {{assessor.accreditation_scheme}}
- Assessor ID
- {{assessor.assessor_ID}}
{% endfor %}


|
KratosMultiphysics
KRATOS Multiphysics (Kratos) is a framework for building parallel, multi-disciplinary simulation software, aiming at modularity, extensibility, and high performance. Kratos is written in C++, and counts with an extensive Python interface.
|
This class creates some auxiliary nodes. More...
Public Member Functions | |
| def | GetDefaultParameters (cls) |
| def | __init__ (self, model, settings) |
| Constructor of the process. More... | |
| def | ExecuteInitialize (self) |
| Create the auxiliary nodes and set up the mapping structure. More... | |
| def | ExecuteBeforeOutputStep (self) |
Public Attributes | |
| settings | |
| model_part | |
| reference_model_part | |
| node_id | |
| variables | |
| entities | |
| area_coords | |
| found_positions | |
This class creates some auxiliary nodes.
If a reference model part is is specified, a mapping structure is created in order to update the solution step data from the reference the auxiliary nodes. The reference model part can be a specified by name or as the root model part.
| def auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.__init__ | ( | self, | |
| model, | |||
| settings | |||
| ) |
Constructor of the process.
| def auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.ExecuteBeforeOutputStep | ( | self | ) |
| def auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.ExecuteInitialize | ( | self | ) |
Create the auxiliary nodes and set up the mapping structure.
| def auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.GetDefaultParameters | ( | cls | ) |
| auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.area_coords |
| auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.entities |
| auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.found_positions |
| auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.model_part |
| auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.node_id |
| auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.reference_model_part |
| auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.settings |
| auxiliary_nodes_visualization_process.AuxiliaryNodesVisualizationProcess.variables |


Many project have a private code, :( ... you can check my github
profile as well, but I put here some project, all of them I used C#, .Net Core, Javascritp, HTML5, SQL Server
or Oracle:
| Software Application | ||
|---|---|---|
| HackQuestion Page | This is a WebSite Tools, to help some candidates to study regular question for interviwers and record yourseflt to check your English | |
| NopCommerce Shippment Plugin | This is a Plugin for Shipment Calculation Price, to use on NopCommerce Solution, It's Free and Open Source. | |
| NopCommerce Payment Plugin | This is a Plugin for Payment Calculation, Integrated with PagSeguro, to use on NopCommerce Solution, It's Free and Open Source. | |
| CRM/SAC Software WebApp | Software Write to Help my customer a plan and control your Customer Services. | |
| Customer Issue Payment Module WebApp | Another Software that help customers a control customer requirement to pay insurance | |
| Smartadmin WebApp | SmartAdmin solves problem for manager DEAL, CUSTOMER with PIPELINE for companies |


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
null
.
Classes
.Elements
.Class.getMethods()
that
are annotated with the given annotation.
AnnotationMirror
corresponding to the given annotation type, if present.
ClassUtils.getSuperclassChains(Class, Class)
.
Element
is an annotation
Element
is a constructor
Class Classes
.
Element
is a method
Element
is of a certain JavaFileObject.Kind
.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


{{course.header}}
{{detail.question}}
{{detail.answer}}
{{breakdown.question}}
{{breakdown.answer}}
{{course.footer}}
The booking form can be found:


2 Chronicles 20:3
And Jehoshaphat feared, and set himself to seek the LORD, and proclaimed a fast throughout all Judah.


--- type: filter title: Filters List Popup usage: This is the field picker control used to select a filter field. stylesheet: '/scss/controls/filters-list.scss' --- Form Toggle


First steps
Ask 10 Programmers, get 15 answers
More important than what language is that you try it
Try one language and go for it!
"I hope to see Ruby help every programmer in the world to be productive, and to enjoy programming, and to be happy. That is the primary purpose of Ruby language."
Yukihiro Matsumoto ("Matz") - Ruby creator
The coaches know it well
Easier to learn than other languages
Active, open and friendly community: "Matz is nice and so we are nice" (MINASWAN)
Your very first error message!
puts "Hello world!"
Your very first Ruby program!
What questions do you have?


The Mask Of Zorro A Film Review By Michael Redman Copyright 1998 By Michael Redman
** (Out of ****)
The old adage "You can't go home again" is often especially true of one's early childhood havens. Things tend to be smaller, less fascinating and not quite as profound as memory would indicate.
Perhaps Zorro is one of those youthful memories best left alone. Out of the several versions of the swashbuckling hero, Disney's Guy Williams was mine. Hours were happily spent in front of the television watching the hero of old California make his enemies look like fools. The current film pales in the _recollection_ of those shows, although probably not compared to the actual programs themselves.
Based loosely on Johnston McCulley's 1919 magazine serialization which was brought to the screen a year later, this movie features two Zorros. We are introduced to the first, Don Diego De La Vega (Anthony Hopkins), in 1812 during his last adventure. The evil governor Don Rafael Montero is ready to execute innocent men to draw out his arch-foe. Zorro rides in, saves the men, fights off an army, poses dramatically a number of times and escapes.
But all is not well. Montero discovers his secret identity and invades De La Vega's home. During the battle, Zorro is captured and his beloved wife killed. The governor then takes De La Vega's young daughter Elena to raise as his own.
Skip ahead twenty years. Montero returns from Spain with the grown Elena (Catherine Zeta-Jones) and a plan to buy California from Mexico. Upon hearing of this, De La Vega, languishing in a squalid prison, escapes. In a tavern he runs into bandit Alejandro Murrieta (Antonio Banderas) who had befriended him as a child.
Murrieta is seeking revenge against Captain Harrison Love (Matt Letscher) for causing the death of his brother. Love is Montero's partner in his depraved plan. The older Zorro takes on this young outlaw and trains him to be the new masked avenger.
And then they fight the bad guys.
The film is a return to a simpler lighter adventure reminiscent of "Raiders Of The Lost Ark". There's no dark brooding Bruce Wayne. It's all played for action and laughs. The problem is that the action is listless and the laughs, forced.
The sword fighting is mostly filmed in medium shots resulting in a flat experience. The scenes are formulaic and repetitive. Each fight looks like the last. Zorro runs to the left and finds a group of soldiers. He runs to the right and finds a group of soldiers. He runs back to the middle and fights them all at once. Fifteen minutes later he does it again.
The comedy is played broadly and over and over. The young Zorro's problems with his horse are slightly humorous the first time. The second and third are less so.
Hopkins is the highlight of the film. His aging mentor is witty and appealing. Banderas fares less well, but does what he can with the limited role. Zeta-Jones certainly has a screen presence. Her sword fight with Banderas which doubles as foreplay is a joy at least until it goes on too long.
Other viewers might find the recent Zorro dazzling. Me, I think I'll stick with my memories.
[This appeared in the 8/6/98 "Bloomington Voice", Bloomington, Indiana. Michael Redman can be contacted at<EMAIL_ADDRESS>--<EMAIL_ADDRESS>This week's film review at http://www.bvoice.com/ Film reviews archive at http://us.imdb.com/M/reviews_by?Michael%20Redman
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


Class State (v2.2.2)
Batch operation states.
Protobuf type google.cloud.vision.v1.OperationMetadata.State
Methods
name
Parameter| Name | Description |
| value |
mixed
|
value
Parameter| Name | Description |
| name |
mixed
|
Constants
STATE_UNSPECIFIED
Value: 0
Invalid.
Generated from protobuf enum STATE_UNSPECIFIED = 0;
CREATED
Value: 1
Request is received.
Generated from protobuf enum CREATED = 1;
RUNNING
Value: 2
Request is actively being processed.
Generated from protobuf enum RUNNING = 2;
DONE
Value: 3
The batch processing is done.
Generated from protobuf enum DONE = 3;
CANCELLED
Value: 4
The batch processing was cancelled.
Generated from protobuf enum CANCELLED = 4;


No definition in Astah file
Networked ontologies used by IntO:
| Ontology | Relation | Integration Level |
No definition in Astah file
Figure 1 presents the conceptual model of the Integrated Model subontology.
Figure 1. Integrated Model conceptual model.
Requirements + (Design) + Coding + Testing
The following table shows the definitions for IntO concepts.
| Concept | Definition |
| Code as Test Case Design Input |
|
| Design Document as Test Case Design Input |
|
| Requirements Document as Test Case Design Input |
|
<<role>> Code as Test Case Design Input |
<<role>> Design Document as Test Case Design Input |
<<role>> Requirements Document as Test Case Design Input |


Query Canvases
GPU
Touching color A?
maybe
Touching color B?
maybe
CPU
Touching color A?
maybe
Touching color B?
maybe
Render Canvas
Cursor Position:
somewhere


http://images.apple.com/cn/news/images/ios_icon_large.png
http://images.apple.com/cn/news/images/ios_icon_large_2x.png
http://images.apple.com/cn/news/images/ios_icon_medium.png
http://images.apple.com/cn/news/images/ios_icon_medium_2x.png
http://images.apple.com/cn/news/images/ios_icon_small.png
http://images.apple.com/cn/news/images/ios_icon_small_2x.png
http://images.apple.com/cn/news/images/news_icon_large.png
http://images.apple.com/cn/news/images/news_icon_large_2x.png
http://images.apple.com/cn/news/images/news_icon_medium.png
http://images.apple.com/cn/news/images/news_icon_medium_2x.png
http://images.apple.com/cn/news/images/news_icon_small.png
http://images.apple.com/cn/news/images/news_icon_small_2x.png
http://images.apple.com/cn/news/images/news_hero_large.png
http://images.apple.com/cn/news/images/news_hero_large_2x.png
http://images.apple.com/cn/news/images/news_hero_medium.png
http://images.apple.com/cn/news/images/news_hero_medium_2x.png
http://images.apple.com/cn/news/images/news_hero_small.png
http://images.apple.com/cn/news/images/news_hero_small_2x.png
http://images.apple.com/cn/news/images/news_hero_large.png
http://images.apple.com/cn/news/images/news_hero_large_2x.png
http://images.apple.com/cn/news/images/news_hero_medium.png
http://images.apple.com/cn/news/images/news_hero_medium_2x.png
http://images.apple.com/cn/news/images/news_hero_small.png
http://images.apple.com/cn/news/images/news_hero_small_2x.png
http://images.apple.com/cn/news/images/experience_large.jpg
http://images.apple.com/cn/news/images/experience_large_2x.jpg
http://images.apple.com/cn/news/images/experience_medium.jpg
http://images.apple.com/cn/news/images/experience_medium_2x.jpg
http://images.apple.com/cn/news/images/experience_small.jpg
http://images.apple.com/cn/news/images/experience_small_2x.jpg
http://images.apple.com/cn/news/images/experience_top_medium.jpg
http://images.apple.com/cn/news/images/experience_top_medium_2x.jpg
http://images.apple.com/cn/news/images/experience_large.jpg
http://images.apple.com/cn/news/images/experience_large_2x.jpg
http://images.apple.com/cn/news/images/experience_medium.jpg
http://images.apple.com/cn/news/images/experience_medium_2x.jpg
http://images.apple.com/cn/news/images/experience_small.jpg
http://images.apple.com/cn/news/images/experience_small_2x.jpg
http://images.apple.com/cn/news/images/experience_bottom_medium.jpg
http://images.apple.com/cn/news/images/experience_bottom_medium_2x.jpg
http://images.apple.com/cn/news/images/sources_small.jpg
http://images.apple.com/cn/news/images/sources_small_2x.jpg
http://images.apple.com/cn/news/images/interest_large.png
http://images.apple.com/cn/news/images/interest_large_2x.png
http://images.apple.com/cn/news/images/interest_medium.png
http://images.apple.com/cn/news/images/interest_medium_2x.png
http://images.apple.com/cn/news/images/interest_small.jpg
http://images.apple.com/cn/news/images/interest_small_2x.jpg
http://images.apple.com/cn/news/images/publisher_large.jpg
http://images.apple.com/cn/news/images/publisher_large_2x.jpg
http://images.apple.com/cn/news/images/publisher_medium.jpg
http://images.apple.com/cn/news/images/publisher_medium_2x.jpg
http://images.apple.com/cn/news/images/publisher_small.jpg
http://images.apple.com/cn/news/images/publisher_small_2x.jpg


#include
<sxcommon.h>
Public Member Functions |
|
| ByteMap (string s="3210XY987654", int bc=2, int b=6) | |
Public Attributes |
|
| string | map |
| int | byteCount |
| int | usableBitsPerByte |
| sx360::ByteMap::ByteMap | ( | string | s = "3210XY987654" ,
|
|
| int | bc = 2 , |
|||
| int | b = 6 |
|||
| ) | [inline] |
Constructor that only needs to be overriden if a nonstandard 360
column binary file is in use.
| string sx360::ByteMap::map |
string representing every possible punch for an sxRecord.
There MUST be an even number of punches in this string since it will be
divided evenly across the number of bytes specfied in the byteCount
variable.
Number of bytes that the map takes up. For instance, the
default has 12 punches, which takes up 2 bytes. 24 would take up
3 bytes, etc.
Number of usable bits per byte. Because of the original design
of the format, the 12 punches are distributed evenly across two bytes,
making 6 bits of each byte actually usable. There are two bits in
each byte that are wasted. So, it is possible to add 4 more
punches to the default punchmap and still use the same amount of disk
space.


University of Johannesburg
Phillip Krüger studies
B.Sc (Hons) Computer Science
Subjects
- Information Security
- Information Security in WWW
- Artificial Intelligence
- IT Project Management
- WWW Programming
- Ethical, Audit and Legal aspects of IT
- Information security systems
- Practical Project
B.Sc Information Technology
Subjects
- Computer Science 1,2 & 3
- Informatics 2 & 3
- Mathematics Analysis 2
- Mathematics Algebra 2
- Mathematics Statistics 1
- Mathematics 1
- Economics 1
- Acounting 1


Uganda slams reckless killing of its nationals by Rwandan officials
Uganda on Tuesday protested to Rwanda over the killing of two of its nationals by Rwandan security personnel and demanded that they be punished in a further sign of fraying relations between the neighbouring states.
The two Ugandans were shot dead early on Sunday after being intercepted by Rwandan police while smuggling goods over the nearby border with Uganda, a Rwandan police statement said.
In a statement, the Ugandan government accused Rwanda’s security personnel of reckless behaviour.
“The government of Uganda protests in the strongest terms the murder of its nationals by Rwandan security personnel,” it said. “The alleged crime (smuggling) cannot justify this high handed and criminal act by Rwandan security personnel.”
A Rwandan government statement on Sunday said the two Ugandans had entered Rwanda illegally on a smuggling run and assaulted its police officers.
Relations between Uganda and Rwanda turned frosty early this year after Rwanda shut its border, accusing Kampala of backing rebels trying to topple President Paul Kagame. Rwanda ordered its nationals not to travel to Uganda and barred imports of Ugandan goods.
In August Kagame and Ugandan President Yoweri Museveni signed a deal to try to mend ties, vowing to respect each other’s sovereignty and refrain from actions that destabilize the other’s territory.
But little has changed since and instead shooting incidents associated with smuggling have been increasing.
Analysts fear an escalation of tensions between both countries could push them to resume proxy wars in the jungles of eastern Congo, further destabilising an already volatile region.
REUTERS