|
EUCHARISTIC PRAYER FOR RECONCILIATION II |
|
The priest, with
hands extended, says: You, therefore, almighty Father, we bless through Jesus Christ your Son, who comes in your name. He himself is the Word that brings salvation, the hand you extend to sinners, the way by which your peace is offered to us. When we ourselves had turned away from you on account of our sins, you brought us back to be reconciled, O Lord, so that, converted at last to you, we might love one another through your Son, whom for our sake you handed over to death. |
|
He joins his hands
and, holding them extended over the offerings, says: |
|
And now, celebrating the reconciliation Christ has brought us, we entreat you: sanctify these gifts by the outpouring of your Spirit, |
|
He joins his hands
and makes the Sign of the Cross once over the bread and chalice together,
saying: |
|
that they may become the
Body and + Blood of
your Son, when we celebrate these mysteries. |
|
He joins his
hands. In the formulas
that follow, the words of the Lord should be pronounced clearly and
distinctly, as the nature of these words requires. For when about to give his life to set us free, as he reclined at supper, |
|
He takes the bread
and, holding it slightly raised above the altar, continues: |
|
he himself took bread into
his hands, and, giving you thanks, he said the blessing, broke the bread and
gave it to his disciples, saying: |
|
He bows slightly Take this, all of you, and eat of it, for this is my Body, which will be given up for you. |
|
He shows the
consecrated host to the people, places it again on the paten, and genuflects
in adoration. |
|
After this, he
continues: In a similar way, on that same evening, He takes the
chalice and, holding it slightly raised above the altar, continues: He took the chalice of blessing in his hands, confessing your mercy, and gave the chalice to his disciples, saying: |
|
He bows slightly |
|
Take this, all of you, and drink from it, for this is the chalice of my Blood, the Blood of the new and eternal covenant, which will be poured out for you and for many for the forgiveness of sins. Do this in memory of me. |
|
He shows the
chalice to the people, places it on the corporal, and genuflects in adoration. |
|
Then he says: The mystery of faith: |
|
And the people
continue, acclaiming: A. We proclaim your Death, O Lord, and profess your Resurrection until you come again. |
|
B. When we eat this Bread and drink this Cup, we proclaim your Death, O Lord, until you come again. |
|
C. Save us, Saviour of the world, for by your Cross and Resurrection you have set us free. |
|
Then the Priest,
with hands extended, says: Celebrating,
therefore, the memorial of the Death and Resurrection of your Son, who left
us this pledge of his love, we offer you what you have bestowed on us, the
Sacrifice of perfect reconciliation. Holy Father, we humbly beseech you to accept us also, together with your Son, and in this saving banquet graciously to endow us with his very Spirit, who takes away everything that estranges us from one another. |
|
May he make your
Church a sign of unity and an instrument of your peace among all people and
may he keep us in communion with N.
our Pope and N., our
Bishop and all the Bishops and your entire people. Just as you have gathered us now at the table of your Son, so also bring us together, with the glorious Virgin Mary, Mother of God, with your blessed Apostles and all the Saints, with our brothers and sisters and those of every race and tongue who have died in your friendship. Bring us to share with them the unending banquet of unity in a new heaven and a new earth, where the fullness of your peace will shine forth He joins his
hands. In Christ Jesus our Lord. He takes the
chalice and the paten with the host and, raising both, he says: |
|
Through him, and with him, and in him, O God, almighty Father, in the unity of the Holy Spirit, all glory and honor is yours, for ever and ever. |
|
The people
continue: Amen. Then follows the
Communion Rite.
|


A representation of a full OpenGL shader program.
More...
#include <shader.hpp>
|
| | ~Shader () |
| | Destroy this shader program. More...
|
| |
|
| Shader ()=default |
| | Construct am empty shader.
|
| |
| | Shader (const std::string &vertexSource, const std::string &fragmentSource) |
| | Construct a shader program. More...
|
| |
|
| Shader (Shader &&o) noexcept=default |
| | Default move constructor.
|
| |
|
Shader & | operator= (Shader &&p) noexcept=default |
| | Default move-assignment operator.
|
| |
| bool | valid () const noexcept |
| | Check whether or not this program is valid. More...
|
| |
| std::string | errorLog () const |
| | Attempt to retrieve any error log for this program. More...
|
| |
|
void | bind () const noexcept |
| | Bind this shader to the currently active context for rendering.
|
| |
| void | uniformLocation (const int location, const vec2 &vector) const noexcept |
| | Copy data to a specific uniform location. More...
|
| |
| void | uniformLocation (const int location, const vec3 &vector) const noexcept |
| | Copy data to a specific uniform location. More...
|
| |
| void | uniformLocation (const int location, const vec4 &vector) const noexcept |
| | Copy data to a specific uniform location. More...
|
| |
| void | uniformLocation (const int location, const ivec2 &vector) const noexcept |
| | Copy data to a specific uniform location. More...
|
| |
| void | uniformLocation (const int location, const ivec3 &vector) const noexcept |
| | Copy data to a specific uniform location. More...
|
| |
| void | uniformLocation (const int location, const ivec4 &vector) const noexcept |
| | Copy data to a specific uniform location. More...
|
| |
| void | uniformLocation (const int location, const mat4 &matrix) const noexcept |
| | Copy data to a specific uniform location. More...
|
| |
A representation of a full OpenGL shader program.
◆ ~Shader()
Destroy this shader program.
Custom Destructor.
◆ Shader()
| Shader::Shader |
( |
const std::string & |
vertexSource, |
|
|
const std::string & |
fragmentSource |
|
) |
| |
Construct a shader program.
Custom Constructor.
- Parameters
-
| vertexSource | the source code for the vertex shader. |
| fragmentSource | the source code for the fragment shader. |
◆ errorLog()
| std::string mini::Shader::errorLog |
( |
| ) |
const |
|
inline |
Attempt to retrieve any error log for this program.
- Returns
- an error log if present.
◆ uniformLocation() [1/7]
| void Shader::uniformLocation |
( |
const int |
location, |
|
|
const vec2 & |
vector |
|
) |
| const |
|
noexcept |
Copy data to a specific uniform location.
uniformLocation
- Parameters
-
| location | the location in - shader to copy to. |
| vector | the data to copy - in. |
◆ uniformLocation() [2/7]
| void Shader::uniformLocation |
( |
const int |
location, |
|
|
const vec3 & |
vector |
|
) |
| const |
|
noexcept |
Copy data to a specific uniform location.
- Parameters
-
| location | the location in - shader to copy to. |
| vector | the data to copy - in. |
◆ uniformLocation() [3/7]
| void Shader::uniformLocation |
( |
const int |
location, |
|
|
const vec4 & |
vector |
|
) |
| const |
|
noexcept |
Copy data to a specific uniform location.
- Parameters
-
| location | the location in - shader to copy to. |
| vector | the data to copy - in. |
◆ uniformLocation() [4/7]
| void Shader::uniformLocation |
( |
const int |
location, |
|
|
const ivec2 & |
vector |
|
) |
| const |
|
noexcept |
Copy data to a specific uniform location.
- Parameters
-
| location | the location in - shader to copy to. |
| vector | the data to copy - in. |
◆ uniformLocation() [5/7]
| void Shader::uniformLocation |
( |
const int |
location, |
|
|
const ivec3 & |
vector |
|
) |
| const |
|
noexcept |
Copy data to a specific uniform location.
- Parameters
-
| location | the location in - shader to copy to. |
| vector | the data to copy - in. |
◆ uniformLocation() [6/7]
| void Shader::uniformLocation |
( |
const int |
location, |
|
|
const ivec4 & |
vector |
|
) |
| const |
|
noexcept |
Copy data to a specific uniform location.
- Parameters
-
| location | the location in - shader to copy to. |
| vector | the data to copy - in. |
◆ uniformLocation() [7/7]
| void Shader::uniformLocation |
( |
const int |
location, |
|
|
const mat4 & |
matrix |
|
) |
| const |
|
noexcept |
Copy data to a specific uniform location.
- Parameters
-
| location | the location in - shader to copy to. |
| matrix | the data to copy - in. |
◆ valid()
| bool Shader::valid |
( |
| ) |
const |
|
noexcept |
Check whether or not this program is valid.
valid
- Returns
- true on success, false otherwise.
The documentation for this class was generated from the following files:


