Twilio Client SDK for Android Quickstart
Overview
You want your Android phone or tablet app to make and receive calls? There’s an SDK for that!
Twilio Client for Android is a Java SDK for Google’s Android platform that enables voice communications with landlines or other Twilio Client devices, including web browsers or other mobile devices.
Architecture
There are three major pieces in a Twilio Client app:
- Your Android app that uses the
twilio-client-sdk.jar
library. - A server-side application to grant a capability token to your Client app, and to orchestrate Twilio’s telephony services using TwiML and Twilio’s REST API. You’ll use a TwiML Application to connect your Android app to Twilio’s cloud.
- Twilio’s cloud services to connect your app to conference calls, IVR applications, and make calls to PSTN and SIP devices.
We’ll walk you through each of these pieces in detail below. Let’s get started.
Quickstart Tutorial
In this tutorial, use the Twilio Client SDK for Android and TwiML APIs to demonstrate how to make an outgoing call, receive an incoming call, and make calls between two Twilio Client instances.
This guide assumes you have familiarity with Android and Java, and concepts like Activities (and their lifecycles), Listeners, and how to build a basic Android application.
Prerequisites
-
Install Eclipse and the Android Developer Tools plugin. We recommend that you use the latest version available.
-
Install the Android SDK and appropriate platform tools and platform API package. Note that the Client SDK depends on a minimum of API level 8 (Android 2.2).
-
Get a Twilio Account SID and Auth Token to initiate calls from your Android device. You will find these in your Account Dashboard. If you don’t have an account, you can always sign up for a free trial account.
-
In the example below, we’ll setup a web server on the public Internet to host the server-side code for generating capability tokens and TwiML. The Quickstart below provides a sample python app deployed to Heroku for this purpose, but you can use whatever method for deploying a web server you like.
Let’s get some of the server-side dependencies out of the way first.
Configure a Placeholder TwiML Application
Visit TwiML Apps in the Twilio Account Portal and click ‘Create TwiML App’. Enter ‘Mobile Quickstart’ as the app’s Friendly Name and click ‘Save’. Don’t worry about the Voice and Messaging URLs yet–we’ll fill them in shortly.
Once the application is saved, make note of its ApplicationSid (a long string like “APa4983020a0b29fb5db1b1dc68e322fbe”). We’ll need this in the upcoming steps.
Setup the back-end Application Server
Next, we’ll deploy a server to perform two functions:
- Provide capability tokens to our Android client application.
- Serve up our TwiML application and/or make REST API calls to orchestrate Twilio’s telephony services.
Quick Tour of the Application
The code for the Quickstart Tutorial server-side application can be found in the Server/
folder inside the SDK tarball. Feel free to open up server.py
and take a look. The app uses Python’s Flask framework and exposes three endpoints:
/
generates TwiML to tell Twilio to play “Welcome to Twilio” whenever you place a call./call
generates TwiML to route calls to/from the PSTN and your Android application./token
returns a capability token to your Android application.
Deploying the Server
Now, we need to make this application available via the public Internet. You can do this with either of the following methods, or another approach to deploy a web server you’re comfortable with.
Option 1: Use Heroku
The easiest way to deploy the application is Heroku. To do this, do the following:
- Visit the Twilio Mobile QuickStart repository on Github and click the “Deploy to Heroku” button. If you don’t have a Heroku account, you’ll be led through the process to set one up.
- Once you’ve signed into Heroku, you’ll be taken to a form to deploy the Quickstart application.
- Enter your Twilio Account Sid and your Twilio Auth Token as the ACCOUNT_SID and AUTH_TOKEN values, respectively.
- Enter the TwiML App Sid you created above as the value for APP_SID.
- Enter any caller ID that you’ve verified with your Twilio account in the CALLER_ID field.
- Click Create your application.
- Once Heroku finishes, open up a second tab and return to the configuration screen for your TwiML app. Configure the Voice URL to point to your Heroku application’s server
/call
URL and save the change.
Option 2: Run Locally Using ngrok
With this method, you’ll run Flask
on your local box and create a
publicly-addressable tunnel to it using ngrok.
- Open server.py and modify
ACCOUNT_SID
andAUTH_TOKEN
to match the values from your Twilio account. - Modify
APP_SID
to match the App Sid you created above. - Modify
CALLER_ID
to any caller ID that you’ve verified with your Twilio account. - Install all the required python dependencies by running
pip install -r requirements.txt
from theServer/
folder at the command line. - Download and install ngrok.
- Run
python server.py
to start the server. - Run
ngrok 5000
to open up a tunnel from the public internet to your server. - Return to the configuration screen for your TwiML app. Configure the Voice URL to point to your ngrok applications’s server
/call
URL and save the change.
Testing your Server
To make sure your server deployed successfully, open a web browser and enter http://{your heroku app or ngrok address}/
and view source on the resulting page. If everything is working, you’ll see some XML that looks like this:
<?xml version="1.0" encoding="UTF-8"?> <Response> <Say>Welcome to Twilio</Say> </Response>
This is a simple TwiML application that will play an announcement whenever you make a call from your Android application.
Now that we have the server-side dependencies setup, let’s get started on our Android app. You can test the examples below in the Android Emulator or on your device.
The Eclipse Project
Please open the “HelloMonkey” Eclipse project in Quickstart
folder (File -> Import -> General
-> Existing Projects into Workspace).
The HelloMonkey app is very simple, presenting “Dial” and “Hangup” buttons, and
a text field for who the app should call. The user interface elements have
already been wired up to the HelloMonkeyActivity
class.
In this step, you’ll fill in the code to give the app its behavior, learning how to use the Twilio Client Android SDK in the process.
Creating a Device
The primary class for connecting to Twilio services from your app is
Device
. This class represents a soft “device” that knows how to speak to Twilio services, coordinates service authorization with Twilio, listens for incoming connections, and establishes outgoing connections.
An instance of this class is created using a “capability token”, described in the next section.
You’ll use a Device
to initiate outgoing calls and listen for incoming calls.
Let’s create an instance and wire it up!
Add a member variable of type Device
to MonkeyPhone.java
like so:
import com.twilio.client.Device; import com.twilio.client.Twilio; public class MonkeyPhone implements Twilio.InitListener { private Device device; }
To initialize a device, you’ll change the URL to point to your server’s /token
URL and pass the resulting string to - HttpHelper.httpGet()
method (you may want to make necessary changes to run this code in separate thread).
Note: Make sure you swap in your back-end server’s /token
URL for the sample URL in MonkeyPhone
’s onInitialized
method.
MonkeyPhone.java
import com.twilio.client.Device; import com.twilio.client.Twilio; public class MonkeyPhone implements Twilio.InitListener { private Device device; public MonkeyPhone(Context context) { Twilio.initialize(context, this /* Twilio.InitListener */); } @Override /* Twilio.InitListener method */ public void onInitialized() { Log.d(TAG, "Twilio SDK is ready"); new RetrieveCapabilityToken().execute("http://companyfoo.com/token"); } }
Making an HTTP request to the /token
endpoint returns a
capability token, a string that, when given to a Device
in your Android app,
grants it capabilities such as making outgoing calls or allowing incoming calls.
Capability tokens are an important part of Twilio Client, so let’s take a moment to explain them. You use capability tokens to sign communications from your Android app to Twilio. In a production application, these tokens are created by you on your server and allow you to specify what capabilities are going to be available to your app, such as whether it can receive incoming connections, make outgoing connections, etc.
For the security of your Twilio account, you should not embed a Capability Token or your Twilio Account’s Auth Token in the app you submit to the Google Play Store.
You can read more about capability tokens and their best practices here.
Tokens always have an expiration, which means all tokens have a limited lifetime to protect you from abuse. The token generated here is valid for one hour unless otherwise specified. To specify a different period of time, pass in the number of seconds as the expires
parameter to TwilioCapability.generate()
– for example, for a token that expires after 5 minutes, call TwilioCapability.generate(expires = 300)
. The maximum allowed lifetime for a token is 24 hours.
Now, back to coding! If you compile and run this code, you should see the following:
Now, we’ve got an app that can create outgoing connections and receive incoming connections.
For the time being, we’ll focus on making an outgoing connection. The connection will call a Twilio sample application that responds with a friendly greeting.
Dialing Out
Let’s add a method to MonkeyPhone
to initiate a connection. Add a member variable of type Connection
to MonkeyPhone.java
. To make a connection, we call the Device.connect()
method. Just pass in null
parameters and a null
listener for the moment; we’ll do more with these
arguments later.
MonkeyPhone.java
public void connect() { connection = device.connect(null /* parameters */, null /* ConnectionListener */); if (connection == null) Log.w(TAG, "Failed to create new connection"); }
Connections to Twilio, either incoming or outgoing, are represented by
instances of the class Connection
. In addition, status callbacks are provided to objects that implement the listener interface DeviceListener
and ConnectionListener
. Add the code below in HelloMonkeyActivity
to call this new method when the Dial
button is pressed:
HelloMonkeyActivity.java
@Override public void onClick(View view) { if (view.getId() == R.id.dialButton) phone.connect(); }
If you now compile the app and run it, you should be able to click the “Dial” button and hear the greeting. Awesome!
Wouldn’t it be nice if you could also hang up on a connection if you don’t want to hear the whole thing? Let’s go do that now.
Hanging up from your Android Device
Congratulations on making your first audio connection from your Android device to Twilio!
You should have heard a welcome message but as you probably noticed, you
had no way to close the connection as the Hangup button doesn’t do
anything. So, let’s add code in MonkeyPhone
to hang up ongoing connection.
MonkeyPhone.java
public void disconnect() { if (connection != null) { connection.disconnect(); connection = null; } }
And add code in HelloMonkeyActivity
to call this new method when the hangup
button is pressed:
HelloMonkeyActivity.java
@Override public void onClick(View view) { if (view.getId() == R.id.dialButton) { phone.connect(); } else if (view.getId() == R.id.hangupButton) { phone.disconnect(); } }
That’s everything! Go ahead and make another call. You can now press the hangup button at any time and your connection will close.
Connecting to a TwiML Application
Wondering what actually happens when you connect using your app, and why you keep hearing that same welcome message? The key to this mystery is in the Python server we deployed earlier. Let’s take a look at that code:
server.py
APP_SID = 'YOUR APP SID HERE' # some code ommitted here @app.route('/token') def token(): account_sid = os.environ.get("ACCOUNT_SID", ACCOUNT_SID) auth_token = os.environ.get("AUTH_TOKEN", AUTH_TOKEN) app_sid = os.environ.get("APP_SID", APP_SID) capability = TwilioCapability(account_sid, auth_token) # This allows outgoing connections to TwiML application if request.values.get('allowOutgoing') != 'false': capability.allow_client_outgoing(app_sid) # This allows incoming connections to client (if specified) client = request.values.get('client') if client != None: capability.allow_client_incoming(client) # This returns a token to use with Twilio based on the account and capabilities defined above return capability.generate()
This portion of the code is responsible for creating a capability token that tells your Twilio Device what actions it is allowed to perform.
The two lines below tell your device to make outgoing connections to the App Sid APa4983020a0b29fb5db1b1dc68e322fbe
.
APP_SID = 'APa4983020a0b29fb5db1b1dc68e322fbe' # ... some code omitted here ... capability.allow_client_outgoing(app_sid)
Applications are just references to TwiML URLs that are fetched when a connection is established from a device, a browser, or a phone. If you are not familiar with TwiML, we suggest you head over to Twilio Markup Language Quick Start.
The string starting with ‘AP’ is an Application SID. You entered this Application Sid when you deployed the server in the steps above. That Application’s Voice URL points to your server’s /
endpoint, which returns the TwiML to say “Welcome to Twilio”.
<?xml version="1.0" encoding="UTF-8"?> <Response> <Say>Welcome to Twilio</Say> </Response>
We change the user’s telephony experience by generating different TwiML. Let’s continue with an example that let’s us dial any phone number.
Passing Parameters to your Application to Make a VoIP Call
Now, let’s make a Twilio Application that can actually do something useful by passing data from your Android app to your TwiML script. Let’s dial out to an arbitrary phone number. It’ll be easy, all we need to do is:
- Grab the phone number that you can enter in the text field.
- Pass that phone number along to the
Device.connect()
method. - Update your TwiML Application to point to the back-end endpoint that receives this input and dials the number entered by the user.
Let’s go do it.
The text field in the app is wired up to the member variable numberField
in
HelloMonkeyActivity
. We’ll now add some code to pass this through to your
script when creating the connection.
First, change the MonkeyPhone.connect()
method to take in a String
for the
phone number in MonkeyPhone.java
, and add the number to a Map
using the key
To
. Then pass that parameter Map
when calling
Device.connect()
:
MonkeyPhone.java
public void connect(String phoneNumber) { Map<String, String> parameters = new HashMap<String, String>(); parameters.put("To", phoneNumber); connection = device.connect(parameters, null /* ConnectionListener */); if (connection == null) Log.w(TAG, "Failed to create new connection"); }
And finally, in HelloMonkeyActivity
, pass the phone number from the text
field to the updated MonkeyPhone.connect()
method.
HelloMonkeyActivity.java
@Override public void onClick(View view) { if (view.getId() == R.id.dialButton) { phone.connect(numberField.getText().toString()); } else if (view.getId() == R.id.hangupButton) { phone.disconnect(); } }
Now, let’s change our TwiML Application to point to our app’s /call
endpoint. Go to the TwiML apps page in the account portal, change your application’s Voice URL to point to your server’s /call
endpoint: http://{your server url}/call
, and save your changes.
Now, go ahead and compile your app for the Android Emulator. Run it, enter another phone number in the box and hit dial. Your phone will ring and you can talk to yourself! Huzzah!
Here’s how it works. When your application connects to Twilio, your TwiML App’s Voice URL points to the /call
endpoint on your python server, which runs the following code:
server.py
@app.route('/call', methods=['GET', 'POST']) def call(): resp = twilio.twiml.Response() from_value = request.values.get('From') to = request.values.get('To') if not (from_value and to): return str(resp.say("Invalid request")) from_client = from_value.startswith('client') caller_id = os.environ.get("CALLER_ID", CALLER_ID) if not from_client: # PSTN -> client resp.dial(callerId=from_value).client(CLIENT) elif to.startswith("client:"): # client -> client resp.dial(callerId=from_value).client(to[7:]) else: # client -> PSTN resp.dial(to, callerId=caller_id) return str(resp)
This code looks at the From
parameter in the request from Twilio. If the connection is coming from your Android application, it grabs the To
parameter passed by your application and dials the number.
Things work a bit differently if the call is coming from a PSTN phone number. Let’s dig into that now: Now, it’s time to get your app ringing.
Receiving Incoming Connections
Now, that we know how to initiate connections from your app, it’s time for your app to start receiving incoming connections. By the end of this tutorial, you will be able to call in to your device using the Android Emulator (or vice-versa). Hold on tight…
To receive incoming connections, we’ll do the following things:
- Give the app client a name and “register” it with Twilio.
- Add callbacks to notify your app of incoming connections via listener methods.
Change your code to pass this client name to your application server when it starts up. (In a real app, you would likely pass a username/password combination that the user would enter, but we’ll omit this for simplicity.)
Device
announces the important events to an object that implements the
DeviceListener
interface:
public void onStartListening(Device inDevice);
- callback for when the device is successfully registered with Twilio
public void onStopListening(Device inDevice);
- callback for when the device is no longer listening for incoming connections due to an explicit request to stop
public void onStopListening(Device inDevice, int inErrorCode, String inErrorMessage);
- callback for when the device is no longer listening for incoming connections due to an error
We’ll modify MonkeyPhone
to implement these methods. First, we’ll declare
the interface and register the instance of MonkeyPhone
to be the Device
’s
listener when we create it, and then we’ll define the three
DeviceListener
methods. We don’t need to take any action here, but
we’ll log the various state transitions and any errors.
MonkeyPhone.java
public class MonkeyPhone implements Twilio.InitListener, DeviceListener { /* ... other methods ... */ private Device device; private Connection connection; /* Twilio.InitListener method */ @Override public void onInitialized() { Log.d(TAG, "Twilio SDK is ready"); new RetrieveCapabilityToken().execute("http://companyfoo.com/token?client=jenny"); } /* ... other methods ... */ @Override /* DeviceListener method */ public void onStartListening(Device inDevice) { Log.i(TAG, "Device is now listening for incoming connections"); } @Override /* DeviceListener method */ public void onStopListening(Device inDevice) { Log.i(TAG, "Device is no longer listening for incoming connections"); } @Override /* DeviceListener method */ public void onStopListening(Device inDevice, int inErrorCode, String inErrorMessage) { Log.i(TAG, "Device is no longer listening for incoming connections due to error " + inErrorCode + ": " + inErrorMessage); } }
Actually accepting the incoming connection is a little bit more work. You might want to glance at the section of the faq page that deals with incoming connections for some background on why this is the case. What it boils down to is:
- Create a
PendingIntent
that can activateHelloMonkeyActivity
. - Register this
PendingIntent
usingDevice.setIncomingIntent()
. - Provide a hook in
MonkeyPhone
to handle the incoming call. - Implement
onNewIntent()
inHelloMonkeyActivity
to update the activity’sIntent
. - Implement
onResume()
inHelloMonkeyActivity
to check to see if we have an incoming connection, and handle it if so.
So for the first half:
MonkeyPhone.java
/* Twilio.InitListener method */ @Override public void onInitialized() { Log.d(TAG, "Twilio SDK is ready"); new RetrieveCapabilityToken().execute("http://companyfoo.com/token?client=jenny"); Intent intent = new Intent(context, HelloMonkeyActivity.class); PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); device.setIncomingIntent(pendingIntent); } /* ... other methods ... */ public void handleIncomingConnection(Device inDevice, Connection inConnection) { Log.i(TAG, "Device received incoming connection"); if (connection != null) connection.disconnect(); connection = inConnection; connection.accept(); }
And for the second half:
HelloMonkeyActivity.java
@Override public void onNewIntent(Intent intent) { super.onNewIntent(intent); setIntent(intent); } @Override public void onResume() { super.onResume(); Intent intent = getIntent(); Device device = intent.getParcelableExtra(Device.EXTRA_DEVICE); Connection connection = intent.getParcelableExtra(Device.EXTRA_CONNECTION); if (device != null && connection != null) { intent.removeExtra(Device.EXTRA_DEVICE); intent.removeExtra(Device.EXTRA_CONNECTION); phone.handleIncomingConnection(device, connection); } }
If you compile and run the app, it’s now ready to receive incoming calls. Now, we
need to
provision a Twilio phone number,
(or use an existing one) and configure the Voice URL to point to your application server: http://{your app's url}/call
.
Call your Twilio number and you should be connected to your device (or Android Emulator, whichever you’re running), which will automatically answer the call. Start talkin’.
Ready to put it all together?
Making Calls in/out of your App
Time to put it all together… using your Quickstart skills, you’ve already initiated an outgoing connection, and received an incoming connection. Now, let’s call from one client to another.
For this example, we’ll make a call between the Android Emulator and your device.
To do this, we’ll need to log in as two different users. We’ll change the login code to register as “tommy” for the app in the Android Emulator, and “jenny” for the app on your Android device.
In MonkeyPhone
’s doInBackground(String... params)
method, add some add some
conditional-compilation code:
MonkeyPhone.java
@Override public void onInitialized() { Log.d(TAG, "Twilio SDK is ready"); new RetrieveCapabilityToken().execute("http://companyfoo.com/token?client="); Intent intent = new Intent(context, HelloMonkeyActivity.class); PendingIntent pendingIntent = PendingIntent.getActivity(context, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT); device.setIncomingIntent(pendingIntent); } private class RetrieveCapabilityToken extends AsyncTask<String, Void, String>{ @Override protected String doInBackground(String... params) { try{ boolean isEmulator = Build.PRODUCT.equals("sdk") || Build.PRODUCT.equals("google_sdk"); String clientName = isEmulator ? "tommy" : "jenny"; String capabilityToken = HttpHelper.httpGet(params[0] + clientName); return capabilityToken; } catch( Exception e ){ Log.e(TAG, "Failed to obtain capability token: " + e.getLocalizedMessage()); return null; } } @Override protected void onPostExecute(String capabilityToken ){ MonkeyPhone.this.setCapabilityToken(capabilityToken); } }
The Python script has some simple call routing rules:
- If the call is coming from PSTN, the app tells to Twilio to dial Client
jenny
. - Otherwise, the application tells Twilio to dial whatever number is passed in the
To
parameter: If theTo
parameter is a PSTN number, it writes that out within the<Number>
noun (which then will call a regular phone). If theTo
parameter is another client name, as indicated byclient:
prefix, it writes out a<Client>
noun, which will try and connect to a named Twilio Client app (a browser or another mobile client).
So now build, install, and run your app on both your Android device and the Android Emulator. Then have one of the platforms call the other (e.g. by typing “client:tommy” into the Android device’s app). Once the connection has been established you should be able to talk between your phone and your laptop! And of course, you can call regular phone numbers as we demonstrated above.
Wrapping up
That’s it for this Quickstart! If you want to learn more about how to customize the telephony experience of your application, check out the TwiML documentation.


