The core model abstraction in the jsPlumb Toolkit is that of a Graph, or more properly, a Directed Graph, as discussed here:
http://en.wikipedia.org/wiki/Directed_graph
A Graph is a collection of Nodes, Groups, Edges and Ports.
As an example of how these data types map to an application - in the Database Visualizer application that ships with the Toolkit - Nodes, Edges and Ports are mapped as follows:
In the Flowchart Builder application, Nodes, Edges and Ports are mapped as follows:
Neither of these applications make use of the concept of Groups, which are new in version 1.1.0. We're currently evaluating a few different options for a demonstration application that uses Groups.
Every application using the Toolkit will have its own mapping of concepts to Nodes, Groups, Edges and Ports. Some applications may not even use Ports at all, since every Node can be an Edge target and/or source. Ports just give you the ability to model more complex data structures.
In addition to Nodes, Ports and Edges, the Toolkit has the concept of a Path: an in-order list of Nodes/Ports and Edges that represent the path from one Node or Port to some other Node or Port.  Paths are discussed in a separate page.
The various parts of your data model can be represented as any valid Javascript type. As an example, here is the backing
data for the Book
table in the Database Visualizer application:
{
"id":"book",
"name":"Book",
"type":"table",
"columns":[
{ "id":"id", "datatype":"integer", "primaryKey":true },
{ "id":"isbn", "datatype":"varchar" },
{ "id":"title", "datatype":"varchar" }
]
}
The Toolkit has its own internal representation of Nodes, Edges and Ports, but your original data is always stored under
the data
member - this is the Node from above:
{
"id":"456",
"data":{
"id":"book",
"name":"Book",
"type":"table",
"columns":[
{ "id":"id", "datatype":"integer", "primaryKey":true },
{ "id":"isbn", "datatype":"varchar" },
{ "id":"title", "datatype":"varchar" }
]
}
}
In the Node data given above there is a columns
array - each entry in this array maps to a Port on the Node
representing that table. The IDs of the Ports here are the id
members from each column in the array.
Every Node is required to have a unique ID. The Toolkit attempts to derive this automatically from your data, by
looking for an id
member - this is why in the above example the Toolkit's ID is the same as the ID from the original
data. Well, it's not exactly the same - the Toolkit converts all IDs into Strings internally.
Should you wish to implement a different strategy, though, you can just supply your own idFunction
to the method you
use to get an instance of the Toolkit:
var toolkit = jsPlumbToolkit.newInstance({
idFunction:function(data) {
return SomeCustomComputing(data);
}
});
Again note this is optional - you do not need to supply this function, but if you do not then the Toolkit will expect
an id
member in your data. Remember, though, the Toolkit converts the ID you supply into a String for internal
use.
IDs for Groups are derived using whatever method the Toolkit is using to derive IDs for Nodes - either by looking
for an id
value in your data, or by using a supplied idFunction
. Group IDs must be unique across all Groups
and Nodes in the dataset: you cannot have a Group that has the same ID as some Node.
Edges are not required to have an ID, but you might find it useful to supply one. If you do not supply an ID, the Toolkit will assign one automatically.
You can also supply separate functions to use for extracting the ID for a Port or Edge from some backing data:
var toolkit = jsPlumbToolkit.newInstance({
idFunction:function(data) {
return SomeCustomComputing(data);
},
portIdFunction:function(data) {
return PortComputations(data);
},
edgeIdFunction:function(data) {
return EdgeComputations(data);
}
});
If you omit either of these, the Toolkit uses whatever it is using to derive Node IDs (either the idFunction
, if
provided, or the default mechanism of looking for an id
member).
Port IDs are required to be unique on the Node on which the Port exists, but may be the same as the ID of a Port on some other Node.
When adding an Edge to a Toolkit instance, you can reference a Port on some Node using, by default, dotted notation. In the data given above there were three Ports. We could connect one of them to a column on another table like this:
toolkit.connect({
source:"book.id",
target:"book_author.book_id"
});
book_author
is another table in the schema from the Database Visualizer application.
If you find that using a period as the separator in a Port ID does not work for your data model, you can override what the Toolkit will use by doing this:
var tk = jsPlumbToolkit.newInstance({
portSeparator:"#"
});
When you load data into an instance of the Toolkit and you have Nodes that themselves have Ports (consider the Database Visualizer demo app - a table is a Node, and the columns on that table are Ports), the data describing your Ports will typically be held within the Node data. For instance, in the Database Visualizer, a Node looks like this:
{
"id":"book",
"name":"Book",
"type":"table",
"columns":[
{ "id":"name", "type":"varchar" },
{ "id":"id", "type":"integer" }
]
}
The entries in the columns
array are the Ports for this Node. In order to get the Toolkit to recognise these
Ports when using the load
function, you should define a portExtractor
in the jsPlumbToolkit.getInstance
function:
var toolkit = jsPlumbToolkit.getInstance({
...
portExtractor:function(node) { return node.columns; }
};
Every Node that is loaded is passed through this function, whose return value must be an array of Port objects. These Port objects are then registered against the given Node.
You can associate a type
with each of your Nodes, Groups, Edges and Ports. This is an important concept in the Toolkit, as
it is the basic means by which the data model is bound to any renderers, via Views.
As with Node/Edge/Port ID, the type of a Node, Group, Edge or Port can be derived using a default function - which looks
for a type
member in the backing data, or you can supply a typeFunction
to the newInstance
method:
var toolkit = jsPlumbToolkit.newInstance({
idFunction:function(data) {
return SomeCustomComputing(data);
},
typeFunction:function(data) {
return SomeOtherComputing(data);
},
edgeTypeFunction:function(data) {
return EdgeTypeComputing(data);
},
portTypeFunction:function(data) {
return PortTypeComputing(data);
}
});
As with ID, omitting either the Port or Edge type functions will cause the Toolkit to use whatever function it has determined it should use for deriving Node types. Also, as with ID, the Toolkit will derive Group types via the same means it is using to derive Node types.
The type
of some Node, Group, Port or Edge is used by the render model in a Surface, to determine the appearance and
behaviour of the object. For a discussion of render models, see here.
When you need to add a new Node programatically, you do so on the Toolkit instance using the addNode
function:
addNode : function(data) {
...
}
It is expected that the current idFunction
and typeFunction
will be able to determine appropriate values from the
data you provide. An example might be something like the following:
toolkitInstance.addNode({
id:"place",
name:"Place",
columns:[
{ id:"id", name:"Id", primaryKey:true, datatype:"integer" },
{ id:"name", name:"Name", datatype:"varchar" },
{ id:"lat", name:"Latitude", datatype:"float" },
{ id:"lng", name:"Longitude", datatype:"float" }
]
})
If, however, you are using a drag and drop mechanism to add new Nodes to the UI (see the page on Rendering),
the Toolkit needs some way of getting the data for a new Node. By default, the Toolkit will create a JS object with an id
member set to a new UUID, but you can provide a NodeFactory
in order to gain control over the creation of the data.
A NodeFactory is a function with this signature:
function myNodeFactory (type, data, callback, originalEvent, isNative);
type
is the type of Node to create. data
is the data appropriate to the given Node type; in the case of drag and drop it has been generated elsewhere (again see the page on Rendering). callback
is a function that your code must call once it has the data for the new Node prepared - having a callback rather than returning a value enables you to optionally prepare the data asynchronously, perhaps via a round trip to the server. If you do not call this function, addition of the new Node is aborted (which you might want to do, sometimes, of course).originalEvent
This is the browser event related to the drop. If isNative
is set, you might wish to access the dataTransfer
member of this event when deciding how to populate the data object.isNative
Set to true if the drop event was "native", for example a file dragged into the browser from the user's desktop or file system.Here's an example of a direct callback:
var toolkit = jsPlumbToolkit.getInstance({
nodeFactory:function(type, data, callback, evt, native) {
callback({
someKey:"aValue",
someArray:[ 1, 2, 3 ]
});
}
};
You might do this instead if you have jQuery in your page and you want to get your new Node from the server:
var toolkit = jsPlumbToolkit.getInstance({
nodeFactory:function(type, data, callback, evt, native) {
$.ajax({
url:"/get/new/" + type,
success:callback
});
}
};
You might do this if it's a native drop:
var toolkit = jsPlumbToolkit.getInstance({
nodeFactory:function(type, data, callback, evt, isNative) {
if (isNative) {
data.name = evt.dataTransfer.files[0].name;
data.size = evt.dataTransfer.files[0].size;
data.type = evt.dataTransfer.files[0].type;
}
callback(data);
}
};
You can call the NodeFactory directly using the addFactoryNode
method:
toolkit.addFactoryNode("someType");
This will result in a call to the NodeFactory with the type someType
.
It is possible to also provide some seed data for the new Node:
toolkit.addFactoryNode("someType", { foo:"bar" });
And also you can provide a callback which will be run after the NodeFactory has finished adding the new Node:
toolkit.addFactoryNode("someType", { foo:"bar" }, function(node) {
// node is your new Node.
});
A Group Factory works in exactly the same way as a Node Factory. Here's the setup of the Toolkit in the groups demonstration that ships with the Toolkit:
var toolkit = jsPlumbToolkit.newInstance({
groupFactory:function(type, data, callback) {
data.title = "Group " + (toolkit.getGroupCount() + 1);
callback(data);
},
nodeFactory:function(type, data, callback) {
data.name = (toolkit.getNodeCount() + 1);
callback(data);
}
});
In this app we simply assign a label that has the Group/Node index in it.
If your data model is sufficiently complex, you will be making use of Ports. In the same way that the Toolkit needs to be able to assemble a JS object for each new Node created through user interaction, it needs a way to assemble a JS object for a new Port.
The Toolkit offers two methods for adding new Ports:
addPort = function(node, data) { ... }
and
addNewPort = function(node, type, portData) { ... }
The first of these - addPort
- takes some existing data as argument, from which it will derive an ID and type (from
the current idFunction
and typeFunction
) and then add the Port to the given Node.
The second function takes only the type of the Port to add, which it hands off to the Port Factory in order to get a data object for the new Port. As with Nodes, if no PortFactory is defined then a simple JS object containing an id parameter is created.
Here's the PortFactory from the Database Visualizer example application - remember, in this application, each column in a table is mapped to a port:
function(node, type, data, callback) {
var column = {
id:data.columnName,
name:data.columnName[0].toUpperCase() + data.columnName.slice(1),
datatype:"varchar",
type:"column"
};
// add to node's data. we have to do this manually. the Toolkit does not know our internal
// data structure.
node.data.columns.push(column);
// handoff the new column.
callback(column);
}
Note the signature is slightly different for a PortFactory: it is given the Node to which the Port should be added,
and it is not given a browser event or the isNative
flag.
Where does data
come from in the code snippet above? In the Database Visualizer app, we use event delegation to
listen to clicks on a certain button, then popup a dialog requesting input from the user. If the user enters data and
presses OK, we inform the Toolkit via the addNewPort
method:
// add new column to table
jsPlumb.on(document, "tap", ".new-column i", function() {
var info = renderer.getObjectInfo(this); // getObjectInfo is a helper method that retrieves the node or port associated with some element in the DOM.
jsPlumbToolkit.Dialogs.show({
id:"dlgName",
title:"Enter new column name:",
onOK:function(data) {
// if the user supplied a column name, tell the toolkit to add a new port. This will result in a callback to the portFactory defined above.
if (data.name) {
if (data.name.length < 3)
alert("Column names must be at least 3 characters!")
else
toolkit.addNewPort(info.id, "column", { id:data.name.toLowerCase(), columnName:data.name });
}
}
});
});
The dialog code shown in this snippet is discussed here.
addNewPort
takes four values:
The Edge Factory is the function that the Toolkit will call whenever a new Connection is established between two
Nodes/Ports, via user mouse action. It follows the same pattern as Nodes and Ports - if there is no EdgeFactory
defined then a default JS object will be used. The EdgeFactory is only ever called when the user creates a new Edge
with the mouse. It is not called if you make a programmatic call tojsPlumbToolkitInstance.addEdge
.
None of the examples that ship with the Toolkit use the EdgeFactory, but the Database Visualizer contains this stub:
edgeFactory : function(params, data, callback) {
// you must hit the callback if you provide the edgeFactory.
callback(data);
// unless you want to return false, to abandon the edge
//return false;
}
Here, we could manipulate the contents of data
before we hit the callback if we wanted to.
When you instantiate a Toolkit, there are various interceptor functions that you can provide, to constrain the connectivity in your application. An example (from the Database Visualizer app):
var toolkit = jsPlumbToolkit.newInstance({
...
beforeConnect:function(source, target, edgeData) {
return source !== target && source.getNode() !== target.getNode();
}
});
beforeConnect
is called when the user drags and drops a new connection. The DatabaseVisualizer connects Ports
;
this interceptor checks that the source and target Ports are not the same, and then that the source and target Ports
are not on the same Node.
The full set of interceptors you can provide is:
This interceptor is called when the user drags and drops a new connection, as well as when connect
is called on a
Toolkit instance.
beforeConnect
is given the source (a Node or Port) and target (a Node or Port) of a newly dragged Edge, as well as,
optionally, data associated with the Edge. Data may be associated with an Edge via the beforeStartConnect
interceptor.
Returning anything other than true from this method discards the new Edge.
This is called as the user begins to drag a new Edge, as well as programmatically when the user calls connect
on a
Toolkit instance. This interceptor behaves slightly differently from the others:
returning false, as with the others, will abort the action (in this case, it will abort the new connection drag).
Returning true will allow the connection to drag to continue. But you can also return some value other than true,
in which case dragging will continue and your return value will become the new Edge's backing data. If you do return
some data from this method, it will be passed in to the beforeConnect
interceptor as the edgeData
parameter.
This interceptor is called prior to any existing edge being moved (either programmatically or via the mouse). It is
passed the source and target of the existing edge, as well as the edge itself, and if it returns anything other than
boolean true, the edge move is aborted. If not supplied, the default behaviour of this function is to honor the
allowLoopback
, allowNodeLoopback
and maxConnections
parameters on any Node or Port definitions you supplied to
this Toolkit via the model
.
This interceptor can be used to override connection detachment from the mouse. The function is given (source, target,
edge)
and is expected to return true to confirm that the detach should occur.
This interceptor can also be used to override connection detachment from the mouse, but it is distinct from
beforeDetach
in that this function is called as soon as the user begins to drag. The function is given (source,
target, edge)
and is expected to return true to confirm the detach should occur. Any other return value will abort
the detach.


// Copyright (c) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE file in the project root for full license information.
'use strict';
var HOSTNAME_LEN = "HostName=".length;
var DEVICEID_LEN = "DeviceId=".length;
var SAK_LEN = "SharedAccessKey=".length;
function parseConnString(connString)
{
var config = {
host: '',
hubName: '',
keyName: '',
key: ''
};
var configArray = connString.split(';');
configArray.forEach(function(element) {
var pos = element.indexOf("HostName=");
if (pos >= 0) {
config.host = element.substring(pos+HOSTNAME_LEN);
// Look for the first period
var periodSeparator = config.host.indexOf('.');
config.hubName = config.host.substring(0, periodSeparator);
}
else if ( (pos = element.indexOf("DeviceId=") ) >= 0) {
config.keyName = element.substring(pos+DEVICEID_LEN);
}
else if ( (pos = element.indexOf("SharedAccessKey=") ) >= 0) {
config.key = element.substring(pos+SAK_LEN);
}
});
return config;
}
/**
* @class Client
* @classdesc Constructs a {@linkcode Client} object with the given IoT device connection
* string and `transport` object.
* @param {String} connString The IoT device connection string
* @param {Object} transport An object that implements the interface
* expected of a transport object. See the
* file **adapters/devdoc/https_requirements.docm**
* for information on what the transport
* object should look like. The {@linkcode Https}
* class is an implementation that uses HTTP as
* the communication protocol.
*/
/*Codes_SRS_NODE_IOTHUB_CLIENT_05_001: [The Client constructor shall accept a transport object]*/
var Client = function (connString, transport) {
this.config = parseConnString(connString);
this.transport = transport;
};
/**
* The [sendEvent]{@linkcode Client#sendEvent} method sends an event message
* to the IoT Hub as the device indicated by the connection string passed
* via the constructor.
* @param {Message} message The [message]{@linkcode module:common/message.Message}
* to be sent.
* @param {Function} done The callback to be invoked when `sendEvent`
* completes execution.
* @see [Message]{@linkcode module:common/message.Message}
*/
Client.prototype.sendEvent = function(message, done) {
/*Codes_SRS_NODE_IOTHUB_CLIENT_05_002: [The sendEvent method shall send the event (indicated by the message argument) via the transport associated with the Client instance.]*/
/*Codes_SRS_NODE_IOTHUB_CLIENT_05_003: [When the sendEvent method completes, the callback function (indicated by the done argument) shall be invoked with the same arguments as the underlying transport method’s callback.]*/
this.transport.sendEvent(message, this.config, done);
};
/**
* The [sendEventBatch]{@linkcode Client#sendEventBatch} method sends a list
* of event messages to the IoT Hub as the device indicated by the connection
* string passed via the constructor.
* @param {array<Message>} messages Array of [Message]{@linkcode module:common/message.Message}
* objects to be sent as a batch.
* @param {Function} done The callback to be invoked when
* `sendEventBatch` completes execution.
*/
Client.prototype.sendEventBatch = function(messages, done) {
/*Codes_SRS_NODE_IOTHUB_CLIENT_07_004: [The sendEventBatch method shall send the list of events (indicated by the messages argument) via the transport associated with the Client instance.]*/
/*Codes_SRS_NODE_IOTHUB_CLIENT_07_005: [When the sendEventBatch method completes the callback function shall be invoked with the same arguments as the underlying transport method’s callback.]*/
this.transport.sendEventBatch(messages, this.config, done);
};
/**
* The receive method queries the IoT Hub (as the device indicated in the
* constructor argument) for the next notification in the queue.
* @param {Function} done The callback to be invoked when `receive`
* completes execution.
*/
Client.prototype.receive = function(done) {
/*Codes_SRS_NODE_IOTHUB_CLIENT_05_004: [The receive method shall query the IoT Hub for the next message via the transport associated with the Client instance.]*/
/*Codes_SRS_NODE_IOTHUB_CLIENT_05_005: [When the receive method completes, the callback function (indicated by the done argument) shall be invoked with the same arguments as the underlying transport method’s callback.]*/
this.transport.receive(this.config, done);
};
/**
* The `abandon` method directs the IoT Hub to re-enqueue a notification
* message so it may be received again later.
* @param {Message} message The [message]{@linkcode module:common/message.Message}
* to be re-enqueued.
* @param {Function} done The callback to be invoked when `abandon`
* completes execution.
*/
Client.prototype.abandon = function(message, done) {
/*Codes_SRS_NODE_IOTHUB_CLIENT_07_001: [The abandon method shall call into the transport’s sendFeedback with the ‘abandon’ keyword and the lockToken.]*/
this.transport.sendFeedback('abandon', message.lockToken, this.config, done);
};
/**
* The `reject` method directs the IoT Hub to delete a notification message
* from the queue and record that it was rejected.
* @param {Message} message The [message]{@linkcode module:common/message.Message}
* to be deleted.
* @param {Function} done The callback to be invoked when `reject`
* completes execution.
*/
Client.prototype.reject = function(message, done) {
/*Codes_SRS_NODE_IOTHUB_CLIENT_07_002: [The reject method shall call into the transport’s sendFeedback with the ‘reject’ keyword and the lockToken.]*/
this.transport.sendFeedback('reject', message.lockToken, this.config, done);
};
/**
* The `complete` method directs the IoT Hub to delete a notification message
* from the queue and record that it was accepted.
* @param {Message} message The [message]{@linkcode module:common/message.Message}
* to be accepted.
* @param {Function} done The callback to be invoked when `complete`
* completes execution.
*/
Client.prototype.complete = function(message, done) {
/*Codes_SRS_NODE_IOTHUB_CLIENT_07_003: [The complete method shall call into the transport’s sendFeedback with the ‘complete’ keyword and the lockToken.]*/
this.transport.sendFeedback('complete', message.lockToken, this.config, done);
};
module.exports = Client;


Personal Information
Name : akrm Abdulh alssed
Nationality : LIBYA
N/ID:119880212545
Address : T,LIBY
E- Mail<EMAIL_ADDRESS><EMAIL_ADDRESS>T:<PHONE_NUMBER>
Certificates & TRAINING COURSES
ELCTRIC AND ELECTRONIC ENGINEER
MCT (Microsoft Certified Trainer)
MCSD (Microsoft Certified Solution Developer)
MCDBA (Microsoft Certified Data Base Administrator)
MCSA (Microsoft Certified Administrator)
A+
Linux
I-Net + Certified
MCP + I
MCSE Messaging
Front-End Developer
Back-End Developer
Microsoft + NETWORK
MCSA Messaging
MCTS (Windows 7)
MCAD
MCITP
Security
Cisco Academy Certified
CCNA
CCNP
Experience :
Working in computer training & IT field and IT Solutions for the
5 years
Courses
+NETWORK
+I-NET
SQL SERVER 2008
SQL SERVER 2012
SQL SERVER 2014
M.S. Access / Excel / 2007
M.S. Access / Excel / 2010
ORACL
MY SQL
Other courses
ICDL
IC3
Diploma
OS Courses
? Windows 7 /8
0 Linux Courses: (Red Hat, KALI Linux)
1
2 CENTOS7 from Red Hat
3 FEDORA WORKSTATION from Linux
4
Network Courses
? PACKET TRACER from CISCO
0 NETWORK ESSENTIALS
1 CCNA ROUTING AND SWITCHING
2 MOBILITY FUNDAMENTALS
3 INTRODUCTION TO CYBERSECURITY
4 GNS3
5 MIKROTIK
6 WIRESHARK
Programming Courses
? * Programming using M.S. Access / Excel 2000 [VBA]
0 * C / C ++ Programming Language
1 * C #Programming Language
2 * JAVA Programming Language
3 * JS Programming Language
4 * ASP WITH C# Programming Language
5 * Programming using Visual Basic 2010
6 * Programming using Visual Basic 2015
7 * Web Pages Design
8 * HTML Courses
9 * Programming ANDROID AND IOS
Design courses
? * Adobe Photoshop Courses
0 * Corel Draw Courses
1 * Adobe Illustrator
2 * 3D Studio Max Courses
3 * Adobe XD (UI/UX)
International /conference/ seminar and Workshop
*Deployment of 5G and the roadmap to 6G
Iraq university college .
? Information security opportunities and challenge from auro university India un
0 Artificial intelligence robotics by department of EEE and ECE (Gandhi institute ) India
1 Cloud security from Stanford university US
2 Student assessment in online learning almansor university
3 Kual lumpur international conference on management
4 Angular js conference
5 Communication conference on university of sumer.
Summary for a job Front-end web developer
1-html/css
2-javascript/jquery
3-responsive design
4-framework
5-testing /debugging
6-browser developer tools
7-web performance .


Creates an Amazon Aurora DB cluster from data stored in an Amazon S3 bucket. Amazon RDS must be authorized to access the Amazon S3 bucket and the data must be created using the Percona XtraBackup utility as described in Migrating Data from MySQL by Using an Amazon S3 Bucket .
See also: AWS API Documentation
restore-db-cluster-from-s3
[--availability-zones <value>]
[--backup-retention-period <value>]
[--character-set-name <value>]
[--database-name <value>]
--db-cluster-identifier <value>
[--db-cluster-parameter-group-name <value>]
[--vpc-security-group-ids <value>]
[--db-subnet-group-name <value>]
--engine <value>
[--engine-version <value>]
[--port <value>]
--master-username <value>
--master-user-password <value>
[--option-group-name <value>]
[--preferred-backup-window <value>]
[--preferred-maintenance-window <value>]
[--tags <value>]
[--storage-encrypted | --no-storage-encrypted]
[--kms-key-id <value>]
--source-engine <value>
--source-engine-version <value>
--s3-bucket-name <value>
[--s3-prefix <value>]
--s3-ingestion-role-arn <value>
[--cli-input-json <value>]
[--generate-cli-skeleton <value>]
A list of EC2 Availability Zones that instances in the restored DB cluster can be created in.
Syntax:
"string" "string" ...
--backup-retention-period (integer)
The number of days for which automated backups of the restored DB cluster are retained. You must specify a minimum value of 1.
Default: 1
Constraints:
- Must be a value from 1 to 35
A value that indicates that the restored DB cluster should be associated with the specified CharacterSet.
The database name for the restored DB cluster.
--db-cluster-identifier (string)
The name of the DB cluster to create from the source data in the S3 bucket. This parameter is isn't case-sensitive.
Constraints:
- Must contain from 1 to 63 alphanumeric characters or hyphens.
- First character must be a letter.
- Cannot end with a hyphen or contain two consecutive hyphens.
Example: my-cluster1
--db-cluster-parameter-group-name (string)
The name of the DB cluster parameter group to associate with the restored DB cluster. If this argument is omitted, default.aurora5.6 will be used.
Constraints:
- Must be 1 to 255 alphanumeric characters
- First character must be a letter
- Cannot end with a hyphen or contain two consecutive hyphens
--vpc-security-group-ids (list)
A list of EC2 VPC security groups to associate with the restored DB cluster.
Syntax:
"string" "string" ...
--db-subnet-group-name (string)
A DB subnet group to associate with the restored DB cluster.
Constraints: Must contain no more than 255 alphanumeric characters, periods, underscores, spaces, or hyphens. Must not be default.
Example: mySubnetgroup
The name of the database engine to be used for the restored DB cluster.
Valid Values: aurora
The version number of the database engine to use.
AuroraExample: 5.6.10a
The port number on which the instances in the restored DB cluster accept connections.
Default: 3306
The name of the master user for the restored DB cluster.
Constraints:
- Must be 1 to 16 alphanumeric characters.
- First character must be a letter.
- Cannot be a reserved word for the chosen database engine.
--master-user-password (string)
The password for the master database user. This password can contain any printable ASCII character except "/", """, or "@".
Constraints: Must contain from 8 to 41 characters.
A value that indicates that the restored DB cluster should be associated with the specified option group.
Permanent options cannot be removed from an option group. An option group cannot be removed from a DB cluster once it is associated with a DB cluster.
--preferred-backup-window (string)
The daily time range during which automated backups are created if automated backups are enabled using the BackupRetentionPeriod parameter.
Default: A 30-minute window selected at random from an 8-hour block of time per region. To see the time blocks available, see Adjusting the Preferred Maintenance Window in the Amazon RDS User Guide.
Constraints:
- Must be in the format hh24:mi-hh24:mi .
- Times should be in Universal Coordinated Time (UTC).
- Must not conflict with the preferred maintenance window.
- Must be at least 30 minutes.
--preferred-maintenance-window (string)
The weekly time range during which system maintenance can occur, in Universal Coordinated Time (UTC).
Format: ddd:hh24:mi-ddd:hh24:mi
Default: A 30-minute window selected at random from an 8-hour block of time per region, occurring on a random day of the week. To see the time blocks available, see Adjusting the Preferred Maintenance Window in the Amazon RDS User Guide.
Valid Days: Mon, Tue, Wed, Thu, Fri, Sat, Sun
Constraints: Minimum 30-minute window.
A list of tags.
Shorthand Syntax:
Key=string,Value=string ...
JSON Syntax:
[
{
"Key": "string",
"Value": "string"
}
...
]
--storage-encrypted | --no-storage-encrypted (boolean)
Specifies whether the restored DB cluster is encrypted.
The KMS key identifier for an encrypted DB cluster.
The KMS key identifier is the Amazon Resource Name (ARN) for the KMS encryption key. If you are creating a DB cluster with the same AWS account that owns the KMS encryption key used to encrypt the new DB cluster, then you can use the KMS key alias instead of the ARN for the KM encryption key.
If the StorageEncrypted parameter is true, and you do not specify a value for the KmsKeyId parameter, then Amazon RDS will use your default encryption key. AWS KMS creates the default encryption key for your AWS account. Your AWS account has a different default encryption key for each AWS region.
The identifier for the database engine that was backed up to create the files stored in the Amazon S3 bucket.
Valid values: mysql
--source-engine-version (string)
The version of the database that the backup files were created from.
MySQL version 5.5 and 5.6 are supported.
Example: 5.6.22
The name of the Amazon S3 bucket that contains the data used to create the Amazon Aurora DB cluster.
The prefix for all of the file names that contain the data used to create the Amazon Aurora DB cluster. If you do not specify a SourceS3Prefix value, then the Amazon Aurora DB cluster is created by using all of the files in the Amazon S3 bucket.
--s3-ingestion-role-arn (string)
The Amazon Resource Name (ARN) of the AWS Identity and Access Management (IAM) role that authorizes Amazon RDS to access the Amazon S3 bucket on your behalf.
--cli-input-json (string) Performs service operation based on the JSON string provided. The JSON string follows the format provided by --generate-cli-skeleton. If other arguments are provided on the command line, the CLI values will override the JSON-provided values.
--generate-cli-skeleton (string) Prints a JSON skeleton to standard output without sending an API request. If provided with no value or the value input, prints a sample input JSON that can be used as an argument for --cli-input-json. If provided with the value output, it validates the command inputs and returns a sample output JSON for that command.
DBCluster -> (structure)
Contains the result of a successful invocation of the following actions:
- create-db-cluster
- delete-db-cluster
- failover-db-cluster
- modify-db-cluster
- restore-db-cluster-from-snapshot
- restore-db-cluster-to-point-in-time
This data type is used as a response element in the describe-db-clusters action.
AllocatedStorage -> (integer)
Specifies the allocated storage size in gigabytes (GB).AvailabilityZones -> (list)
Provides the list of EC2 Availability Zones that instances in the DB cluster can be created in.
(string)
BackupRetentionPeriod -> (integer)
Specifies the number of days for which automatic DB snapshots are retained.CharacterSetName -> (string)
If present, specifies the name of the character set that this cluster is associated with.DatabaseName -> (string)
Contains the name of the initial database of this DB cluster that was provided at create time, if one was specified when the DB cluster was created. This same name is returned for the life of the DB cluster.DBClusterIdentifier -> (string)
Contains a user-supplied DB cluster identifier. This identifier is the unique key that identifies a DB cluster.DBClusterParameterGroup -> (string)
Specifies the name of the DB cluster parameter group for the DB cluster.DBSubnetGroup -> (string)
Specifies information on the subnet group associated with the DB cluster, including the name, description, and subnets in the subnet group.Status -> (string)
Specifies the current state of this DB cluster.PercentProgress -> (string)
Specifies the progress of the operation as a percentage.EarliestRestorableTime -> (timestamp)
Specifies the earliest time to which a database can be restored with point-in-time restore.Endpoint -> (string)
Specifies the connection endpoint for the primary instance of the DB cluster.ReaderEndpoint -> (string)
The reader endpoint for the DB cluster. The reader endpoint for a DB cluster load-balances connections across the Aurora Replicas that are available in a DB cluster. As clients request new connections to the reader endpoint, Aurora distributes the connection requests among the Aurora Replicas in the DB cluster. This functionality can help balance your read workload across multiple Aurora Replicas in your DB cluster.
If a failover occurs, and the Aurora Replica that you are connected to is promoted to be the primary instance, your connection will be dropped. To continue sending your read workload to other Aurora Replicas in the cluster, you can then recoonect to the reader endpoint.
MultiAZ -> (boolean)
Specifies whether the DB cluster has instances in multiple Availability Zones.Engine -> (string)
Provides the name of the database engine to be used for this DB cluster.EngineVersion -> (string)
Indicates the database engine version.LatestRestorableTime -> (timestamp)
Specifies the latest time to which a database can be restored with point-in-time restore.Port -> (integer)
Specifies the port that the database engine is listening on.MasterUsername -> (string)
Contains the master username for the DB cluster.DBClusterOptionGroupMemberships -> (list)
Provides the list of option group memberships for this DB cluster.
(structure)
Contains status information for a DB cluster option group.
DBClusterOptionGroupName -> (string)
Specifies the name of the DB cluster option group.Status -> (string)
Specifies the status of the DB cluster option group.PreferredBackupWindow -> (string)
Specifies the daily time range during which automated backups are created if automated backups are enabled, as determined by the BackupRetentionPeriod .PreferredMaintenanceWindow -> (string)
Specifies the weekly time range during which system maintenance can occur, in Universal Coordinated Time (UTC).ReplicationSourceIdentifier -> (string)
Contains the identifier of the source DB cluster if this DB cluster is a Read Replica.ReadReplicaIdentifiers -> (list)
Contains one or more identifiers of the Read Replicas associated with this DB cluster.
(string)
DBClusterMembers -> (list)
Provides the list of instances that make up the DB cluster.
(structure)
Contains information about an instance that is part of a DB cluster.
DBInstanceIdentifier -> (string)
Specifies the instance identifier for this member of the DB cluster.IsClusterWriter -> (boolean)
Value that is true if the cluster member is the primary instance for the DB cluster and false otherwise.DBClusterParameterGroupStatus -> (string)
Specifies the status of the DB cluster parameter group for this member of the DB cluster.PromotionTier -> (integer)
A value that specifies the order in which an Aurora Replica is promoted to the primary instance after a failure of the existing primary instance. For more information, see Fault Tolerance for an Aurora DB Cluster .VpcSecurityGroups -> (list)
Provides a list of VPC security groups that the DB cluster belongs to.
(structure)
This data type is used as a response element for queries on VPC security group membership.
VpcSecurityGroupId -> (string)
The name of the VPC security group.Status -> (string)
The status of the VPC security group.HostedZoneId -> (string)
Specifies the ID that Amazon Route 53 assigns when you create a hosted zone.StorageEncrypted -> (boolean)
Specifies whether the DB cluster is encrypted.KmsKeyId -> (string)
If StorageEncrypted is true, the KMS key identifier for the encrypted DB cluster.DbClusterResourceId -> (string)
The region-unique, immutable identifier for the DB cluster. This identifier is found in AWS CloudTrail log entries whenever the KMS key for the DB cluster is accessed.DBClusterArn -> (string)
The Amazon Resource Name (ARN) for the DB cluster.AssociatedRoles -> (list)
Provides a list of the AWS Identity and Access Management (IAM) roles that are associated with the DB cluster. IAM roles that are associated with a DB cluster grant permission for the DB cluster to access other AWS services on your behalf.
(structure)
Describes an AWS Identity and Access Management (IAM) role that is associated with a DB cluster.
RoleArn -> (string)
The Amazon Resource Name (ARN) of the IAM role that is associated with the DB cluster.Status -> (string)
Describes the state of association between the IAM role and the DB cluster. The Status property returns one of the following values:
- ACTIVE - the IAM role ARN is associated with the DB cluster and can be used to access other AWS services on your behalf.
- PENDING - the IAM role ARN is being associated with the DB cluster.
- INVALID - the IAM role ARN is associated with the DB cluster, but the DB cluster is unable to assume the IAM role in order to access other AWS services on your behalf.
ClusterCreateTime -> (timestamp)
Specifies the time when the DB cluster was created, in Universal Coordinated Time (UTC).


1. Introduction
Oftentimes, your business logic relies on remote data that you need to fetch from different sources: databases, caches, web services, or third party APIs, and you can’t mess things up. Urania helps you to keep your business logic clear of low-level details while performing efficiently:
-
batch multiple requests to the same data source
-
request data from multiple data sources concurrently
-
cache previous requests
Having all this gives you the ability to access remote data sources in a concise and consistent way, while the library handles batching and overlapping requests to multiple data sources behind the scenes.
2. Installation
The simplest way to use urania in a Clojure project is by including it as a dependency in your project.clj:
[funcool/urania "0.1.0"]
2.1. Limitations
-
requires Java 8 when used from Clojure due to its use of
java.util.concurrent.CompletableFuture
-
works with the Promesa library only (if you use other async mechanism like futures you can easily turn your code to be compatible with promises)
-
assumes your operations with data sources are "side-effect free", so you don’t really care about the order of fetches
-
you need enough memory to store the whole data fetched during a single
run!
call (in case it’s impossible you should probably look into other ways to solve your problem, i.e. data stream libraries)
3. User Guide
3.1. Rationale
A core problem of many systems is balancing expressiveness against performance.
Let’s imagine the problem of calculating the number of friends in common that two users have, where we fetch the user data from a remote data source.
(require '[clojure.set :refer [intersection]])
(defn friends-of
[id]
;; ...
)
(defn count-common
[a b]
(count (intersection a b)))
(defn count-common-friends
[x y]
(count-common (friends-of x) (friends-of y)))
(count-common-friends 1 2)
Here, (friends-of x)
and (friends-of y)
are independent, and you want them to be fetched concurrently
or in a single request. Furthermore, if x
and y
refer to the same person, you don’t want to redundantly re-fetch
their friend list. What would the code look like if we applied the mentioned optimizations? We’d have to mix
different concerns like caching and batching together with the business logic we perform with the data.
Urania allows your data fetches to be implicitly concurrent with little changes to the original code, here’s a spoiler:
(require '[urania.core :as u])
(defn count-common-friends [x y]
(u/map count-common
(friends-of x)
(friends-of y)))
(u/run! (count-common-friends 1 2))
As you may have noticed, Urania does so separating the data fetch declaration from its execution. When running
your fetches, urania
will:
-
request data from multiple data sources concurrently
-
batch multiple requests to the same data source
-
cache repeated requests
3.2. Fetching data from remote sources
Reading data from remote data sources is usually asynchronous and/or has the possibility of error, that’s why urania
uses the
Promise type available in the Promesa library as its result abstraction.
We’ll start by writing a small function for emulating data sources with unpredictable latency.  Remote data sources
Now, we define our data sources as types that implement Urania’s DataSource
protocol. This protocol
has two functions:
-
-identity
, which returns an identifier for the resource (used for caching and deduplication). -
-fetch
, which fetches the result from the remote data source returning a promise.
(require '[urania.core :as u])
(defrecord FriendsOf [id]
u/DataSource
(-identity [_] id)
(-fetch [_ _]
(remote-req id (set (range id)))))
(defn friends-of [id]
(FriendsOf. id))
Now let’s try to fetch some data with Urania.
We’ll use urania.core/run! for running a fetch, it returns a promise.
(u/run! (friends-of 10))
;; -->[ 10 ] waiting<PHONE_NUMBER>9719886
;; => #<Promise [~]>
;; <--[ 10 ] finished, result: #{0 7 1 4 6 3 2 9 5 8}
We can block for the promise’s result with deref:
(deref
(u/run! (friends-of 10)))
;; -->[ 10 ] waiting<PHONE_NUMBER>406875
;; <--[ 10 ] finished, result: #{0 7 1 4 6 3 2 9 5 8}
;; => #{0 7 1 4 6 3 2 9 5 8}
Or use Urania’s run!! function. Note that we can only block in Clojure, not in ClojureScript.
(u/run!! (friends-of 10))
;; -->[ 10 ] waiting<PHONE_NUMBER>406875
;; <--[ 10 ] finished, result: #{0 7 1 4 6 3 2 9 5 8}
;; => #{0 7 1 4 6 3 2 9 5 8}
For convenience, the rest of the documentation will be using run!!
although is not available in
ClojureScript.
3.3.1. Transforming fetched data
We can use urania.core/map
function for transforming results of a data source.
(u/run!!
(u/map count (friends-of 10)))
;; -->[ 10 ] waiting<PHONE_NUMBER>19846
;; <--[ 10 ] finished, result: #{0 7 1 4 6 3 2 9 5 8}
;; => 10
And compose multiple transformations together:
(u/run!!
(u/map dec (u/map count (friends-of 10))))
;; -->[ 10 ] waiting<PHONE_NUMBER>19846
;; <--[ 10 ] finished, result: #{0 7 1 4 6 3 2 9 5 8}
;; => 9
3.3.2. Dependencies between results
Let’s imagine we have another information we want to fetch: a user’s activity score. For fetching
a user’s activity score we’ll need to fetch the user first, and urania
provides a combinator
for doing so: urania.core/mapcat
.
First of all, let’s define our activity score data source:
(defrecord ActivityScore [id]
u/DataSource
(-identity [_] id)
(-fetch [_ _]
(remote-req id (inc id))))
(defn activity
[id]
(ActivityScore. id))
Now we want to fetch the activity scores of the first friend of a certain user. We need to know intermediate
results of a fetch to continue, so we use urania.core/mapcat
:
(defn first-friends-activity
[id]
(u/mapcat (fn [friends]
(activity (first friends)))
(friends-of id)))
We can now run this fetch:
(u/run!! (first-friends-activity 10))
;; -->[ 10 ] waiting<PHONE_NUMBER>556875
;; <--[ 10 ] finished, result: #{0 7 1 4 6 3 2 9 5 8}
;; -->[ 0 ] waiting 63.24540090623976
;; <--[ 0 ] finished, result: 1
;; => 1
But, what if we wanted the activity score for every friend of a user? urania
provides a combinator for
transforming a list of data sources into a data source that returns a list of results: urania.core/collect
.
Let’s use it to collect the activity score for every user:
(defn friends-activity
[id]
(u/mapcat (fn [friends]
(u/collect (map activity friends)))
(friends-of id)))
If we run it:
(u/run!! (friends-activity 5))
;; -->[ 5 ] waiting<PHONE_NUMBER>476696
;; <--[ 5 ] finished, result: #{0 1 4 3 2}
;; -->[ 0 ] waiting<PHONE_NUMBER>9535687
;; -->[ 1 ] waiting 87.96784013662884
;; -->[ 4 ] waiting<PHONE_NUMBER>486679
;; <--[ 1 ] finished, result: 2
;; -->[ 3 ] waiting<PHONE_NUMBER>2774116
;; <--[ 3 ] finished, result: 4
;; -->[ 2 ] waiting<PHONE_NUMBER>7346835
;; <--[ 0 ] finished, result: 1
;; <--[ 2 ] finished, result: 3
;; <--[ 4 ] finished, result: 5
;; => [1 2 5 4 3]
As you may have noticed, the data sources passed to urania.core/collect
are fetched concurrently. Furthermore,
it will detect and eliminate duplicate requests:
(u/run!! (u/collect [(friends-of 1) (friends-of 2) (friends-of 2)]))
;; -->[ 2 ] waiting<PHONE_NUMBER>264134
;; -->[ 1 ] waiting<PHONE_NUMBER>535985
;; <--[ 2 ] finished, result: #{0 1}
;; <--[ 1 ] finished, result: #{0}
;; => [#{0} #{0 1} #{0 1}]
See how the friends of the user with id 2
are only fetched once, even when is duplicated in the collection passed to
urania.core/collect
.
The above pattern of using collect
and mapcat
is captured by the urania.core/traverse
combinator so we can just write:
(defn friends-activity
[id]
(u/traverse activity (friends-of id)))
3.3.3. Batching requests
We’ve seen that urania
organizes and deduplicates fetches for us but there is still room for improvement. In our
examples using urania.core/collect
, we’ve seen how requests to the same data source are run concurrently.
In many cases, remote data sources will offer a batch API that we can use to reduce latency when fetching multiple
results. If our data sources can be fetched in batches, urania
can detect it and optimize our fetches further.
Let’s add batch fetching to the ActivityScore
, we just need to implement the BatchedSource
protocol. It
has only one method: -fetch-multi
, which receives the data sources to fetch and must return a promise with a
map from the data source identities to their results.
(extend-type ActivityScore
u/BatchedSource
(-fetch-multi [score scores _]
(let [ids (cons (:id score) (map :id scores))]
(remote-req ids (zipmap ids (map inc ids))))))
Let’s try to run our friends-activity
again:
(u/run!! (friends-activity 5))
;; -->[ 5 ] waiting<PHONE_NUMBER>2157954
;; <--[ 5 ] finished, result: #{0 1 4 3 2}
;; -->[ (0 1 4 3 2) ] waiting 97.95578032830765
;; <--[ (0 1 4 3 2) ] finished, result: {0 1, 1 2, 4 5, 3 4, 2 3}
;; [1 2 5 4 3]
Our previous fetch of (friends-activity 5)
did n + 1
requests to fetch remote data, where n
is
the number of results of the first query, and we’ve been able to reduce it to 2! This is called the
N + 1 selects problem and urania
solves it nicely.
3.3.4. Fetching data conditionally
Sometimes we want to fetch some data conditionally. For example, when one of our data sources may have a relation with another but this relation is conditional, we may want to fetch the related data of the ones that have it.
Let’s imagine for a moment that some friends may have a pet associated. For simplicity, we will assume that users with an even id have a pet, and users with an odd id don’t. In real examples you may want to inspect the user’s payload and make the decision accordingly.
We want to fetch the pet for those users that have it, so how do we solve this? We can use another combinator
that the library provides: urania.core/value
. First of all, let’s define the data source for pets.
(defrecord Pet [id]
u/DataSource
(-identity [_] id)
(-fetch [_ _]
(remote-req id :dog)))
(defn pet
[id]
(Pet. id))
Now that we have it, we can define a function for fetching our friends and their pets:
(defn fetch-pet
[usr]
(if (even? usr)
(pet usr)
(u/value :no-pet)))
(defn friends-with-pets
[id]
(u/traverse fetch-pet (friends-of id)))
Note how requests for a pet only are sent when the user has a pet:
(u/run!! (friends-with-pets 3))
;; -->[ 3 ] waiting<PHONE_NUMBER>502036
;; <--[ 3 ] finished, result: #{0 1 2}
;; -->[ 0 ] waiting<PHONE_NUMBER>404947
;; -->[ 2 ] waiting<PHONE_NUMBER>212589
;; <--[ 2 ] finished, result: :dog
;; <--[ 0 ] finished, result: :dog
;; => [:dog :no-pet :dog]
4. Advanced usage
While providing a convenient high-level API, urania
allows you to customize how your fetches are run.
4.1. Caching
urania
stores intermediate results in a cache, grouping data sources by their name and mapping their
identity to the fetched value. You can run a fetch and get back both the final cache and the results using
urania.core/execute!
instead of urania.core/run!
.
Let’s define a simple data source and fetch some results with urania.core/execute!
to see the cached
values:
(deftype Simple [id result]
u/DataSource
(-identity [_] id)
(-fetch [_ _] (prom/resolved result)))
(deref
(u/execute! (Simple. 1 42)))
;; => [42 {"user.Simple" {1 42}}]
You can see how the resulting promise will have a two-element vector, the first being the result and the second the cache.
We now can run the same fetch without even having to call -fetch
again, just by passing a prepopulated cache.
We pass it under the :cache
keyword to the urania.core/run!
method’s options:
(u/run! (Simple. 1 42) {:cache {"user.Simple" {1 42}}})
Note that both urania.core/run!!
and urania.core/execute!
support receiving an options map with the cache.
If you want to programmaticaly populate a cache, you can do so easily:
(def simple1 (Simple. 1 42))
(def simple2 (Simple. 2 99))
{(u/resource-name simple1) {(u/cache-id simple1) 42
(u/cache-id simple2) 99}}
;; => {"user.Simple" {1 42, 2 99}}
4.2. Executor
urania
will run your fetch functions asynchronously by default. In Clojure it’ll use java.util.concurrent.ForkJoinPool/commonPool
whereas
in ClojureScript will use the global setTimeout
function.
However, you can customize how the fetch functions are run providing a custom executor as an option. In Clojure, you can pass any object that implements java.util.concurrent.Executor
and it will just work. If you want more fine-grained control you must pass a type implementing the IExecutor
protocol.
Let’s implement a dummy synchronous executor as an example and use it:
(def sync-executor
(reify u/IExecutor
(-execute [_ task]
(task))))
(u/run!! (Simple. 1 42) {:executor sync-executor})
;; => 42
4.3. Environment
The data fetching is commonly performed using stateful objects like a database connection, HTTP client and so on. You
may have noticed that both -fetch
and -fetch-multi
take a last argument that we haven’t used so far: the environment.
The environment is a way for passing arguments to the fetch and fetch-multi functions, let’s see it in action:
(defrecord Environment [id]
u/DataSource
(-identity [_] id)
(-fetch [_ env] (prom/resolved env)))
(u/run!! (Environment. 1) {:env {:connection :a-connection}})
;; => {:connection :a-connection}
As you can see, the :env
value that we pass in the options is available for single fetches. Batched fetches are no
exception:
(defrecord Environment [id]
u/DataSource
(-identity [_] id)
(-fetch [_ env] (prom/resolved env))
u/BatchedSource
(-fetch-multi [_ envs env]
(let [ids (cons id (map :id envs))]
(prom/resolved (zipmap ids (map vector ids (repeat env)))))))
(u/run!! (u/collect [(Environment. 1) (Environment. 2)])
{:env {:connection :a-connection}})
;; => [[1 {:connection :a-connection}] [2 {:connection :a-connection}]]
5. More resources
5.1. Talks
-
"Reinventing Haxl: Efficient, Concurrent and Concise Data Access" at EuroClojure 2015: [Video](https://goo.gl/masrsz), [Slides](https://goo.gl/h4Zuvr)
6. Development
6.1. Contributing
Just open an issue or pull request.
7. Acknowledgements
urania
is based on the initial work on Muse by Alexey Kachayev. It is also heavily inspired by:
-
Haxl (https://github.com/facebook/Haxl) - Haskell library, Facebook, open-sourced
-
Stitch (https://www.youtube.com/watch?v=VVpmMfT8aYw) - Scala library, Twitter, not open-sourced
8. License
Copyright (c) 2015 Alexey Kachayev
Copyright (c) 2015 Alejandro Gómez<EMAIL_ADDRESS>Copyright (c) 2015 Andrey Antukh<EMAIL_ADDRESS>Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublicense, and/or sell copies of the Software, and to
permit persons to whom the Software is furnished to do so, subject to
the following conditions:
The above copyright notice and this permission notice shall be
included in all copies or substantial portions of the Software.

IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.


The purpose of this section is to present the way FreeType manages bitmaps and pixmaps, and how they relate to the concepts previously defined. The relationship between vectorial and pixel coordinates is explained.
This sub-section explains the difference between vectorial and pixel coordinates. To make things clear, brackets will be used to describe pixel coordinates, e.g. ‘[3,5]’, while parentheses will be used for vectorial ones, e.g. ‘(-2, 3.5)’.
In the pixel case, as we use the Y upwards convention; the coordinate [0, 0] always refers to the lower left pixel of a bitmap, while coordinate [width-1, rows-1] to its upper right pixel.
In the vectorial case, point coordinates are expressed in floating units, like (1.25, -2.3). Such a position doesn't refer to a given pixel, but simply to an immaterial point in the 2D plane.
The pixels themselves are indeed square boxes of the 2D plane, whose centers lie in half pixel coordinates. For example, the lower left pixel of a bitmap is delimited by the square (0, 0)-(1, 1), its center being at location (0.5, 0.5).
This introduces some differences when computing distances. For example, the length in pixels of the line [0, 0]-[10, 0] is 11. However, the vectorial distance between (0, 0)-(10, 0) covers exactly 10 pixel centers, hence its length is 10.
FT_Bitmap
descriptorIn FreeType, a bitmap or pixmap is described through a
single structure
called FT_Bitmap
.
The fields we are interested in are:
rows
|
the number of rows, i.e., lines, in the bitmap |
width
|
the number of horizontal pixels in the bitmap |
pitch
|
its absolute value is the number of bytes per bitmap line; it can be either positive or negative depending on the bitmap's vertical orientation |
buffer
|
a typeless pointer to the bitmap pixel buffer |
pixel_mode
|
an enumeration used to describe the pixel format of
the bitmap; examples
are ft_pixel_mode_mono for 1-bit
monochrome bitmaps
and ft_pixel_mode_grays for 8-bit
anti-aliased ‘gray’ values
|
num_grays
|
this is only used for ‘gray’ pixel modes, it gives the number of gray levels used to describe the anti-aliased gray levels (256 by default with FreeType 2) |
Note that the sign of the pitch
field
determines whether the rows in the pixel buffer are stored
in ascending or descending order.
Remember that FreeType uses the Y upwards convention in the 2D plane, which means that a coordinate of (0, 0) always refer to the lower-left corner of a bitmap.
If the pitch is positive, the rows are stored in decreasing vertical position; the first bytes of the pixel buffer are part of the upper bitmap row.
On the opposite, if the pitch is negative, the first bytes of the pixel buffer are part of the lower bitmap row.
In all cases, one can see the pitch as the byte increment needed to skip to the next lower scanline in a given bitmap buffer.
The ‘positive pitch’ convention is very often used, though some systems might need the other.
To speed up memory access, pitch
is in most
cases a multiple of 16bit, 32bit, or even 64bit. It often
happens that the pitch is thus larger than the necessary
bits (or bytes) for a bitmap or pixmap row; in such cases,
unused bits (or bytes) are at the very right (i.e., the
end) of a row.
Generating a bitmap or pixmap image from a vectorial image is easy with FreeType. However, one must understand a few points regarding the positioning of the outline in the 2D plane before converting it to a bitmap:
The glyph loader and hinter always places the outline in the 2D plane so that (0, 0) matches its character origin. This means that the glyph's outline (and corresponding bounding box), can be placed anywhere in the 2D plane (see the graphics in section III).
The target bitmap's area is mapped to the 2D plane, with its lower left corner at (0, 0). This means that a bitmap or pixmap of dimensions [w, h] will be mapped to a 2D rectangle window delimited by (0, 0)-(w, h).
When scan-converting the outline, everything that falls within the bitmap window is rendered, the rest is ignored.
A common mistake made by many developers when they begin using FreeType is believing that a loaded outline can be directly rendered in a bitmap of adequate dimensions. The following images illustrate why this is a problem.
Indeed, in nearly all cases, the loaded or transformed outline must be translated before it is rendered into a target bitmap, in order to adjust its position relative to the target window.
For example, the correct way of creating a stand-alone glyph bitmap is as follows:
Get the size of the glyph bitmap. It can be computed directly from the glyph metrics, or by computing its bounding box (this is useful when a transformation has been applied to the outline after loading it, as the glyph metrics are not valid anymore).
Create the bitmap with the computed dimensions. Don't forget to fill the pixel buffer with the background color.
Translate the outline so that its lower left corner matches (0, 0). Don't forget that in order to preserve hinting, one should use integer, i.e., rounded distances (of course, this isn't required if preserving hinting information doesn't matter, like with rotated text). Usually, this means translating with a vector (-ROUND(xMin), -ROUND(yMin)).
Call the rendering function (it can be
FT_Outline_Render
,
for example).
In the case where one wants to write glyph images directly into a large bitmap, the outlines must be translated so that their vectorial position corresponds to the current text cursor or character origin.
Last update: 13-Feb-2018


Toggle navigation
Start Wars FB
FaceBook
Contact Fan Page
Find what you like !!!
Films
People
Vehicles
Planets
Species
Starships


Class BulkRenderingRequest
Represents a request to render many template files in bulk.
Inheritance
Inherited Members
Namespace: ZptSharp.BulkRendering
Assembly: ZptSharp.Abstractions.dll
Syntax
public class BulkRenderingRequest
Properties
| Improve this Doc View SourceExcludedPaths
Gets or sets a collection of paths/glob patterns used to match files which should be excluded from the operation. The files matched by these exclusions are subtracted from IncludedPaths before rendering begins.
Declaration
public ICollection<string> ExcludedPaths { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Collections.Generic.ICollection<System.String> | The excluded paths. |
IncludedPaths
Gets or sets a collection of paths/glob patterns used to match valid input templates.
Declaration
public ICollection<string> IncludedPaths { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Collections.Generic.ICollection<System.String> | The included paths where input templates are found. |
InputRootPath
Gets or sets a single directory path, used as reference for the 'root' input directory. This will be used to determine each input file's relative path from the input. This allows it to be written to the same relative path for output.
Declaration
public string InputRootPath { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String | The root path for the input files. |
Remarks
If left null or empty, then the current working directory will be used as the root path. Note that any input files which are not descendents of the root path will not be included in the rendering operation.
Model
Gets or sets the model object to be used when rendering the templates.
Declaration
public object Model { get; set; }
Property Value
| Type | Description |
|---|---|
| System.Object | The model. |
OutputFileExtension
If set, then output files will have their file extension replaced with this extension, instead of their previous extension.
Declaration
public string OutputFileExtension { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String | The output file extension. |
OutputPath
Gets the directory path to where the files shall be output once they are rendered.
Declaration
public string OutputPath { get; set; }
Property Value
| Type | Description |
|---|---|
| System.String | The output path. |
RenderingConfig
Gets or sets the rendering configuration to be used when rendering the templates.
Declaration
public RenderingConfig RenderingConfig { get; set; }
Property Value
| Type | Description |
|---|---|
| RenderingConfig | The rendering config. |


The Sound of One Eye Blinking Kikujiro
By Ross Anthony
The film opens gently, introducing us to young Masao on the first day of his summer vacation. Other kids go out of town with their parents, but Masao is being raised by his working grandmother, so he has no one to play with. Sad and lonely, one day he sets out to visit the mother he's never known and who resides off in some distant city making money to support him.
A sympathetic neighbor-lady catching him on his way out assigns her do-nothing thug boyfriend (Kikujiro) to escort Masao on his travel. This entire set up is assembled nicely, capturing our interest and, of course, teasing us with the tasty premise of a small innocent boy, old beer-bellied thug pairing.
Kikujiro is fantastic. Expressing half of all his emotions though a single eye twitch-like blink staring blankly off of a rough, stone chiseled face. A rose on a grave. His stocky body and dispassionate demeanor make no attempts to hide a cave-cold rock-hardened heart. I love this character.
Wallet thickened with his girlfriend's funds, Kikujiro drags the poor boy to the racetrack. Though well shot this sequence lasts too long. In fact, that sentence sums the lead weights that drag this potentially buoyant production from high recommendations. By way of example ... Kikujiro walks across the sandy beach to a waiting Masao in one touching scene, but for an audience to watch a lead character walk 50 feet through the sand on a 100 foot wide shot - it's just asking too much.
Since the film is essentially a road trip (lots of hitchhiking), the gentle pace is inherent and previously established. These long drawn out shots try our patience, while several good sequences would be strengthened with just a few more beats cut from them. In the end, these delays dilute our sympathies.
One other note, a nudist occurrence appears nearer to the end (of the film). Americans may find this a bit troubling and even obscene, but if memory serves me, Japanese still enjoy communal bathing, in fact, an invite of a guest to bath with the family or children is really a warm extension of friendship. It is from this perspective, the character's (Baldy's) nudism ought be interpreted. (This is not to be confused with the sick old man's behavior in the park, earlier in the film.)
All in all, though too slow and too long for its own good, "Kikujiro" gives us a juicy character so rough to like that his description must have been written on sandpaper.  That's acting and direction with depth, with grit, with boldness. Kikujiro is played by his writer/director Kitano.
Kikujiro. Copyright © 2000. Starring Beat Takeshi (Kitano), Yusuke Sekiguchi, Kayoko Kishimoto, Yuko Daike, Kazuko Yoshiyuiki, Beat Kiyoshi, Great Gidayu, Rakkyo Ide. Written and Directed by Takeshi Kitano. Produced by Masayuki Mori, Takio Yoshida a Sony Classics Release .
Grade..........................B -- Copyright © 2000. Ross Anthony, currently based in Los Angeles, has scripted and shot documentaries, music videos, and shorts in 35 countries across North America, Europe, Africa and Asia. For more reviews visit: http://RossAnthony.com
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


RohitRavipati
Objective
SkillSet
Hobbies
ContactInfo
To download my resume, drag the PDF icon and drop it into the folder


Michelle Fullwood / @michelleful
I'm a grad student in linguistics.
I love languages and maps.
I'm from Singapore.
© Open Street Map contributors
{ "type": "Feature", "properties": { "id": 5436.0, "osm_id": 48673274.0, "type": "residential", "name": "Montreal Drive", ... "class": "highway" }, "geometry": { "type": "LineString", "coordinates": [ [<PHONE_NUMBER>75898062, 1.45001447378366 ], [<PHONE_NUMBER>55256259, 1.450088485988644 ], [<PHONE_NUMBER>7016174 , 1.450461983594056 ], ... ] } }
>>> import geopandas as gpd
>>> df = gpd.read_file('singapore-roads.geojson')
>>> df.shape
(59218, 13)
>>> df.plot()
>>> # `within` function returns true if one feature
>>> # sits within the boundary of another
>>> df = df[df.geometry.within(singapore.geometry)]
>>> df.plot()
>>> # filter out empty road names
>>> df = df[df['name'].notnull()]
>>> # only accept roads whose 'highway' variable is
>>> # in an accepted list (not a footpath, etc)
>>> df = df[df['highway'].isin(accepted_road_types)]
| Hand label | ||||
| Train | Classify | |||
| Train | Hand correct | |||
| Train | Train | Classify | ||
# split into train and test data
from sklearn.cross_validation import train_test_split
data_train, data_test, y_train, y_true = \
train_test_split(df['road_name'], df['classification'], test_size=0.2)
(Jalan) Malu-Malu
| unigrams | m(2) a(2) l(2) u(2) -(1) |
| bigrams | #m(1) ma(2) al(2) lu(2) u-(1) ... |
| trigrams | ##m(1) #ma(1) mal(2) alu(2) ... |
| British | Chinese | Malay | Indian |
| 23 | 17 | 0 | 0 |
| Alnwick Berwick Brickson ... | Boon Teck Hock Chye Kheam Hock ... |
>>> from sklearn.feature_extraction.text import CountVectorizer
>>> ngram_counter = CountVectorizer(ngram_range=(1, 4), analyzer='char')
>>> X_train = ngram_counter.fit_transform(data_train)
>>> X_test = ngram_counter.transform(data_test)
>>> from sklearn.svm import LinearSVC
>>> classifier = LinearSVC()
>>> model = classifier.fit(X_train, y_train)
>>> y_test = model.predict(X_test)
>>> sklearn.metrics.accuracy_score(y_true, y_test)
0.551818181818
At the end of the day, some machine learning projects succeed and some fail. What makes the difference? Easily the most important factor is the features used...This is typically where most of the effort in a machine learning project goes.- Pedro Domingos, "A Few Useful Things to Know about Machine Learning"
>>> from sklearn.feature_extraction.text import CountVectorizer
>>> ngram_counter = CountVectorizer(ngram_range=(1, 4), analyzer='char')
>>> X_train = ngram_counter.fit_transform(data_train)
>>> X_test = ngram_counter.transform(data_test)
>>> from sklearn.pipeline import Pipeline
>>> ppl = Pipeline([
('ngram', CountVectorizer(ngram_range=(1, 4), analyzer='char')),
('clf', LinearSVC())
])
>>> model = ppl.fit(data_train)
>>> y_test = model.predict(data_test)
Average word length
from sklearn.base import BaseEstimator, TransformerMixin
class SampleExtractor(BaseEstimator, TransformerMixin):
def __init__(self, vars):
self.vars = vars
def transform(self, X, y=None):
return do_something_to(X, self.vars)
def fit(self, X, y=None):
return self
from sklearn.base import BaseEstimator, TransformerMixin
class AverageWordLengthExtractor(BaseEstimator, TransformerMixin):
"""Takes in df, extracts road name column, outputs average word length"""
def __init__(self):
pass
def average_word_length(self, name):
return np.mean([len(word) for word in name.split()])
def transform(self, X, y=None):
return X['road_name'].apply(self.average_word_length)
def fit(self, X, y=None):
return self
from sklearn.pipeline import Pipeline, FeatureUnion
pipeline = Pipeline([
('feats', FeatureUnion([
('ngram', ngram_count_pipeline), # can pass in either a pipeline
('ave', AverageWordLengthExtractor()) # or a transformer
])),
('clf', LinearSVC()) # classifier
])
>>> # When you do this:
>>> clf = LinearSVC()
>>> # You're really doing this:
>>> clf = LinearSVC(C=1.0, loss='l2', ...)
>>> # changing the values of these hyperparameters can alter performance,
>>> # sometimes quite significantly
| C | |||||
| 0.10 | 1.00 | 10.0 | 100 | 1000 | |
| Gamma 2-2 | |||||
| 20 | ✔ | ||||
| 22 |
| 20% | 20% | 20% | 20% | 20% |
| 20% | 20% | 20% | 20% | 20% |
| 20% | 20% | 20% | 20% | 20% |
| 20% | 20% | 20% | 20% | 20% |
| 20% | 20% | 20% | 20% | 20% |
>>> from sklearn.grid_search import GridSearchCV
>>> pg = {'clf__C': [0.1, 1, 10, 100]}
>>> grid = GridSearchCV(pipeline, param_grid=pg, cv=5)
>>> grid.fit(X_train, y_train)
>>> grid.best_params_
{'clf__C': 0.1}
>>> grid.best_score_
0.702290076336
>>> model = grid.best_estimator_.fit(X_train, y_train)
>>> y_test = model.predict(X_test)
>>> accuracy_score(y_test, y_true)
0.686590909091
>>> pipeline.get_params() # only works if all transformers
# inherit from BaseEstimator!
{'clf__C': 1.0,
'clf__class_weight': None,
'clf__dual': True,
...
'feats__ngram__vect__ngram_range': (1, 4),
'feats__ngram__vect__preprocessor': None,
'feats__ngram__vect__stop_words': None,
}
>>> ax = df.plot(column='classification', colormap='accent')
>>> import mplleaflet
>>> mplleaflet.display(fig=ax.figure, crs=df.crs, tiles='cartodb_positron')


LinkedIn
Home
What is LinkedIn?
Join Today
Sing In
Email:
Password:
Over 175 million professionals use LinkedIn to exchange information, ideas and opportunities
Stay informed about your contacts and industry
Find the people & knowledge you need to achieve your goals
Control your professional identity online
Join LinkedIn Today
Sing Up
First Name:
Last Name:
Email:
Password:
6 or more characters
*
Already on LinkedIn?
Sing in
Search for someone by name:
First Name
Last Name


warming climate forcing temperature Climate uncertainty anthropogenic global response {border-style data Change GMST natural px;} #ffffff;} Geophysical Nature using GWI observed change HadCRUT human-induced model period University radiative reference variability Fig. Research aerosol contribution index . °C CMIP Global estimate line total Letters based px; uncertainties {font-family Earth New Reseach contributions font-size monthly range recent surface time use volcanic ./ngeo Geoscience Group Meteorological Otto Science Warming [], analysis coverage double; fast internal models possible rate responses sensitivity supplementary variations ./JD Basis. Cambridge, Contribution Cowtan HadCRUT-CW IPCC Intergovernmental Kingdom NASA/GISS NY, Panel Physical Press, Report Society Surface Temperature USA, United Working York, attribution biases border-color border-width current data. does evolution future land material method observational results solid; variability, years {font-style {font-weight (Cambridge (see ./GL ./nclimate ./s--- Allen Attribution Berkeley Commons Creative HadCRUT. Index NOAA Physics air bold changes courier; different effect em; eruptions estimated estimates example, grid.. human increase insensitive leads near-surface need observations ocean period. proposed provide pt;} real-time red shown simple temperatures transient trend year


This demo is using header rows of type "fixed", "row" and "sticky" together, which is not recommended. Unless you're using Chrome / FireFox, expect quirks.
Features
Show Paginator
Transpose
Show Header
Show Footer
Hide Columns
{{o.label}}
-1">Sticky Start
Detail Row
Off
On
Predicate (Even rows only)
Force Single Detail Row
Enable Row Selection
Selected ({{dataSource.selection.selected.length}}):
{{item.id}},
Sticky Header
{{ i === 0 ? 'Main' : '#' + i}}
Sticky Footer
{{ i === 0 ? 'Main' : '#' + i}}
Sticky Column
{{o.label}}
Sticky Start
Sticky End


First, we're planning to collaborate with the big shampoo brands and make our proposal for the betterment of the society by explaining every bit and byte around the plastic pollution , climate change and how it's affecting , not only the marine and ecosystem , but directly harming our health and proposing them the idea of manufacturing non plastic bottles to store shampoo, conditioners,etc , in place of the plastic ones.
Then, We'll be proposing our plan and approach and will try to influence the authorities , government and the common people through various platforms to adapt this approach and to use the non-plastic bottles ,e.g. aluminium or steel bottles, in place of plastic bottles and make their contribution for this humanity saving cause and the betterment of the society.
and then, We'll be proposing our model and will encourage the authorities and people to use this approach, to tackle this big time battle of the drastic climate change coming our way, by using the refillable
non plastic bottles and get it refilled by the Vend-E-Shampoo machine ,installed at the local shops in thier locality.
The Machine will be managed and operated manually by the shopkeeper ,in the beginning phase of this project,where the Token will be provided by the shopkeeper to the customer to access the machine where the customers can refilled
their non-plastic shampoo bottles, according to their preferred brands, labelled on the machine .


{{ article['subtitle'] }}
Lorem Ipsum passage, and going through the cites of the word here classical literature passage disvered undou btable source. which looks reasonable the generated charac eristic words.


Bulletin Board: PLM students learn emergency preparedness, response
by Manila Standard LifestyleNearly 1,000 students of Pamantasan ng Lungsod ng Maynila recently joined a seminar on emergency preparedness and response organized by PLDT wireless unit Smart Communications.
Smart brought to PLM its TNT Tropang Ready caravan, which featured lectures, games, and other interactive activities geared toward educating the public on disaster preparedness.
During the event, the participants learned practical tips on what to do in cases of fire, typhoon, flood, or earthquakes, among other calamities, as well as basic first aid skills.
The Tropang Ready program aims to empower the youth with preparedness and response skills that will enable them to mobilize members of their families and communities in times of calamities.
Since 2016, the TNT Tropang Ready caravan has been to nearly 20 state universities and colleges all over the Philippines, and conducted trainings on disaster preparedness and response to more than 30,000 students.
TNT Tropang Ready is part of Smart’s #SafePH program, which promotes preparedness through network resilience, and continuous availability of communication services and mobile solutions and activities that help communities mitigate disaster risks.


| DOSE: |
20 mg |
oral |
2C-T-7 |
(pill / tablet) |
Well what a day to discover you are probably one of the 15% that this effects a little stronger. I took 2 10mg pills after work on a friday at 6 pm. Thanks to erowid for helping me choose that dose. The pills were blue with ying yang symbols.
6:45pm (t+45min) Well i decided to keep a journal, and now is when i experienced the 'body load'. Basically felt like a small burst of energy with heat radiating around my body, similar to mild sunburn.
7:30pm (t+1hr30min) Now my muscles are getting tence. Mostly my neck and legs. I get up and walk around and my legs feel better. I did start to feel sick to stomach but i found this to be due to the gas it was producing, so i would just burp alot and that feeling would go away. No puking for me.
7:45pm (t+1hr45min) Ok now we are talking. I have numb lips, pupils are fully dilated and have that MDMA glow in my body but my head is extremely clear. I put on some music and start dancing.
8:00pm (t+2hrs) Visuals start. they seem to come in waves that retreat a little longer than their onset. I like this because I was feeling a bit overwhelmed by the visuals and i was able to handle them better in slow waves. I still feel very hot and sunburned i have the airconditioner on 73 degrees. It did not help.
9:00pm (t+3hrs) Ok begining the upward peak. I would say my visuals are stroby and organic. Sat down and watched TV, everything was very funny. Light sources change colors from pastel green, pink, and peach. These light changes are not dramatic and very pleaseant. I would have to say the visuals are much like LSD. During the ride up the MDMA feeling has gone away except for wanting to talk to my friends.
1230am (t+6hrs 30min) Visuals are coming down. Music is a big influence on my overall trip. I suggest nothing too 'evil'.
1:30am (T+ 7hrs 30min) ok the body load is back with visuals minimum. So I call a friend to bring over some cannabis. I feel slightly agitated and restless. I find it hard to sit still and just quite annoyed.
2:30pm (t+ 8hrs 30min) Smoked one joint of cannabis. Visuals stopped 30 minutes prior.
5:00am (T+ 10 hrs) Finally feel normal enough to go to sleep.
Overall this was a fun time. I recommend to do your research and thank erowid again on providing me information to make an educated guess on my dosage. I really believe 20mg will be the max dose for me in the future. Time dialation was very minimal and the visuals were lots of fun. I just did not like the agitated state at the end but the cannabis did cure that problem.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


Suggested Friends
Want some personalized suggestions,
Recent Messages
- No messages yet.
{% extends 'base.html' %} {% block title %}User: {{ user.user_id }}{% endblock %} {% block content %}
| Friends |
|---|
| {{ total_friends }} |
Want some personalized suggestions,


MyBingeTV is a web app designed to allow a user to create a “BingeList” of TV shows they want to watch, while also providing detail about the shows in an easy to digest format. It uses Spring Boot and Java to consume a RESTful API and a Postgres database to save the users and their BingeLists.
This is a simple console app to play Hangman with homemade graphics and fun sounds.
GameTracker is the first SpringBoot project I created. It includes a simple Postgres database for storing users and tracked games.
This simple CRUD app is a superhero tracker made using Java and the Spark framework. It is the first web app I created.
IronGram was a fun project influenced by SnapChat. The idea was to use Java and Spring to post an image to a user, then have the image auto-delete after a set time limit once that user has logged in.
This project was my intro into JavaFX. It is a basic desktop app that emulates a web browser.


Click on the map below to drill down to lower admin levels.
Click on the charts to filter data.
To return/change level, you can click on the map, use the reset button or the navigation links.


What: TileJs brings the (lovable?) subtle effects of windows 8 tiles to the web, with css3 and a touch of javascript. What are these subtle effects, I hear you ask? Well, more or less its just a slight tilting of the metro tiles when you click, leaning towards the edge closest to your cursor (or finger!) or, if you click in the center, the slight depression of the tile into the screen.
Why: Because these subtle effects are what make websites great!... perhaps most people won't notice them, but some will... and it will make them smile :)
Demo: Just click the tiles, and see that sleek tilting action!
How: Using tileJs is easy! The code is open source on github , so you can easily download the tileJs script (or the minified version) and get started! All you need to do is add "metro-tile" to the class of you tile-to-be elements, and include the script at the bottom of the page! There's no jquery, or css required either!! There's a more detailed, step by step guide on github: here
Who: You! No... ME! I'm Tim, an Australian interactive developer, living busy New York. I love to tinker and play with Javascript, css and any new technology. You can see my experiments , blog or reach out to me on twitter: @twholman


Resource paths in monkey.
App resources may be stored in many different locations, for example, in an app's data dir, on the local filesystem, or on a remote server.
When using functions and methods that open or load resources, you can use any of the following special prefixes when specifying resource paths:
Not all prefixes work on all targets and the exact behavior of each prefix is target dependant. For example, android and ios can load images from http:// but not audio, while glfw cannot load from http:// at all. Full support for all prefixes is an ongoing mission!
Also, note that Mojo module load commands will automatically insert a "monkey://data/" prefix before any path that does not already incude a prefix.
Supported resource path prefixes
| Function | Html5 | Flash | Glfw | Android | iOS | XNA | PSM |
|---|---|---|---|---|---|---|---|
| LoadString | web, data | data | data, file | web, data, file | data, file | data | data |
| LoadImage | web, data | data | data, file | web, data, file | web, data, file | data | data |
| LoadSound | web, data | data | data, file | data | data, file | data | data |
| PlayMusic | web, data | data | data, file | data | data, file | data | data |
| DataBuffer.Load | web, data | data | data, file | web, data, file | data, file | data | data |
| FileStream.Open | N/A | N/A | file | file | file | file | file |


{% extends 'base.html' %} {% block pagetitle %}500 Oops{% endblock %} {% block main_section %} Oops! An error occurred. Please try again later. {% endblock %}
An error occurred. Please try again later.


I am a passionate and drive Network Engineer. I love building networks, in particular SD WAN networks. I also have a strong passion for network automation and programmability. I have built many scripts and applications either through Ansible or Python to do my tasks faster, more accurately and most importantly consistently.
is the Asia-Pacific’s leader in health and wellness with a portfolio of globally recognised brands across 450 locations.
Jun 2019 - Aug 2020, Brisbane City
We create awesome, instant and secure payment solutions that connect our customers to their customers, anytime, anywhere, wherever money is in motion.
Jan 2017 - Jun 2019, Hamilton, QLD
Domino’s Pizza Enterprises Ltd (Domino’s) is the largest pizza chain in Australia in terms of both network store numbers and network sales. It is also the largest franchisee for the Domino’s Pizza brand in the world.
Jan 2019 - Jun 2019
Jan 2017 - Jan 2019
GB is the largest multi-disciplinary Third Party Claims Administrator in Australia.
Production-Grade Container Scheduling and Management.
StarAn Open Source Machine Learning Framework for Everyone.
StarLorem ipsum dolor sit amet consectetur adipisicing elit. Sapiente eius reprehenderit animi suscipit autem eligendi esse amet aliquid error eum. Accusantium distinctio soluta aliquid quas placeat modi suscipit eligendi nisi.
DetailsThe best way to write secure and reliable applications. Write nothing; deploy nowhere.
StarA Hugo theme for personal portfolio.
Star


Just add this bot to your group or supergroup and enjoy!
Messages received: {{ messgaes_count }}
Groups added bot: {{ chats_count }}
Users added bot: {{ users_count }}
Add to Telegram
Cover template for Bootstrap, by @mdo.


@* * Copyright 2021 HM Revenue & Customs * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import play.api.data.Form @import play.api.mvc.Request @import play.api.i18n.Messages @import uk.gov.hmrc.play.views.html.{helpers => govHelpers} @import views.html.main_template @import views.html.helpers.templates._ @import models.view.FormerNameView @import config.FrontendAppConfig @import controllers.registration.applicant.{routes => applicantRoutes} @import views.html.helpers.saveProgressButton @(formerNameForm: Form[FormerNameView])(implicit request: Request[_], messages: Messages, appConfig: FrontendAppConfig) @fieldSetClasses = @{ if(formerNameForm.hasErrors && (formerNameForm.errors.exists(_.args.nonEmpty))) "form-field--error" else "" } @main_template(title = title(formerNameForm, messages("pages.formerName.heading"))) { @errorSummary( formerNameForm, Seq("formerName") )
@messages("pages.formerName.married")
@govHelpers.form(action = applicantRoutes.FormerNameController.submit()) {


cvc-complex-type.2.3:Element 'beans' cannot have character [children] type's content type is element
Post by: Satyajeet Kadam, Ranch Hand
on Mar 05, 2010 19:44:52
I am unable to run the source code for AOP. I am using spring framework 3.0.This code is from the book "Spring in Simple steps". I am getting error as:
Source code
beans.xml
Main.java
Asp.java
Code.java
Q1) Is there any problem in beans.xml?
Post by: Satyajeet Kadam, Ranch Hand
on Mar 05, 2010 21:39:39
PLease reply urgently. I tried to all possiable ways to run above program but still i am unable to run it?
Post by: Alaa Nassef, Ranch Hand
on Mar 06, 2010 00:06:40
Well, it seems fine to me, but there must be something wrong with it, since this is the meaning of the exception. The meaning of the exception is that the XML, somewhere between the opening and the closing of the beans element, there are some text written, which is not enclosed in an element. Please make sure that this is not in the XML file being parsed, and if you have copied any part of the XML (no matter how small) from somewhere, make sure that every character is correct (sometimes double quotes are writted differently in PDFs for example). Finally, I have a few comments, but don't know if they have any value for your case.
Line 15 of your XML has a double slash instead of one (this might cause a problem)
Line 17 of your XML can be written as <aop:aspectj-autoproxy/> instead of <aop:aspectj-autoproxy></aop:aspectj-autoproxy>
No need to define bean for Main class in line 20 of your XML[/tt]
Use the following snippet to load the application context instead of what you have in line 11
Post by: Satyajeet Kadam, Ranch Hand
on Mar 06, 2010 01:55:29
Thanks for your reply Alaa Nassef.
To Run this program i included:
1) aopalliance. jar in classpath
2)i commented the first line
Now Output of the program is simply Hello World.
Excepted Output is
Q1) Why actual output is different from expected output?Why "Hello from @Before Annotation in Aspectj" and "Hello from @AfterReturning Annotation in Aspectj" is not getting printed in console?Please refer above program for more details.
Post by: Alaa Nassef, Ranch Hand
on Mar 06, 2010 02:09:58
Well, I don't know a lot of AOP, so I can't help with that. Sorry
Post by: Satyajeet Kadam, Ranch Hand
on Mar 06, 2010 05:37:34
Please any one can help me?
Post by: Kuntal Mondal, Greenhorn
on Nov 27, 2010 10:34:34
I know it is kind of late - but your "beans.xml" file has a syntax problem - there is an extra ">" at the following line !!!


If you have several View Models separated in partial Views and you want to use both in a main View
you can do this creating each context with a specific name like
var ko = Html.CreateKnockoutContext("HelloWorldViewModel");
and applying only a specific container id for avoid viewmodel overwriting:
@ko.Apply(Model,"js-helloWorldViewModelWrapper")
In this way you can have two different view models in the same View even if the view models has the same properties.


--- layout: session academic: true title: "Board + Working Groups meeting" code: "9MR9QK" speaker_names_with_affiliations: ['Joost Schouppe (OSMF)'] extra_tags: room: "Hörsaal West" length: "01:30" time: "Saturday, 16:30" recording: True ---
SotM is about the community meeting the community. But we don't always seek out everyone we would like to talk to. So let's use this space to make sure as many members of the working groups and the board get to know each other as people and not just online text. All working group and board members are invited on the stage and can discuss anything. The public can also ask questions.
Feel free to suggest some agenda items to joost -at- osmfoundation.org


If you've forgotten your password, you can go reset it now.
If you remember your password, try signing in again.
For more options, head back home.


Globes Rules Two Popes Drama, will Netflix Power Through with Three in the Category?
by Sasha StoneI didn’t realize it when I wrote the Ace Editors column but The Two Popes is going into drama, not comedy, at the Globes and at the Ace awards. That means, three of the four Netflix movies heading into the race will have to compete for the five slots at the Globes:
The Irishman
Marriage Story
The Two Popes
The comedy category will be free and clear for Dolemite is My Name to compete against Once Upon a Time in Hollywood and Jojo Rabbit, which will end up there. That is going to be a blood bath. There is no other way to put it. But so is drama. Other potential comedy/musical titles – Rocketman, The Farewell, Booksmart, and Late Night.
I think this is nonsense, by the way. The Two Popes should be in comedy.
Other films that will head for the drama category, competing against Netflix would be:
Joker
Little Women
1917
Ford v Ferrari
Just Mercy
Hustlers
Uncut Gems
Queen & Slim
Waves
Judy
Bombshell
Us
Beautiful Day in the Neighborhood
Motherless Brooklyn
Dark Waters
The Lighthouse
Honey Boy
The Peanut Butter Falcon
This year is tough all the way around. Predicting is anyone’s game. We say that every year but this year it’s actually true.


ABOUT US: In October 2004, Aston Martin set up the dedicated 12,500 square metres (135,000 sq ft) AMEP engine production plant within the Ford Germany Niehl, Cologne plant. With capacity to produce up to 5,000 engines a year by 100 specially trained personnel, like traditional Aston Martin engine production from Newport Pagnell, assembly of each unit is entrusted to a single technician from a pool of 30, with V8 and V12 variants assembled in under 20 hours. By bringing engine production back to within Aston Martin, the promise was that Aston Martin would be able to produce small runs of higher performance variants engines.This expanded engine capacity allowed in 2006, the V8 Vantage sports car to enter production at the Gaydon factory, joining the DB9 and DB9 Volante. In December 2003 Aston Martin announced it would return to motor racing in 2005. A new division was created, called Aston Martin Racing, which became responsible, together with Prodrive, for the design, development, and management of the DBR9 program. The DBR9 competes in the GT class in sports car races, including the world-famous 24 Hours of Le Mans. In 2006, an internal audit led Ford to consider divesting itself of parts of its Premier Automotive Group. After suggestions of selling Jaguar Cars, Land Rover, or Volvo Cars were weighed, Ford announced in August 2006 it had engaged UBS AG to sell all or part of Aston Martin at auction. On 19 July 2007, the Newport Pagnell plant rolled out the last of nearly 13,000 cars made there since 1955, a Vanquish S. The Tickford Street facility was converted to Aston Martin's service and restoration department.UK production is now concentrated at Gaydon on the former RAF V-bomber airfield.In March 2008 Aston Martin announced a partnership with Magna Steyr to outsource manufacture of over 2,000 cars annually to Graz, Austria, reassuringly stating: "The continuing growth and success of Aston Martin is based upon Gaydon as the focal point and heart of the business, with the design and engineering of all Aston Martin products continuing to be carried out there."


Pierre van Hooijdonk's reason for going on strike at Nottingham Forest was 'spot on' says ex-Red
Former Reds midfielder Andy Johnson says he sympathised with the Dutch striker
by Tom LeachEx-Nottingham Forest midfielder Andy Johnson says he and his teammates sympathised with Pierre van Hooijdonk's decision to go on strike while at the City Ground, but did not commend his actions.
The striker famously refused to return to pre-season training after seeing a number of Forest's high-profile stars leave during the summer, including his attacking sidekick Kevin Campbell.
Once the club's record signing, van Hooijdonk was crowned Reds player of the year in 1998 but after forcing his exit never played in England again and instead flourished in his native Holland
There he would win the golden boot in both the Eredivise and the UEFA cup as well as being named Dutch footballer of the year.

“The club sold our best players," said Johnson, speaking to Seat Pitch. "Campbell went, Colin Cooper left, Scot Gemmill and Steve Stone were sold during the season and we were all thinking ‘hold on a minute this is a time to build on the squad, not go selling our best players’.
“Pierre went on strike and never came back for pre-season. We all agreed with him in terms of the direction the club was going.
“We didn’t agree with him leaving us in the lurch and having to start our season without a star striker but we all felt the same as him in terms of the club selling the best players.
“Looking back I don’t agree with him physically striking but we all know why he did. He wanted to make a stand against the club and in that sense he was spot on.
“We lost 8-1!," he continued, "8-1! We didn’t just get beat we got thrashed, it was completely humiliating.
“As players we held it against the club, who had put us in such a situation by stripping us of our best players.”


Andreas Angourakis, Agnese Fusaro, Verónica Martínez Ferreras, Josep M. Gurt Session #672 - CAA @ EAA: Computational Models in Archaeology
available at https://andros-spica.github.io/EAA2018_simulation/
Stride, S. (2005). Géographie archéologique de la province du Surkhan Darya (Ouzbékistan du sud / Bactriane du nord). Ph.D thesis, Université Paris I Panthéon-Sorbonne.
Overlapping niches: Stakeholders must cooperate or compete for land use
Are farming-herding interactions competitive or cooperative?
Through which mechanisms
and under which conditions may
stakeholders cooperate or compete?
What impact does these aspects have on the existence of certain land use patterns?
→ Strong bimodality
→ Bias favouring farming
Publications ⇓
ANGOURAKIS, A., RONDELLI, B., STRIDE, S., RUBIO–CAMPILLO, X., BALBO, A. L., TORRANO, A., MARTÍNEZ, V., MADELLA, M.; GURT, J. M. 2014, “Land Use Patterns in Central Asia. Step 1: The Musical Chairs Model”, Journal of Archaeological Method and Theory, 21: 405-425. http://dx.doi.org/10.1007/s10816–013–9197–0.
ANGOURAKIS, A. 2014, “Exploring the oases of Central Asia: A model of interaction between mobile livestock breeding and sedentary agriculture”, in Antela-Bernárdez, B. and Vidal, J. (eds.) Central Asia in Antiquity: Interdisciplinary Approaches, BAR International Series 2665, pp. 3-16.
ANGOURAKIS, A., 2016a (February 3). "Musical Chairs" (Version 1). CoMSES Computational Model Library. https://www.openabm.org/model/4880/version/1
Publications ⇓
Angourakis, A., Salpeteur, M., Martínez, V., and Gurt, J.M. (2017). The Nice Musical Chairs model. Exploring the role of competition and cooperation between farming and herding in the formation of land use patterns in arid Afro-Eurasia. Journal of Archaeological Method and Theory, 21: 405-425. http://dx.doi.org/10.1007/s10816-016-9309-8.
Angourakis, A. (2017, January 9). "Nice Musical Chairs" (Version 5). CoMSES Computational Model Library. https://www.openabm.org/model/4885/version/5
$$Autonomy index = {{numAutonomousEntities * numGroups} \over maxNumGroups^2}$$
$$Land use centralization index =$$
$${bigAutonomousEntityTerritory \over {(countAutonomousEntities * meanAutonomousEntityTerritory)}}$$
Simulations: 1000 steps (years). Steps shown: 5, 10, and 100 steps intervals up to 1000.
Andreas Angourakis, Agnese Fusaro, Verónica Martínez Ferreras, Josep M. Gurt Session #672 - CAA @ EAA: Computational Models in Archaeology
THANK YOU!
address any questions to A. Angourakis: andros.spica@gmail.com