Specifies where results from a SQL query are placed when they are retrieved with SQL.RETRIEVE. If this function is not available, you must install the Microsoft ODBC add-in (XLODBC.XLA).
Syntax
SQL.BIND(connection_num, column, reference)
Connection_num is the unique connection ID of the data source for which you want to define storage.
Connection_num was returned by a previously executed SQL.OPEN function.
If connection_num is not valid, then SQL.BIND returns the #VALUE! error value.
Column is the number of the result column that is to be bound. Result columns are numbered from left to right starting with 1. If column is omitted then all bindings for connection_num are removed. Column number 0 contains row numbers for the result set. If column number 0 is bound then SQL.RETRIEVE will return row numbers in the bound location.
Reference is a single cell reference on the worksheet where the results should be placed. If reference is omitted, the binding is removed for the column.
When SQL.RETRIEVE is called, the result rows in this column will be placed in the reference cell and the cells immediately below reference. The number of rows that will be retrieved is one of the SQL.RETRIEVE arguments.
Remarks
If SQL.BIND is completed successfully then it will return a vertical array listing the bound columns on the current connection. If SQL.BIND is unable to bind the result column then it will return the error value #N/A. In such a case SQL.BIND will place error information in memory for the SQL.ERROR function, if such information is available.
SQL.BIND tells the ODBC interface where to place results when they are retrieved using SQL.RETRIEVE. Binding is not necessary but can be useful if you want the results from different columns to be placed in disjoint worksheet locations.
If bindings are used, SQL.BIND must be called once for each column in the result set. If a result column is not bound then it will not be returned. A binding remains valid for as long as connection_num is open.
Call SQL.BIND after calling SQL.OPEN and SQL.EXEC.QUERY, but before calling SQL.RETRIEVE or SQL.RETRIEVE.TO.FILE. Calls to SQL.BIND will not affect results that have already been retrieved.
Example
SQL.BIND(conn1,1,"[Book1]Sheet1!C1") stores data obtained from the data source conn1 on Sheet1 from left to right in cell C1, starting with column1.
Related Functions
SQL.OPEN Establishes a connection with a data source
SQL.EXEC.QUERY Sends a query to a data source
SQL.RETRIEVE.TO.FILE Retrieves query results and places them in a file
SQL.RETRIEVE Retrieves query results
SQL.GET.SCHEMA Gets information about a connected data source.
SQL.CLOSE Closes a connection to a data source.
SQL.ERROR Returns detailed error information
Return to index