An OMLDataSet
consists of an OMLDataSetDescription
, a
data.frame
containing the data set, the old and new column names and,
finally, the target features.
The OMLDataSetDescription
provides information on the data set,
like the ID, name, version, etc. To see a full list of all elements, please see the
XSD.
The slot colnames.old
contains the original names, i.e., the column names that were
uploaded to the server, while colnames.new
contains the names that you will see when
working with the data in R.
Most of the time, old and new column names are identical. Only if the original names are
not valid, the new ones will differ.
The slot target.features
contains the column name(s) from the data.frame
of the OMLDataSet
that refer to the target feature(s).
makeOMLDataSet(desc, data, colnames.old = colnames(data), colnames.new = colnames(data), target.features = NULL)
| desc | [ |
|---|---|
| data | [ |
| colnames.old | [ |
| colnames.new | [ |
| target.features | [ |
[OMLDataSet
]
Other data set-related functions: OMLDataSetDescription
,
convertMlrTaskToOMLDataSet
,
convertOMLDataSetToMlr
,
deleteOMLObject
,
getOMLDataSet
,
listOMLDataSets
,
tagOMLObject
,
uploadOMLDataSet
data("airquality") dsc = "Daily air quality measurements in New York, May to September 1973. This data is taken from R." cit = "Chambers, J. M., Cleveland, W. S., Kleiner, B. and Tukey, P. A. (1983) Graphical Methods for Data Analysis. Belmont, CA: Wadsworth." desc_airquality = makeOMLDataSetDescription(name = "airquality", description = dsc, creator = "New York State Department of Conservation (ozone data) and the National Weather Service (meteorological data)", collection.date = "May 1, 1973 to September 30, 1973", language = "English", licence = "GPL-2", url = "https://stat.ethz.ch/R-manual/R-devel/library/datasets/html/00Index.html", default.target.attribute = "Ozone", citation = cit, tags = "R") airquality_oml = makeOMLDataSet(desc = desc_airquality, data = airquality, colnames.old = colnames(airquality), colnames.new = colnames(airquality), target.features = "Ozone")


Installing DBNsim
Requirements
For running DBNsim on you own server you will need:
- Some knowledge of the command line interface of your machine;
- An intepreter for Python 2.7 (not Python 3);
- the pip package manager for Python 2, which should be shipped with a standard Python installation;
- optionally (for GPU support) the NVIDIA drivers for CUDA.
Please note that you have to use Python 2 (preferably 2.7), not Python 3! This is beacause, unfortunately, DBNsim currently depends on two libraries that are only available for Python 2.
If you have installed Python under Windows but your command line says it doesn't recognize the commands pip
and python
, then you just have to add Python to your path. This is generally done by going to System Properties / Advanced / Environment Variables.
Basic installation
For installing DBNsim (both for CPU and GPU usage) follow these steps:
git clone https://github.com/ggiuffre/DBNsim.git cd DBNsim pip install --user -r requirements.txt
In addition, it is recommended to install scipy, with the command pip install --user scipy
. Windows user may find it difficult but this is currently an optional dependency; the only thing is that without it you won't be able to handle MATLAB files as an administrator (see here).
If you don't have Git installed, you can still go to the GitHub repo, click "Clone or Download", then "Download ZIP"; now extract the archive, and then cd
into the extracted directory.
Adding GPU support
If you have a CUDA-enabled GPU, you can install CUDAMat. To install it, first exit the DBNsim
directory (this is very important) — a simple way to exit the directory is to cd
into your home directory; then execute the following commands:
git clone https://github.com/cudamat/cudamat.git cd cudamat pip install --user .
As before, if you don't have Git installed you can download a zipped version of CUDAMat from GitHub.
If you get errors while installing with pip
, make sure you have the CUDA drivers installed, along with the NVIDIA CUDA compiler (nvcc). If you're using Ubuntu, then you can install them with:
sudo apt-get install nvidia-cuda-toolkit
After you manage to install CUDAMat, remember to test it. To do this, exit the cudamat
directory (this is very important), enter a Python interpreter and type:
import numpy as np import cudamat as cm cm.cublas_init() a = cm.CUDAMatrix(np.random.rand(32, 256)) b = cm.CUDAMatrix(np.random.rand(256, 32)) c = cm.dot(a, b) d = c.sum(axis = 0) print(d.asarray())
Launching DBNsim
Finally, launch DBNsim with:
cd path/to/DBNsim python DBNsite/manage.py runserver
... this actually launches DBNsim only locally. Instead, if you want other users to access it, type:
cd path/to/DBNsim python DBNsite/manage.py runserver your.public.ip.address:8000
You should see something like:
Performing system checks... loading data from pickle... loading data from pickle... loading data from pickle... loading data from pickle... System check identified no issues (0 silenced). June 22, 2017 - 16:02:15 Django version 1.11.2, using settings 'DBNsite.settings' Starting development server at http://your.public.ip.address:8000/ Quit the server with CONTROL-C.
This means the server is up and running. Now you should find the user interface at http://<IP_ADDRESS>:8000
if you're running the app locally. Or, if you're publishing it to a network, you should find it at http://your.public.ip.address:8000
. 8000 is just an example — you can run DBNsim on any port you have access to.
Once you're on the page, you will be asked for a password. If the server administrator didn't change the default configuration, the password is user.
When you want to shut down the server, return to the command line interface and press CONTROL-C.
Changing the default configuration
As the server administrator, you have more power than normal users. It is possible to configure DBNsim under the following aspects:
- you can edit the available training datasets, removing them and/or adding new ones;
- you can set a password that the users have to know in order to use the app;
- you can alter the default values of the hyper-parameters (e.g. you can set a default value of 0.5 for the learning rate, if the user doesn't change it on the form);
- you can change some graphical parameters in the user interface.
For more about how to change the configuration, please read here.


# Returning event emitter ## Common Patterns for EventEmitters There are two common patterns that can be used to raise and bind an event using EventEmitter class in Node.js. - Return EventEmitter from a function - Extend the EventEmitter class --- ## Return EventEmitter from a function In this pattern, a constructor function returns an EventEmitter object, which was used to emit events inside a function. This EventEmitter object can be used to subscribe for the events. --- ## Example: Return EventEmitter from a function ```js var emitter = require('events').EventEmitter; function LoopProcessor(num) { var e = new emitter(); setTimeout(function () { for (var i = 1; i <= num; i++) { e.emit('BeforeProcess', i); console.log('Processing number:' + i); e.emit('AfterProcess', i); } }, 2000) return e; } var lp = LoopProcessor(3); lp.on('BeforeProcess', function (data) { console.log('About to start the process for ' + data); }); lp.on('AfterProcess', function (data) { console.log('Completed processing ' + data); }); ``` --- ## Output ```shell About to start the process for 1 Processing number:1 Completed processing 1 About to start the process for 2 Processing number:2 Completed processing 2 About to start the process for 3 Processing number:3 Completed processing 3 ``` --- # The End


CTO and Board Member at
Merck Pharmacueticals, Inc.
CTO and Board Member at
Merck Pharmacueticals, Inc.
CTO and Board Member at
Merck Pharmacueticals, Inc.
Software company in Chicago, IL
software-company.com
Software company in Chicago, IL
software-company.com
Merck Pharmaceuticals, Inc.
$100K
Mar 5
Hard Commit


Location: Nagarnar Integrated Steel Plant, Jagdalpur, Chhattisgarh India.
Industry: Government
Occupational Category: Safety
Description: National Mineral Development Corporation (NMDC)
Educational requirements: Degreein Mechnical / Fire and Safety Engg. with Degree / Diploma in Industrial Safety recognized by Central / State Government Institute.


Data Sync
- Introduction
- Setting Up the Data Sync Mobile Service
- Managing your data sources using the Data Sync UI
- Defining a Schema using the Data Sync UI
- Adding Resolvers to a Schema
- Adding Subscriptions to a Schema
- Using the Data Sync SDK
- Monitoring Data Sync Service
- Authentication for Data Sync
- Role Based Authorization in Data Sync
Introduction
| The Data Sync mobile service is currently in development. Current released version is 0.1.0. The software is available for you to use and investigate, however it might not work as expected and functionality might change over time. |
The Data Sync service allows you to synchronize data between multiple mobile clients and easily query exactly the data you need.
-
Synchronize data between multiple clients
-
Define and connect your own data sources
-
Retrieve and update your records using GraphQL
-
Robust offline experience and good performance thanks to Apollo caching
Additional resources
For more information, see the Apollo Client Documentation
Setting Up the Data Sync Mobile Service
Provisioning Data Sync Service
Prerequisites
-
You are running OpenShift with Mobile Services as described in Setting up AeroGear Mobile Services on OpenShift.
-
You have provisioned Mobile Developer Console as described in Provisioning Mobile Developer Console.
To provision the Data Sync mobile service:
-
Log into the OpenShift console.
-
Choose a project where you have previously provisioned Mobile Developer Console.
-
Select Catalog from the left hand menu.
You can filter the catalog items to only show mobile specific items by selecting the Mobile tab.
-
Choose the Data Sync service.
-
Follow the wizard for provisioning that service.
If prompted to Create a Binding, choose Do not bind at this time.
When provisioning a Data Sync Service, you are prompted to set the following:
| Field | Description |
|---|---|
Postgres Storage Size (Gb) |
Size of persistent volume for Postgres (default value is recommended) |
Postgres User |
User name that will be used to connect to postgres ('user' will be used if blank) |
Postgres Password |
Password to connect to Postgres (generated if blank) |
Query depth limit |
Limit the complexity of the queries solely by their depth |
Query complexity limit |
Limit the complexity of the queries based on the data |
|
If the Postgres password was generated, retrieve the password using:
Wait for the database provisioning to finish before executing this command. |
Once the wizard steps are completed, navigate to the Project Overview in OpenShift to see the newly provisioned service. Provisioning a service may take some time.
Binding a Mobile App with the Data Sync Service
To use mobile services, you must represent your mobile app in Mobile Developer Console, and that app must be associated with the mobile service. This association is called binding and it is necessary for your mobile app to use that service.
To bind a Mobile App with a mobile service:
Procedure
-
Launch Mobile Developer Console
-
Click on the Mobile App on the Overview screen
-
Navigate to Mobile Services tab.
It is possible to bind a Mobile App with a mobile service in the OpenShift console, however such bindings are not valid for the purposes of this procedure. -
Press Bind to App in the Data Sync
-
Fill out the binding parameters required by the Data Sync Service.
Managing your data sources using the Data Sync UI
The Data Sync UI allows you to manage your data sources.
To access the Data Sync UI, you will need to:
-
Make sure the Data Sync service is provisioned.
-
Select a route in OpenShift.
-
Login with your OpenShift credentials.
| On first login you need to provide the OpenShift OAuth service permissions to read your user account. |
Data Source Introduction
A Data Source is a representation of your data storage solution. The Data Source consists of a Name, a Type, and a Configuration. The Type of Data Source which are currently supported are Postgres and InMemory. For information on how to use Postgres, refer to the documentation here. The In Memory Data Source that is currently supported is NeDB, for more information on how to use this please refer to the documentation here.
| The In Memory Data Source is not recommended for production use. |
Data Source Options
The data sources tab on the Data Sync UI allows you to perform the following operatations:
View Existing Data Sources
This is the default view on the Data Sync UI. It lists all of the existing data sources. This view currently displays the data source name and the type of the data source.
Data sources can be filtered using the name property.
Edit an Existing Data Source
To edit an existing data source, choose the Edit Data Source option from the data source menu.
Update the data source with the new values.
Delete an Existing Data Source
To delete a data source, choose the Delete Data Source option from the data source menu. Next confirm that you wish to delete the data source.
| When you delete a data source, all resolvers that are attached to it will also be deleted. |
Create a New Data Source
If no data source exists, a new data source can be created by clicking the Add Data Source button. Select the type of your data source from the dropdown. For more information about the In Memory option have a look at the In Memory Option. Information about the Postgres option can be found here.
In Memory Data Sources
You need to provide a name for the data source. The only other option is TimeStamp Data
. If checked, timestamps will be stored along with your data in NeDB
.
To find more about NeDB and how to write queries, have a look at the Github Repository.
|
| Some features like unique indices and persistence are not supported in the In Memory database and it is therefore only recommended for evaluation purposes. |
Postgres Data Sources
You need to provide a name for the data source. Postgres
has a number of other required options:
-
Server: The host name of the PostgreSQL instance.
-
Port: The Network Port used by PostgreSQL (defaults to
5432
). -
Database: The name of the database to connect to. PostgreSQL servers can host multiple databases.
-
Username: The username of the PostgreSQL user account.
-
Password: (Optional) The password of the PostgreSQL user account.
| To find out more about Postgres and how to work with it, have a look at the official documentation. |
You can test your data source before saving by clicking on the Test button. Data Sync will then attempt to connect to the provided PostgreSQL server. If the connection fails you will see the error message in the dialog.
|
Defining a Schema using the Data Sync UI
A schema describes the structure of the data the Data Sync deals with. It allows you to configure your data types, queries and mutations in a format that is independent of the underlying data source. To learn more Schemas have a look at the GraphQL documentation.
The Schema Editor
The Schema Editor can be found under the Schema
tab in the UI. It consists of a text editor where
you can write and edit your schema and a structure view on the right. To try it out you can use a simple schema like this:
type Query {
notes: [Note]
}
type Comment {
from: String
text: String
}
type Note {
text: String!
comments: [Comment]
}
Save the schema by pressing the Save Schema
button. Upon saving the Data Sync will check your schema for errors and compile it to a JSON representation.
You can download this JSON representation by clicking on Download Compiled Schema
. This is needed in the client SDKs.
| When defining custom scalars on your schema it is important to assert that the data types match the expected type. This is important as custom Scalar definitions could potentially lead to security vulnerabilities such as SQL Injection. |
Structure View
After saving a schema the structure view on the right side of the Schema
tab will be updated. If your schema contains errors you will see the error message there.
Otherwise you will see a list of all your types, queries, mutations and subscriptions. This view is read only and can be used to quickly browse a schema.
Playground
A playground is provided which allows you to test your changes to the schema. To use the playground, navigate to the tab in the UI and then write any queries or mutations you wish. Some useful features of the playground include code completion, query variables and full http header support. For more information about the playground and what is possible please visit Prisma Playground.
Adding Resolvers to a Schema
A schema describes the structure of your data and the operations to query or mutate that data.
When a query is executed, GraphQL runs the attached Resolver
. Resolvers implement the actual
operations on the data and can be attached to Queries, Mutations and Properties of custom types.
| to learn more about resolvers and their role in GraphQL have a look at the official documentation. |
Defining Resolvers
Resolvers are defined in the Resolvers
tab of the UI. If you have a valid schema you can see its
structure on the left side and the resolver details on the right side.
Structure View
The structure view is different from the one in the schema tab in that it is grouped
by Queries
, Mutations
, Subscriptions
and Custom Types
. All entries can be expanded to see their
arguments (queries and mutations) or fields (custom types). The lines in the view have three columns:
-
Name: The name of the Query/Mutation/Custom Type
-
Argument count: The number of fields / arguments
-
Resolver: Shows the name of the Resolver’s data source when one is assigned. Otherwise shows
No resolver
. Click here to start editing the resolver details.
Resolvers can only be attached directly to Queries and Mutations and not their arguments. For Custom Types the opposite is true: you usually want to assign resolvers to more complex properties, for example the comments field in the Note type of the above example.
|
Resolver Details
Here you can add the details of a resolver. The following fields must be provided:
-
Data Source: The data source this resolver gets executed against.
-
Request Mapping Template: The query that is executed to retrieve a result.
Mutations
in GraphQL are required to return a result too. NOTE: Have a look at mapping templates to learn how to make use of thecontext
object in your queries.
The following fields are optional:
-
Response Mapping Template: Allows you to transform the result before passing it to the caller. For example you could convert a string response to JSON, or parse a XML response.
-
Pre Hook: A WebHook that is called before running the
Request Mapping
. -
Post Hook: A WebHook that is called if the
Request Mapping
was run successfully.
| The Drop-Down buttons above the Request and Response Mappings fields allow you to pick one of the pre-defined templates of your data source. |
Request Mapping Templates
To write meaningful queries you need access to the arguments passed to the resolver by the client.
This is achieved by making use of the context
object. Request and response mappings are evaluated in the Data Sync backend and you can use Handlebars templates to inject values from the context object.
The structure of the context object is the following:
context: {
arguments, // The arguments passed to the resolver
parent // Parent object reference
}
For example, a request mapping to retrieve all the comments for a particular Note
could look like this:
select * from Comments where NoteId = '{{ context.parent.id }}'
Response Mapping Templates
Use a response mapping to transform a result or extract certain properties from the result. As with request mappers, response mapper have access to a context
object with the following format:
context: {
result // The result returned from the query or mutation
}
Handlebars helpers can be applied to the result. Currently the following helpers are available:
-
toJSON: Parses a string and returns the result as JSON.
-
toBoolean: Parses a string and returns the result as either
true
orfalse
. -
convertNeDBIds: Changes all id fields in the input object from
_id
toid
, the latter being a more common name for a GraphQL property.
An example response mapper for an in memory result could look like this:
{{ toJSON (convertNeDBIds context.result) }}
Adding Subscriptions to a Schema
GraphQL subscriptions allow you to be notified in realtime of changes to your data.
Subscriptions
are defined in the Schema as their own type, just like with Query
and Mutation
:
type Query {
notes: [Note]
}
type Mutation {
addNote(text: String!)
}
type Subscription {
noteAdded: Note
}
Learn more about Subscriptions and other operation types at GraphQL documentation
Using the Data Sync SDK
This section will help you to set up the Data Sync service SDK in your App.
Importing the libraries
Add apollo-gradle-plugin
dependency to your project’s build.gradle
file:
buildscript {
repositories {
...
}
dependencies {
classpath 'com.apollographql.apollo:apollo-gradle-plugin:0.5.0'
}
}
Apply the plugin in your app module’s build.gradle
file:
apply plugin: 'com.android.application'
apply plugin: 'com.apollographql.android'
Add android-sync
dependency to your app module’s build.gradle
file:
implementation "org.aerogear:android-sync:2.1.0-alpha.1"
-
Add the dependency to your Podfile:
target '[TARGET NAME]' do pod 'AGSSync' end
-
Update the dependencies:
$ pod install
Setting Up the Sync Mobile Service
The Sync SDK is using the Apollo GraphQL Client behind of the scenes to handle GraphQL.
Apollo client requires some configuration to work.
-
Download Compiled GraphQL Schema from Data Sync UI
-
Create a special folder
graphql
inside ofsrc/main
-
Create a file
schema.json
with your Compiled GraphQL Schema -
Create a file with a name that corresponds to your business objects and a
.graphql
extension -
Add all your queries/mutations/subscriptions to the
.graphql
file. Apollo will generate the appropriate Java classes with nested classes for reading from the network response.
For example if you create a file graphql/com/example/somefile.graphql
with the content bellow:
query myNotes {
allNotes() {
id,
text
}
}
mutation createNote(text: String!) {
createNote($text: String!) {
id
text
}
}
subscription noteAdded {
noteAdded {
id
note
}
}
Apollo will automatically create a file MyNotesQuery
, CreateNoteMutation
and NoteAddedSubscription
(in compile time) in the package com.example
for you.
-
Download Compiled GraphQL Schema from Data Sync UI.
-
Create a file
schema.json
with your Compiled GraphQL Schema. -
Create a file with a name that corresponds to your business objects and a
.graphql
extension. -
Add all your queries/mutations/subscriptions to the
.graphql
file. -
Add a code generation build step to your target.
-
Drag the generated API.swift file to your target.
During a build Appolo will generate appropriate classes in API.swift file for reading from the network response.
For example if you create a file somefile.graphql
with the content bellow:
query myNotes {
allNotes() {
id,
text
}
}
mutation createNote(text: String!) {
createNote($text: String!) {
id
text
}
}
subscription noteAdded {
noteAdded {
id
note
}
}
Apollo will automatically create a file called API.swift with classes MyNotesQuery
, CreateNoteMutation
and NoteAddedSubscription
(in build time) for you.
Using the Sync Mobile Service
Use the AeroGear SDK sync library to provision a configured instance of the sync client (SyncClient):
Query
Use the query
method from SyncClient:
SyncClient
.getInstance()
.query(MyNotesQuery.builder().build())
.execute(MyNotesQuery.Data.class)
.respondWith(new Responder<Response<MyNotesQuery.Data>>() {
@Override
public void onResult(Response<MyNotesQuery.Data> value) {
// Do some magic with the response.
}
@Override
public void onException(Exception exception) {
/// Oops! Something went wrong.
}
});
The MyNotesQuery class is generated from the example schema above
|
Use the fetch
method from Apollo client to fire a query:
AgsSync.instance.client?.fetch(query: MyNotesQuery()) { result, error in
if let error = error {
// Oops! Something went wrong.
} else {
// Do some magic with the response.
}
}
The MyNotesQuery class is generated from the example schema above
|
Check the Apollo GraphQL Client for iOS for a complete list of options.
Mutation
Use the mutate
method from SyncClient:
SyncClient
.getInstance()
.mutation(CreateNoteMutation.builder().text("The note text").build())
.execute(CreateNoteMutation.Data.class)
.respondWith(new Responder<Response<TestMutMutation.Data>>() {
@Override
public void onResult(Response<TestMutMutation.Data> value) {
// Do some magic with the response.
}
@Override
public void onException(Exception exception) {
// Oops! Something went wrong.
}
});
The CreateNoteMutation class is generated from the example schema above
|
Use the perform
method from Apollo client to fire a mutation:
AgsSync.instance.client?.perform(mutation: CreateNoteMutation(text: "The note text")) { result, error in
if let error = error {
// Oops! Something went wrong.
} else {
// Do some magic with the response.
}
}
The CreateNoteMutation class is generated from the example schema above
|
Check the Apollo GraphQL Client for iOS for a complete list of options.
Subscription
Use the subscribe
method from SyncClient:
SyncClient
.getInstance()
.subscribe(new NoteAddedSubscription())
.execute(NoteAddedSubscription.Data.class)
.respondWith(new Responder<Response<NoteAddedSubscription.Data>>() {
@Override
public void onResult(Response<NoteAddedSubscription.Data> response) {
// Do some magic with the response.
}
@Override
public void onException(Exception exception) {
// Oops! Something went wrong.
}
});
The NoteAddedSubscription class is generated from the example schema above
|
AgsSync.instance.client?.subscribe(subscription: NoteAddedSubscription()) { result, error in
if let error = error {
// Oops! Something went wrong.
} else {
// Do some magic with the response.
}
}
The NoteAddedSubscription class is generated from the example schema above
|
Check the Apollo GraphQL Client for iOS for a complete list of options.
Monitoring Data Sync Service
Prerequisites
-
You have provisioned the Mobile Metrics service.
-
You have provisioned the Data Sync service.
| The Mobile Metrics Service and Data Sync Service must be provisioned in the same OpenShift project to access data. |
Overview
After the Mobile Metrics Service (includes Grafana for visualization and the Prometheus monitoring system) and Data Sync Service are provisioned, you should be able to see the "Data Sync Metrics" in the list of available dashboards (navigate to Grafana’s exposed URL → Log in → Home → Select Data Sync Metrics).
Dashboard panel descriptions
The Data Sync dashboard consists of several panels which give you an overview of the specific events and resources, such as memory usage, CPU usage, resolved operation count etc.
Below you will find a detailed description of each panel and its values.
Singlestat Panels
Singlestat panels show you the main summary of a single data series.
-
CPU Usage: CPU usage percentage of Data Sync Service used currently.
-
Memory Usage: The amount of memory currently used by the Data Sync Service
Graph panels
Used to show how certain values change over time, e.g. the number of operations resolved.
-
Memory Usage in Time: The amount of memory used by the Data Sync Service over time
-
CPU Usage in Time: The percentage of CPU used by the Data Sync Service over time
-
Queries/Mutations Resolved: Overview of the resolved queries and mutations over time
-
Resolver Timings: Overview of the how long it took to resolve operations over time.
Authentication for Data Sync
By default, Data Sync does not provide any authentication and authorization mechanism. Users can configure Data Sync to work with Identity Management to provide authentication and authorization for their applications.
Prerequisites
-
Make sure the Data Sync service is provisioned.
-
Make sure the Identity Management service is provisioned.
-
Create an app that works with the Identity Management service.
Binding the Data Sync service to an Identity Management Instance
To benefit from authentication, developers need to connect (bind) Data Sync into Identity Management Instance.
Creating the binding secret from a Keycloak Instance
-
Navigate to your Openshift project
-
Select Applications and then Provisioned Services
-
Copy the Instance Name field from the Data Sync service
-
Select the Identity Management service from the list of Provisioned Services
-
Select the Create Binding option
-
Enter the copied Instance Name of the provisioned Data Sync service
A secret will be created as a result of this binding.
Making the Secret available to the Data Sync
-
Select View Secret on the Identity Management details page
-
Select Add to Application and select the data-sync-server from the options
-
Select the Volume option and enter the following mount path:
/opt/keycloak
The mount path must be set to /opt/keycloak for the Data Sync to be configured to use the secret.
|
Making Secret available to application
By default, the secret is not visible to the server application. To point the server to the application, please add a new environment variable:
KEYCLOAK_CONFIG_FILE=/opt/keycloak/config
| When working with OpenShift with self-signed certificate, add NODE_TLS_REJECT_UNAUTHORIZED=0 environment variable to deployment config of data-sync-server, otherwise the Keycloak-protected Data Sync won’t work - the playground will be unavailable. |
Role Based Authorization in Data Sync
Prerequisites
Role based authorization can be applied to Queries, Mutations, Subscriptions and individual fields in a GraphQL schema, when Data Sync is used with Keycloak. This means it is possible to restrict individual fields and/or operations defined in the GraphQL schema to users with specific roles in Keycloak.
Take a publishing platform as an example. Role Based Authorization could be used to ensure only users with the role editor
can perform the editPublication
mutation.
Data Sync currently supports authorization using client roles and realm roles defined in keycloak. Consult the Keycloak documentation to learn how to create roles.
The @hasRole Directive
Role based authorization can be defined using the @hasRole
directive. The @hasRole
directive is a special annotation that can be applied to
-
Fields
-
Queries
-
Mutations
-
Subscriptions
The @hasRole
usage is as follows:
-
@hasRole(role: String)
-
Example -
@hasRole(role: "admin"])
-
If the authenticated user has the role
admin
they will be authorized. -
@hasRole(role: [String])
-
Example -
@hasRole(role: ["admin", "editor"])
-
If the authenticated user has at least one of the roles in the list, they will be authorized.
The default behaviour is to check client roles. For example, @hasRole(role: "admin"])
will check that user has a client role called admin
. @hasRole(role: "realm:admin"])
will check if that user has a realm role called admin
The syntax for checking a realm role is @hasRole(role: "realm:<role>")
. For example, @hasRole(role: "realm:admin")
. Using a list of roles, it is possible to check for both client and realm roles at the same time.
Example: Using the @hasRole Directive to Apply Role Based Authorization on a Schema
The following example demonstrates how the @hasRole
directive can be used to define role based authorization on various parts of a GraphQL schema. This example schema represents publishing application like a news or blog website.
type Post { id: ID! title: String! author: Author! content: String! createdAt: Int! } type Author { id: ID! name: String! posts: [Post]! address: String! @hasRole(role: "admin") age: Int! @hasRole(role: "admin") } type Query { allPosts:[Post]! getAuthor(id: ID!):Author! } type Mutation { editPost:[Post]! @hasRole(role: ["editor", "admin"]) deletePost(id: ID!):[Post] @hasRole(role: "admin") }
There are two types:
-
Post
- This might be an article or a blog post -
Author
- This would represent the person that authored a Post
There are two Queries:
-
allPosts
- This might return a list of posts -
getAuthor
- This would return details about an Author
There are two Mutations:
-
editPost
- This would edit an existing post -
deletePost
- This would delete a post.
Role Based Authorization on Queries and Mutations
In the example schema, the @hasRole
directive has been applied to the editPost
and deletePost
mutations. The same could be done on Queries.
-
Only users with the roles
editor
and/oradmin
are allowed to perform theeditPost
mutation. -
Only users with the role
admin
are allowed to perform thedeletePost
mutation.
This example shows how the @hasRole
directive can be used on various queries and mutations.
Role Based Authorization on Fields
In the example schema, the Author
type has the fields address
and age
which both have hasRole(role: "admin")
applied.
This means that users without the role admin
are not authorized to request these fields in any query or mutation.
For example, non admin users are allowed to run the getAuthor
query, but they cannot request back the address
or age
fields.


Battle Switch
Server is not responding!
Please set the following ships:
Start Game
Game is over.
Restart Game


Game
Settings
Catchphrases
Catchphrase
Press play below when you're ready.
Reset
Play
0.00 seconds
Next
Skip


---
layout: default
---
{% include banner.html title='2019 Festival' subtitle='in retrospective' color='red' %}
{% include quote.html
content="In 2019 we held the first ever Montgomery International Film Festival
in beautiful Gaithersburg, Maryland.
Here are some of the highlights from the festival!"
%}
{% include summary_row.html
image='./img/films.png'
title='Films'
content="In our inaugural year we welcomed film-makers from over a dozen countries,
with a diverse set of projects. We've collected some of our favorite films from
last year here.
See 2019 Films"
%}
{% include summary_row.html
reverse=true
image='./img/panelists.png'
title='Guests and Panelists'
content="The Montgomery International Film Festival hosted some
amazing jury members, panelists, and honorary guests for our inaugural year.
Check out some of our amazing guests here.
See 2019 Honorary Guests and Panelists"
%}
{% include summary_row.html
image='./img/gallery.png'
title='Gallery'
content="See photos from last year's celebration. Hope to see everyone again in 2020!
Go to MIFF 2019 Gallery"
%}
{% capture submissions_blurb %}
Submit your film for consideration here
{% endcapture %}
{% include banner.html
title='Interested in screening at the 2023 Festival?'
subtitle=submissions_blurb
%}


JComponent
class.
For example,
JPanel
,
JScrollPane
,
JButton
, and
JTable
all inherit from JComponent
.
However, JFrame
and JDialog
don't
because they implement top-level containers.
The JComponent
class
extends the
Container
class,
which itself extends
Component
.
The Component
class includes everything from
providing layout hints
to supporting painting and events.
The Container
class has support
for adding components to the container and
laying them out.
This section's
API tables summarize the most often used
methods of Component
and Container
,
as well as of JComponent
.
JComponent Features
The JComponent
class provides
the following functionality to its descendants:
setToolTipText
method,
you can provide help to users of a component.
When the cursor pauses over the component,
the specified string is displayed in a small window
that appears near the component.
See How to Use Tool Tips
for more information.
setBorder
method allows you
to specify the border
that a component displays around its edges.
To paint the inside of a component,
override the paintComponent
method.
See
How to Use Borders and
Performing Custom Painting for details.
JComponent
object
has a corresponding ComponentUI
object
that performs all the drawing, event handling, size determination,
and so on for that JComponent
.
Exactly which ComponentUI
object is used
depends on the current look and feel,
which you can set using the UIManager.setLookAndFeel
method. See
How to Set the Look and Feel for details.
JComponent
.
For example,
a layout manager might use properties
to associate a constraints object
with each JComponent
it manages.
You put and get properties using the
putClientProperty
and
getClientProperty
methods.
For general information about properties, see
Properties.
Component
class
provides layout hint methods such as
getPreferredSize
and getAlignmentX
,
it doesn't provide any way to set these layout hints,
short of creating a subclass and overriding the methods.
To give you another way to set layout hints,
the JComponent
class adds
setter methods —
setMinimumSize
,
setMaximumSize
,
setAlignmentX
, and
setAlignmentY
.
See
Laying Out Components Within a Container for more information.
JComponent
class provides
API and basic functionality
to help assistive technologies
such as screen readers
get information from Swing components,
For more information about accessibility, see
How to Support Assistive Technologies.
JComponent
class provides API
to set a component's transfer handler,
which is the basis for Swing's
drag and drop support.
See
Introduction to DnD for details.
The JComponent API
The JComponent
class provides many new methods
and inherits many methods
from Component
and Container
.
The following tables summarize the methods
we use the most.
| Method | Purpose |
|---|---|
|
void setBorder(Border) Border getBorder() |
Set or get the border of the component. See How to Use Borders for details. |
|
void setForeground(Color) void setBackground(Color) | Set the foreground or background color for the component. The foreground is generally the color used to draw the text in a component. The background is (not surprisingly) the color of the background areas of the component, assuming that the component is opaque. |
|
Color getForeground() Color getBackground() | Get the foreground or background color for the component. |
|
void setOpaque(boolean) boolean isOpaque() |
Set or get whether the component is opaque. An opaque component fills its background with its background color. |
|
void setFont(Font) Font getFont() | Set or get the component's font. If a font has not been set for the component, the font of its parent is returned. |
|
void setCursor(Cursor) Cursor getCursor() |
Set or get the cursor displayed over the component
and all components it contains
(except for children that have their own cursor set).
Example:
aPanel.setCursor( Cursor.getPredefinedCursor( Cursor.WAIT_CURSOR));
|
| Method | Purpose |
|---|---|
| void setComponentPopupMenu(JPopupMenu) |
Sets the JPopupMenu for this JComponent . The UI is responsible for registering bindings and adding the necessary listeners such that the JPopupMenu will be shown at the appropriate time. When the JPopupMenu is shown depends upon the look and feel: some may show it on a mouse event, some may enable a key binding.If popup is null, and getInheritsPopupMenu returns true , then getComponentPopupMenu will be delegated to the parent. This provides for a way to make all child components inherit the popupmenu of the parent. |
|
void setTransferHandler(TransferHandler) TransferHandler getTransferHandler() |
Set or remove the transferHandler property.
The TransferHandler supports exchanging data
via cut, copy, or paste to/from a clipboard as well a
drag and drop. See
Introduction to DnD for more details.
|
| void setToolTipText(String) | Set the text to display in a tool tip. See How to Use Tool Tips for more information. |
|
void setName(String) String getName() | Set or get the name of the component. This can be useful when you need to associate text with a component that does not display text. |
| boolean isShowing() | Determine whether the component is showing on screen. This means that the component must be visible, and it must be in a container that is visible and showing. |
|
void setEnabled(boolean) boolean isEnabled() |
Set or get whether the component is enabled. An enabled component can respond to user input and generate events. |
|
void setVisible(boolean) boolean isVisible() |
Set or get whether the component is visible. Components are initially visible, with the exception of top-level components. |
| Method | Purpose |
|---|---|
|
void addHierarchyListener(hierarchyListener l) void removeHierarchyListener(hierarchyListener l) |
Adds or removes the specified hierarchy listener to receive hierarchy changed events from this component when the hierarchy to which this container belongs changes. If listener l is null, no exception is thrown and no action is performed. |
|
void addMouseListener(MouseListener) void removeMouseListener(MouseListener) |
Add or remove a mouse listener to or from the component. Mouse listeners are notified when the user uses the mouse to interact with the listened-to component. |
|
void addMouseMotionListener(MouseMotionListener) void removeMouseMotionListener(MouseMotionListener) |
Add or remove a mouse motion listener to or from the component. Mouse motion listeners are notified when the user moves the mouse within the listened-to component's bounds. |
|
void addKeyListener(KeyListener) void removeKeyListener(KeyListener) | Add or remove a key listener to or from the component. Key listeners are notified when the user types at the keyboard and the listened-to component has the keyboard focus. |
|
void addComponentListener(ComponentListener) void removeComponentListener(ComponentListener) | Add or remove a component listener to or from the component. Component listeners are notified when the listened-to component is hidden, shown, moved, or resized. |
|
boolean contains(int, int) boolean contains(Point) |
Determine whether the specified point is within the component.
The argument should be specified
in terms of the component's coordinate system.
The two int arguments specify x and y coordinates,
respectively. |
|
Component getComponentAt(int, int) Component getComponentAt(Point) |
Return the component that contains the specified x, y position.
The top-most child component is returned
in the case where components overlap.
This is determined by finding the component closest to the index 0
that claims to contain the given point via
Component.contains() . |
|
Component setComponentZOrder(component comp, int index) |
Moves the specified component to the specified z-order index in the container. If the component is a child of some other container, it is removed from that container before being added to this container. The important difference between this method and java.awt.Container.add(Component, int) is that this method doesn't call removeNotify on the component while removing it from its previous container unless necessary and when allowed by the underlying native windowing system. This way, if the component has the keyboard focus, it maintains the focus when moved to the new position.Note: The z-order determines the order that components are painted. The component with the highest z-order paints first and the component with the lowest z-order paints last. Where components overlap, the component with the lower z-order paints over the component with the higher z-order. |
|
Component getComponentZOrder(component comp) |
Returns the z-order index of the component inside the container. The higher a component is in the z-order hierarchy, the lower its index. The component with the lowest z-order index is painted last, above all other child components. |
| Method | Purpose |
|---|---|
|
void repaint() void repaint(int, int, int, int) |
Request that all or part of the component be repainted.
The four int arguments specify
the bounds (x, y, width, height, in that order)
of the rectangle to be painted.
|
| void repaint(Rectangle) | Request that the specified area within the component be repainted. |
| void revalidate() |
Request that the component and its affected containers
be laid out again.
You should not generally need to invoke this method
unless you explicitly change a component's size/alignment hints
after it's visible
or
change a containment hierarchy after it is visible.
Always invoke repaint
after revalidate .
|
| void paintComponent(Graphics) | Paint the component. Override this method to implement painting for custom components. |
| Method | Purpose |
|---|---|
|
Component add(Component) Component add(Component, int) void add(Component, Object) |
Add the specified component to this container.
The one-argument version of this method adds
the component to the end of the container.
When present, the int argument indicates the
new component's position within the container.
When present, the Object argument
provides layout constraints to the current layout manager. |
|
void remove(int) void remove(Component) void removeAll() |
Remove one of or all of the components from this container.
When present, the int argument indicates the
position within the container of the component to remove.
|
| JRootPane getRootPane() | Get the root pane that contains the component. |
| Container getTopLevelAncestor() |
Get the topmost container for the component —
a Window , Applet , or null
if the component has not been added to any container. |
| Container getParent() | Get the component's immediate container. |
| int getComponentCount() | Get the number of components in this container. |
|
Component getComponent(int) Component[] getComponents() |
Get the one of or all of the components in this container.
The int argument indicates
the position of the component to get.
|
|
Component getComponentZOrder(int) Component[] getComponentZOrder() |
Returns the z-order index of the component inside the container. The higher a component is in the z-order hierarchy, the lower its index. The component with the lowest z-order index is painted last, above all other child components. |
| Method | Purpose |
|---|---|
|
void setPreferredSize(Dimension) void setMaximumSize(Dimension) void setMinimumSize(Dimension) |
Set the component's preferred, maximum, or minimum size, measured in pixels. The preferred size indicates the best size for the component. The component should be no larger than its maximum size and no smaller than its minimum size. Be aware that these are hints only and might be ignored by certain layout managers. |
|
Dimension getPreferredSize() Dimension getMaximumSize() Dimension getMinimumSize() |
Get the preferred, maximum, or minimum size of the component,
measured in pixels. Many JComponent classes have setter and getter methods.
For those non-JComponent subclasses,
which do not have the corresponding setter methods,
you can set a component's preferred, maximum, or minimum size
by creating a subclass and overriding these methods.
|
|
void setAlignmentX(float) void setAlignmentY(float) |
Set the alignment along the x- or y- axis. These values indicate how the component would like to be aligned relative to other components. The value should be a number between 0 and 1 where 0 represents alignment along the origin, 1 is aligned the furthest away from the origin, and 0.5 is centered, and so on. Be aware that these are hints only and might be ignored by certain layout managers. |
|
float getAlignmentX() float getAlignmentY() |
Get the alignment of the component along the
x- or
y- axis.
For non-JComponent subclasses,
which do not have the corresponding setter methods,
you can set a component's alignment
by creating a subclass and overriding these methods.
|
|
void setLayout(LayoutManager) LayoutManager getLayout() |
Set or get the component's layout manager. The layout manager is responsible for sizing and positioning the components within a container. |
| void applyComponentOrientation(ComponentOrientation) void setComponentOrientation(ComponentOrientation) | Set the ComponentOrientation property of this container
and all the components contained within it.
See
Setting the Container's Orientation for more information.
|
| Method | Purpose |
|---|---|
|
int getWidth() int getHeight() |
Get the current width or height of the component measured in pixels. |
|
Dimension getSize() Dimension getSize(Dimension) |
Get the component's current size measured in pixels.
When using the one-argument version of this method,
the caller is responsible for creating the Dimension
instance in which the result is returned.
|
|
int getX() int getY() |
Get the current x or y coordinate of the component's origin relative to the parent's upper left corner measured in pixels. |
|
Rectangle getBounds() Rectangle getBounds(Rectangle) |
Get the bounds of the component measured in pixels.
The bounds specify the component's width, height,
and origin relative to its parent.
When using the one-argument version of this method,
the caller is responsible for creating the Rectangle
instance in which the result is returned. |
|
Point getLocation() Point getLocation(Point) |
Gets the current location of the component
relative to the parent's upper left corner
measured in pixels.
When using the one-argument version of getLocation method,
the caller is responsible for creating the Point
instance in which the result is returned.
|
| Point getLocationOnScreen() | Returns the position relative to the upper left corner of the screen. |
| Insets getInsets() | Get the size of the component's border. |
| Method | Purpose |
|---|---|
|
void setLocation(int, int) void setLocation(Point) |
Set the location of the component, in pixels,
relative to the parent's upper left corner.
The two int arguments specify x and y,
in that order.
Use these methods to position a component
when you are not using a layout manager. |
|
void setSize(int, int) void setSize(Dimension) |
Set the size of the component measured in pixels.
The two int arguments specify width and height,
in that order.
Use these methods to size a component
when you are not using a layout manager. |
|
void setBounds(int, int, int, int) void setBounds(Rectangle) |
Set the size and location
relative to the parent's upper left corner,
in pixels,
of the component.
The four int arguments specify x, y, width, and height,
in that order.
Use these methods to position and size a component
when you are not using a layout manager. |


GROSSE POINTE BLANK A film review by Michael Redman Copyright 1997 Michael Redman
*** (out of ****)
Heading to his 10-year high school reunion, Martin Blank (John Cusack) is having something of an early mid-life career crisis. It seems that his chosen profession of hitman-for-hire just isn't as emotionally rewarding as he would like for it to be. He's even seeing therapist Dr. Oatman (Alan Arkin) who's so afraid of him that the sessions are monologues.
At the urging of his office manager Marcella (sister Joan Cusack) and Oatman, Blank decides to attend the reunion and patch things up with his high-school sweetheart that he stood up for the prom just before he disappeared from sight for a decade. Conveniently he also has a hit scheduled nearby.
 He does find his ex though. Suspicious Debi (Minnie Driver) appropriately keeps him at arm's length as she perfects her "Don't! Stop! Don't! Stop! Don't stop! Don't stop!" routine. Odd chemistry that works well on occasion.
To further complicate matters there are several uninvited guests in town. Rival assassin Grocer (Dan Aykroyd) is attempting to start a hitman union and Blank doesn't want to join. Grocer decides to exterminate the scab in the time-honored tradition of the vocation. Another killer is hanging out to eliminate Blank. Two G-Men are trailing our hero waiting for him to strike. It's a crowded little rich suburb.
The film milks the most out of every situation. High school reunions are inherently ripe with comedic possibilities. People who knew each other for a few years as kids and haven't been in touch for years are desperate to impress. As everyone else is bragging about their adult careers, Blank is upfront about his and receives remarkably blase' responses: "Good for you. Growth industry."
The dialog is thickly layered. You have to pay attention to catch everything that is going on as often more than one character is talking at the same time. When that's not happening, the retorts come fast and furious. Much of the subtle humor is easy to miss if you're careless.
Despite the commercials promising a light romantic comedy, there's a very dark tint to the story.  Grocer and Blank shoot at each other with a gun in each hand in a scene (unfortunately, more than one) straight out of a Clint Eastwood western while blasting away others. The extreme violence goes hand in hand with the extreme wit.
Although the humor is of the highest level, the movie doesn't provoke much psychological involvement. Even with her standoffishness, there isn't much guesswork involved in figuring out if Martin and Debi will get together. Will Blank survive? You can probably figure it out. Cusack is a tad too cool for me to care much about him.
But it doesn't matter very much. The comedy is king here and the characters secondary. Check it out. Watch and listen closely and you'll be entertained. And that's what you're going to this film for.
[This appeared in the 4/17/97 "Bloomington Voice", Bloomington, Indiana. Michael Redman can be reached at<EMAIL_ADDRESS>]
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


in touchscreen,the controls will be,tap once in the direction you want to go in.tap and drag to use selected item (blocks,weapons,etc.) tap the cube/ball to consume something.(health packs,potions,etc.) if you have auto-consume on, it will automatically consume it if you save it,you will have to do it manually. if you put it in the emergency pack,it will compress it into one emergency pack. use it in emergencies and all the stuff you have compressed in will be consumed, all at the same time.
| control | action | skin |
|---|---|---|
| W or foward arrow key | move foward | all |
| A or left arrow key | move left | all |
| D or right arrow key | move right | all |
| S or back arrow key | move backwards | all |
| E | open emergency pack | all |
| ESC | pause the game (press again to resume) | all |
| F | open equipping set(press again to close) | all |
| M | open map (press again to close) | all(it will only show what you've seen) |
| left click | use the selected item |


Creativity is the act of turning new and imaginative ideas into reality. Creativity is characterised by the ability to perceive the world in new ways, to find hidden patterns, to make connections between seemingly unrelated phenomena, and to generate solutions. Creativity involves two processes: thinking, then producing. Every project we make for our clients is an individual attempt to meet the requirements with maintaining the highest quality of the product. we hate mediocrity and boredom. Ourself development is our main goal. this is yhe main reason that we always tyr to do our best for the production of a product. We thinkm that creativity is only the thing through which we can create new designs,everything which is expected by our clients from us.
We often hear the word Passion, but have never thought or tried to understand in depth about it. We all have an inner liking to certain kind of art or act, that really drives us crazy and we love doing it. We never get tired or bored while being in such kind of act.Painting and drawing is an art and I have developed it over the years by attending various drawing and painting classes and participating in competitions. We love what we do. every project is made with passion and engagement. Our work profits so we can make our dreams come true and find even more inspiration from our future work. Even when we are not working we still think about new solutions,ideas and improvements that we can adopt so that our work could be more effective to our clients and others. So that we can get more and more projects in the future.
A teamwork environment promotes an atmosphere that fosters friendship and loyalty. These close-knit relationships motivate employees in parallel and align them to work harder, cooperate and be supportive of one another. Individuals possess diverse talents, weaknesses, communication skills, strengths, and habits. Teamwork is the collaborative effort of a team to achieve a common goal or to complete a task in the most effective and efficient way. This concept is seen within the greater framework of a team, which is a group of interdependent individuals who work together towards a common goal. During the years of working together we have excuted our own methodology which fits everyone of Prime Union Team. we always work together for every project detail never individually.We are real team.


My name is Anton Thomanek and I began programming in March of 2017. I have so far enjoyed the process of creating new applications. I am looking forward to seeing what else I am able to accomplish once I have learned HTML, CSS, JavaScript, Git, and Ruby.
I enjoy writing front-end code with HTML and CSS
Contact me through email


A tiny, fast JavaScript parser, written completely in JavaScript.
Acorn is open source software released under an MIT license.
You are welcome to report bugs or create pull requests on github. For questions and discussion, please use the Tern discussion forum.
The easiest way to install acorn is with npm
.
npm install acorn
Alternately, you can download the source and build acorn yourself:
git clone https://github.com/acornjs/acorn.git
cd acorn
npm install
npm run build
When run in a CommonJS (node.js) or AMD environment, exported values
appear in the interfaces exposed by the individual files, as usual.
When loaded in the browser (Acorn works in any JS-enabled browser more
recent than IE5) without any kind of module management, a single
global object acorn
will be defined, and all the exported properties
will be added to that.
This is implemented in dist/acorn.js
, and is what you get when you
require("acorn")
in node.js.
parse(input, options)
is used to parse a JavaScript program.
The input
parameter is a string, options
can be undefined or an
object setting some of the options listed below. The return value will
be an abstract syntax tree object as specified by the
ESTree spec.
When encountering a syntax error, the parser will raise a
SyntaxError
object with a meaningful message. The error object will
have a pos
property that indicates the character offset at which the
error occurred, and a loc
object that contains a {line, column}
object referring to that same position.
ecmaVersion: Indicates the ECMAScript version to parse. Must be either 3, 5, 6 (2015), 7 (2016), 8 (2017), 9 (2018) or 10 (2019, partial support). This influences support for strict mode, the set of reserved words, and support for new syntax features. Default is 7.
NOTE: Only 'stage 4' (finalized) ECMAScript features are being implemented by Acorn.
sourceType: Indicate the mode the code should be parsed in. Can be
either "script"
or "module"
. This influences global strict mode
and parsing of import
and export
declarations.
onInsertedSemicolon: If given a callback, that callback will be
called whenever a missing semicolon is inserted by the parser. The
callback will be given the character offset of the point where the
semicolon is inserted as argument, and if locations
is on, also a
{line, column}
object representing this position.
onTrailingComma: Like onInsertedSemicolon
, but for trailing
commas.
allowReserved: If false
, using a reserved word will generate
an error. Defaults to true
for ecmaVersion
3, false
for higher
versions. When given the value "never"
, reserved words and
keywords can also not be used as property names (as in Internet
Explorer's old parser).
allowReturnOutsideFunction: By default, a return statement at
the top level raises an error. Set this to true
to accept such
code.
allowImportExportEverywhere: By default, import
and export
declarations can only appear at a program's top level. Setting this
option to true
allows them anywhere where a statement is allowed.
allowAwaitOutsideFunction: By default, await
expressions can only appear inside async
functions. Setting this option to true
allows to have top-level await
expressions. They are still not allowed in non-async
functions, though.
allowHashBang: When this is enabled (off by default), if the
code starts with the characters #!
(as in a shellscript), the
first line will be treated as a comment.
locations: When true
, each node has a loc
object attached
with start
and end
subobjects, each of which contains the
one-based line and zero-based column numbers in {line, column}
form. Default is false
.
onToken: If a function is passed for this option, each found
token will be passed in same format as tokens returned from
tokenizer().getToken()
.
If array is passed, each found token is pushed to it.
Note that you are not allowed to call the parser from the callback—that will corrupt its internal state.
onComment: If a function is passed for this option, whenever a comment is encountered the function will be called with the following parameters:
block
: true
if the comment is a block comment, false if it
is a line comment.text
: The content of the comment.start
: Character offset of the start of the comment.end
: Character offset of the end of the comment.When the locations
options is on, the {line, column}
locations
of the comment’s start and end are passed as two additional
parameters.
If array is passed for this option, each found comment is pushed to it as object in Esprima format:
{
"type": "Line" | "Block",
"value": "comment text",
"start": Number,
"end": Number,
// If `locations` option is on:
"loc": {
"start": {line: Number, column: Number}
"end": {line: Number, column: Number}
},
// If `ranges` option is on:
"range": [Number, Number]
}
Note that you are not allowed to call the parser from the callback—that will corrupt its internal state.
ranges: Nodes have their start and end characters offsets
recorded in start
and end
properties (directly on the node,
rather than the loc
object, which holds line/column data. To also
add a semi-standardized range
property holding a
[start, end]
array with the same numbers, set the ranges
option
to true
.
program: It is possible to parse multiple files into a single
AST by passing the tree produced by parsing the first file as the
program
option in subsequent parses. This will add the toplevel
forms of the parsed file to the "Program" (top) node of an existing
parse tree.
sourceFile: When the locations
option is true
, you can pass
this option to add a source
attribute in every node’s loc
object. Note that the contents of this option are not examined or
processed in any way; you are free to use whatever format you
choose.
directSourceFile: Like sourceFile
, but a sourceFile
property
will be added (regardless of the location
option) directly to the
nodes, rather than the loc
object.
preserveParens: If this option is true
, parenthesized expressions
are represented by (non-standard) ParenthesizedExpression
nodes
that have a single expression
property containing the expression
inside parentheses.
parseExpressionAt(input, offset, options)
will parse a single
expression in a string, and return its AST. It will not complain if
there is more of the string left after the expression.
getLineInfo(input, offset)
can be used to get a {line,
column}
object for a given program string and character offset.
tokenizer(input, options)
returns an object with a getToken
method that can be called repeatedly to get the next token, a {start,
end, type, value}
object (with added loc
property when the
locations
option is enabled and range
property when the ranges
option is enabled). When the token's type is tokTypes.eof
, you
should stop calling the method, since it will keep returning that same
token forever.
In ES6 environment, returned result can be used as any other protocol-compliant iterable:
for (let token of acorn.tokenizer(str)) {
// iterate over the tokens
}
// transform code to array of tokens:
var tokens = [...acorn.tokenizer(str)];
tokTypes holds an object mapping names to the token type objects
that end up in the type
properties of tokens.
Escodegen supports generating comments from AST, attached in Esprima-specific format. In order to simulate same format in Acorn, consider following example:
var comments = [], tokens = [];
var ast = acorn.parse('var x = 42; // answer', {
// collect ranges for each node
ranges: true,
// collect comments in Esprima's format
onComment: comments,
// collect token ranges
onToken: tokens
});
// attach comments using collected information
escodegen.attachComments(ast, comments, tokens);
// generate code
console.log(escodegen.generate(ast, {comment: true}));
// > 'var x = 42; // answer'
This file implements an error-tolerant parser. It exposes a single
function. The loose parser is accessible in node.js via require("acorn/dist/acorn_loose")
.
parse_dammit(input, options)
takes the same arguments and
returns the same syntax tree as the parse
function in acorn.js
,
but never raises an error, and will do its best to parse syntactically
invalid code in as meaningful a way as it can. It'll insert identifier
nodes with name "✖"
as placeholders in places where it can't make
sense of the input. Depends on acorn.js
, because it uses the same
tokenizer.
Implements an abstract syntax tree walker. Will store its interface in
acorn.walk
when loaded without a module system.
simple(node, visitors, base, state)
does a 'simple' walk over
a tree. node
should be the AST node to walk, and visitors
an
object with properties whose names correspond to node types in the
ESTree spec. The properties should contain functions
that will be called with the node object and, if applicable the state
at that point. The last two arguments are optional. base
is a walker
algorithm, and state
is a start state. The default walker will
simply visit all statements and expressions and not produce a
meaningful state. (An example of a use of state is to track scope at
each point in the tree.)
const acorn = require("acorn")
const walk = require("acorn/dist/walk")
walk.simple(acorn.parse("let x = 10"), {
Literal(node) {
console.log(`Found a literal: ${node.value}`)
}
})
ancestor(node, visitors, base, state)
does a 'simple' walk over
a tree, building up an array of ancestor nodes (including the current node)
and passing the array to the callbacks as a third parameter.
const acorn = require("acorn")
const walk = require("acorn/dist/walk")
walk.ancestor(acorn.parse("foo('hi')"), {
Literal(_, ancestors) {
console.log("This literal's ancestors are:",
ancestors.map(n => n.type))
}
})
recursive(node, state, functions, base)
does a 'recursive'
walk, where the walker functions are responsible for continuing the
walk on the child nodes of their target node. state
is the start
state, and functions
should contain an object that maps node types
to walker functions. Such functions are called with (node, state, c)
arguments, and can cause the walk to continue on a sub-node by calling
the c
argument on it with (node, state)
arguments. The optional
base
argument provides the fallback walker functions for node types
that aren't handled in the functions
object. If not given, the
default walkers will be used.
make(functions, base)
builds a new walker object by using the
walker functions in functions
and filling in the missing ones by
taking defaults from base
.
full(node, callback, base, state)
does a 'full'
walk over a tree, calling the callback with the arguments (node, state, type)
for each node
fullAncestor(node, callback, base, state)
does a 'full' walk over
a tree, building up an array of ancestor nodes (including the current node)
and passing the array to the callbacks as a third parameter.
const acorn = require("acorn")
const walk = require("acorn/dist/walk")
walk.full(acorn.parse("1 + 1"), node => {
console.log(`There's a ${node.type} node at ${node.ch}`)
})
findNodeAt(node, start, end, test, base, state)
tries to
locate a node in a tree at the given start and/or end offsets, which
satisfies the predicate test
. start
and end
can be either null
(as wildcard) or a number. test
may be a string (indicating a node
type) or a function that takes (nodeType, node)
arguments and
returns a boolean indicating whether this node is interesting. base
and state
are optional, and can be used to specify a custom walker.
Nodes are tested from inner to outer, so if two nodes match the
boundaries, the inner one will be preferred.
findNodeAround(node, pos, test, base, state)
is a lot like
findNodeAt
, but will match any node that exists 'around' (spanning)
the given position.
findNodeAfter(node, pos, test, base, state)
is similar to
findNodeAround
, but will match all nodes after the given position
(testing outer nodes before inner nodes).
The bin/acorn
utility can be used to parse a file from the command
line. It accepts as arguments its input file and the following
options:
--ecma3|--ecma5|--ecma6|--ecma7|--ecma8|--ecma9|--ecma10
: Sets the ECMAScript version
to parse. Default is version 7.
--module
: Sets the parsing mode to "module"
. Is set to "script"
otherwise.
--locations
: Attaches a "loc" object to each node with "start" and
"end" subobjects, each of which contains the one-based line and
zero-based column numbers in {line, column}
form.
--allow-hash-bang
: If the code starts with the characters #! (as in a shellscript), the first line will be treated as a comment.
--compact
: No whitespace is used in the AST output.
--silent
: Do not output the AST, just return the exit status.
--help
: Print the usage information and quit.
The utility spits out the syntax tree as JSON data.
Acorn is written in ECMAScript 6, as a set of small modules, in the
project's src
directory, and compiled down to bigger ECMAScript 3
files in dist
using Browserify and
Babel. If you are already using Babel, you can
consider including the modules directly.
The command-line test runner (npm test
) uses the ES6 modules. The
browser-based test page (test/index.html
) uses the compiled modules.
The bin/build-acorn.js
script builds the latter from the former.
If you are working on Acorn, you'll probably want to try the code out directly, without an intermediate build step. In your scripts, you can register the Babel require shim like this:
require("babel-core/register")
That will allow you to directly require
the ES6 modules.
Acorn is designed support allow plugins which, within reasonable bounds, redefine the way the parser works. Plugins can add new token types and new tokenizer contexts (if necessary), and extend methods in the parser object. This is not a clean, elegant API—using it requires an understanding of Acorn's internals, and plugins are likely to break whenever those internals are significantly changed. But still, it is possible, in this way, to create parsers for JavaScript dialects without forking all of Acorn. And in principle it is even possible to combine such plugins, so that if you have, for example, a plugin for parsing types and a plugin for parsing JSX-style XML literals, you could load them both and parse code with both JSX tags and types.
A plugin should register itself by adding a property to
acorn.plugins
, which holds a function. Calling acorn.parse
, a
plugins
option can be passed, holding an object mapping plugin names
to configuration values (or just true
for plugins that don't take
options). After the parser object has been created, the initialization
functions for the chosen plugins are called with (parser,
configValue)
arguments. They are expected to use the parser.extend
method to extend parser methods. For example, the readToken
method
could be extended like this:
parser.extend("readToken", function(nextMethod) {
return function(code) {
console.log("Reading a token!")
return nextMethod.call(this, code)
}
})
The nextMethod
argument passed to extend
's second argument is the
previous value of this method, and should usually be called through to
whenever the extended method does not handle the call itself.
Similarly, the loose parser allows plugins to register themselves via
acorn.pluginsLoose
. The extension mechanism is the same as for the
normal parser:
looseParser.extend("readToken", function(nextMethod) {
return function() {
console.log("Reading a token in the loose parser!")
return nextMethod.call(this)
}
})
acorn-jsx
: Parse Facebook JSX syntax extensionsacorn-objj
: Objective-J language parser built as Acorn plugin
Plugins for ECMAScript proposals:
acorn-stage3
: Parse most stage 3 proposals, bundling:
acorn-async-iteration
: Parse async iteration proposalacorn-bigint
: Parse BigInt proposalacorn-class-fields
: Parse class fields proposalacorn-dynamic-import
: Parse import() proposalacorn-import-meta
: Parse import.meta proposalacorn-numeric-separator
: Parse numeric separator proposalacorn-optional-catch-binding
: Parse optional catch binding proposalacorn-private-methods
: parse private methods, getters and setters proposalacorn5-object-spread
: Parse Object Rest/Spread Properties proposalacorn-object-rest-spread
: Parse Object Rest/Spread Properties proposalacorn-es7
: Parse decorator syntax proposalacorn-static-class-property-initializer
: Partial support for static class properties from ES Class Fields & Static Properties Proposal to support static property initializers in React components written as ES6+ classes


This shows the Cayley for the dihedral group $D_8$, which is a Latin square. The group elements are called $r_i$ and $s_i$, and they satisfy \begin{align*} r_ir_j &= r_{i+j} & r_is_j &= s_{i+j} \\ s_ir_j &= s_{i-j} & s_is_j &= r_{i-j}. \end{align*}


Write a program that reads two integer numbers from the standard input and outputs them in the reverse order separated by one space.
[HINT]Do not forget to import Scanner before using it.
import java.util.Scanner;
[/HINT]


---
layout: post
title: Linux Shell Tips - rm exclude emulation
date: 2012-06-21 13:21:45 UTC
updated: 2012-06-21 13:21:45 UTC
comments: true
category: linux
tags: [linux, shell]
---
If you want to remove all files and sub-directories from directory exept some files you can use rm and find combination as described below: :
rm -rf $(find . ! -wholename './web/index.php' ! -wholename './web/.htaccess' ! -name '.' ! -name 'web')


The official cli tool for making financial markets analysis as fast as you are.
Pronounced “quote-tron” as a throwback to those awesome financial terminals of the 80’s. This project is intended as a living example of the capabilities of the finance-go library.
Commands
The current available commands are:
quote
- prints tables of quotes to the current shelloptions
- prints tables of options contract quotes to the current shellwrite
- writes tables of quotes/history to csv files
Installation
In order to use this awesome tool, you’ll need to get it on your machine!
From Homebrew
If you’re on macOS, the easiest way to get qtrn is through the homebrew tap.
brew tap piquette/qtrn
brew install qtrn
From Release
- Head over to the official releases page
- Determine the appropriate distribution for your operating system (mac | windows | linux)
- Download and untar the distribution. Shortcut for macs:
curl -sL https://github.com/piquette/qtrn/releases/download/v0.0.7/qtrn_0.0.7_darwin_amd64.tar.gz | tar zx
- Move the binary into your local
$PATH
. - Run
qtrn help
.
From Source
qtrn is built in Go. go get
the source repo, like this:
go get github.com/piquette/qtrn
If your $GOPATH
is configured, and git is setup to know your credentials, in a few moments the command should complete with no output. The repository will exist under $GOPATH/src/github.com/piquette
.
Usage
Run the command qtrn
in your shell for the list of possible commands.


{% extends 'base.html' %} {% load bootstrap4 %} {% load static %} {% block content %}
NEIGHBOURHOOD: {{neighbourhood.neighbourhood_name}}
{{neighbourhood.neighbourhood_location}}
Resident Population: {{ neighbourhood.population}}
{% endif %}{{business.neighbourhood_id}}
Contact Information:
{{ business.business_email_address}}


tree
Show the contents of the current directory as a tree.
More information: home page
- Print files and directories up to 'num' levels of depth (where 1 means the current directory):
tree -L num
- Print directories only:
tree -d
- Print hidden files too with colorization on:
tree -a -C
- Print the tree without indentation lines, showing the full path instead (use `-N` to not escape non-printable characters):
tree -i -f
- Print the size of each file and the cumulative size of each directory, in human-readable format:
tree -s -h --du
- Print files within the tree hierarchy, using a wildcard (glob) pattern, and pruning out directories that don't contain matching files:
tree -P '*.txt' --prune
- Print directories within the tree hierarchy, using the wildcard (glob) pattern, and pruning out directories that aren't ancestors of the wanted one:
tree -P directory_name --matchdirs --prune
- Print the tree ignoring the given directories:
tree -I 'directory_name1|directory_name2'


C++ Library Documentation
Version 1.2 Released
The Apache XML Security team are proud to announce the release of version 1.2 of the xml-security-c library. This is the first version of the library to provide processing and handling of XML Key Management Specification (XKMS) (currently XML Key Information Service Specification - XKISS - only) messages together with a command line client for performing XKMS requests and reading/dumping XKMS messages.
The team were involved in World Wide Web Consortium (w3c) interoperability testing with a reference XKMS server built using the xml-security-c library.
This version also includes a number of other changes and bugfixes, including updates to support Xerces 2.6 with Xalan 1.9. See changes.html for more information.
Overview of the C++ Library
The C++ library is an implementation of the XML Digital Signature specification. It is designed to be easily ported to new platforms, and has been tested on Solaris, Linux, FreeBSD, NetBSD and Windows.
The library makes use of the Apache XML project's Xerces-C XML Parser and Xalan-C XSLT processor. The latter is used for processing XPath and XSLT transforms. The use of Xalan-C is optional, but without it, XPath and XSLT transformations cannot be performed.
In addition, the library currently uses OpenSSL to provide cryptographic functionality. The cryptographic interface is implemented via a thin wrapper layer, and a development version of an implementation for the Windows Cryptographic API has also been implemented.
Old News
News - March 2004
Version 1.1 of the C++ library has been released. Supporting Xerces 2.5, 2.4 and 2.3 together with Xalan 1.6 and 1.7, this version provides :
- Beta implementation of XML Encryption
- Improved support for Windows Crypto API
- Bug fixes to Signature implementation
May 2003
Beta 0.2 has been released. It covers :
- some minor bug-fixes in the code and the UNIX build system
- a first cut at a Windows Crypto API provider interface
- methods to extract information from signature objects; and
- updates to tools to allow (and demonstrate) use of Windows CAPI and new extraction methods
Beta 0.2 is has been tested with Xerces-C v2.2 and the newly released Xalan-C v1.5.
February 2003
The C++ library has now been fully transferred into the Apache XML project. It was previously hosted on SourceForge.
The first release under Apache is 0.10. This is a Beta release, with fairly complete documentation, and a stable code base. It fully validates the various interop documents held in the xml-security CVS, with the exception of those related to :
- MD5 Digests (to be added in next point release)
- XPath Filter (to be added in next point release)
- XML Encryption (to be added post 1.00 release)
News - August 2003
Version 1.00 of the library has now been released. It features :
- the first stable release
- full implementation of all mandatory requirements of DSIG
- implementation of canonicalised XML
- implementation of exclusive-canonicalised XML
- implementation of XPath-filter
- FreeBSD, NetBSD and Cygwin builds
Version 1.00 is has been tested with Xerces-C v2.2 and the newly released Xalan-C v1.6. Xerces-C v2.3 is also supported. Note that versions of Xalan prior to v1.6 are not supported (due to the new changed location of include files).


13.8. Release 0.242
Warning
There is a bug in LambdaDefinitionExpression canonicalization introduced since 0.238. For more details, go to #15424.
Highlights
- Add configuration property
experimental.spiller.task-spilling-strategy
for choosing different spilling strategy to use. - Add support for fragment result caching.
- Add support for partition versioning.
- Add support for caching HiveMetastore calls at a more granular level.
Details
General Changes
- Fix compiler error in
LambdaBytecodeGenerator
when common sub-expression optimization is enabled and multiple SQL functions contain lambda expressions. - Fix possible permanently stucked queries when memory limit is exceeded during shuffle.
- Fix a bug where
IS DISTINCT FROM NULL
produces wrong results for columns with null values. - Add configuration property
experimental.spiller.task-spilling-strategy
for choosing different spilling strategy to use. - Add session property
query_max_output_bytes
and configuration propertyquery.max-output-bytes
to control how much data a query can output. - Add support for fragment result caching. This can be enabled by
fragment-result-cache.enabled
andexperimental.fragment-result-caching-enabled
.
Hive Changes
- Fix a bug where DWRF encryption would fail for large uncompressed column values.
- Fix a bug where non-Presto readers could not read encrypted DWRF files written by Presto if the encryption group listed columns out of order.
- Fix a performance regression for String field handling in GenericHiveRecordCursor when the SerDe does not provide an efficient Writable implementation.
- Improve split loading efficiency by only using as many threads as are required.
- Add support for file renaming for Hive connector. This can be enabled with the
hive.file_renaming_enabled
configuration property. - Add support to query parquet files written by parquet-avro library that uses
TIMESTAMP_MICROS
as theOriginalType
to represent timestamp. - Add support for partition versioning. This can be enabled with
hive.partition-versioning-enabled
configuration property - Add support for caching HiveMetastore calls at a more granular level. This can be specified by the
hive.metastore-cache-scope
configuration property.
Pinot Changes
- Add configuration property
pinot.pushdown-topn-broker-queries
to allow pushing down TOPN queries to Pinot.
Cassandra Change
- Add
SMALLINT
,TINYINT
, andDATE
type support.
Verifier Changes
- Fix an issue in determinism analysis which would indicate failing due to data being changed while the data is not changed.
- Improve JSON plan comparison for explain verification. (#15198).
- Add application-name config to override source passed in ClientInfo.
- Add support to fetch the list of queries to be verified by running a Presto query.
- Add support to run explain verification. (#15101). This can be enabled by configuration property
explain
.
SPI Changes
- Add
getIdentifier
toConnectorTableLayoutHandle
. Layout identifier is used in fragment result caching to construct canonical plan. - Add
getSplitIdentifier
toConnectorSplit
. Split identifier is used in fragment result caching to identify if splits are identical.
Geospatial Changes
- Upgrade Esri to [2.2.4](https://github.com/Esri/geometry-api-java/releases/tag/v2.2.4). This includes two fixes for bug (https://github.com/Esri/geometry-api-java/issues/266 and https://github.com/Esri/geometry-api-java/issues/247) that were seen in production.
Contributors
Andrii Rosa, Ariel Weisberg, Bin Fan, Daniel Ohayon, Dharak Kharod, James Gill, James Petty, James Sun, Ke Wang, Leiqing Cai, Masha Basmanova, Mayank Garg, Nikhil Collooru, Palash Goel, Rebecca Schlussel, Rongrong Zhong, Saksham Sachdev, Sanjay Sundaresan, Saumitra Shahapure, Shixuan Fan, Sreeni Viswanadha, Tim Meehan, Vic Zhang, Vivek, Weidong Duan, Wenlei Xie, Xiang Fu, Ying Su, Yuya Ebihara, Zhenxiao Luo, ankit0811, asdf2014, fornaix


HumanReadable
Human readable random tokens without ambiguous characters, and optional Emoji support.
Focus is readability in poor conditions or from potentially damaged printed documents rather than cryptographic uses. Despite this focus, SecureRandom is used to help avoid collisions.
Inspired by Douglas Crockford's Base 32, but attempts to correct mistakes by substituting the most likely misread. To make substitution safer, the token includes a check character generated using the Luhn mod N algorithm. Default character set is all caps based on this published study on text legibility, which matches Crockford as well.
Installation
Add this line to your application's Gemfile:
gem 'human_readable'
And then execute:
$ bundle install
Or install it yourself as:
$ gem install human_readable
Usage
For 10 characters of the default character set, use HumanReadable.generate
. For other lengths (2..x), use HumanReadable.generate(output_size: 50)
, or change output_size
in the configuration.
Configuration
-
Add or change substitutions by configuring
substitution_hash
-
To include non-default characters without substitution, configure
extend_chars
-
To exclude default characters, configure
exclude_chars
-
Inspect available characters using
HumanReadable.charset
-
For convenience, numbers and symbols are allowed in
substitution_hash
and are translated to characters during usage
CAUTION: Changing available characters alters the check character, invalidating previous tokens.
HumanReadable.configure do |c|
c.substitution_hash = { %w[I L] => 1, O: 0, U: :V } # Default
c.output_size = 10 # Default
# Add or change substitutions
c.substitution_hash[:B] = 8
c.substitution_hash[:U] = nil
# or equivalently
c.substitution_hash = { %w[I L] => 1, O: 0, U: nil, B: 8}
# Extend charset when no substitution is needed
c.extend_chars << %w[~ ! @ $]
# Exclude from charset
c.exclude_chars = %w[X Y Z]
# Supports Emoji!!
c.extend_chars << %w[⛰ 🧻 ✂ 🦎 🖖]
c.substitution_hash['🖤'] = '❤'
# And understands skin tones
c.remove_skin_tones = false # Default
c.substitution_hash[%w[👍🏻 👍🏼 👍🏽 👍🏾 👍🏿]] = '👍'
# -or-
c.remove_skin_tones = true
c.extend_chars << '👍'
end
Development
After checking out the repo, run bin/setup
to install dependencies. Then, run rake spec
to run the tests. You can also run bin/console
for an interactive prompt that will allow you to experiment.
To install this gem onto your local machine, run bundle exec rake install
. To release a new version, update the version number in version.rb
, and then run bundle exec rake release
, which will create a git tag for the version, push git commits and tags, and push the .gem
file to rubygems.org.
Contributing
Bug reports and pull requests are welcome on GitHub at github.com/MacksMind/human_readable.
License
The gem is available as open source under the terms of the MIT License.


A software based solution that can bring efficiency to inventory management, and perform inventory management tasks accurately, effortlessly forecast sales to optimise cashflow and increase business.
Using the ARIMA model products are accurately forecasted to give the latest insights.
Extensive reporting throughout the system provides the extra information for growth.
Know of immediate changes and alerts through the vast number of notification channels.
Clean and minimalistic interface allowing for an intuitive experience across the board.
Hand-in-hand mobile application for quick access, purchasing tools and board room reporting.
Manage your staff easily, by defining what their given roles & permissions are in the company.
Johan le Roux is an overall hard-head and perfectionist, who loves to run his team like a well oiled McLaren Formula1 team.
Xander Ferreira enjoys problem solving not related to his studies. Would much rather relax in front of the computer than working on the project.
Ryan Henstock is a gamer and writer who has mastered the arts of daydreaming, watching his favourite TV shows, and hide and go seek. He enjoys walks outside, Fanta Grape, and sleeping if time permits.
Steven Wessels is a professional procrastinator with a severe tea addiction. Over the course of the last eight months, he definitely spent more time playing guitar then working on this project.