seattle_flu_incidence_mapper package¶
Subpackages¶
Submodules¶
seattle_flu_incidence_mapper.apikey_auth module¶
seattle_flu_incidence_mapper.config module¶
seattle_flu_incidence_mapper.model_store module¶
seattle_flu_incidence_mapper.orm_config module¶
seattle_flu_incidence_mapper.pathogen_models module¶
-
seattle_flu_incidence_mapper.pathogen_models.
create
()[source]¶ This function creates a new pathogen_model in the pathogen_models structure based on the passed in pathogen_model data :param pathogen_model: pathogen_model to create in pathogen_models structure :return: 201 on success, 406 on pathogen_model exists
-
seattle_flu_incidence_mapper.pathogen_models.
delete
(pathogen_model_id)[source]¶ This function deletes a pathogen_model from the pathogen_models structure :param pathogen_model_id: Id of the pathogen_model to delete :return: 200 on successful delete, 404 if not found
-
seattle_flu_incidence_mapper.pathogen_models.
model_file
(modelId)[source]¶ Returns the model file to the user :param pathogen_model_id: :return:
-
seattle_flu_incidence_mapper.pathogen_models.
model_rds
(modelId)[source]¶ Returns the model file to the user :param pathogen_model_id: :return:
-
seattle_flu_incidence_mapper.pathogen_models.
read
(model_id)[source]¶ This function responds to a request for /api/pathogen_models/{pathogen_model_id} with one matching pathogen_model from pathogen_models :param pathogen_model_id: Id of pathogen_model to find :return: pathogen_model matching id
-
seattle_flu_incidence_mapper.pathogen_models.
read_all
()[source]¶ This function responds to a request for /api/pathogen_models with the complete lists of models :return: json string of list of models
-
seattle_flu_incidence_mapper.pathogen_models.
update
(pathogen_model_id, pathogen_model)[source]¶ This function updates an existing pathogen_model in the pathogen_models structure :param pathogen_model_id: Id of the pathogen_model to update in the pathogen_models structure :param pathogen_model: pathogen_model to update :return: updated pathogen_model structure