表达¶
$ npm install @feathersjs/express --save
The @feathersjs/express
module contains
Express framework integrations for Feathers:
The Express framework bindings to make a Feathers application Express compatible
An Express based transport to expose services through a REST API
An :doc:`Express error handler <#expresserrorhandler>`_ for Feathers errors <./errors>
const express = require('@feathersjs/express');
Very Important: This page describes how to set up an Express server and REST API. See the REST client chapter how to use this server on the client.
重要
This chapter assumes that you are familiar with Express.
express(app)¶
:doc:express(app) -> app
is a function that turns a Feathers application <./application> into a fully Express (4+) compatible
application that additionally to Feathers functionality also lets you
use the Express API.
const feathers = require('@feathersjs/feathers');
const express = require('@feathersjs/express');
// Create an app that is a Feathers AND Express application
const app = express(feathers());
Note that @feathersjs/express
(express
) also exposes the
standard Express
middleware:
express.json
- A JSON body parserexpress.urlencoded
- A URL encoded form body parserexpress.static
- To statically host files in a folderexpress.Router
- Creates an Express router object
express()¶
If no Feathers application is passed, express() -> app
returns a
plain Express application just like a normal call to Express would.
app.use(path, service|mw|[mw])¶
:doc:app.use(path, service|mw|[mw]) -> app
registers either a service object <./services>,
an Express middleware or
an array of Express middleware on
the given path. If 服务 is passed it
will use Feathers registration mechanism, for a middleware function
Express.
// Register a service
app.use('/todos', {
get(id) {
return Promise.resolve({ id });
}
});
// Register an Express middleware
app.use('/test', (req, res) => {
res.json({
message: 'Hello world from Express middleware'
});
});
// Register multiple Express middleware functions
app.use('/test', (req, res, next) => {
res.data = 'Step 1 worked';
next();
}, (req, res) => {
res.json({
message: 'Hello world from Express middleware ' + res.data
});
});
app.listen(port)¶
app.listen(port) -> HttpServer
will first call Express
app.listen and then
internally also call the Feathers app.setup(server).
// Listen on port 3030
const server = app.listen(3030);
server.on('listening', () => console.log('Feathers application started'));
app.setup(server)¶
app.setup(server) -> app
is usually called internally by
app.listen
but in the cases described below needs to be called
explicitly.
Sub-Apps¶
When registering an application as a sub-app, app.setup(server)
has
to be called to initialize the sub-apps services.
const feathers = require('@feathersjs/feathers');
const express = require('@feathersjs/express');
const api = express(feathers())
.configure(express.rest())
.use('/service', myService);
const mainApp = express().use('/api/v1', api);
const server = mainApp.listen(3030);
// Now call setup on the Feathers app with the server
api.setup(server);
ProTip: We recommend avoiding complex sub-app setups because websockets and Feathers built in authentication are not fully sub-app aware at the moment.
HTTPS¶
HTTPS requires creating a separate server in which case
app.setup(server)
also has to be called explicitly.
const fs = require('fs');
const https = require('https');
const feathers = require('@feathersjs/feathers');
const express = require('@feathersjs/express');
const app = express(feathers());
const server = https.createServer({
key: fs.readFileSync('privatekey.pem'),
cert: fs.readFileSync('certificate.pem')
}, app).listen(443);
// Call app.setup to initialize all services and SocketIO
app.setup(server);
Virtual Hosts¶
The vhost Express middleware
can be used to run a Feathers application on a virtual host but again
requires app.setup(server)
to be called explicitly.
const vhost = require('vhost');
const feathers = require('@feathersjs/feathers');
const express = require('@feathersjs/express');
const app = express(feathers());
app.use('/todos', todoService);
const host = express().use(vhost('foo.com', app));
const server = host.listen(8080);
// Here we need to call app.setup because .listen on our virtal hosted
// app is never called
app.setup(server);
express.rest()¶
express.rest
registers a Feathers transport mechanism that allows
you to expose and consume 服务 through a
RESTful
API.
This means that you can call a service method through the GET
,
POST
, PUT
, PATCH
and DELETE
HTTP
methods:
Service method |
HTTP method |
Path |
|---|---|---|
.find() |
GET |
/messages |
.get() |
GET |
/messages/1 |
.create() |
POST |
/messages |
.update() |
PUT |
/messages/1 |
.patch() |
PATCH |
/messages/1 |
.remove() |
DELETE |
/messages/1 |
To expose services through a RESTful API we will have to configure
express.rest
and provide our own body parser middleware (usually the
standard Express 4
body-parser) to make REST
.create
, .update
and .patch
calls parse the data in the HTTP
body. If you would like to add other middleware before the REST
handler, call app.use(middleware)
before registering any services.
ProTip: The body-parser middleware has to be registered before any service. Otherwise the service method will throw a
No data provided
orFirst parameter for 'create' must be an object
error.
app.configure(express.rest())¶
Configures the transport provider with a standard formatter sending JSON response via res.json.
const feathers = require('@feathersjs/feathers');
const express = require('@feathersjs/express');
// Create an Express compatible Feathers application
const app = express(feathers());
// Turn on JSON parser for REST services
app.use(express.json())
// Turn on URL-encoded parser for REST services
app.use(express.urlencoded({ extended: true }));
// Set up REST transport
app.configure(express.rest())
app.configure(express.rest(formatter))¶
The default REST response formatter is a middleware that formats the
data retrieved by the service as JSON. If you would like to configure
your own formatter
middleware pass a formatter(req, res)
function. This middleware will have access to res.data
which is the
data returned by the service.
res.format can be
used for content negotiation.
const feathers = require('@feathersjs/feathers');
const express = require('@feathersjs/express');
const app = express(feathers());
// Turn on JSON parser for REST services
app.use(express.json())
// Turn on URL-encoded parser for REST services
app.use(express.urlencoded({ extended: true }));
// Set up REST transport
app.configure(express.rest(function(req, res) {
// Format the message as text/plain
res.format({
'text/plain': function() {
res.end(`The Message is: "${res.data.text}"`);
}
});
}))
Custom service middleware¶
Custom Express middleware that only should run before or after a
specific service can be passed to app.use
in the order it should
run:
const todoService = {
get(id) {
return Promise.resolve({
id,
description: `You have to do ${id}!`
});
}
};
app.use('/todos', ensureAuthenticated, logRequest, todoService, updateData);
Middleware that runs after the service has the service call information available as
res.data
- The data that will be sent钩 context of the service method call
For example updateData
could look like this:
function updateData(req, res, next) {
res.data.updateData = true;
next();
}
ProTip: If you run
res.send
in a custom middleware after the service and don’t callnext
, other middleware (like the REST formatter) will be skipped. This can be used to e.g. render different views for certain service method calls.
params¶
All middleware registered after the ./rest will
have access to the req.feathers
object to set properties on the
service method params
:
const feathers = require('@feathersjs/feathers');
const express = require('@feathersjs/express');
const bodyParser = require('body-parser');
const app = express(feathers());
app.configure(express.rest())
.use(bodyParser.json())
.use(bodyParser.urlencoded({extended: true}))
.use(function(req, res, next) {
req.feathers.fromMiddleware = 'Hello world';
next();
});
app.use('/todos', {
get(id, params) {
console.log(params.provider); // -> 'rest'
console.log(params.fromMiddleware); // -> 'Hello world'
return Promise.resolve({
id, params,
description: `You have to do ${id}!`
});
}
});
app.listen(3030);
You can see the parameters set by running the example and visiting
http://localhost:3030/todos/test
.
Avoid setting req.feathers = something
directly since it may already
contain information that other Feathers plugins rely on. Adding
individual properties or using
Object.assign(req.feathers, something)
is the more reliable option.
Very important: Since the order of Express middleware matters, any middleware that sets service parameters has to be registered before your services (in a generated application before
app.configure(services)
or inmiddleware/index.js
).
ProTip: Although it may be convenient to set
req.feathers.req = req;
to have access to the request object in the service, we recommend keeping your services as provider independent as possible. There usually is a way to pre-process your data in a middleware so that the service does not need to know about the HTTP request or response.
params.query¶
params.query
will contain the URL query parameters sent from the
client. For the REST transport the query string is parsed using the
qs module. For some query string
examples see the 查询
chapter.
重要
Only params.query
is passed between the server and
the client, other parts of params
are not. This is for security
reasons so that a client can’t set things like params.user
or the
database options. You can always map from params.query
to other
钩.
For example:
GET /messages?read=true&$sort[createdAt]=-1
Will set params.query
to
{
"read": "true",
"$sort": { "createdAt": "-1" }
}
ProTip: Since the URL is just a string, there will be no type conversion. This can be done manually in a 钩 or with the query-types Express middleware to convert Boolean and Numeric types.
params.provider
¶
For any 服务 made through REST 钩 this can for example be used to prevent external users from making a service method call:
app.service('users').hooks({
before: {
remove(context) {
// check for if(context.params.provider) to prevent any external call
if(context.params.provider === 'rest') {
throw new Error('You can not delete a user via REST');
}
}
}
});
params.route¶
See the routing section.
express.notFound(options)¶
express.notFound()
returns middleware that returns a NotFound
(404) 错误. It should be used as the last
middleware before the error handler. The following options are
available:
verbose
: Set totrue
if the URL should be included in the error message (default:false
)
// Return errors that include the URL
app.use(express.notFound({ verbose: true });
app.use(errorHandler());
express.errorHandler()¶
expres.errorHandler
is an Express error
handler
middleware that formats any error response to a REST call as JSON (or
HTML if e.g. someone hits our API directly in the browser) and sets the
appropriate error code.
ProTip: You can still use any other Express compatible error middleware with Feathers. In fact, the
express.errors
is just a slightly customized one. Very Important: Just as in Express, the error handler has to be registered after all middleware and services.
app.use(express.errorHandler())
¶
Set up the error handler with the default configuration.
const feathers = require('@feathersjs/feathers');
const express = require('@feathersjs/express');
const app = express(feathers());
// before starting the app
app.use(express.errorHandler())
app.use(express.errorHandler(options))
¶
const feathers = require('@feathersjs/feathers');
const express = require('@feathersjs/express');
const app = express(feathers());
// Just like Express your error middleware needs to be
// set up last in your middleware chain.
app.use(express.errorHandler({
html: function(error, req, res, next) {
// render your error view with the error object
res.render('error', error);
}
}));
app.use(errorHandler({
html: {
404: 'path/to/notFound.html',
500: 'there/will/be/robots.html'
}
}));
ProTip: If you want to have the response in json format be sure to set the
Accept
header in your request toapplication/json
otherwise the default error handler will return HTML.
The following options can be passed when creating a new localstorage service:
html
(Function|Object) [optional] - A custom formatter function or an object that contains the path to your custom html error pages.logger
(Function|false) (default:console
) - Set a logger object to log the error (it will be logger withlogger.error(error)
ProTip:
html
can also be set tofalse
to disable html error pages altogether so that only JSON is returned.
Routing¶
Express route placeholders in a service URL will be added to the
services params.route
.
重要
See the FAQ entry on nested routes for more details on when and when not to use nested routes.
const feathers = require('@feathersjs/feathers');
const express = require('@feathersjs/express');
const app = express(feathers());
app.configure(express.rest())
.use(function(req, res, next) {
req.feathers.fromMiddleware = 'Hello world';
next();
});
app.use('/users/:userId/messages', {
get(id, params) {
console.log(params.query); // -> ?query
console.log(params.provider); // -> 'rest'
console.log(params.fromMiddleware); // -> 'Hello world'
console.log(params.route.userId); // will be `1` for GET /users/1/messages
return Promise.resolve({
id,
params,
read: false,
text: `Feathers is great!`,
createdAt: new Date().getTime()
});
}
});
app.listen(3030);


an object-oriented computer programming language commonly used to create interactive effects within web browsers.
The definition of an operator is a symbol that is used to perform an operation. Most often these operations are arithmetic (addition, subtraction, etc), but not always.
Variable declarations, wherever they occur, are processed before any code is executed. The scope of a variable declared with var is its current execution context, which is either the enclosing function or, for variables declared outside any function, global.
Essential conventions include generic patterns that should be adhered in order to write readable, consistent and maintainable code.
 A JavaScript function is executed when "something" invokes it (calls it).
JavaScript methods are the actions that can be performed on objects. A JavaScript method is a property containing a function definition.
JavaScript functions have a built-in object called the arguments object. The argument object contains an array of the arguments used when the function was called (invoked).
Function parameters are the names listed in the function definition.
The return statement ends function execution and specifies a value to be returned to the function caller.
Method chaining is a technique that can be used to simplify code in scenarios that involve calling multiple functions on the same object consecutively.
A sequence of characters.
A JavaScript Boolean represents one of two values: true or false.
Undefined is a non-configurable, non-writable property.
The NaN property represents "Not-a-Number" value.
he escape() function encodes a string. This function makes a string portable, so it can be transmitted across any network to any computer that supports ASCII characters. This function encodes special characters, with the exception of: * @ - _ + . /
The alert() method displays an alert box with a specified message and an OK button.
JavaScript comments can be used to explain JavaScript code, and to make it more readable. JavaScript comments can also be used to prevent execution, when testing alternative code. Single line comments start with //. Any text between // and the end of the line will be ignored by JavaScript (will not be executed).
jQuery is a concise and fast JavaScript library that can be used to simplify event handling, HTML document traversing, Ajax interactions and animation for speedy website development.
Attributes provide additional information about an element.
this is an example
this is another example


Data flow and staging methods
Overview
The execution components involved in a Swift workflow are the client, the swift service and the workers. The client is the program that executes the workflow described in a swift script and is invoked by the swift command. The service may be started separately or automatically by the swift client and is responsible for provisioning resources from clouds, clusters or HPC systems. The workers are launched by the swift-service and are responsible for controlling the execution of the user’s application on the compute nodes.
Different clusters, HPC systems, and cloud vendors may have shared file-systems, varying network characteristics and local-disks available which can be utilized differently to marshal data efficiently within a workflow. Data flow refers to this movement of data within a workflow. On distributed systems with varying levels of shared resources, the Swift client and service coordinates the flow of data among the worker-nodes such that the data required for computation is available to the worker prior to the execution of the users’s application as well as ensuring that the computed results are captured once tasks run to completion.
There are 6 different staging methods that are supported by Swift. They are:
-
Local
-
Direct
-
Wrapper
-
Swift
-
Shared-fs
-
Service-local
These staging methods are explained in detail in the following sections.
Legend for the following sections:
Staging method : local
Data flow in local staging:
Summary
The local staging method is designed for shared-nothing architectures such as clusters and clouds with no shared file-systems. The data originates on the node where the client runs and all data transfers are done explicity over the network. This method avoids using a shared-filesystem to transfer the files over the network, as in many cases the shared-filesystem is a shared among multiple users which adds congestion and it also could just be unsuitable for certain file access patterns. The client and service need not be on the same machine, which allows a client running on a local workstation to channel data through a service on the headnode of a Cluster1 to compute nodes provisioned from Cluster1. The is the default file staging method as this works on all computational resources. Since all the data is transferred via the swift-service the network bandwidth of the service could bottleneck the data flow. Similarly if the swift client is running remotely, the network links between the client and the service could potentially become a bottleneck for large volumes of data.
When to use this mode
The data volumes that need to be transferred to and from the workers to the client per worker are not more that hundreds of MB. As data sizes approach GBs of data per task, other transport mechanisms such as Globus transfers are worth considering.
When each task either consumes or generates a large number of small files, shared-filesystem based copies can be very slow. The local staging method is an ideal candidate for this scenario. However, when there are large number of files involved the filesystem of the system on which the client is executing could become a bottleneck. Using a faster non-disk filesystem when available generally improves performance significantly.
Example configs
sites: midway site.midway { execution { type: "coaster" URL: "swift.rcc.uchicago.edu" jobManager: "ssh-cl:slurm" # Client connects remotely to the login node. options { nodeGranularity: 1 maxNodesPerJob: 1 jobQueue: "sandyb" maxJobs: 1 tasksPerNode: 1 maxJobTime: "00:08:20" } } staging: "local" workDirectory: "/tmp/"${env.USER} app.date { executable: "/bin/date" maxWallTime: "00:05:00" } }
Performance
All data-flow is over the network links from the client node and service node in this staging method and as a result, the network capacity of the client node is a potential limiting factor for large data volumes.
When several small files are involved, or with sufficiently large files, the filesystem on the client node can become a bottleneck.
There are performance limitations to the the staging/transport mechanism that swift uses, which could limit transfer throughputs. [TODO: Data to support this would be very nice]
Notes:
When running using local coasters (local instead of ssh-cl), the client and service run on the same node. In this case, the network links are between the service and workers.
Staging method : Direct
Data flow with Direct staging:
Data flow with Direct staging and a scratch directory:
Summary
The direct staging mode is designed for computational resources with High-Performance shared-filesystems. This mode requires that a shared filesystem such as NFS, Lustre, or even FUSE-mounted-S3 is mounted across the nodes where the client, service, and the workers are executing. Instead of Swift managing network transfers, the network transfers are implicitly managed by the shared-filesystem. The apps run in sandbox directories created under the workDirectory, but the tasks themselves will receive absolute paths for the input and output files. For applications that are IO bound, writing directly to the shared-filesystem can adversely affect the shared filesystem performance. To avoid this there is an option to specify a “scratch” folder on a local disk on the compute nodes.
When to use this mode
Large volumes of data are either consumed or generated by the application and a High Performance shared-filesystem is available across the nodes. On systems which have shared-filesystems, with I/O bandwidth that exceeds the network links between the headnode and the worker nodes, using the network to transfer data to the compute nodes could be sub-optimal.
When a high-performance shared filesystem is available, such as the case on many supercomputing systems, there is sufficient I/O bandwidth to support several applications reading and writing to the filesystem in parallel.
Another scenario is when the shared-filesystem is sensitive to creation and deletion of small files and directories. The swift workers create a sandbox directory for each task, which is (3 : TODO:confirm this with Mihael) levels deep. Using the direct mode with the workDirectory on a local disk (say /tmp) could avoid the overhead from swift’s mechanisms for sandboxing tasks.
Example configs
The following is an example for the direct staging mode. * Staging method is set to “direct”. * workDirectory may be set to the shared filesystem or a local filesystem.
In this case, Swift assumes that file variables point at files on the shared filesystem. The apps which are executed on the workers resolve the file variables to absolute paths to the input and output files on the shared-filesystem.
sites: midway site.midway { execution { type: "coaster" URL: "swift.rcc.uchicago.edu" jobManager: "local:slurm" options { nodeGranularity: 1 maxNodesPerJob: 1 jobQueue: "sandyb" maxJobs: 1 tasksPerNode: 1 maxJobTime: "00:08:20" } } staging: direct workDirectory: "/tmp/"${env.USER}"/swiftwork" app.bash { executable: "/bin/bash" maxWallTime: "00:05:00" } }
The following is an example for the direct staging mode.
-
Staging method is set to “direct”
-
workDirectory may be set to the shared filesystem or a local filesystem.
-
Scratch is set to a directory on the local disks of the workers.
Since the staging method is set to “direct”, swift will assume that file are on a shared file-system. In the context of user-application the file variables will resolve to absolute paths of the input/output files on the scratch directory. Before the workers start the execution of user tasks, the workers will copy the input files from the shared-filesystem to the scratch directory, and after execution will copy out the output files from the scratch directory to the shared-filesystem.
sites: midway site.midway { execution { type: "coaster" URL: "swift.rcc.uchicago.edu" jobManager: "local:slurm" options { nodeGranularity: 1 maxNodesPerJob: 1 jobQueue: "sandyb" maxJobs: 1 tasksPerNode: 1 maxJobTime: "00:08:20" } } staging: direct workDirectory: "/tmp/"${env.USER}"/swiftwork" scratch: "/scratch/local/"${env.USER}"/work/" app.bash { executable: "/bin/bash" maxWallTime: "00:05:00" } } TCPPortRange: "50000,51000" lazyErrors: false executionRetries: 0 keepSiteDir: true providerStagingPinSwiftFiles: false alwaysTransferWrapperLog: true
Notes:
TODO : Details of the filename behavior in apps and within swiftscript body.
When this configuration is used, the worker copies the input files from the shared-filesystem to the scratch directory, and the user application will get the path to the file on scratch when the filename(<file_variable>) and it’s shorthand @<file_variable> primitives are used in the app definition. The filename and @ primitives when used outside of the app definitions will point at the files on the shared-filesystem.
Performance
"Direct" is theoretically the optimal way to use the shared-filesystem. There are no unnecessary copies, and the application that requires the file alone access the data.
If the data access pattern of the application involves random seeks or creation of several intermediate small files, the "scratch" option allows you to offload sub-optimal file access patterns to a local disk/memory. This avoids costly accesses on the shared-filesystem and indirectly the network.
Staging method : Swift
Data flow with staging method Swift:
Summary
Swift staging, involves the client accessing file over a supported method like ssh or a local-filesystem access, and making the inputs available to the workers over a work-directory on a shared filesystem. This staging method uses an intermediate staging location that is on a shared-FS so each files is, in addition to being read from the initial location, written to and read from a shared FS, both of each are overhead. The only advantage to this is that you don’t need coasters to use it and it’s supported on a large number of computational resources.
This is the default staging mechanism used if no staging method is defined in the swift config file.
When to use this mode
-
You can access data using one of the supported methods like: local filesystem access ssh - Use scp to access files GSIFTP GridFTP
-
A shared-FS is present, that works well for your data access patterns.
-
You want to use a non-coaster execution provider.
The GSIFTP and GridFTP are not actively tested, and are not guaranteed to work.
Example configs
sites: midway site.midway { execution { type: "coaster" URL: "swift.rcc.uchicago.edu" jobManager: "local:slurm" options { nodeGranularity: 1 maxNodesPerJob: 1 jobQueue: "sandyb" maxJobs: 1 tasksPerNode: 1 maxJobTime: "00:08:20" } } filesystem { type: "local" URL: "localhost" } staging: direct workDirectory: "/scratch/midway/"${env.USER}"/swiftwork" app.bash { executable: "/bin/bash" maxWallTime: "00:05:00" } } TCPPortRange: "50000,51000" lazyErrors: false executionRetries: 0 keepSiteDir: true providerStagingPinSwiftFiles: false alwaysTransferWrapperLog: true
Performance
The Swift staging method uses an intermediate staging location that is on a shared FS, each files is, in addition to being read from the initial location, written to and read from a shared FS, both of each are overhead. The only advantage to this is that you don’t need coasters to use it and it’s supported in a lot of cases.
Staging method : Wrapper
Summary
The wrapper staging method relies on a wrapper script used to stage files to and from the swift workers. Currently the wrapper staging method supports fetching files over HTTP and between the client filesystem. The wrapper staging method provides a flexible interface to add support for third party transfer mechanisms to the swift worker.
TODO: Is guc supported ?
When to use this mode
The repository for the input or output data can be accessed over a supported tranfer mechanism.
The data can be accessed only by an exotic tranfer mechanism, which could be incorporated into the supported methods for wrapper staging.
Example configs
sites: midway site.midway { execution { type: "coaster" jobManager: "local:local" URL: "localhost" } filesystem { type: local } staging: "wrapper" scratch: "/tmp/"${env.USER}"/swift-scratch" workDirectory: "swiftwork" app.ALL { executable: "*" } } wrapperStagingLocalServer: "file://"


public class MessageBus
extends java.lang.Object
MessageData
s| Constructor and Description |
|---|
MessageBus()
Constructor
|
| Modifier and Type | Method and Description |
|---|---|
void |
broadcast(MessageExchange source,
java.lang.String messageType)
Broadcasts a message to all
MessageExchange s from a specified
MessageExchange |
void |
broadcast(MessageExchange source,
java.lang.String messageType,
MessageData messageData)
|
void |
broadcast(java.lang.String messageType)
Broadcasts a message to all
MessageExchange s from an anonymous
source |
void |
broadcast(java.lang.String messageType,
MessageData messageData)
Broadcasts a message with
MessageData to all
MessageExchange s from an anonymous source |
void |
broadcastQuery(java.lang.String messageType,
MessageData messageData,
java.lang.String responseMessageType,
boolean requiresDirectResponse,
MessageHandler queryHandler)
Broadcasts a message and calls a
MessageHandler when a response
message is received. |
void |
broadcastQuery(java.lang.String messageType,
MessageData messageData,
java.lang.String responseMessageType,
MessageHandler queryHandler)
Broadcasts a message and calls a
MessageHandler when a response
message is received. |
void |
broadcastQuery(java.lang.String messageType,
java.lang.String responseMessageType,
boolean requiresDirectResponse,
MessageHandler queryHandler)
Broadcasts a message and calls a
MessageHandler when a response
message is received. |
void |
broadcastQuery(java.lang.String messageType,
java.lang.String responseMessageType,
MessageHandler queryHandler)
Broadcasts a message and calls a
MessageHandler when a response
message is received. |
MessageExchange |
createConcurrentExchange(MessageHandler... messageHandlers)
Creates a
ConcurrentMessageExchange that processes messages on
its own Thread . |
MessageExchange |
createImmediateExchange(MessageHandler... messageHandlers)
Creates a
ImmediateMessageExchange that processes messages
immediately when they are received |
MessageExchange |
createIntervalExchange(float interval,
MessageHandler messageHandlers)
Creates a
IntervalMessageExchange that processes messages after a
certain amount of time has elapsed. |
MessageExchange |
createOnUpdateExchange(MessageHandler... messageHandlers)
Creates a
OnUpdateMessageExchange that processes messages when
update(float) is called |
int |
getAnonymousExchangeId()
Returns the id of the
MessageExchange used for anonymous sending |
int |
getQueryMessagePoolSize()
Returns the amount of
QueryMessageExchange instances available |
int |
getTotalActiveExchanges()
Returns the total amount of active
MessageExchange s (including
QueryMessageExchange s |
void |
send(MessageExchange source,
MessageExchange destination,
java.lang.String messageType)
Sends a message from one
MessageExchange to another |
void |
send(MessageExchange source,
MessageExchange destination,
java.lang.String messageType,
MessageData messageData)
Sends a message with
MessageData from one MessageExchange
to another |
void |
sendTo(MessageExchange destination,
java.lang.String messageType)
Sends a message to a
MessageExchange from an anonymous source |
void |
sendTo(MessageExchange destination,
java.lang.String messageType,
MessageData messageData)
Sends a message with
MessageData to a MessageExchange
from an anonymous source |
void |
update(float delta)
Updates all
MessageExchange s |
public void update(float delta)
MessageExchange
sdelta
- (in seconds) The timestep or amount of time that has elapsed
since the last framepublic MessageExchange createImmediateExchange(MessageHandler... messageHandlers)
ImmediateMessageExchange
that processes messages
immediately when they are receivedmessageHandlers
- The MessageHandler
instances for processing messages received by
the MessageExchange
ImmediateMessageExchange
public MessageExchange createIntervalExchange(float interval, MessageHandler messageHandlers)
IntervalMessageExchange
that processes messages after a
certain amount of time has elapsed.interval
- The interval between processing MessageData
s (in
seconds)messageHandlers
- The MessageHandler
instances for processing messages received by
the MessageExchange
IntervalMessageExchange
public MessageExchange createOnUpdateExchange(MessageHandler... messageHandlers)
OnUpdateMessageExchange
that processes messages when
update(float)
is calledmessageHandlers
- The MessageHandler
instances for processing messages received by
the MessageExchange
OnUpdateMessageExchange
public MessageExchange createConcurrentExchange(MessageHandler... messageHandlers)
ConcurrentMessageExchange
that processes messages on
its own Thread
. The exchanger/thread can be stopped by calling
MessageExchange.dispose()
messageHandlers
- The MessageHandler
instances for processing messages received by
the MessageExchange
ConcurrentMessageExchange
running on its own threadpublic void broadcast(java.lang.String messageType)
MessageExchange
s from an anonymous
sourcemessageType
- The message typepublic void broadcast(java.lang.String messageType, MessageData messageData)
MessageData
to all
MessageExchange
s from an anonymous sourcemessageType
- The message typemessageData
- The MessageData
to be publishedpublic void broadcast(MessageExchange source, java.lang.String messageType)
MessageExchange
s from a specified
MessageExchange
source
- The MessageExchange
to broadcast the
MessageData
frommessageType
- The message typepublic void broadcast(MessageExchange source, java.lang.String messageType, MessageData messageData)
source
- The MessageExchange
to broadcast the
MessageData
frommessageType
- The message typemessageData
- The MessageData
to broadcastpublic void send(MessageExchange source, MessageExchange destination, java.lang.String messageType)
MessageExchange
to anothersource
- The MessageExchange
the MessageData
is sent
fromdestination
- The MessageExchange
the MessageData
is sent tomessageType
- The message typepublic void send(MessageExchange source, MessageExchange destination, java.lang.String messageType, MessageData messageData)
MessageData
from one MessageExchange
to anothersource
- The MessageExchange
the MessageData
is sent
fromdestination
- The MessageExchange
the MessageData
is sent tomessageType
- The message typemessageData
- The MessageData
that is sentpublic void sendTo(MessageExchange destination, java.lang.String messageType)
MessageExchange
from an anonymous sourcedestination
- The MessageExchange
the MessageData
is sent tomessageType
- The message typepublic void sendTo(MessageExchange destination, java.lang.String messageType, MessageData messageData)
MessageData
to a MessageExchange
from an anonymous sourcedestination
- The MessageExchange
the MessageData
is sent tomessageType
- The message typemessageData
- The MessageData
that is sentpublic void broadcastQuery(java.lang.String messageType, java.lang.String responseMessageType, MessageHandler queryHandler)
MessageHandler
when a response
message is received.messageType
- The message type to sendresponseMessageType
- The required message type of the responsequeryHandler
- The MessageHandler
to call when the response is
receivedpublic void broadcastQuery(java.lang.String messageType, java.lang.String responseMessageType, boolean requiresDirectResponse, MessageHandler queryHandler)
MessageHandler
when a response
message is received.messageType
- The message type to sendresponseMessageType
- The required message type of the responserequiresDirectResponse
- True if a direct response is required. A direct response is a
message sent explicitly from a MessageExchange
to the
MessageExchange
used to send the query.queryHandler
- The MessageHandler
to call when the response is
receivedpublic void broadcastQuery(java.lang.String messageType, MessageData messageData, java.lang.String responseMessageType, MessageHandler queryHandler)
MessageHandler
when a response
message is received.messageType
- The message type to sendmessageData
- The MessageData
to sendresponseMessageType
- The required message type of the responsequeryHandler
- The MessageHandler
to call when the response is
receivedpublic void broadcastQuery(java.lang.String messageType, MessageData messageData, java.lang.String responseMessageType, boolean requiresDirectResponse, MessageHandler queryHandler)
MessageHandler
when a response
message is received.messageType
- The message type to sendmessageData
- The MessageData
to sendresponseMessageType
- The required message type of the responserequiresDirectResponse
- True if a direct response is required. A direct response is a
message sent explicitly from a MessageExchange
to the
MessageExchange
used to send the query.queryHandler
- The MessageHandler
to call when the response is
receivedpublic int getQueryMessagePoolSize()
QueryMessageExchange
instances availablepublic int getAnonymousExchangeId()
MessageExchange
used for anonymous sendingpublic int getTotalActiveExchanges()
MessageExchange
s (including
QueryMessageExchange
s


--- layout: about permalink: / priority: 1.0 ---
I'm a freelance data and policy analyst focusing on international development, financing for development, and effective development cooperation. I am passionate about translating rigorous explanatory data analysis into interactive data visualizations and concise policy recommendations. My in-depth experience is based on collaborations with renowned institutions such as the United Nations and the German Development Institute in different country settings. To learn more about me and my motivation, browse through my website, read my posts and don't hesitate to leave a comment by email.


new Keyboard()
Creates keyboard instance which handles chip8 input.
- Source:
Members
-
<static> Keyboard.CHIP8_KEYS :Object
-
Maps chip8 keys to PC keys. Populated in constructor.
Type:
- Object
- Source:
-
<static> Keyboard.PC_KEY_MAP :Object
-
Maps PC keys to chip8 keys.
Type:
- Object
- Source:
Properties:
Name Type Default Description "88"
Object 0 "49"
Object 1 "50"
Object 2 "51"
Object 3 "81"
Object 4 "87"
Object 5 "69"
Object 6 "65"
Object 7 "83"
Object 8 "68"
Object 9 "90"
Object A "67"
Object B "52"
Object C "82"
Object D "70"
Object E "86"
Object F
Methods
-
isKeyPressed(key) → {boolean}
-
Checks if given key is pressed.
Parameters:
Name Type Description key
number key number (0x0 - 0xF)
- Source:
Returns:
true if key is pressed, false otherwise
- Type
- boolean
-
keyDown(chip8Key)
-
Simulates key down.
Parameters:
Name Type Description chip8Key
number key number (0x0 - 0xF)
- Source:
-
keyUp(chip8Key)
-
Simulates key up.
Parameters:
Name Type Description chip8Key
number key number (0x0 - 0xF)
- Source:
-
onNextKeyPressed(chip8Key)
-
This method is called and set to NOP after each key down.
Parameters:
Name Type Description chip8Key
number pressed key number (0x0 - 0xF)
- Source:
-
reset()
-
Resets keyboard state.
- Source:


Atatürk was a Turkish nationalist leader and founder and first president of the republic of Turkey.
Mustafa Kemal Atatürk was born in 1881 in Salonika (now Thessaloniki) in what was then the Ottoman Empire. His father was a minor official and later a timber merchant. When Atatürk was 12, he was sent to military school and then to the military academy in Istanbul, graduating in 1905.
In 1911, he served against the Italians in Libya and then in the Balkan Wars (1912 - 1913). He made his military reputation repelling the Allied invasion at the Dardanelles in 1915.
In May 1919, Atatürk began a nationalist revolution in Anatolia, organising resistance to the peace settlement imposed on Turkey by the victorious Allies. This was particularly focused on resisting Greek attempts to seize Smyrna and its hinterland. Victory over the Greeks enabled him to secure revision of the peace settlement in the Treaty of Lausanne.
In 1921, Atatürk established a provisional government in Ankara. The following year the Ottoman Sultanate was formally abolished and, in 1923, Turkey became a secular republic with Atatürk as its president. He established a single party regime that lasted almost without interruption until 1945.
He launched a programme of revolutionary social and political reform to modernise Turkey. These reforms included the emancipation of women, the abolition of all Islamic institutions and the introduction of Western legal codes, dress, calendar and alphabet, replacing the Arabic script with a Latin one. Abroad he pursued a policy of neutrality, establishing friendly relations with Turkey's neighbours.
In 1935, when surnames were introduced in Turkey, he was given the name Atatürk, meaning 'Father of the Turks'. He died on 10 November 1938.


INVISIBLE MAN'S REVENGE, THE (director: Ford Beebe; screenwriter: suggested from the book by H. G. Wells/Bertram Millhauser; cinematographer: Milton Krasner; editor: Saul A. Goodkind; cast: Jon Hall (Robert Griffin), Alan Curtis (Mark Foster), Evelyn Ankers (Julie Herrick), Leon Errol (Herbert Higgins), John Carradine (Dr. Peter Drury), Gale Sondergaard (Lady Irene Herrick), Lester Matthews (Sir Jasper Herrick), Leyland Hodgson (Sir Frederick Travers), Ian Wolfe (Jim Feeny), Halliwell Hobbes (Cleghorn, Butler); Runtime: 77; Universal; 1944)
Reviewed by Dennis Schwartz
This was the fifth 'Invisible Man' Universal filmed in its ongoing series for the money making sci-fier. John Fulton's special effects are the unabashed star of this film. There was one very good trick photography shot of Jon Hall putting his invisible arm into an aquarium, the arm becoming visible like a bubble and then with water delineating his invisible face to make it visible to those he's threatening. But it is the script that does it in, as the Invisible Man is made into a heartless villain and the storyline was very weak.
Warning: spoilers throughout the review.
Robert Griffin (Jon Hall) sneaks into London from Capetown on a ship, where he escaped from a prison psycho ward after murdering two people. He visits the home of his former partners in a South African diamond mine, Sir Jasper Herrick (Lester Matthews) and his wife Lady Irene Herrick (Gale Sondergaard). They were on a safari together in Africa and did not try to save him when he got into trouble there, leaving him for dead five years ago. He has now come back to get his half share of the wealth from the diamonds, but is told by the unscrupulous couple that they don't have the money because of bad investments. He then tells them he will instead take their estate, all the money they have, and their beautiful daughter Julie (Ankers) as his bride. Irene spikes his drink with some kind of sedative and they steal his legal contract he planned to use for proof, tossing him out of their house as an unwanted guest in full view of their servant, Cleghorn.
In the woods, he's saved from drowning by a small-time con man, Herbert (Leon Errol). He tries to help Griffin by going to Herrick's estate with a shady lawyer, Jim Feeny, and threatening to sue. But the chief constable, Sir Frederick Travers, is called by Jasper and the two con men are dismissed. Griffin fearing he will be arrested, goes on the run and happens by chance to come to the isolated home of an eccentric doctor, Dr. Peter Drury (John Carradine), who has experimented with a new serum and has made his dog Brutus invisible. Before you can say have some coffee, Griffin is also invisible--which is the first experiment Drury ever did on a human. When he tells Griffin to get some rest he wants to show him off tomorrow to the science world and get their accolades, Griffin walks out on him and goes back to see Herbert as he plans to get revenge on the Herricks.
But first Griffin forces Herbert to get some money by going to a pub, where Herbert plays someone darts for a wager of five pounds and wins because the Invisible Man cheats as he runs the darts up to the bull's-eyes. He also hears at the pub a reporter, Mark Foster (Curtis), say he's going after a story on the rumor that there's an Invisible Man. But what gets Griffin's goat about the reporter, is that he's the man Julie is set to marry.
Griffin goes as an Invisible Man to visit Jasper, as he frightens him into signing a confession of his misdeeds and signing over his estate to him. But when he also wants Julie, he's told he has to be visible to have her.
When Griffin returns to Drury's lab and requests being made visible again, he's told that he would have to drain the blood out of some living person for that to happen. When Drury says he's a scientist and not a killer, refusing to get Foster over to the lab--Griffin instead drains Drury's blood to make him visible again on a temporary basis as he will need a constant supply of blood. He also burns down his house, but Brutus is now also visible and seeks revenge on Griffin for what he did to his master.
In this episode it's not the invisible serum that makes the man insane, as the man is already mentally unbalanced.
This hokum story could have and should have been more entertaining, but it still had the presence of the legendary John Carradine to give the flick some spice to it. But it was still a far come down from James Whale's original Invisible Man.
REVIEWED ON 9/19/2001 GRADE: C
Dennis Schwartz: "Ozus' World Movie Reviews"
http://www.sover.net/~ozus
<EMAIL_ADDRESS>© ALL RIGHTS RESERVED DENNIS SCHWARTZ
========== X-RAMR-ID: 29521 X-Language: en X-RT-SourceID: 873 X-RT-AuthorID: 1315 X-RT-RatingText: C
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


Analyzing the latest data for you.Please hold on.
Sorry we did not find anyone with this account
Sorry there's some glitch :(. Please try again later.
Sorry we did not find anyone with this account
Sorry there's some glitch :(. Please try again later.


This document describes the GNU History library, a programming tool that provides a consistent user interface for recalling lines of previously typed input.
This chapter describes how to use the GNU History Library interactively, from a user's standpoint. It should be considered a user's guide. For information on using the GNU History Library in your own programs, see Programming with GNU History.
The History library provides a history expansion feature that is similar
to the history expansion provided by csh
. This section
describes the syntax used to manipulate the history information.
History expansions introduce words from the history list into the input stream, making it easy to repeat commands, insert the arguments to a previous command into the current input line, or fix errors in previous commands quickly.
History expansion takes place in two parts. The first is to determine
which line from the history list should be used during substitution.
The second is to select portions of that line for inclusion into the
current one. The line selected from the history is called the
event, and the portions of that line that are acted upon are
called words. Various modifiers are available to manipulate
the selected words. The line is broken into words in the same fashion
that Bash does, so that several words
surrounded by quotes are considered one word.
History expansions are introduced by the appearance of the
history expansion character, which is !
by default.
An event designator is a reference to a command line entry in the history list.
!
=
.
!
n
!-
n
!!
!-1
.
!
string
!?
string[?]
?
may be omitted if the string is followed immediately by
a newline.
^
string1^
string2^
!!:s/
string1/
string2/
.
!#
Word designators are used to select desired words from the event.
A :
separates the event specification from the word designator. It
may be omitted if the word designator begins with a ^
, $
,
*
, -
, or %
. Words are numbered from the beginning
of the line, with the first word being denoted by 0 (zero). Words are
inserted into the current line separated by single spaces.
For example,
!!
!!:$
!$
.
!fi:2
fi
.
Here are the word designators:
0 (zero)
0
th word. For many applications, this is the command word.
n
^
$
%
?
string?
search.
x-
y
-
y
abbreviates 0-
y
.
*
0
th. This is a synonym for 1-$
.
It is not an error to use *
if there is just one word in the event;
the empty string is returned in that case.
x*
x-$
x-
x-$
like
x*
, but omits the last word.
If a word designator is supplied without an event specification, the previous command is used as the event.
After the optional word designator, you can add a sequence of one or more
of the following modifiers, each preceded by a :
.
h
t
r
.
suffix
, leaving
the basename.
e
p
s/
old/
new/
/
.
The delimiter may be quoted in old and new
with a single backslash. If &
appears in new,
it is replaced by old. A single backslash will quote
the &
. The final delimiter is optional if it is the last
character on the input line.
&
g
a
s
, as in gs/
old/
new/
,
or with &
.
G
s
modifier once to each word in the event.
This chapter describes how to interface programs that you write with the GNU History Library. It should be considered a technical guide. For information on the interactive use of GNU History, see Using History Interactively.
Many programs read input from the user a line at a time. The GNU History library is able to keep track of those lines, associate arbitrary data with each line, and utilize information from previous lines in composing new ones.
The programmer using the History library has available functions for remembering lines on a history list, associating arbitrary data with a line, removing lines from the list, searching through the list for a line containing an arbitrary text string, and referencing any line in the list directly. In addition, a history expansion function is available which provides for a consistent user interface across different programs.
The user using programs written with the History library has the
benefit of a consistent user interface with a set of well-known
commands for manipulating the text of previous lines and using that text
in new commands. The basic history manipulation commands are similar to
the history substitution provided by csh
.
If the programmer desires, he can use the Readline library, which includes some history manipulation by default, and has the added advantage of command line editing.
Before declaring any functions using any functionality the History
library provides in other code, an application writer should include
the file <readline/history.h>
in any file that uses the
History library's features. It supplies extern declarations for all
of the library's public functions and variables, and declares all of
the public data structures.
The history list is an array of history entries. A history entry is declared as follows:
typedef void *histdata_t; typedef struct _hist_entry { char *line; char *timestamp; histdata_t data; } HIST_ENTRY;
The history list itself might therefore be declared as
HIST_ENTRY **the_history_list;
The state of the History library is encapsulated into a single structure:
/* * A structure used to pass around the current state of the history. */ typedef struct _hist_state { HIST_ENTRY **entries; /* Pointer to the entries themselves. */ int offset; /* The location pointer within this array. */ int length; /* Number of elements within this array. */ int size; /* Number of slots allocated to this array. */ int flags; } HISTORY_STATE;
If the flags member includes HS_STIFLED
, the history has been
stifled.
This section describes the calling sequence for the various functions exported by the GNU History library.
This section describes functions used to initialize and manage the state of the History library when you want to use the history functions in your program.
| void using_history (void) | Functie |
| Begin a session in which the history functions might be used. This initializes the interactive variables. |
| HISTORY_STATE * history_get_history_state (void) | Functie |
| Return a structure describing the current state of the input history. |
| void history_set_history_state (HISTORY_STATE *state) | Functie |
| Set the state of the history list according to state. |
These functions manage individual entries on the history list, or set parameters managing the list itself.
| void add_history (const char *string) | Functie |
Place string at the end of the history list. The associated data
field (if any) is set to NULL .
|
| void add_history_time (const char *string) | Functie |
| Change the time stamp associated with the most recent history entry to string. |
| HIST_ENTRY * remove_history (int which) | Functie |
| Remove history entry at offset which from the history. The removed element is returned so you can free the line, data, and containing structure. |
| histdata_t free_history_entry (HIST_ENTRY *histent) | Functie |
| Free the history entry histent and any history library private data associated with it. Returns the application-specific data so the caller can dispose of it. |
| HIST_ENTRY * replace_history_entry (int which, const char *line, histdata_t data) | Functie |
Make the history entry at offset which have line and data.
This returns the old entry so the caller can dispose of any
application-specific data. In the case
of an invalid which, a NULL pointer is returned.
|
| void clear_history (void) | Functie |
| Clear the history list by deleting all the entries. |
| void stifle_history (int max) | Functie |
| Stifle the history list, remembering only the last max entries. |
| int unstifle_history (void) | Functie |
Stop stifling the history. This returns the previously-set
maximum number of history entries (as set by stifle_history() ).
The value is positive if the history was
stifled, negative if it wasn't.
|
| int history_is_stifled (void) | Functie |
| Returns non-zero if the history is stifled, zero if it is not. |
These functions return information about the entire history list or individual list entries.
| HIST_ENTRY ** history_list (void) | Functie |
Return a NULL terminated array of HIST_ENTRY * which is the
current input history. Element 0 of this list is the beginning of time.
If there is no history, return NULL .
|
| int where_history (void) | Functie |
| Returns the offset of the current history element. |
| HIST_ENTRY * current_history (void) | Functie |
Return the history entry at the current position, as determined by
where_history() . If there is no entry there, return a NULL
pointer.
|
| HIST_ENTRY * history_get (int offset) | Functie |
Return the history entry at position offset, starting from
history_base (see History Variables).
If there is no entry there, or if offset
is greater than the history length, return a NULL pointer.
|
| time_t history_get_time (HIST_ENTRY *entry) | Functie |
| Return the time stamp associated with the history entry entry. |
| int history_total_bytes (void) | Functie |
| Return the number of bytes that the primary history entries are using. This function returns the sum of the lengths of all the lines in the history. |
These functions allow the current index into the history list to be set or changed.
| int history_set_pos (int pos) | Functie |
| Set the current history offset to pos, an absolute index into the list. Returns 1 on success, 0 if pos is less than zero or greater than the number of history entries. |
| HIST_ENTRY * previous_history (void) | Functie |
Back up the current history offset to the previous history entry, and
return a pointer to that entry. If there is no previous entry, return
a NULL pointer.
|
| HIST_ENTRY * next_history (void) | Functie |
Move the current history offset forward to the next history entry, and
return the a pointer to that entry. If there is no next entry, return
a NULL pointer.
|
These functions allow searching of the history list for entries containing a specific string. Searching may be performed both forward and backward from the current history position. The search may be anchored, meaning that the string must match at the beginning of the history entry.
| int history_search (const char *string, int direction) | Functie |
| Search the history for string, starting at the current history offset. If direction is less than 0, then the search is through previous entries, otherwise through subsequent entries. If string is found, then the current history index is set to that history entry, and the value returned is the offset in the line of the entry where string was found. Otherwise, nothing is changed, and a -1 is returned. |
| int history_search_prefix (const char *string, int direction) | Functie |
| Search the history for string, starting at the current history offset. The search is anchored: matching lines must begin with string. If direction is less than 0, then the search is through previous entries, otherwise through subsequent entries. If string is found, then the current history index is set to that entry, and the return value is 0. Otherwise, nothing is changed, and a -1 is returned. |
| int history_search_pos (const char *string, int direction, int pos) | Functie |
| Search for string in the history list, starting at pos, an absolute index into the list. If direction is negative, the search proceeds backward from pos, otherwise forward. Returns the absolute index of the history element where string was found, or -1 otherwise. |
The History library can read the history from and write it to a file. This section documents the functions for managing a history file.
| int read_history (const char *filename) | Functie |
Add the contents of filename to the history list, a line at a time.
If filename is NULL , then read from ~/.history .
Returns 0 if successful, or errno if not.
|
| int read_history_range (const char *filename, int from, int to) | Functie |
Read a range of lines from filename, adding them to the history list.
Start reading at line from and end at to.
If from is zero, start at the beginning. If to is less than
from, then read until the end of the file. If filename is
NULL , then read from ~/.history . Returns 0 if successful,
or errno if not.
|
| int write_history (const char *filename) | Functie |
Write the current history to filename, overwriting filename
if necessary.
If filename is NULL , then write the history list to
~/.history .
Returns 0 on success, or errno on a read or write error.
|
| int append_history (int nelements, const char *filename) | Functie |
Append the last nelements of the history list to filename.
If filename is NULL , then append to ~/.history .
Returns 0 on success, or errno on a read or write error.
|
| int history_truncate_file (const char *filename, int nlines) | Functie |
Truncate the history file filename, leaving only the last
nlines lines.
If filename is NULL , then ~/.history is truncated.
Returns 0 on success, or errno on failure.
|
These functions implement history expansion.
| int history_expand (char *string, char **output) | Functie |
Expand string, placing the result into output, a pointer
to a string (see History Interaction). Returns:
If an error ocurred in expansion, then output contains a descriptive error message. |
| char * get_history_event (const char *string, int *cindex, int qchar) | Functie |
| Returns the text of the history event beginning at string + *cindex. *cindex is modified to point to after the event specifier. At function entry, cindex points to the index into string where the history event specification begins. qchar is a character that is allowed to end the event specification in addition to the "normal" terminating characters. |
| char ** history_tokenize (const char *string) | Functie |
| Return an array of tokens parsed out of string, much as the shell might. The tokens are split on the characters in the history_word_delimiters variable, and shell quoting conventions are obeyed. |
| char * history_arg_extract (int first, int last, const char *string) | Functie |
Extract a string segment consisting of the first through last
arguments present in string. Arguments are split using
history_tokenize .
|
This section describes the externally-visible variables exported by the GNU History Library.
| int history_base | Variabele |
| The logical offset of the first entry in the history list. |
| int history_length | Variabele |
| The number of entries currently stored in the history list. |
| int history_max_entries | Variabele |
The maximum number of history entries. This must be changed using
stifle_history() .
|
| int history_write_timestamps | Variabele |
| If non-zero, timestamps are written to the history file, so they can be preserved between sessions. The default value is 0, meaning that timestamps are not saved. |
| char history_expansion_char | Variabele |
The character that introduces a history event. The default is ! .
Setting this to 0 inhibits history expansion.
|
| char history_subst_char | Variabele |
The character that invokes word substitution if found at the start of
a line. The default is ^ .
|
| char history_comment_char | Variabele |
| During tokenization, if this character is seen as the first character of a word, then it and all subsequent characters up to a newline are ignored, suppressing history expansion for the remainder of the line. This is disabled by default. |
| char * history_word_delimiters | Variabele |
The characters that separate tokens for history_tokenize() .
The default value is " \t\n()<>;&|" .
|
| char * history_search_delimiter_chars | Variabele |
The list of additional characters which can delimit a history search
string, in addition to space, TAB, : and ? in the case of
a substring search. The default is empty.
|
| char * history_no_expand_chars | Variabele |
The list of characters which inhibit history expansion if found immediately
following history_expansion_char. The default is space, tab, newline,
carriage return, and = .
|
| int history_quotes_inhibit_expansion | Variabele |
| If non-zero, single-quoted words are not scanned for the history expansion character. The default value is 0. |
| rl_linebuf_func_t * history_inhibit_expansion_function | Variabele |
This should be set to the address of a function that takes two arguments:
a char * (string)
and an int index into that string (i).
It should return a non-zero value if the history expansion starting at
string[i] should not be performed; zero if the expansion should
be done.
It is intended for use by applications like Bash that use the history
expansion character for additional purposes.
By default, this variable is set to NULL .
|
The following program demonstrates simple use of the GNU History Library.
#include <stdio.h> #include <readline/history.h> main (argc, argv) int argc; char **argv; { char line[1024], *t; int len, done = 0; line[0] = 0; using_history (); while (!done) { printf ("history$ "); fflush (stdout); t = fgets (line, sizeof (line) - 1, stdin); if (t && *t) { len = strlen (t); if (t[len - 1] == '\n') t[len - 1] = '\0'; } if (!t) strcpy (line, "quit"); if (line[0]) { char *expansion; int result; result = history_expand (line, &expansion); if (result) fprintf (stderr, "%s\n", expansion); if (result < 0 || result == 2) { free (expansion); continue; } add_history (expansion); strncpy (line, expansion, sizeof (line) - 1); free (expansion); } if (strcmp (line, "quit") == 0) done = 1; else if (strcmp (line, "save") == 0) write_history ("history_file"); else if (strcmp (line, "read") == 0) read_history ("history_file"); else if (strcmp (line, "list") == 0) { register HIST_ENTRY **the_list; register int i; the_list = history_list (); if (the_list) for (i = 0; the_list[i]; i++) printf ("%d: %s\n", i + history_base, the_list[i]->line); } else if (strncmp (line, "delete", 6) == 0) { int which; if ((sscanf (line + 6, "%d", &which)) == 1) { HIST_ENTRY *entry = remove_history (which); if (!entry) fprintf (stderr, "No such entry %d\n", which); else { free (entry->line); free (entry); } } else { fprintf (stderr, "non-numeric arg given to `delete'\n"); } } } }
Copyright © 2000,2001,2002 Free Software Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA Everyone is permitted to copy and distribute verbatim copies of this license document, but changing it is not allowed.
The purpose of this License is to make a manual, textbook, or other functional and useful document free in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.
This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.
We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.
This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.
A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.
A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.
The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.
The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.
A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not "Transparent" is called "Opaque".
Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.
The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.
A section "Entitled XYZ" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as "Acknowledgements", "Dedications", "Endorsements", or "History".) To "Preserve the Title" of such a section when you modify the Document means that it remains a section "Entitled XYZ" according to this definition.
The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.
You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and you may publicly display copies.
If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.
If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.
It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.
You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:
If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.
You may add a section Entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.
You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.
The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.
In the combination, you must combine any sections Entitled "History" in the various original documents, forming one section Entitled "History"; likewise combine any sections Entitled "Acknowledgements", and any sections Entitled "Dedications". You must delete all sections Entitled "Endorsements."
You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.
A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an "aggregate" if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.
Translation is considered a kind of modification, so you may distribute translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may include a translation of this License, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this License and the original versions of those notices and disclaimers. In case of a disagreement between the translation and the original version of this License or a notice or disclaimer, the original version will prevail.
If a section in the Document is Entitled "Acknowledgements", "Dedications", or "History", the requirement (section 4) to Preserve its Title (section 1) will typically require changing the actual title.
You may not copy, modify, sublicense, or distribute the Document except as expressly provided for under this License. Any other attempt to copy, modify, sublicense or distribute the Document is void, and will automatically terminate your rights under this License. However, parties who have received copies, or rights, from you under this License will not have their licenses terminated so long as such parties remain in full compliance.
The Free Software Foundation may publish new, revised versions of the GNU Free Documentation License from time to time. Such new versions will be similar in spirit to the present version, but may differ in detail to address new problems or concerns. See http://www.gnu.org/copyleft/.
Each version of the License is given a distinguishing version number. If the Document specifies that a particular numbered version of this License "or any later version" applies to it, you have the option of following the terms and conditions either of that specified version or of any later version that has been published (not as a draft) by the Free Software Foundation. If the Document does not specify a version number of this License, you may choose any version ever published (not as a draft) by the Free Software Foundation.
To use this License in a document you have written, include a copy of the License in the document and put the following copyright and license notices just after the title page:
Copyright (C) year your name. Permission is granted to copy, distribute and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license is included in the section entitled ``GNU Free Documentation License''.
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts, replace the "with...Texts." line with this:
with the Invariant Sections being list their titles, with the Front-Cover Texts being list, and with the Back-Cover Texts being list.
If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.
If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software license, such as the GNU General Public License, to permit their use in free software.
add_history
: History List Management
add_history_time
: History List Management
append_history
: Managing the History File
clear_history
: History List Management
current_history
: Information About the History List
free_history_entry
: History List Management
get_history_event
: History Expansion
history_arg_extract
: History Expansion
history_base
: History Variables
history_comment_char
: History Variables
history_expand
: History Expansion
history_expansion_char
: History Variables
history_get
: Information About the History List
history_get_history_state
: Initializing History and State Management
history_get_time
: Information About the History List
history_inhibit_expansion_function
: History Variables
history_is_stifled
: History List Management
history_length
: History Variables
history_list
: Information About the History List
history_max_entries
: History Variables
history_no_expand_chars
: History Variables
history_quotes_inhibit_expansion
: History Variables
history_search
: Searching the History List
history_search_delimiter_chars
: History Variables
history_search_pos
: Searching the History List
history_search_prefix
: Searching the History List
history_set_history_state
: Initializing History and State Management
history_set_pos
: Moving Around the History List
history_subst_char
: History Variables
history_tokenize
: History Expansion
history_total_bytes
: Information About the History List
history_truncate_file
: Managing the History File
history_word_delimiters
: History Variables
history_write_timestamps
: History Variables
next_history
: Moving Around the History List
previous_history
: Moving Around the History List
read_history
: Managing the History File
read_history_range
: Managing the History File
remove_history
: History List Management
replace_history_entry
: History List Management
stifle_history
: History List Management
unstifle_history
: History List Management
using_history
: Initializing History and State Management
where_history
: Information About the History List
write_history
: Managing the History File


---
title: "Registry"
permalink: /registry/
layout: page
---
{% assign latestRelease = site.data.registry.latestRelease %}
{%- include navtabs.html -%}
High performance, runtime registry
for API Designs and Schemas
{%- include registry/_projnav.html -%}
In the context of Apicurio, a registry is a runtime system (server) that stores a
specific set of artifacts (files). At its core, a registry provides the ability to add,
update, and remove the artifacts from the store, typically via a remote API of some kind
(often a REST API).
API Registry
The key use-case for the Apicurio community, an API Registry is a system that allows users
to register their API designs (e.g. OpenAPI or AsyncAPI files) so that potential API
consumers can do the following:
- Browse/search the list of APIs available in production
- View details about a single available API
- Learn how to use an API (via generated documentation)
- Generate Client SDKs for an API
Schema Registry
In the messaging and event streaming world, data that are published to topics and queues
often must be serialized or validated using a Schema (e.g. Apache Avro, JSON Schema, or
Google protocol buffers). Schemas can be packaged in each application, but it is often a
better architectural pattern to instead register them in an external system and then
referenced from each application. This allows the following:
- Decoupling of schemas from producers and consumers
- Potential to upgrade producers without upgrading consumers
- Central location to track all Schemas used in production
- Document the data format required for each topic/queue
- Centralized control of data format (schema) evolution
Storage/management of several types of artifacts
The registry supports adding, removing, and updating the following types of artifacts:
OpenAPI,
AsyncAPI,
GraphQL,
Apache Avro,
Google protocol buffers,
JSON Schema,
Kafka Connect schema,
WSDL,
XML Schema (XSD)
Configurable content rules
Content evolution (adding and updating artifact content) can be controlled by enabling
content rules, including Validity and Compatibility.
Multiple storage options
The registry can be configured to store data in various back-end storage systems
depending on use-case, including Kafka, PostgreSQL, and Infinispan (embedded).


reST has the concept of “field lists”; these are a sequence of fields marked up like this:
:Field name: Field content
A field list at the very top of a file is parsed as the “docinfo”, which in normal documents can be used to record the author, date of publication and other metadata. In Sphinx, the docinfo is used as metadata, too, but not displayed in the output.
At the moment, these metadata fields are recognized:
The maximum depth for a table of contents of this file.
New in version 0.4.
Identifies the author of the current section. The argument should include the author’s name such that it can be used for presentation and email address. The domain name portion of the address should be lower case. Example:
.. sectionauthor:: Guido van Rossum<EMAIL_ADDRESS>By default, this markup isn’t reflected in the output in any way (it helps keep track of contributions), but you can set the configuration value show_authors to True to make them produce a paragraph in the output.
Use standard reStructuredText tables. They work fine in HTML output, however there are some gotchas when using tables in LaTeX: the column width is hard to determine correctly automatically. For this reason, the following directive exists:
This directive gives a “column spec” for the next table occurring in the source file. The spec is the second argument to the LaTeX tabulary package’s environment (which Sphinx uses to translate tables). It can have values like
|l|l|l|
which means three left-adjusted, nonbreaking columns. For columns with longer text that should automatically be broken, use either the standard p{width} construct, or tabulary’s automatic specifiers:
| L | ragged-left column with automatic width |
| R | ragged-right column with automatic width |
| C | centered column with automatic width |
| J | justified column with automatic width |
The automatic width is determined by rendering the content in the table, and scaling them according to their share of the total width.
By default, Sphinx uses a table layout with L for every column.
New in version 0.3.
Warning
Tables that contain literal blocks cannot be set with tabulary. They are therefore set with the standard LaTeX tabular environment. Also, the verbatim environment used for literal blocks only works in p{width} columns, which means that by default, Sphinx generates such column specs for such tables. Use the tabularcolumns directive to get finer control over such tables.


Introduction
With Kwik Source Search (KSS) you can perform powerful standard and regular expression searches through one or multiple text files, such as source code, logging, and debugging information.
KSS is capable of finding the exact text you are looking for in any ASCII file or files. However, sometimes you have only part of the information that you want to match, or you want to find a wider range of information. In such cases, KSS has the powerful capability to search for patterns of text using regular expressions.
The underlying search engine for KSS is the Findstr command. KSS provides a convenient, user friendly, interface for the many command line options. Search text is always treated as a literal search string [/l and /c:] and files with non-printable characters are always skipped [/p]. The regular expression functionality of the Findstr command is used for the main text search. There are many examples that can be found on the internet.
KSS captures and filters the output of the Findstr command, opens the file associated with the selected result list item, and displays it in a syntax highlighting editor built on the Scintilla control. KSS has built-in styling for the Clarion language and can easily be extended, through the use of special property files, to provide styling for other languages supported by the Scintilla control.


"I would rather fail in a cause that will ultimately triumph than to triumph in a cause that will ultimately fail."
- Woodrow Wilson
-Built a cascaded deep learning model to improve sensitivity of medical images.
-Developed a back-end server engine running on a deep learning medical platform to infer lesions from CT/MRI images.
Graded submitted materials and provided feedback with guidance for over a year in two classes of computer science department; COMP.1000 Media Computing, COMP.2030 Computer Org & Assembly Language.
 In the spring and summer season, I play baseball. And I also enjoy motorcycle riding.
In my spare time, I get into music producing. I believe musical sensitivity creates proper motivation to those who pursue an optimistic life. And I spend my extra free time exploring and studying the latest technology advancements in the AI development world.


Novartis nears deal to buy US biotech firm Medicines Co for about US$7 billion: WSJ
Swiss drugmaker Novartis AG is nearing an agreement to acquire U.S. biotechnology firm The Medicines Co for about US$7 billion, the Wall Street Journal reported on Saturday.
REUTERS: Swiss drugmaker Novartis AG is nearing an agreement to acquire U.S. biotechnology firm The Medicines Co for about US$7 billion, the Wall Street Journal reported on Saturday.
The deal, in which Novartis has agreed to pay US$85 a share, could be announced this weekend, the Journal reported, citing people familiar with the matter.
Going by a fully diluted share count, the agreement is worth about US$10 billion, according to the report.
Novartis declined to comment. The Medicines Co did not respond to a request for comment on Saturday.
The deal could broaden the Swiss drugmaker's cabinet of heart medicines and shore up growth threatened by patent expirations.
Novartis has been hunting for a US$5 billion acquisition in the United States, two banking sources told Reuters earlier this week without identifying a target.
New Jersey-based The Medicines Co's top drug candidate is cholesterol-lowering drug inclisiran for heart patients. Novartis has historically had a strong cardiovascular drug franchise, but lost ground when Diovan, once a US$6 billion-per-year seller, lost patent protection in 2012 and left the company without an immediate, innovative follow-up product.
Novartis has since been building up its portfolio, which now includes Entresto, a US$1 billion seller for heart failure, as well as an experimental RNA-targeting molecule from Ionis Pharmaceuticals that it licensed earlier this year for US$150 million.
(Reporting by Kanishka Singh in Bengaluru; editing by Jonathan Oatis and Chizu Nomiyama)


Writing
MediaWiki Hackathon BITS Pilani Hyderabad Campus 2016
I was invited by BITS Pilani Hyderabad Campus, to give a talk on WikiToLearn at the MediaWiki Hackathon on 24th and 25th September, 2016.
It was a great event indeed, and an amazing experience to speak about WikiToLearn among those students. I spoke on ‘How to contribute to WikiToLearn’ and the talk can be found here.
Few amazing things, I found out at BITS was :
-
0% attendance requirements, creating nocturnal but hardcore engineers! Met crazy Subham Soni waking up at 6 pm, like its 6 am. Met couple of others brushing at 20:00 in the washroom, getting ready for work.
-
Give students bad mess food, they would complain. Give students good mess food, they would complain in a month. Baffled at crazy Subham Soni addressing their mess food as boring/bad etc.
Since, this was my first visit to Hyderabad, I also got an opportunity to roam around the city, with my BPHC Friends, Utkarsh and Utsav. Some of the photos :
Visit to Charminar
BITS Pilani Hyderabad Campus
Giving talk


整理一下容易签证的国家， 请大家帮忙为跑路反贼准备一点签证知识， 有不对的地方请指正，有过期的资料请刷新。
到达自由签证的三个国家：
护照无需签证的国家：
Bahamas [33] 3 months[34] √
Haiti [120] 3 months X
Saint Kitts and Nevis [223] 3 months X
Seychelles [238] 3 months[239] √
Fiji [102] 4 months √
Saint Lucia [224][225] 6 weeks X
Uzbekistan [289] 10 days Must arrive by air. Otherwise an electronic visa is available.[290] X
Oman [205] 14 days * Chinese national are also eligible for single / multiple entry electronic visa valid for 30 days. X
Dominica [86] 21 days X
Iran [128][129] 21 days[130] X
Antigua and Barbuda [19] 30 days X
Barbados [37] 30 days √
Belarus [38] 30 days Visa free for 30 days, for a maximum total stay of 90 days within any year period.[39][40] Holders of passports for public affairs do not require a visa for up to 30 days.[41] √
Grenada [113] 30 days[114]
Beginning on December 1, 2020, all travellers to Grenada will be required to complete an online application in order to receive a Pure Safe Travel Authorization Certificate to enter Grenada.[115]
√
Indonesia [127] 30 days X
Jamaica [138] 30 days X
Micronesia [179] 30 days X
Qatar [218] 30 days √
Serbia [236] 30 days[237]
Holders of passports for public affairs do not require a visa up to 90 days within a six-month period.
√
Suriname [254] 30 days Visa liberalization agreement between China and Suriname was ratified on 1 May 2021.[255] COVID-19 entry restrictions still apply for foreign citizens entering Suriname. √
Tonga [266] 30 days[267] √
Ukraine [277] 30 days Temporary Visa free regime from the 1st of April, 2021 to the 30th of September, 2021.[278] Ukrainian authorities intend to sign reciprocal visa-free agreement with China in the next five years.[279] X United Arab Emirates [280] 30 days √
Vanuatu [291] 30 days Passengers must have a medical certificate proving they do not have COVID-19 X
Samoa [202] 60 days X
Albania [11][12] 90 days X
Armenia [23][24] 90 days 90 days within any 180 day period Holders of passports for public affairs do not require a visa for up to 30 days.[25] √
Bosnia and Herzegovina [52] 90 days 90 days within any 180 day period[53] √
Ecuador [88] 90 days 90 days within any one-year period √
Mauritius [176] 90 days √
Morocco [186] 90 days X
Tunisia [269] 90 days[270] X
San Marino [227][228] 90 days.[229]
Although officially no visa is required, at least a Single Entry Schengen visa is required to enter San Marino since it does not have an own airport facility and no border controls.
√
参考： https://en.wikipedia.org/wiki/Visa_requirements_for_Chinese_citizens#Exit_and_Entry_Permit