To comment-out part of a line in a template, use the comment syntax: {# #}
.
For example, this template would render as 'hello'
:
{# greeting #}hello
A comment can contain any template code, invalid or not. For example:
{# {% if foo %}bar{% else %} #}
If you need to comment out a multiline portion of the template, see the comment
tag.


Eileen is a current participant at the Recurse Center, where she focuses her time on web app development and machine learning with feelings. She has worked as a software developer on a variety of projects, using Java/Spring, TypeScript, and AWS. With a background in legal aid, Eileen remains involved in civic tech projects, such as OpenOversight. When not programming, she enjoys doing yoga, reading, and people-watching. She once dropped her camera into a waterfall in Ecuador after rappelling down aforementioned waterfall. The camera still works, and Eileen likes to view it as a reminder of the importance of resilience.


A GitHub App built with Probot that replies to closed bugs with a Please…can I have more…? — ala Oliver Twist
.github/oliver.yml
based on the following templateA .github/oliver.yml
file is required to enable the plugin. The file can be empty, or it can override any of these default settings:
# Configuration for oliver - https://github.com/remy/oliver
# Number of days the issue was closed in before the bot should reply.
# If the issue was closed in more days than this, the bot won't reply.
# Use `daysClosedIn: false` to *always* reply.
daysClosedIn: 5
# Labels to look for on issues the bot can reply to
labels:
- bug
# Comment to post when replying
comment: >
Thanks for raising this issue. If you're happy with how it was handled,
maybe you could star this repo by way of thanks 👍


CU-Boulder Labs
University Libraries
Home Page
Chinook Library Catalog
Library Hours
Ask a Librarian
Campus Services
Free and discounted software
Identity Manager
Printing Services
Computing Labs
Reserve a lab
Find labs with specific software
Report a workstation or lab problem
Kiosks
UCB Wireless
eduroam
VPN


Jaguar XJR
Specs
Price |
$67,400 |
Top Speed |
155mph(electronically limited) |
Acceleration |
|
Engine |
|
0-30mph |
2.0sec |
Type |
Supercharged V8, 32valve DOHC |
0-60mph |
5.2sec |
Displacement |
4.0L(3996cc) |
0-100 |
12.8sec |
Power |
370hp@6150rpm |
1/4 mile |
13.7sec/103.8mph |
Torque |
387 lbs-ft@3600rpm |
Weight |
4,026 lbs |
Handling |
|
Gas mileage |
|
Skidpad |
.88g |
City |
16mpg |
600ft slalom |
65.3mph |
Highway |
22mpg |
Powertrain |
Front engined, rear wheel drive, 5 speed automatic |
(? = incomplete data or unverified info, N/A = info Not Available)
Beyond the specs:
The amazing musclecar eating Jaguar sedan, the only sports sedan offered by Jaguar and the only sports that offers a true Jaguar interior. Speed is not an attribute many expect from a Jaguar sedan, but anyone who tries out this machine will quickly forget that they ever doubted a Jaguar sedan's ability to burn rubber. This car will easily embarrass any Camaro or Mustang owner you thinks their car is faster that this large 2 ton Jaguar sedan. It does suffer from a few problems though, it supercharger whines at high rpm, its brakes are only adequate, and it does not come with any kind of stability control likes its competitors. Also, don't expect to get the kind of road feel you can find in a BMW for despite the quick ratio steering its light weight feel makes it bad for "spirited" driving. Fortunately it is cheaper than its competitors, and being the longer than its competitors it has more interior space. Another plus for those who like oversteer is that this car can safely and easily swing its tail out if asked, just watch out for traffic and that concrete barrier. This car is a combination of understatement (few visual changes from the regular XJ8), Jaguar luxury, quality, and performance unheard of in a Jaguar sedan. After all, what do you expect when you take the luxurious XJ8 sedan and attach a supercharger to its wonderful smooth 290hp Jaguar V8 power plant.
~Oracle


File and Pay Taxes Online Login or register to start filing and paying your taxes through the web. Register|Forgot password?


On all platforms, a 1.5+ JRE is required to run Hudson. This is a challenge on FreeBSD 4.9, since the FreeBSD organization no longer supports this major version, and no 1.5+ JRE was ever licensed for distribution on the FreeBSD 4 platform. The FreeBSD Foundation did later license the Java JDK and JRE from Sun, but it is only available for FreeBSD 5 and later. If you are on FreeBSD 5 or later, just get your Java tools from the FreeBSD Foundation.
Failed Quick Solutions
- Get a pre-built JRE or JDK for FreeBSD 4. To the best of my knowledge, they don't exist, due to licensing problems when FreeBSD 4 was current.
- Get a Linux 1.5+ JRE to run on FreeBSD 4. Linux compatibility under FreeBSD 4 is not sufficient for the 1.5 and later JREs to run.
- Use the OpenJDK or IcedTea. I haven't tried this, but I suspect it won't build on FreeBSD 4, as few people are using FreeBSD 4
A working solution: build an older version of the 1.5 JDK
Steps to build your own 1.5 JRE:
- Get a 1.4 JDK installed and running, which is required as part of the 1.5 bootstrap build process
- Enable Linux compatibility in the FreeBSD kernel. Run "kldload linux" with root permissions.
- Enable Linux procfs compatibility.
- Add "linproc /compat/linux/proc linprocfs rw 0 0" to your /etc/fstab
- Load the procfs kernel module "kldload linprocfs"
- Mount the filesystem "mount /compat/linux/proc"
- Install Linux libraries. The machine I am using already had these installed - check /compat/linux/lib for a bunch of .so files. If there aren't any, install one of the linux emulation ports under /usr/ports/emulators
- Install the Linux <IP_ADDRESS> JDK. Later releases of the 1.4.2 JDK use Linux functionality that FreeBSD 4.x is not able to satisfy, and none of the tools will run.
- Run javac from the <IP_ADDRESS>. If you get the usage screen, you are done with installing a bootstrap JDK.
- Get the JRL/JIUL source distribution and installation binaries from Sun
- http://download.java.net/tiger/archive/tiger_u11/index.html; This link goes to the patchlevel 11 sources of the 1.5.0 JDK. Get both the source distribution and installation binaries. You will have to decide which license is appropriate for your use of these source files.
- Get the BSD patches from eyesbeyond.com
- http://www.eyesbeyond.com/freebsddom/java/JDK15JRLConfirm.html; Choose patchset 5 to match the JDK sources downloaded in the previous step
- Apply patch and build
- Follow the instructions in the file BUILD, inside the eyesbeyond tarball.
- Use the newly built JRE to start Hudson as a master, or more likely, as a slave


The grid below is a AngularJS UI Grid control, styled with CSS overrides in a local resource. The data displayed is loaded from a WebAPI data service hosted locally.


- name(String) - Method in interface org.mockito.MockSettings
-
Specifies mock name.
- name(String) - Method in interface org.mockito.session.MockitoSessionBuilder
-
Configures the name of the MockitoSession
instance.
- never() - Static method in class org.mockito.Mockito
-
- never() - Method in class org.mockito.verification.Timeout
-
- never() - Method in interface org.mockito.verification.VerificationAfterDelay
-
Allows verification that there are no invocations at any point during the given period.
- NeverWantedButInvoked - Error in org.mockito.exceptions.verification
-
- NeverWantedButInvoked(String) - Constructor for error org.mockito.exceptions.verification.NeverWantedButInvoked
-
- newInstance(Class<T>) - Method in interface org.mockito.creation.instance.Instantiator
-
Creates instance of given class
- NoInteractionsWanted - Error in org.mockito.exceptions.verification
-
No interactions wanted.
- NoInteractionsWanted(String) - Constructor for error org.mockito.exceptions.verification.NoInteractionsWanted
-
- nonMockableReason() - Method in interface org.mockito.plugins.MockMaker.TypeMockability
-
informs why type is not mockable
- not(T) - Static method in class org.mockito.AdditionalMatchers
-
Object argument that does not match the given argument matcher.
- not(short) - Static method in class org.mockito.AdditionalMatchers
-
short argument that does not match the given argument matcher.
- not(int) - Static method in class org.mockito.AdditionalMatchers
-
int argument that does not match the given argument matcher.
- not(long) - Static method in class org.mockito.AdditionalMatchers
-
long argument that does not match the given argument matcher.
- not(float) - Static method in class org.mockito.AdditionalMatchers
-
float argument that does not match the given argument matcher.
- not(double) - Static method in class org.mockito.AdditionalMatchers
-
double argument that does not match the given argument matcher.
- not(char) - Static method in class org.mockito.AdditionalMatchers
-
char argument that does not match the given argument matcher.
- not(boolean) - Static method in class org.mockito.AdditionalMatchers
-
boolean argument that does not match the given argument matcher.
- not(byte) - Static method in class org.mockito.AdditionalMatchers
-
byte argument that does not match the given argument matcher.
- NotAMockException - Exception in org.mockito.exceptions.misusing
-
- NotAMockException(String) - Constructor for exception org.mockito.exceptions.misusing.NotAMockException
-
- NotExtensible - Annotation Type in org.mockito
-
Indicates to the user that she should not provide custom implementations of given type.
- notNull() - Static method in class org.mockito.ArgumentMatchers
-
Not null
argument.
- notNull(Class<T>) - Static method in class org.mockito.ArgumentMatchers
-
- nullable(Class<T>) - Static method in class org.mockito.ArgumentMatchers
-
Argument that is either null
or of the given type.
- NullInsteadOfMockException - Exception in org.mockito.exceptions.misusing
-
- NullInsteadOfMockException(String) - Constructor for exception org.mockito.exceptions.misusing.NullInsteadOfMockException
-


This is just a template, not a theme
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus a euismod est. Curabitur aliquet nibh mauris, eu consectetur turpis bibendum sed. Sed id molestie ex. Vivamus vestibulum nibh leo, quis pharetra quam laoreet eu. Duis rhoncus ut ex nec rutrum. Nunc fermentum tincidunt orci, ac varius lacus mollis ut.
The usefulness of Enabled templates is unmatched. I personally find the value to be many, many times the purchase price. There is no question this is one of the top tier development houses on CodeCanyon.
Don't be afraid to ask this developer for support, and lay out exactly what you need in your mobile presence. He will respond, and he will work tirelessly until your mobile world delivers exactly what you wish to offer. Any dollar you spend with Enabled is worth $10 anywhere else. I have experienced this value, and it's rare. A++ all the way.


Case insensitve text! (in iframe)
Some pretty long link text that is partly clipped by the iframe edge.


My name is nelson
My name is Ladyjoy
Alade Nosirat is one of the Group members , Very honoured to be one.
My name is Hope Adegbe
my name is adeniji oreoluwa
Akinlalu Sharon


Airbnb signs up as Olympic sponsor through 2028 Games
by The Associated PressLONDON (AP) — The IOC has signed home-sharing company Airbnb to a sponsorship deal that will run from next year’s Tokyo Olympics through the 2028 Los Angeles Games.
The Olympic leadership, however, will not be swapping its luxury hotels for rental accommodation.
International Olympic Committee President Thomas Bach says “it will be very difficult” to organize meetings “if we would be in very difficult locations.”
Bach, speaking at a news conference in London, adds “we are there at the games not to watch like tourists. We are there to organize the games.”
The IOC is pledging to make at least $28 million worth of Airbnb accommodation available to athletes at the Olympics and Paralympics.
___
More AP sports: https://apnews.com/apf-sports and https://twitter.com/AP_Sports
The Associated Press


{% extends 'layout.html' %} {% block content %}
This tutorial assumes you know your way around Redis as well as JavaScript and is intended to quickly get you up to speed on what could be done with Redis-V8. If you are not familiar with Redis, we would suggest completing this tutorial, with more Redis tutorials available here.
Compiling the project source is not covered by this introductory material.
git clone git://github.com/h0x91b/Redis-V8.git cd Redis-V8/redis/ make cd src/ ./redis-server ../redis.conf
<?php //load the predis library require '[Redis-V8_source_folder]/Client-Libraries/PHP/predis-0.8.3/Autoloader.php'; Predis\Autoloader::register(); //Create a connection (the default <IP_ADDRESS>:6379) $redis = new Predis\Client(); //The following JS command will execute a JS script inside the database //JS has a "redis" object, which includes the database functions "set", "get", "incr" etc ... //Let`s make a key named "hello", with a value "world" and return it to the PHP var_dump( $redis->js( 'redis.set("hello","world"); return redis.get("hello");' ) ); ?>The output should be:
array(2) { ["ret"]=> string(5) "world" ["cmds"]=> int(2) }When using JS and JSCALL commands, Redis-V8 returns a JSON-formatted string as follows:
{ret:<answer>,cmds:<the number of requests to the database>}
Info For more convenient use with PHP, the modified Predis library will automatically convert JSON into a standard PHP array.
//This function will add a comment to the database function makeCommentForPost(postId, title, body, author){ //Obtain a new unique ID for the comment var commentId = redis.incr( 'INCR:COMMENT_ID' ); //Create a JS object for the comment var comment = { id: commentId, title: title, body: body, author: author }; //Write the comment object to the database redis.hmset( 'HSET:COMMENT_FOR_POST:'+postId+':'+commentId, comment ); //Add a comment to the Ordered set, sorted by time redis.zadd( 'ZSET:COMMENTS_FOR_POST:'+postId, Math.floor(+new Date/1000), commentId ); //Return the comment's ID return commentId; }
We have created the function "makeCommentForPost" in our database's JS engine, which will be available under the JS and JSCALL commands. To make Redis-V8 aware of the new function, the V8 programming environment must be re-loaded by performing the "JSRELOAD" command within any Redis client, such as the standard redis-cli:
cd Redis-V8/redis/src/ ./redis-cli JSRELOAD
Info Redis-V8 will automatically locate and load every .js file under /redis-v8/redis/src/js/ and any existing subfolders, so creating an extensive (and comprehensive) folder tree is encouraged. The location of the user scripts folder can be changed by modifying the "js-dir" value within the redis.conf file.
<?php //load the modified predis library require '[Redis-V8_source_folder]/Client-Libraries/PHP/predis-0.8.3/Autoloader.php'; Predis\Autoloader::register(); //Create a connection (the default <IP_ADDRESS>:6379) $redis = new Predis\Client(); var_dump( $redis->jscall( //jscall allows you to call JS functions and pass any arguments safely "makeCommentForPost", //the called JS function's name 1, //argument 1 (postId) "post title", //argument 2 (title) "post body", //argument 3 (body) "post author" //argument 4 (author) ) ); ?>The result returned by JSCALL will look the same as that of a regular JS request:
array(2) { ["ret"]=> int(1) ["cmds"]=> int(3) }
Execute the script a few more times to populate the database.
function getCommentsForPost(postId){ //Get the list of IDs of comments in a descending order, ordered by creation time. var comment_ids = redis.zrevrange('ZSET:COMMENTS_FOR_POST:'+postId,0,-1); var comments = comment_ids.map(function(commentId){ //We get the comment itself var comment = redis.hgetall('HSET:COMMENT_FOR_POST:'+postId+':'+commentId); //Find the comment's timestamp comment.timestamp = redis.zscore('ZSET:COMMENTS_FOR_POST:'+postId,commentId); //Add it to the list return comment; }); //Return list return comments; }Do not forget to update your V8 environment using JSRELOAD :)
var_dump( $redis->jscall("getCommentsForPost",1) );Execute index.php to output the full list of comments:
array(2) { ["ret"]=> array(4) { [0]=> array(5) { ["id"]=> string(1) "4" ["title"]=> string(10) "post title" ["body"]=> string(9) "post body" ["author"]=> string(11) "post author" ["timestamp"]=> string(13) "1369063795714" } [1]=> array(5) { ... } ... } ["cmds"]=> int(9) }
As you can see, a single command to Redis-V8 using PHP actually executed 9 Redis commands and returned a single "package" containing the entire formatted list of comments, ready to be rendered within template.
cd Redis-V8/redis/src ./redis-cli JS "console.log('return of redis.get is',redis.get('hello'))"
The terminal window running redis-server will display the following:
[2326] 22 May 02:01:51.171 * console.log argument[0] = return of redis.get is [2326] 22 May 02:01:51.171 * console.log argument[1] = world
function getPost(alias){ //getPostByAlias will return the post itself //Will find post by its alias, make the necessary increment of views, etc ... var post = getPostByAlias(alias); var postId = post.id; //This function will run through the lists of related posts and return them post.relatedPosts = relatedPosts(postId); //Load the required number of comments //Let's say a 100 comments from the first page post.comments = commentsForPost(postId,1,100); //Get all of the post's tags to create a neat tag cloud post.tags = tagsForPost(postId); //Get the post's category, which is likely to be needed post.category = getCategory(post.category); //Get the author's info, such as karma, avatar, etc. post.author = getAuthor(postId); //Get a list of the author's 5 recent articles post.author.last_articles = lastArticlesByAuthor(post.author.id, 5); //And return a complete object that can be rendered within the template return post; }
The JS functionality of Redis-V8 described above will allow you to not only reduce the amount of traffic generated, but can also potentially replace the entire Model of MVC-like design patterns. As a direct result of the commands being executed within the database itself, its overall performance increases significantly.
Another advantage of this approach is the ease of tracking a multitude of Redis database keys thanks to the small size of the created JS scripts.


{% get_providers as socialaccount_providers %} {% if socialaccount_providers %}
{% blocktrans with site.name as site_name %}Please sign in with one of your existing third party accounts. Or, sign up for a {{ site_name }} account and sign in below:{% endblocktrans %}
{% include "socialaccount/snippets/provider_list.html" with process="login" %}


{% extends 'templates/nhs_transaction_layout.html' %} {% block content %} Register with a GP practice Use this service if you need to: register with a GP practice for the first time register with a new GP practice after moving house register someone else with a new GP practice Start now {% endblock %}
Use this service if you need to:


We are not alone!
Ask your neighbors and friends...
Name
Name
Name
Name
Name
Search!
Date
City
State
Country
Shape
Duration
Comments


Raul Sanllehi and Edu 'looked furious' after Arsenal's draw with Southampton
Arsenal's head of football Raul Sanllehi and technical director Edu were seen leaving the away dressing room following the Gunners' 2-2 draw with Southampton on Saturday
by Jake Polden, https://www.mirror.co.uk/authors/jake-polden/Raul Sanllehi and Edu reportedly looked furious following Arsenal's 2-2 draw with Southampton.
The Gunners were shocking against the relegation-threatened Saints, with Alexandre Lacazette rescuing them a point with one of the final kicks of the game, deep into stoppage time at the Emirates.
Unai Emery is under intense pressure to turn things around, and admitted it is his sole responsibility to get the Gunners firing once more.
"The club are supporting me every day and also I have a responsibility," said the Spaniard after the game. "I know I can do better, I can take more performances with the players and I'm going to try to do that. Now my job is to analyse, to try to move on with confidence with the players.
"It's difficult but we need to move on in the next days. After analysing that match we are going to play at home again on Thursday, prepare as well as possible.
"We know, and I know, that we need to connect with our supporters."
Arsenal's head of football Sanllehi and technical director Edu were seen leaving the home dressing room after the match.
According to Goal, the duo 'had faces like thunder' on account of the result.
Emery received backing from Sanllehi and managing director Vinai Venkatesham ahead of the international break, but stressed they are looking to see improvements.
"We are as disappointed as everyone else with both our results and performances at this stage of the season," the statement read.
"We share the frustration with our fans, Unai, players and all our staff as they are not at the level we want or expect.
"Things need to improve to meet our objectives for the season and we firmly believe Unai is the right man for the job."


NeedleJS overview
NeedleJS is an object oriented javascript framework, realizing the notion of classes. In the same time it provides features no different than what other libraries like JQuery provide.
The goal this framework sets is to help developers better organize their code using NeedleJS features or any general purpose library. Doing that by separating logic and complexity into different files (classes), which then can be requested dynamically and extended if needed. Organizing code into "classes" helps you implement different object oriented design patters and benefits especially if you build large scale web applications. Those familiar with PHP or Java will find NeedleJS syntax handy.
- Private properties and methods
- Public properties and methods
- Static properties and methods
- Constants
- Constructors
- NeedleJS contains many classes.
- Class name is the same as the file.
- Each class can be requested dynamically.
- All classes can be extended.
- All base classes inherit from N.Object class.
- Plugins can extend base classes or other plugins.
If you want to learn more let's go to getting started section


I am probably in minority but I rather like playing ports of old games on handhelds.If it is a complete remake even better.In fact I prefer playing old games on handhelds to playing it on a home console. Even though I enjoy a fresh title as much as any other guy, I will be pretty happy if I get a remake of a game I played years ago.
My fascination for ports on handelds started when I first played Super mario on my friends’ GBA.I absolutely loved it. All the excitement of playing the game as a child came rushing back to me. I followed it with other remakes.Metroid , Legend of zelda,Mega man and many more.I discovered my favorite final fantasy game in a port(final fantasy 5 in case you are interested). I learned later that final fantasy 5 was never localized in the west. It was through GBA that many gamers like myself first got to play it.
Later on I payed many original titles on the system.But it were the familiar games, the ones that I had already played and loved that introduced me to the handheld gaming. DS’s full support for backward compatibility was a dream come true. I had spent years amassing my favorite GBA games and the fact that I could play it on DS was a sweet bonus.
With the PSP the trend continued.The system was powerful enough that it could handle the games from both of sony’s previous generation of home consoles. The list of remakes was just crazy
I never played many of these games before.One of my most prized discoveries in the PSP port library was monster hunter.
Not everyone appreciates remakes though. PSP throughout it’s life was often criticized for the amount of ports it had. But for someone like me this was nostalgia heaven. I fell in love with these games all over again. Many of the remakes were actually more comfortable to play on the handheld. Take Disgaea, a game which involves countless hours of grinding (which is very enjoyable, though repetitive) to complete. Playing it in the palm of your hands in small sessions was very engaging. Every small increase in the stat of your character gave an incredible sense of accomplishment. Ditto for Final Fantasy Tactics.
One of the things that I like about handhelds is the convenience they offer. It is hard go back once you have had a taste of them.  I rarely play video games outside. I am talking about playing it on my bed, or on my sofa or on my terrace during winters.The sleep feature (that both DS and PSP had) was incredible.Who needed frequent save points now?
As good as the last generation of handhelds were, they were limited by their design. There were no analog sticks on Nintendo’s consoles while PSP had just one. Playstation Vita and the 3DS have outstretched the boundaries of what is possible on handheld devices. Now with two analog sticks and a loads of other features these devices are more than capable of handling resource hungry games.The quality remakes that have appeared in the yet short life of these consoles is amazing.
A question that I often hear is, if the games are so good why not play them on their intended device in the first place?
Remakes are dismissed as a sign of laziness on the part of developers.But they have given me so many hours of enjoyment that I just love them.If it were not for remakes I am certain that I would have have missed out on some of my favorite games.I would never have played final fantasy 5 and probably would remain deprived of the awesomeness of gilgamesh or monster hunter.


|
SideCar
|
Maintain a shared list of the task IDs and their input channels which should receive a message. More...
#include </Users/howes/src/sidecar/IO/RecipientList.h>
Public Types | |
| using | TaskRef = boost::shared_ptr< Task > |
Public Member Functions | |
| RecipientList () | |
| Default constructor. More... | |
| void | add (const TaskRef &task, size_t channelIndex) |
| Adds a recipient to this list. More... | |
| size_t | size () const |
| Obtain the number of Entry objects. More... | |
| bool | deliver (ACE_Message_Block *data) const |
| Distribute a message to each registered recipient Task object. More... | |
| std::ostream & | print (std::ostream &os) const |
| Print out the task/channel entries to a C++ text output stream. More... | |
| bool | areAnyTasksUsingData () const |
| Determine if there are any recipients actively processing data. More... | |
Static Public Member Functions | |
| static Logger::Log & | Log () |
| Log device for RecipientList messages. More... | |
Maintain a shared list of the task IDs and their input channels which should receive a message.
When a Task object emits a message, it adds a set of recipients to the message via MessageManager::setRecipients(). The recipient list contains a 2-tuple for each recipent that contains the unique task ID of the Task object to receive the next message, and the index of the Task's channel to deliver to.
The deliver() method distributes ACE_Message_Block message objects to registred recipients. However, it only deliver a message to if the recipient desired data.
Definition at line 25 of file RecipientList.h.
| RecipientList::RecipientList | ( | ) |
Default constructor.
Creates an empty vector of Entry objects.
Definition at line 17 of file RecipientList.cc.
| void RecipientList::add | ( | const TaskRef & | task, |
| size_t | channelIndex | ||
| ) |
Adds a recipient to this list.
NOTE: there is no check for duplicate entries (assumed done elsewhere)
| taskIndex | unique recipient index |
| channelIndex | input channel index of task |
Definition at line 24 of file RecipientList.cc.
| bool RecipientList::areAnyTasksUsingData | ( | ) | const |
Determine if there are any recipients actively processing data.
If so, then deliver() will distribute data. Otherewise, it does nothing.
Definition at line 114 of file RecipientList.cc.
| bool RecipientList::deliver | ( | ACE_Message_Block * | data | ) | const |
Distribute a message to each registered recipient Task object.
| data | the message to deliver |
Definition at line 45 of file RecipientList.cc.
|
static |
Log device for RecipientList messages.
Definition at line 11 of file RecipientList.cc.
References Logger::Log::Find().
| std::ostream & RecipientList::print | ( | std::ostream & | os | ) | const |
Print out the task/channel entries to a C++ text output stream.
| os | stream to write to |
Definition at line 35 of file RecipientList.cc.
|
inline |


2 DAYS IN THE VALLEY A film review by Christopher Null Copyright 1996 Christopher Null
If you've seen the trailer, the #1 question on your mind about 2 DAYS IN THE VALLEY must be: Is it a PULP FICTION rip-off, or is it a *bad* PULP FICTION rip-off?
Well, the answer is this: Yes, it's a shameless PULP FICTION rip-off (more like PULP FICTION meets SHORT CUTS), but it's actually quite entertaining, in its own quirky little way.
In fact, 2 DAYS IN THE VALLEY is the best (and possibly the last [hint, hint]) of these knockoffs to come down the interstate. The only problem is that writer/director John Herzfeld forgot one critical part: a cool soundtrack! The main difficult with 2 DAYS is an uncommonly lousy score that kills the suspense and the comedy with equal ability.
But let's talk about the good parts, those mainly being the rich characters Herzfeld has created to act out his play. (Please pay attention.) It starts with Peter Horton (gets shot early on, a very big plus) as a deadbeat husband to downhill skier/aspiring scam artist Teri Hatcher. James Spader (by far the most fun of the film) and newcomer Charlize Theron as Hatcher's partners in crime. Danny Aiello as an aging hitman working with Spader. NAKED's Greg Cruttwell as Aiello's whining hostage. Glenne Headly as Cruttwell's bookish assistant. Marsha Mason as Cruttwell's nurse/half-sister. Paul Mazursky as a suicidal Hollywood has-been who is picked up by Mason. And Jeff Daniels and Eric Stoltz (the only PULP veteran in the show) as hapless cops on to all of these characters. (Plus there are at least three good cameos.)
Whew! D'you catch all that? It's easier than it sounds, trust me -- in fact, the fun of 2 DAYS is watching all the pieces come together via a mixture of slapstick comedy, generally witty dialogue, and blackly comedic gunfights, fistfights, dogfights, catfights, and any other kind of fight you can think of. All the while, Herzfeld manages to weave in unexpectedly powerful themes of bygone happiness, greed, and desperation... and The Valley. And Herzfeld manages to pack all of this into a very tight 105 minutes. There's very little wasted footage on the screen, which is hard to say about many directors today.
It winds up as a solid picture that is probably accessible to a wider audience than PULP FICTION was -- there were plenty of squeamish girly types in the crowd, and no one walked out. And I was actually expecting a bad movie! Go figure.
[Food for thought: When was the last time you could get gas in Los Angeles for $1.07, as is seen in the film? Talk amongst yourselves.]

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


Sports
CLEVELAND CAVILIERS (KYRIE IRVING) BUFFALO BILLS (LESEAN MCCOY) LOS ANGELES ANGLES (ALBERT PUJOLS):
$
If you're using the GitHub for Mac, simply sync your repository and you'll see the new branch.
Basketball
Football
Baseball
Support or Contact
Having trouble with Pages? Check out the documentation at https://help.github.com/pages or contact<EMAIL_ADDRESS>and we’ll help you sort it out.


This is a simple plugin for Vue, creating drag and drop functionality for components. A lot of inspiration was taken from ReactDnd, so if you're familiar with that you will have no trouble using this plugin.
Pretty standard procedure. Make sure you have Vue > 2 and Vuex in your project as those are dependencies of this plugin.
yarn add vue-drag-n-drop
npm i -S vue-drag-n-drop
Register the plugin first.
import VueDnD from 'vue-drag-n-drop';
const store = new Vuex.Store({ ... });
Vue.use(VueDnD, { store });
The drag source helper makes a component draggable.
import { DragSource } from 'vue-drag-n-drop';
import Component from 'Component'; // import your component.
const source = {
// Get the data that will be passed to the DropTarget once this component is dropped on one
// First parameter is the instance of your Component.
dragData: componentInstance => ({
data1: componentInstance.getData1(),
data2: componentInstance.data2,
}),
};
// Make your Component draggable and specify a type for it.
export default DragSource('custom_drag_component', source)(Component);
// The component is now draggable and can be dropped onto DropTargets.
The drop target helper makes a component a drop zone.
import { DropTarget } from 'vue-drag-n-drop';
import TargetComponent from 'TargetComponent'; // import your component.
const target = {
// Restrict what components can get dropped on the drop target.
canDrop(dropTarget, dragMonitor) {
return dropTarget.id !== dragMonitor.getItem().id;
},
// This method is called once a drag source is dropped on the drop target.
drop(dropTarget, dragMonitor) {
// do something
},
};
// Create a drop target, that will accept multiple drag source types.
export default DropTarget(['custom_drag_component', 'other_type'], target)(TargetComponent);
// The component is now a drop target.
The drag monitor is used to pass information from the drag source to the drop target.
It currently has 3 methods.
getItem() -> Get the drag source Vue instance.
getData() -> Get the data that was generated in the source contract of the drag source.
getType() -> Get the type of the drag source.
Sometimes you dont want the default browser ghost image when dragging, but rather some custom element. You can do that by using the dragPreview() method of the source contract of any drag source.
const source = {
dragData() { ... }
dragPreview() {
// Here you can return any element or image (also canvas) that will then be used as the drag preview.
}
}
View the generated documentation.
In order to build vue-drag-n-drop, ensure that you have Git and Node.js installed.
Clone a copy of the repo:
git clone https://github.com/mediamonks/vue-drag-n-drop.git
Change to the vue-drag-n-drop directory:
cd vue-drag-n-drop
Install dev dependencies:
yarn
Use one of the following main scripts:
yarn build # build this project
yarn dev # run dev-watch mode, serving example/index.html in the browser
yarn generate # generate all artifacts (compiles ts, webpack, docs and coverage)
yarn typings # install .d.ts dependencies (done on install)
yarn test:unit # run the unit tests
yarn validate # runs validation scripts, including test, lint and coverage check
yarn lint # run tslint on this project
yarn doc # generate typedoc documentation
When installing this module, it adds a pre-push hook, that runs the validate
script before committing, so you can be sure that everything checks out.
If you want to create the distribution files yourself, you can run the
build-dist
script, and the following files will get generated in the
dist
folder:
window.VueDragNDrop
View CONTRIBUTING.md
View CHANGELOG.md
View AUTHORS.md
MIT © MediaMonks
Generated using TypeDoc


Class: Aws::OpsWorks::Types::CloudWatchLogsLogStream
| Relationships & Source Files | |
| Super Chains via Extension / Inclusion / Inheritance | |
|
Class Chain:
self,
Struct
|
|
|
Instance Chain:
self,
::Aws::Structure ,
Struct
|
|
| Inherits: |
Struct
|
| Defined in: | gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb |
Overview
Describes the Amazon CloudWatch logs configuration for a layer. For detailed information about members of this data type, see the CloudWatch Logs Agent Reference.
Constant Summary
Instance Attribute Summary
-
#batch_count ⇒ Integer
rw
Specifies the max number of log events in a batch, up to 10000.
-
#batch_size ⇒ Integer
rw
Specifies the maximum size of log events in a batch, in bytes, up to 1048576 bytes.
-
#buffer_duration ⇒ Integer
rw
Specifies the time duration for the batching of log events.
-
#datetime_format ⇒ String
rw
Specifies how the time stamp is extracted from logs.
-
#encoding ⇒ String
rw
Specifies the encoding of the log file so that the file can be read correctly.
-
#file ⇒ String
rw
Specifies log files that you want to push to
::Aws::CloudWatch
Logs. -
#file_fingerprint_lines ⇒ String
rw
Specifies the range of lines for identifying a file.
-
#initial_position ⇒ String
rw
Specifies where to start to read data (start_of_file or end_of_file).
-
#log_group_name ⇒ String
rw
Specifies the destination log group.
-
#multi_line_start_pattern ⇒ String
rw
Specifies the pattern for identifying the start of a log message.
-
#time_zone ⇒ String
rw
Specifies the time zone of log event time stamps.
Instance Method Summary
::Aws::Structure
- Included
| #to_hash | Alias for Structure#to_h. |
Instance Attribute Details
#batch_count ⇒ Integer
(rw)
Specifies the max number of log events in a batch, up to 10000. The default value is 1000.
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end
#batch_size ⇒ Integer
(rw)
Specifies the maximum size of log events in a batch, in bytes, up to 1048576 bytes. The default value is 32768 bytes. This size is calculated as the sum of all event messages in UTF-8, plus 26 bytes for each log event.
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end
#buffer_duration ⇒ Integer
(rw)
Specifies the time duration for the batching of log events. The minimum value is 5000ms and default value is 5000ms.
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end
#datetime_format ⇒ String
(rw)
Specifies how the time stamp is extracted from logs. For more information, see the CloudWatch Logs Agent Reference.
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end
#encoding ⇒ String
(rw)
Specifies the encoding of the log file so that the file can be read
correctly. The default is utf_8
. Encodings supported by Python
codecs.decode()
can be used here.
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end
#file ⇒ String
(rw)
Specifies log files that you want to push to ::Aws::CloudWatch
Logs.
File
can point to a specific file or multiple files (by using wild
card characters such as /var/log/system.log*
). Only the latest
file is pushed to ::Aws::CloudWatch
Logs, based on file modification time.
We recommend that you use wild card characters to specify a series
of files of the same type, such as access_log.2014-06-01-01
,
access_log.2014-06-01-02
, and so on by using a pattern like
access_log.*
. Don't use a wildcard to match multiple file types,
such as access_log_80
and access_log_443
. To specify multiple,
different file types, add another log stream entry to the
configuration file, so that each log file type is stored in a
different log group.
Zipped files are not supported.
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end
#file_fingerprint_lines ⇒ String
(rw)
Specifies the range of lines for identifying a file. The valid
values are one number, or two dash-delimited numbers, such as '1',
'2-5'. The default value is '1', meaning the first line is used
to calculate the fingerprint. Fingerprint lines are not sent to
::Aws::CloudWatch
Logs unless all specified lines are available.
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end
#initial_position ⇒ String
(rw)
Specifies where to start to read data (start_of_file or end_of_file). The default is start_of_file. This setting is only used if there is no state persisted for that log stream.
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end
#log_group_name ⇒ String
(rw)
Specifies the destination log group. A log group is created
automatically if it doesn't already exist. ::Aws::Log
group names can be
between 1 and 512 characters long. Allowed characters include a-z,
A-Z, 0-9, '_' (underscore), '-' (hyphen), '/' (forward
slash), and '.' (period).
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end
#multi_line_start_pattern ⇒ String
(rw)
Specifies the pattern for identifying the start of a log message.
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end
#time_zone ⇒ String
(rw)
Specifies the time zone of log event time stamps.
# File 'gems/aws-sdk-opsworks/lib/aws-sdk-opsworks/types.rb', line 812
class CloudWatchLogsLogStream < Struct.new( :log_group_name, :datetime_format, :time_zone, :file, :file_fingerprint_lines, :multi_line_start_pattern, :initial_position, :encoding, :buffer_duration, :batch_count, :batch_size) SENSITIVE = [] include Aws::Structure end


{{template "header.tmpl.html"}}
This is a sample page to show different ways to recover passwords
More to come...