What's new in yepnope 1.5?
- Scripts with the same url won't execute twice, but their callbacks fire in the correct order.
- The complete function behaves much more like the callback function with respect to 'recursive yepnope'.
- CSS load callbacks were taken out by default and put in an official plugin. Too few people used it.
- We exposed yepnope.injectJs and yepnope.injectCss in order to give you direct access to the injection functions.
yepnope.injectJs( scriptSource [, callback ] [, elemAttributes ] [, timeout ]);
// Example
yepnope.injectJs( "jquery.js", function() {
console.log("jQuery loaded!");
}, {
charset : "utf-8"
}, 5000 );
yepnope.injectCss( stylesheetSource [, callback ] [, elemAttributes ] [, timeout ]);
// Example
yepnope.injectCss( "print.css", function() {
console.log("css injected!");
}, {
media : "print"
}, 5000 );
- We added the ability to use key/value pairs in prefixes.
- We added a builtin prefix for overriding the global yepnope.errorTimeout with a specific timeout per script.
yepnope('timeout=5000!script.js');
- We smarten'd up detection of CSS files even if there are query parameters (without the use of the css prefix plugin)
- We added the ability to write filters and prefixes that add arbitrary attributes on the eventual script and link tags.
- We removed the old and busted demo/ folder since we just use the tests folder for everything.
- We just assume you have closure compiler and uglifyjs if you're running our compress script. (it makes it super small, trust us)
-
While you can still set up your own labels for resource callbacks, yepnope now automatically creates keys for you, derived from the basename of the resource. For example, if you were loading https://my-cdn.com/jquery-ui.min.js?v=1.8.16, the derived key would be jquery-ui.min.js.
yepnope({
load: [
"https://my-cdn.com/jquery.min.js?v=1.7.1",
"https://my-cdn.com/jquery-ui.min.js?v=1.8.16"
],
callback: {
"jquery.min.js" : function() {
console.log("jquery loaded!");
},
"jquery-ui.min.js" : function() {
console.log("jquery-ui loaded!");
}
}
});
- You can now run the unit tests locally using Node.js. Simply navigate to the tests folder and run:
npm install
node run.js
The API
There are only a handful of things to know about yepnope. There are only 5 functions available to you
and there's only one that's really important.
yepnope(resources )
The yepnope function is the core of yepnope.js (crazy, huh?). It takes a whole bunch
of stuff, to try to make it easy on you.
The recommended type for resources is an array of test objects. The consistency helps
make your code look better and stay maintainable.
However, if you don't need more than one test group, then you can avoid putting it in an array, and just send
in the object.
If you're really feeling lazy, you can just pass a string in, as well.
On top of all that, inside of your array, each item can be a test object, another array, or a string
literal. Just send in whatever you got, and there's a good chance yepnope will take it (as long as it's
a string, array, or test object)
What's in a test object?!
Great question! Here's a list of the things that yepnope will care about if you put it in a test object. All of these
properties are optional.
yepnope([{
test : /* boolean - Something truthy that you want to test */,
yep : /* array | string - The things to load if test is true */,
nope : /* array | string - The things to load if test is false */,
both : /* array | string - Load everytime (sugar) */,
load : /* array | string - Load everytime (sugar) */,
callback : /* function ( testResult, key ) | object { key : fn } */,
complete : /* function */
}, ... ]);
Note that yepnope can load CSS or JS files. All resources will be considered JS files unless they end
in '.css'. As of yepnope 1.5, css files with cachebusting query parameters
are correctly detected. If you don't have a .css extension anywhere download the css! prefix
plugin from the github repository and include it at the end of your yepnope file.
Another Script Loader?#?@$!@# - Why Use Yepnope?
You're right. The last few months we've been inundated by new script loaders. I'd like to first point
out that that is awesome. It goes to show that there is a real benefit to using a script/resource loader.
In fact, the yepnope prototype launched at JSConfEU back in November of 2010. Since then, we've used some of
the best techniques from other script loaders and packaged up the magic for you in a piece-of-cake API.
I'd like it to be very clear why/when you'd want to use yepnope instead of one of the many other options,
as well as when yepnope is not appropriate.
Good Things
- yepnope.js is only 1.7kb - smaller than most and certainly a good size for its functionality set.
- yepnope.js is called a "resource loader" because it can work with both JavaScript and CSS.
- yepnope.js has a full test suite in QUnit that you can run in your set of supported browsers to make
sure it works. (We run it via TestSwarm in every browser we can get our hands on)
- yepnope.js fully decouples preloading from execution. This means that you have ultimate control of when your resource is executed and you can change that order on the fly.
- The yepnope.js api is friendly and encourages logical grouping of resources.
- yepnope.js is modular. It has a whole system for adding your own functionality and a couple examples
of how you might do that. (Prefixes and filters).
- The yepnope.js api encourages you to only load the resources that you need. This means that even when
it's slower than another script loader, it still can come out on top, because you could avoid an entire resource.
- yepnope.js is integrated into Modernizr.
- yepnope.js always executes things in the order they are listed. This is a pro for some, and a con for others.
We think it's a friendly default. You can override this functionality with yepnope.injectJs
and yepnope.injectCss.
- yepnope.js has the capability to do resource fallbacks and still download dependent scripts in parallel
with the first. More clearly:
yepnope([
{
load: 'http://ajax.googleapis.com/ajax/libs/jquery/1.5.1/jquery.min.js',
complete: function () {
if ( ! window.jQuery ) {
yepnope( 'local/jquery.min.js' );
}
}
},
{
load : 'jquery.plugin.js',
complete: function () {
jQuery(function () {
jQuery( 'div' ).plugin();
});
}
}
]);
In most loaders, in order to test for and potentially use the fallback version of jQuery, said loader must
download load the rest of the "chain" of scripts in the callback for jQuery:
someLoader('http://ajax.googleapis.com/ajax/libs/jquery/1.5.1/jquery.min.js', function(){
if ( ! window.jQuery ) {
someLoader( 'local/jquery.min.js', 'jquery.plugin.js' );
} else {
someLoader( 'jquery.plugin.js' );
}
});
Not only is this not very pretty, and not very DRY, it's slow. It essentially means that jQuery will load in serial
everytime. It also means that anything that depends on or comes after jQuery wont start downloading until after jQuery
has executed.
yepnope, on the other hand, can start downloading `jquery.plugin.js` right away (at the same time as the google cdn
version of jQuery). In the normal case, these will download at the same time and they will execute in order. In the case
where our fallback is needed, we only have to wait the additional time for the second jQuery to load in order to continue
on. This is made possible by yepnope's fully decoupled preloading and executing.
Things to keep in mind
Conclusion
In short, we want you to make the right decision for your application. We can certainly think of times when yepnope.js
would not be the correct choice for a resource loader, and we hope we've made those situations abundantly clear in our
documentation. However, we also think that yepnope meets a lot of people where they are, when it comes to a balance of
performance, usability, size and feature-set.
If you have questions about if yepnope is right for your application. Send us a tweet or an email and we'll help you
out. Most of us in the script-loader author scene are total BFFs and we aren't about competition, we're about pushing
the edge. In other words, we totally use LABjs and RequireJS in a bunch of our projects, because they're badass (and the
other ones are probably great too!).
Yepnope: The Guide
Why should you use yepnope?
Yepnope has a simple API to help you order load and execute your scripts in the fastest possible way.
Yepnope natively supports JavaScript and CSS resources, and loads them asynchronously and in parallel,
but always executes them in the order you intended. Yepnope is customizable and extendable so you can
add your own customizations with ease! Yepnope is small, weighing in at just over 1.7kb minified and gzipped.
Why not just concatenate all my scripts and put them at the bottom?
While this is not a bad practice, it is advice from the early days of performance driven script loading. Since
then, we've found that in many cases, you can get better performance. For instance, if you concatenate all of your
JavaScript into a single file, you are often loading large chunks of JavaScript that don't actually run
on the page that you're on. These are wasted bytes, and cost you time and user-experience street cred. Also, it's
been shown that loading a small amount of scripts in parallel is actually faster than loading them all
concatenated together, since they can all download at the same time (yes, even though there are more http requests).
More specifically, a lot of the time, code is specific to a certain situation, yepnope capitalizes on this fact, and
allows you to load your scripts based on the situation you find yourself in. Many times, this manifests itself as
Feature Tests. Feature Tests check for the availability of a feature in the executing browser environment. Usually
when a feature is not supported, a "polyfill" is loaded in to offer backwards compatibility in non-supporting browsers.
With yepnope, the only people who pay the cost of the polyfill file are those who need it.
If yepnope saves you from loading a single JavaScript file, it probably paid for itself. Everything after that
is just gravy.
Can't I do this with other script loaders?
Yep. We just think this approach is specifically well-suited for this use-case, and other loaders are geared towards
other problems. Most of them are super-awesome too!
What does this have to do with Modernizr? ( or What is Modernizr.load ? )
Currently yepnope is being included in special builds of Modernizr, because it's such a good companion to a feature
testing library. The output of Modernizr is a fantastic input to yepnope. Yepnope is currently included unmodified from
its original state, but is also aliased as Modernizr.load - you can use the two interchangeably, though we suggest that you
stick to one or the other.
Using Yepnope
yepnope();
Takes: string, object, array of either
The yepnope function is where all the magic happens. It's built to take what you give it, so pay close attention:
A String
The most simple thing you can pass the yepnope function is a string.
yepnope( '/url/to/your/script.js' );
This will load your js file at sometime in the future (but as soon as possible into the future). That's because yepnope
is _asynchronous_. It doesn't wait for the script to be finished loading before the next thing is allowed to happen. This
is why yepnope can make your apps faster!
"I'm still confused, why can't I use the script that I just loaded?"
You can! Just not like that. If you need to do something after your file has been loaded, you'll want to use a callback
function.
"You mean I can't do this?":
yepnope( 'js/jquery.js' );
$.ajax(...); // NOPE
Sorry, but that's not the way it works! If you're not used to asynchronous code, this can be a chore, but we'll go through
how you can make it work like you want!
An Object
yepnope( {
load : '/url/to/your/script.js'
} );
This is exactly equivalent to the first example with a string, except we can add on to this one. For instance, we can
add a callback function to run whenever the file is done loading. This is done with the 'callback' property (go figure!).
From now on, we'll refer to this object as a Test Object (even though sometimes it doesn't have a test in it ;).
yepnope( {
load : '/url/to/your/script.js',
callback : function ( url, result, key ) {
// whenever this runs, your script has just executed.
alert( 'script.js has loaded!' );
}
} );
If you're used to the asynchronous pattern, this should be a breeze, and if not, it'll seem natural in no time.
One of the most important parts of yepnope is your ability to pass in feature test results to determine whether or
not you need to load a script. Here's yepnope's API for doing that:
yepnope( {
test : window.JSON,
nope : 'json2.js',
complete : function () {
var data = window.JSON.parse( '{ "json" : "string" }' );
}
} );
The power here, is that you were able to parse a JSON string, but if your browser already had built in support for
JSON parsing, it didn't require you to load anything extra!
Notice that we don't have a 'yep' script property set. That's because it isn't mandatory. If you don't have anything
to load when your script passes, you can leave out the 'yep', the same goes for 'nope'.
This is a simple example, and one based on a very easily replaceable browser feature. Many other things that you may
feature test for often require some set of scripts and styles that aren't always able to be exact fill-ins for their native
counterparts. Regardless, yepnope likely has a way to help you structure it nicely.
Now if you want to load more than one script, you have a few options (based on your app, one might feel better than
another - the yepnope developers suggest that you always do what feels better).
You can set the load property in the test object to an array of urls.
yepnope( {
load : [ 'script1.js', 'style1.css' ],
callback: function ( url, result, key ) {
// Wait! What happens in here now?! Does this get called once or twice?
}
} );
The callback becomes a little bit confusing when we introduce a multiple file load. In fact, the callback function gets
called for every single file you load in the test object (keep that in mind when you learn new ways to load files).
It's about time you learned what the parameters that get passed into your function are for.
...
callback: function ( url, result, key ) {
console.log( url, result, key );
}
...
- url - This is the url (without any prefixes attached) that was loaded
- result - This is the result of your test, treat it as a truthy value
- key - If you provided a key mapping to your file, this is that key. Also if you
use an array, it's the index of the array it came from ( can get confusing if you used multiple arrays ).
In cases where you just use a string to load a resource, it's 0.
These are here to help you make decisions in your callbacks.
As shown in the previous example, often times we end up loading more than just one thing at a time. Yepnope gets
its name from being able to act on either outcome of a test, so your callback often needs to know how that test turned
out (without you having to copy it and run it again).
In the following example, assume your browser does not support geolocation (and the 'nope' array is what gets loaded):
yepnope( {
test : Modernizr.geolocation,
yep : 'regular-styles.css',
nope : [ 'modified-styles.css', 'geolocation-polyfill.js' ],
callback : function ( url, result, key ) {
alert( url );
}
} );
This will cause TWO separate alerts to occur. They will each contain the exact string (minus any prefixes, if you add
those in the future) of the url that was loaded from the `nope` array.
So in a simple case you could check to see which url is being loaded in order to know to do a certain thing:
yepnope( {
test : Modernizr.geolocation,
yep : 'regular-styles.css',
nope : [ 'modified-styles.css', 'geolocation-polyfill.js' ],
callback : function ( url, result, key ) {
if ( url === 'modified-styles.css' ) {
alert( 'The Styles loaded!' );
}
}
} );
In this example, unlike the previous one, there will only be one alert. After the css has loaded, the url will match
in our if-statement, and the alert will occur. Since the url of the 'geolocation-polyfill.js' file does not match, there
will be no alert.
Another thing you might want to know in this situation is the result of your test. Luckily, that's the second parameter.
So if you wanted the alert to mention which styles were loaded, then you might try something like this:
yepnope( {
test : Modernizr.geolocation,
yep : 'regular-styles.css',
nope : [ 'modified-styles.css', 'geolocation-polyfill.js' ],
callback : function ( url, result, key ) {
if ( url === 'modified-styles.css' ) {
alert( 'The Styles loaded!' );
if ( result ) {
alert( 'The Test Passed!' );
}
else {
alert( 'The test Failed!' );
}
}
}
} );
Obviously, this example is a little bit unrealistic, but hopefully it helps you picture how you might use
these in your application.
You may be thinking that it's a bit cumbersome to always have to repeat the urls of the files that you
load in order to write callback functions for them. We agree!
There are a few options if you need very unique callbacks for your scripts. The first is the most simple,
but a bit longer to write. Since yepnope supports an array of test objects, you can just separate the file
declarations!
An Array
yepnope( [
{
load : 'file1.js',
callback : function ( url, result, key ) {
alert( 'This is definitely file1!' );
}
},
{
load : 'file2.js',
callback : function ( url, result, key ) {
alert( 'This is definitely file2!' );
}
}
] );
This can get a little bit long and when the files rely on the same test, you don't want to have to rerun your
feature test for each file you want load based on its result. So you can use a key/value mapping in an object
literal to name your resources. Then the 'key' variable will let you know which of the files the callback is
related to.
yepnope( {
test : Modernizr.geolocation,
yep : {
'rstyles' : 'regular-styles.css'
},
nope : {
'mstyles' : 'modified-styles.css',
'geopoly' : 'geolocation-polyfill.js'
},
callback : function ( url, result, key ) {
if ( key === 'geopoly' ) {
alert( 'This is the geolocation polyfill!' );
}
}
} );
Now we have a much more succinct way of knowing which one of our files our callback is related to. But as you
may suspect, the code that you would have to write in order to find every single key would get ugly fast. So we
also allow you to give a key value set for your callbacks:
yepnope( {
test : Modernizr.geolocation,
yep : {
'rstyles' : 'regular-styles.css'
},
nope : {
'mstyles' : 'modified-styles.css',
'geopoly' : 'geolocation-polyfill.js'
},
callback : {
'rstyles' : function ( url, result, key ) {
alert( 'This is the regular styles!' );
},
'mstyles' : function ( url, result, key ) {
alert( 'This is the modified styles!' );
},
'geopoly' : function ( url, result, key ) {
alert( 'This is the geolocation polyfill!' );
}
}
} );
Only the keys that correspond to a file that actually got loaded will be called. So in this case, if geolocation
was not supported, the 'rstyles' callback would never fire.
We don't want this tutorial to sound too much like it's reading your mind, but we know what you're asking
yourself. "Well now that I've split up all my callbacks, how do I just run some code at the very end, after
everything is done loading?"
That's a great question! You are absolutely right. With this current situation, you'd have to
duplicate code in order to make sure something ran at the very end ( depending on if the test passed or failed ).
That's why there's also the 'complete' callback. Here it is in action:
yepnope( {
test : Modernizr.geolocation,
yep : {
'rstyles' : 'regular-styles.css'
},
nope : {
'mstyles' : 'modified-styles.css',
'geopoly' : 'geolocation-polyfill.js'
},
callback : {
'rstyles' : function ( url, result, key ) {
alert( 'This is the regular styles!' );
},
'mstyles' : function ( url, result, key ) {
alert( 'This is the modified styles!' );
},
'geopoly' : function ( url, result, key ) {
alert( 'This is the geolocation polyfill!' );
}
},
complete : function () {
alert( 'Everything has loaded in this test object!' );
}
} );
Now you can act on individual file loads and entire test object groups with clarity.
Here are some more questions and answers now that you're a little more familiar with how yepnope works:
How do I know what order my files are going to execute in? Can I force an order?
In short, whatever order you put them in, that's the order that we execute them in. The 'load' and 'both'
sets of files are executed after your 'yep' or 'nope' sets, but the order that you specificy within those sets
is also preserved. This doesn't mean that the files always load in this order, but we guarantee that they execute
in this order. Since this is an asynchronous loader, we load everything all at the same time, and we just delay
running it (or injecting it) until the time is just right.
What happens if I use yepnope inside of a yepnope callback?
This is actually an advanced feature of yepnope. We call it 'recursive yepnope'. It actually places the files of the
internal yepnope call into the correct place in the outer yepnope call. So the next file in the outer yepnope call
will wait until the inner yepnope call loads and executes before it executes. This is a great feature to use as a
fallback enabler. We encourage you to use it with caution, because it results in slower script loading since we can't
start preloading the files until the callback occurs (serial loading instead of parallel), but when it's the only option,
it's nice. Here is an example of how it could be used as a fallback technique.
yepnope( [
{
// Load jquery from a 3rd party CDN
load: 'http://code.jquery.com/jquery-1.5.0.js',
callback: function ( url, result, key ) {
// The boss doesn't trust the jQuery CDN, so you have to have a fallback
// So here you can check if your file really loaded (since callbacks will still
// fire after an error or a timeout)
if ( ! window.jQuery ) {
// Load jQuery from our local server
// Inject it into the middle of our order of scripts to execute
// even if other scripts are listed after this one, and are already
// done loading.
yepnope( 'local/js/jquery15.js' );
}
}
},
{
// This file will start downloading as soon as this line is executed,
// but if the jQuery CDN was down it won't be executed until after the
// local version was loaded.
load: 'jQuery.plugins.js',
callback: function ( url, result, key ) {
jQuery( '.fun' ).plugin();
}
}
] );
Depending on your browser, when there's an error, your callbacks may fire back immediately, but in other
browsers, there is no distinction between a successful script load and an error state, so we opt not to expose
potentially wrong information. If your script hangs or is unavailable, there is a maximum timeout that you can set
for how long it will wait before just calling back anyways. This setting is at yepnope.errorTimeout.
I'm seeing two requests in my dev tools, why is it loading everything twice?
Depending on your browser and your server this could mean a couple different things. Due to the nature of
how yepnope works, there are two requests made for every file. The first request is to load the resource
into the cache and the second request is to execute it (but since it's in the cache, it should execute immediately).
Seeing two requests is pretty normal as long as the second request is cached. If you notice that the second request
isn't cached (and your script load times are doubling), then make sure you are sending the correct cache headers to
allow the caching of your scripts. This is vital to yepnope. It will not work without proper caching enabled. We
actually test to make sure things aren't loaded twice in our test suite, so if you think we may have a bug in your
browser regarding double loading, we encourage you to run the test suite to see if the double loading test passes.
I am requesting a file twice and it's only loading once?
By popular demand, in yepnope 1.5+ we added the feature that scripts that have already been requested not be re-executed
when they are requested a second time. This can be helpful when you are dealing with less complex serverside templating
system and all you really care about is that all of your dependencies are available. If you need to force a load, you can
do so with a plugin.
When does the complete callback fire?
In versions of yepnope prior to 1.5 this could vary from time to time, but now the `complete` callback is always called
regardless of what happens when all (or even when nothing loads) the resources are loaded.
Does yepnope wait for my CSS to load?
It used to, but we didn't see a lot of use. So in order to keep speeds up, we removed this functionality from the
core, but offer it as a plugin in the github repo. Adding it to your project should make calls to yepnope wait until
css files are fully loaded before calling the callbacks and complete functions.
Yepnope Plugins!
Yepnope was designed to be customizable. There are a few simple hooks throughout the loading process
that allow you to inject code and change settings around on the fly. There are two main ways to do this: Prefixes
and Filters.
Prefixes and Filters do the same thing, except that a prefix is only applied to scripts that explicitly have the
related prefix, and a filter is a global modication of every script that goes through yepnope. Prefixes are added to
files individually by prepending the prefix value to the file name and separating them with a ! character. Examples
to follow.
Yepnope officially supports a few prefixes and filters.
In no specific order, they are:
timeout! Prefix
The timeout! prefix accepts a value as an override to the global yepnope errorTimeout. This value is the number of milliseconds
to wait for a resource to load before just calling the callbacks for that resource. Simply separate the `timeout` keyword
with a `=` and then list the the new number of milliseconds that you want to use.
yepnope( {
load : 'timeout=2000!jquery.1.5.0.js',
callback : function ( url, result, key ) {
if ( ! window.jQuery ) {
// load a different one
}
}
} );
Other plugins can use this key/val style if they so choose. Simply look at the implementation of the timeout plugin for
details. The timeout plugin is the only one that's included by default in yepnope.
css! Prefix
The css! prefix is for those people who need to load css files without a `.css` extension. Since yepnope 1.5 - yepnope can
detect the presence of query parameters without the help of the css prefix, so this is usually for cases when the css files
have a php ending or something similar.
yepnope( 'css!mystyles.php?version=1532' ); // loads as a style!
preload! Prefix
The preload! prefix does pretty much what it says it does. When used on any file, it loads the file without executing
it. The callback occurs when the file has been completely loaded. If proper cache headers have been set up, these files
will be cached but not executed. This could be potentially beneficial as a technique to load future resources and prime
the caches of your users at your discretion.
yepnope( {
load : 'preload!jquery.1.5.0.js',
callback : function ( url, result, key ) {
window.jQuery; // undefined (but it's cached!);
}
} );
Please note that the only types of things that are tested for the preload plugin are script and javascript files,
though we're sure it will work on a few other types.
ie! Prefix(es)
While everyone knows that sniffing for browsers is bad practice, sometimes it's necessary. This plugin allows you to
use different sets of ie related prefixes to only load content for the dreaded IE browser of your choosing.
Here is a list of supported prefixes in the IE package:
ie, ie5, ie6, ie7, ie8, ie9, iegt5, iegt6, iegt7, iegt8, ielt7, ielt8, and ielt9
The function of these should be pretty self-explanatory (hopefully), but if it's not clear: ie followed by a single
number will execute the following script if the IE version matches that number. iegt is for 'versions greater than' x,
and ielt is for 'versions less than' x. The sole ie tag will allow for any Internet Explorer version.
Since you can chain multiple prefixes, these prefixes work together to perform a logical OR. So if any of your IE
logic returns true, the resource will load (assuming there isn't something else that's stopping it).
yepnope( {
load: [ 'normal.js', 'ie6!ie7!ie-patch.js' ] // ie6 or ie7 only (on patch)
} );
Adding Your Own Prefixes and Filters
Yepnope allows you to add your own custom prefixes and filters.
There are two functions on the yepnope object that allow you to add these: addFilter
and addPrefix. The only difference between them, is that 'addPrefix' takes a name (string)
as the first value, and the filter has no name, so only takes a callback function.
The function that gets run is passed a resource object that describes things about each individual
file that gets loaded through yepnope. In this function you should modify it to your choosing, and then return it.
Consider it middleware if you believe in that type of thing.
The resource object has the following properties that you are allowed to modify:
- url - The url that is injected
- prefixes - the array of applied prefixes
- autoCallback - a callback function that runs after each script load separately from the others
- noexec - boolean to force a preload, but no execution
- instead - a function that takes all the same parameters as our internal loader (advanced)
- forceJS - boolean force the file to be treated as a JS file
- forceCSS - boolean for force the file to be treated as a CSS file
- bypass - boolean for do or don't load the file
- attrs - key value pairs that will be applied as attributes to the injected elements. (new in 1.5+)
Here's a somewhat silly example:
yepnope.addPrefix( 'bypass', function ( resourceObj ) {
resourceObj.bypass = true;
return resourceObj;
} );
This will cause any file with the bypass! prefix to not load or execute.
A bypass Filter would look almost exactly the same, except it would apply to all files, and you don't
need to pass a name:
yepnope.addFilter( function ( resourceObj ) {
resourceObj.bypass = true;
return resourceObj;
} );
Each function passed in is required to send back the request object (whether modified or not).
Errors and Timeouts
Yepnope ( or any other script loader that we know of ) cannot accurately report script loading errors in a
cross browser manner. For this reason, we have a good amount of code in place to ensure that errors that we can
detect fail quickly (so you could potentially try a fallback), and that errors we cannot detect are automatically
called back after the amount of time that's specified in the yepnope.errorTimeout property. The default for yepnope
is 10,000 milliseconds ( or 10 seconds for all you humans ). At any point in time you can change this value and
any script loaded after it's change will obey it's timeout length. Different organizations tend to require
different times. Please adjust to your liking before making any requests.
example:
yepnope.errorTimeout = 4000; // set to 4 second error timeout
Check out the section on fallback loading if you have any questions on how to set it up.
COMMON GOTCHAS
- You cannot use document.write() (which means no google maps or ads) in the scripts that you load with yepnope. This is true for every asynchronous script loader. We suggest that you avoid document.writes all the time though.
- IEs less than 9 don't guarantee that the callbacks for scripts run immediately after the related script executes. There are hacks for this but they are not universally applicable to all scripts. Please see Julian Aubourg's blog post on this subject if you you'd like to learn more information.
- Just because your script is done, doesn't mean the document is ready. Don't forget that you can use document ready callbacks inside of your yepnope callbacks. If you're toying with the DOM, we'd heavily encourage you to do so, because your test environment may act differently than your production server the speeds are dramatically different.
- Loading too many scripts can be worse than not using yepnope. Yepnope is not to be used as an excuse not to group alike scripts and styles into single files. This is still a great practice. We just don't want you to group it into one.
- Old IEs can only load 2 things at a time from the same domain, others only 6. This means that if you are using more than 2 scripts from the same domain, you might consider getting some subdomains and serving your files from those in order to alleviate this limit.
Brought to you by


$def with (group)
$group['name']
In hierarchy: $group['parent']['hierarchy']
$group['parent']['hierarchy']
Subgroups:
$for subgroup in group['subgroups'].keys():
$subgroup
Control files:
$for file in group['controlfiles'].keys():
$file: $group['controlfiles'][file]
Tasks:
$for systasks in group['tasks'].keys():
$systasks: $group['tasks'][systasks]


# So, you have a stock ride height Panther and want to lower it?
![Alt text](img/stock.jpg)
## Here's a quick and easy guide on how to do so:
### [Step 1](http://lmgtfy.com/?q=how+do+i+lower+my+car)
### That's it, you're lowered!
![Alt text](img/lowered.jpg)
---
Copyright © wheelsandbytes 2015-2017. All Rights Reserved


Back to Dashboard
Administration Management
Search:
Search
To reset a password do an edit and change the *********, otherwise leave as is


0.5 minute(s)
Smile! you are alive!
Base Ambience Sounds
More...
River
Ocean
Bird
Tab 2
This is the content of tab 2.
Root Chakra
Sacral Chakra
Solar Plexus Chakra
Heart Chakra
Throat Chakra
Third Eye Chakra
Crown Chakra


--- title: Batchwise dot product. type: docs repo: https://github.com/rstudio/keras menu: main: name: Batchwise dot product. - keras parent: keras-reference aliases: - /reference/keras/k_batch_dot.html - /keras/reference/k_batch_dot.html - /guide/keras/reference/k_batch_dot.html - /tools/tools/keras/reference/k_batch_dot.html - /installation/keras/reference/k_batch_dot.html - /tutorials/keras/reference/k_batch_dot.html - /guide/tools/keras/reference/k_batch_dot.html - /deploy/keras/reference/k_batch_dot.html - /tools/keras/reference/k_batch_dot.html - /tutorials/tools/keras/reference/k_batch_dot.html ---
batch_dot
is used to compute dot product of x
and y
when x
and y
are data in batch, i.e. in a shape of (batch_size)
. batch_dot
results in
a tensor or variable with less dimensions than the input. If the number of
dimensions is reduced to 1, we use expand_dims
to make sure that ndim is
at least 2.
k_batch_dot(x, y, axes)
| x | Keras tensor or variable with 2 more more axes. |
| y | Keras tensor or variable with 2 or more axes |
| axes | List of (or single) integer with target dimensions (axis indexes
are 1-based). The lengths of |
A tensor with shape equal to the concatenation of x
's shape (less
the dimension that was summed over) and y
's shape (less the batch
dimension and the dimension that was summed over). If the final rank is 1,
we reshape it to (batch_size, 1)
.
This function is part of a set of Keras backend functions that enable lower level access to the core operations of the backend tensor engine (e.g. TensorFlow, CNTK, Theano, etc.).
You can see a list of all available backend functions here: https://keras.rstudio.com/articles/backend.html#backend-functions.


How to Add a Task to the Source
You can associate
a line in a file with a
task.
There are 2 possibilities to add a task to the source:
- Just place the cursor at the desired position in the
editor, open
a task list and press the "New Task..." button from the local toolbar.
Select "Context" tab and press the "Add..." button to associate a line
in a text file or an URL with the task. You can also enter
multiple tasks at once. Just
press "Add Another" button instead of "OK".
- There is a special bridge module between the User Tasks
module
and the editor: Task List Editor Support. Install it and open the local
menu over the left editor margin:
Comments & requests to<EMAIL_ADDRESS>.
Further information at http://tasklist.netbeans.org
.


| Color | Hardness | Size | Surface | Hubs Options |
|---|---|---|---|---|
| Emerald | 101A | 175lbs | Coated Wood Floor | Speed Removable |
| Amethyst | 99A | 160lbs | Not Recently Coated Wood Floor | Speed Removable |
| Sapphire | 98A | 150lbs | Not Recently Coated Wood Floor | Speed Removable |
| Ruby | 97A | 140lb - 175lb | Not Recently Coated Wood Floor Coated Concrete |
Speed Removable Nylon |
| Pearl | 96A | 120lb - 150lb | Not Recently Coated Wood Floor Coated Concrete Sport Court |
Speed Removable Nylon |
| Tourmaline | 96A | 120lb - 150lb | Not Recently Coated Wood Floor Coated Concrete Sport Court |
Speed Removable Nylon |
| Onyx | 94A | 100lb - 130lb | Not Recently Coated Wood Floor Coated Concrete Sport Court |
Removable Nylon |
| Citrine | 93A | <100lb | Not Recently Coated Wood Floor Coated Concrete Sport Court |
Removable Nylon |


TO DELANI STUDIO
AMAZING PEOPLE ARE MAKING AMAZING DESIGNS IN A FUN ENVIRONMENT
When you work with us, you are part of a team of committed collaborators. All aspects of our software development process are integrated, interactive and agile.
Our approach unites design, development an product management to create
exceptional products.
We start each project by understanding your business goals, there's needs and the the product requirements.
Then we help translate them into effective and elegant solutions.
Before we sign a contract or write a line of code our team will spend the necessary time needed to understand your product vision.
The outcome of the scoping session is a proposal or high-level statement of work.
Based on your
requirements, we can provide a complete offering or just the pieces you need.
Our deign practice offers a full range of services including brand strategy, interaction and visual design and user experience testing.
Throughout your project, our designers create and implement visual design and workflows,
solicit user feedback and work with you to make sure what gets built is what is needed.
All engineers are fluent in the latest enterprise, mobile and web development technologies.
they collaborate with your team to write, and improve code on a daily basis, using proven practices such as test-driven development
and pair programming.
Planning and development is iterative. Because we are constantly coding and testing, the products we build are always ready to go live.
This iterative process allows for changes as business requirements evolve.
Sample One:Jim Carrey
Sample Two:Wallpaper
Sample Three:Mighty Ontario Security
Sample Four:Green Background
Sample Five:Have a Good Day.
Sample Six:Customizer
Sample Seven:Burned Logo
Sample Eight:Girraffe Restaurant


What kind of hike would you like to find?
Based on your search terms, you might be interested in one of these hikes.
| Hike Name | Score |
|---|---|
| {{ l1[0] }} | {{ l2[0]}} |
| {{ l1[1] }} | {{ l2[1]}} |
| {{ l1[2] }} | {{ l2[2]}} |
| {{ l1[3] }} | {{ l2[3]}} |
| {{ l1[4] }} | {{ l2[4]}} |
Hikers who visted these trails recently are discussing {{l7}}.


Terms and conditions
By using this service you’re agreeing to the following terms of use.
This includes the privacy policy
Who we are
This service is managed by Her Majesty’s Courts and Tribunals Service and will be referred to as we from now on.
Information provided by this service
This service provides information to support you. HMCTS cannot give legal advice on individual cases.
You should answer the questions in the service based on your circumstances, and seek legal advice if you need it.
Applicable law
Your use of this service and any dispute arising from its use will be governed by and construed in accordance with the laws of England and Wales, including but not limited to the:
- Computer Misuse Act 1990
- Data Protection Act 1998
- Mental Capacity Act 2005
Responsible use of this service
The service is designed for people who need to use it or by others on their behalf and only with their consent.
There are risks in using a shared computer (for example in an internet café) to access this service. It’s your responsibility to be aware of these risks and to avoid using any computer which may leave your personal information accessible to others. You’re responsible if you choose to leave a computer unprotected while using this service.
You must take your own precautions to ensure that the way you access this service does not expose you to the risk of:
- viruses
- malicious computer code
- other forms of interference which may damage your computer system
You must not misuse this service by knowingly introducing viruses, trojans, worms, logic bombs or other material which is malicious or technologically harmful. You must not attempt to gain unauthorised access to this service, the system on which it is stored or any server, computer or database connected to it. You must not attack this site via a denial-of-service attack or a distributed denial-of-service attack.
This online service contains several free-text fields in which you will need to enter certain types of information. You should not enter sensitive information into these free-text fields. Sensitive information may include, but is not limited to, details of religious beliefs and financial information. Entering sensitive information is done so at your own risk.
Information about you and your visits to GOV.UK
We collect information about you in accordance with our privacy policy and our cookie policy
Disclaimer
While we make every effort to keep GOV.UK up to date, we don’t provide any guarantees, conditions or warranties that the information will be:
- current
- secure
- accurate
- complete
- free from bugs or viruses
We don’t publish advice on GOV.UK. You should get professional or specialist advice before doing anything on the basis of the content.
We’re not liable for any loss or damage that may come from using GOV.UK. This includes:
- any direct, indirect or consequential losses
- any loss or damage caused by civil wrongs (‘tort’, including negligence), breach of contract or otherwise
- the use of GOV.UK and any websites that are linked to or from it
- the inability to use GOV.UK and any websites that are linked to or from it
This applies if the loss or damage was foreseeable, arose in the normal course of things or you advised us that it might happen.
This includes (but isn’t limited to) the loss of your:
- income or revenue
- salary, benefits or other payments
- business
- profits or contracts
- opportunity
- anticipated savings
- data
- goodwill or reputation
- intangible property, including loss, corruption or damage to data or any computer system
- wasted management or office time
We may still be liable for:
- death or personal injury arising from our negligence
- fraudulent misrepresentation
- any other liability which cannot be excluded or limited under applicable law
Changes to these terms and conditions
Please check these terms and conditions regularly. HMCTS may and can update them at any time without notice.
You’ll agree to any changes if you continue to use this service after the terms and conditions have been updated.


{{participants.length}} wonderful people have already registered! Please note that you have to be registered here or have bought a pre-sale ticket before the party starts, otherwise we cannot allow you access to the venue due to Swedish law!


Cache Class
The cache class allows you to cache the result of a resource heavy operation.
Configuration
The cache class's defaults are configured through the fuel/core/config/cache.php configuration file. It is already populated with a default configuration. You can override this configuration adding a config file with the same name to your application config directory, and set the values you want to change there. These will overwrite the core config but keep what you didn't overwrite.
The following global configuration values can be defined:
| Param | Type | Default | Description |
|---|---|---|---|
| driver | string |
|
The default storage driver used for saving the caches. |
| expiration | int |
|
The default number of seconds until expiration, used when no lifetime is given. When set to null it won't expire. |
| (type)_handler | string |
|
When caching strings nothing special happens unless when caching more complex things like
objects, or even more primitive like doubles. For those cases there are "content handlers"
included which can ensure you'll get your object back as the right kind of object. By
default handlers are included for using PHP serialization and JSON encoding. You can add your own or handle different kinds of objects/primitive types in different ways by adding handlers for each of them: 'int_handler' => 'json', 'string_handler' => 'string', 'Model_Post' => 'serialize', etc... |
For each of the cache storage drivers, a separate configuration section exists. This section contains the driver specific parameters.
File driver configuration
Saves the caches to the filesystem.
Specific driver configuration:
| Param | Type | Default | Description |
|---|---|---|---|
| path | string |
|
Basepath for saving the caches. |
MemCached driver configuration
Specific driver configuration:
| Param | Type | Default | Description |
|---|---|---|---|
| cache_id | string |
|
Unique id to distinguish fuel cache items from others stored on the same server(s). |
| servers | string |
|
Array of servers and portnumbers that run the memcached service. |
Redis driver configuration
Specific driver configuration:
| Param | Type | Default | Description |
|---|---|---|---|
| database | string |
|
Name of the redis database to use (as configured in config/db.php) |


If you have forgotten your password, then you can reset it by entering your email address below.
You will receieve an email with further directions on how to reset your password.
Please enter a valid email address.


C64 Colors
concieved by Michael Steil, based on Pepto's work.
| Palette | Adjustments | ||||||||||||||||||||||||||||||||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
|
|
Link to this Palette
Colorspace Diagram
|
|
Palette
Notes
- VIC-II Rev:
- Mixed Colors:
- Max Luma Diff:
- Limit Max Luma Diff:
- Mixing Pattern: On a real system, *alternating columns* and *checkered* will produce nasty vertical low-frequency color stripes ("GEOS effect") for larger areas. The same is true for *checkered 2x* for lower luma diffs. The previews do not account for this.
- Sort by: The color index is defined as follows: The 16 base colors have their natural indexes. Mixed colors are sorted first by luma diff, then by the index of the component with the lower index, then by the component with the higher index.
References
- pepto: Calculating the color palette of the VIC II
- groepaz: Accurately reproducing the Video Output of a Commodore C64
- Jon Woods: Luma-Driven Graphics on the Commodore 64
- Ilkka Sjöstedt: Old VIC-II Colors and Color Blending
- Digger/Elysium: Retro Palette Explorer
- CSDb User Forums: Joe's 136 colors technique
- Great Hierophant: The Search for Artifact Color on the Commodore 64


--- layout: post date: 2012-02-15 time: "11:00:00" authors: ["Greg Wilson"] title: Slide Drive tags: ["Content", "Education"] ---
Speaking of new kinds of content (which I've been doing a lot), David Seifreid has built a working prototype of a new slideshow tool that combines deck.js with an HTML5 audio player. You can check out a demo or grab the source from https://github.com/dseif/slide-drive. Slides are pure HTML like this:

Solution

Short intensive workshops

 Our solution combines short, intensive workshops...

Plus self-paced online instruction

 ...with self-paced online instruction.

which combines slide pages and transcripts in a single file suitable for diffing and merging. (Images are still in external files, but I can live with that.) You can pause the slideshow at any point to select and copy the content (something you definitely can't do with a video), and we'll add support for translations into other languages and so on.
Many thanks to David for pulling this together; please let us know what you think.


Class LayerMasker
Allows convenient interpretation and creation of layer masks (bit-masks which indicate one or more layers) that can be used to interact with LayeredSpatialMap<T>.
Namespace: SadRogue.Primitives.SpatialMaps
Assembly: TheSadRogue.Primitives.dll
Syntax
public sealed class LayerMasker : Object
Remarks
A layer mask is simply a list of layers encoded as a bit mask. It is frequently used in LayeredSpatialMap<T> as an optional parameter that indicates what layers should apply to an operation or given set of functionality. LayeredSpatialMap defines its own LayerMask variable that should be used to retrieve layer masks for use with that object whenever possible. For layer masks needed outside of that, use Default; but this won't enforce the maximum number of layers automatically. There are also constants defined in LayerMasker to represent "all layers" and "no layers".
Constructors
LayerMasker(Int32)
Constructor. Takes the number of layers allowed, which must be more than 0 and less than or equal to 32.
Declaration
public LayerMasker(int numberOfLayers = 32)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | numberOfLayers | The number of layers supported by this layer mask generator. |
Fields
AllLayers
Layer-mask representing all layers.
Declaration
public readonly uint AllLayers
Field Value
| Type | Description |
|---|---|
| UInt32 |
Default
Default layer masker, that excludes no possible layers from its results.
Declaration
public static readonly LayerMasker Default
Field Value
| Type | Description |
|---|---|
| LayerMasker |
NoLayers
Layer mask representing no layers.
Declaration
public readonly uint NoLayers
Field Value
| Type | Description |
|---|---|
| UInt32 |
Properties
NumberOfLayers
Maximum number of layers supported by this layer masker. Functions using layer masks enforce this limit, and will not consider layers outside the range [0, NumberOfLayers - 1]
Declaration
public int NumberOfLayers { get; }
Property Value
| Type | Description |
|---|---|
| Int32 |
Methods
AddLayers(UInt32, IEnumerable<Int32>)
Adds the given layers to the given layer mask, provided those layers are within the supported number of layers. Any layer outside of this range will not be added.
Declaration
public uint AddLayers(uint mask, IEnumerable<int> layers)
Parameters
| Type | Name | Description |
|---|---|---|
| UInt32 | mask | The mask to add the layers to. |
| IEnumerable<Int32> | layers | Layers to include in the resulting layer mask. |
Returns
| Type | Description |
|---|---|
| UInt32 | A layer mask including any original layers that were in the given mask (regardless of whether they were within the supported number of layers), as well as the new layers provided (provided they are within the supported number of layers). |
AddLayers(UInt32, Int32[])
Adds the given layers to the given layer mask, provided those layers are within the supported number of layers. Any layer outside of this range in either of the function's parameters will not be included.
Declaration
public uint AddLayers(uint mask, params int[] layers)
Parameters
| Type | Name | Description |
|---|---|---|
| UInt32 | mask | The mask to add the layers to. |
| Int32[] | layers | Layers to include in the resulting layer mask. |
Returns
| Type | Description |
|---|---|
| UInt32 | A layer mask including any original layers that were in the given mask, as well as the new layers provided. However, the mask will exclude any layers not within the range of this LayerMasker's supported layers. |
AddLayers(UInt32, UInt32)
Adds layers active in the mask addMask
to the mask
value, and returns
the result. The result will include all layers on in the original mask, as well as all layers on in
addMask
, provided those layers are within the supported number of layers. Any layer
outside of this range will not be added.
Declaration
public uint AddLayers(uint mask, uint addMask)
Parameters
| Type | Name | Description |
|---|---|---|
| UInt32 | mask | |
| UInt32 | addMask |
Returns
| Type | Description |
|---|---|
| UInt32 |
HasLayer(UInt32, Int32)
Returns whether or not a layer is contained within the given layer mask. Returns false if the layer given is outside the supported number of layers.
Declaration
public bool HasLayer(uint mask, int layer)
Parameters
| Type | Name | Description |
|---|---|---|
| UInt32 | mask | Layer mask to check. |
| Int32 | layer | Layer to check for. |
Returns
| Type | Description |
|---|---|
| Boolean | True if the given layer is present in the given layer mask, false if it is not or the layer is outside the supported number of layers for this LayerMasker. |
Layers(UInt32)
Returns a custom enumerator that will enumerate all layers contained within the given layer mask (that fall within the supported number of layers). This function is intended to be used primarily with a foreach loop (see remarks).
Declaration
public LayerMaskEnumerator Layers(uint mask)
Parameters
| Type | Name | Description |
|---|---|---|
| UInt32 | mask | Layer mask to return layers for. |
Returns
| Type | Description |
|---|---|
| LayerMaskEnumerator | All layers contained within the given layer mask that fall within the supported number of layers for this LayerMasker. |
Remarks
This function returns a custom value type which can be treated like an enumerator and used with C#'s foreach loop. It is intended to be used like so:
foreach (int layerID in myLayerMasker.Layers(myLayerMask))
Console.WriteLine($"Do something with layer {layerID}.")
This custom iterator will perform many times better (up to 25x better, in fact) than an IEnumerable, when used in a foreach loop, since it is a value type and thus incurs no GC allocation and no boxing/unboxing.
The returned enumerator also contains a function you can use to retrieve an IEnumerable if you wish to use the returned values with System.Linq or similar:
var array = myLayerMasker.Layers(myLayerMask).ToEnumerable().ToArray()
Note, however, that using this function will entirely erase the performance benefits of the custom type.
Mask(IEnumerable<Int32>)
Gets a layer mask including exactly the given layer indices. Any layer given outside the maximum number of layers is ignored, and will not be added to the resulting mask.
Declaration
public uint Mask(IEnumerable<int> layers)
Parameters
| Type | Name | Description |
|---|---|---|
| IEnumerable<Int32> | layers | Layers to include in generated layer mask. |
Returns
| Type | Description |
|---|---|
| UInt32 | A layer mask including exactly those layers in the input that were within the supported number of layers. |
Mask(Int32[])
Gets a layer mask including exactly the given layer indices. Any layer given outside the maximum number of layers is ignored, and will not be added to the resulting mask.
Declaration
public uint Mask(params int[] layers)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32[] | layers | One or more layers to include in generated layer mask. |
Returns
| Type | Description |
|---|---|
| UInt32 | A layer mask including exactly those layers in the input that were within the supported number of layers. |
MaskAllAbove(Int32)
Generates and returns a layer mask including the given layer and any layer above (greater than) it. Layers not in the supported number of layers will be ignored, and will not be added to the resulting layer mask.
Declaration
public uint MaskAllAbove(int layer)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | layer | Layer to start the mask at. |
Returns
| Type | Description |
|---|---|
| UInt32 | A layer mask including the specified layer and all layers above it, provided those layers fall within the supported number of layers. |
MaskAllBelow(Int32)
Generates and returns a layer mask including the given layer and any layer below (less than) it. Layers not in the supported number of layers will be ignored, and will not be added to the resulting layer mask.
Declaration
public uint MaskAllBelow(int layer)
Parameters
| Type | Name | Description |
|---|---|---|
| Int32 | layer | Layer to start the mask at. |
Returns
| Type | Description |
|---|---|
| UInt32 | A layer mask including the specified layer and all layers below it, provided those layers fall within the supported number of layers. |


@* * Copyright 2010-2014 Artima, Inc. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. *@ @import controllers.Application.scaladocsPageUrl @import controllers.Application.milestoneScaladoc @combinedReleaseNotesPage("Scalactic/ScalaTest 3.0.7 Release Notes") {
This release has the same functionality as 3.0.6, and should be source compatible with 3.0.6, but unlike 3.0.6, is binary compatible with 3.0.5. Please see the release notes for 3.0.6 to find out the details of what the release contains. The goal with this release it to achieve binary compatibility with 3.0.5. Unfortunately although 3.0.6 should be source compatible with 3.0.5, it was not binary compatible. Also, because 3.0.6 was accidentally not binary compatible with 3.0.5, you may need to do a clean build to upgrade from 3.0.6.
For information on how to include ScalaTest in your project, see the install page. For information on how to use Scalactic in your production code, see its install page.
Visit ScalaTest Release Notes for links to the release notes of all previous versions, or step back in time by visiting the release notes for the previous version.


MBRTOWC
Section: Linux Programmer's Manual (3)
Updated: 2014-03-18
Index
Return to Main Contents
NAME
mbrtowc - convert a multibyte sequence to a wide character
SYNOPSIS
#include <wchar.h>
size_t mbrtowc(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps);
DESCRIPTION
The main case for this function is when
s
is not NULL and
pwc
is
not NULL.
In this case, the
mbrtowc()
function inspects at most
n
bytes of the multibyte string starting at
s,
extracts the next complete
multibyte character, converts it to a wide character and stores it at
*pwc.
It updates the shift state
*ps.
If the converted wide
character is not L'\0' (the null wide character),
it returns the number of bytes that were consumed
from
s.
If the converted wide character is L'\0', it resets the shift
state
*ps
to the initial state and returns 0.
If the
n
bytes starting at
s
do not contain a complete multibyte
character,
mbrtowc()
returns
(size_t) -2.
This can happen even if
n
>=
MB_CUR_MAX,
if the multibyte string contains redundant shift
sequences.
If the multibyte string starting at
s
contains an invalid multibyte
sequence before the next complete character,
mbrtowc()
returns
(size_t) -1
and sets
errno
to
EILSEQ.
In this case,
the effects on
*ps
are undefined.
A different case is when
s
is not NULL but
pwc
is NULL.
In this case, the
mbrtowc()
function behaves as above, except that it does not
store the converted wide character in memory.
A third case is when
s
is NULL.
In this case,
pwc
and
n
are
ignored.
If the conversion state represented by
*ps
denotes an
incomplete multibyte character conversion, the
mbrtowc()
function
returns
(size_t) -1,
sets
errno
to
EILSEQ,
and
leaves
*ps
in an undefined state.
Otherwise, the
mbrtowc()
function
puts
*ps
in the initial state and returns 0.
In all of the above cases, if
ps
is NULL, a static anonymous
state known only to the
mbrtowc()
function is used instead.
Otherwise,
*ps
must be a valid
mbstate_t
object.
An
mbstate_t
object
a
can be initialized to the initial state
by zeroing it, for example using
memset(&a, 0, sizeof(a));
RETURN VALUE
The
mbrtowc()
function returns the number of bytes parsed from the
multibyte sequence starting at
s,
if a non-L'\0' wide character
was recognized.
It returns 0, if a L'\0' wide character was recognized.
It returns
(size_t) -1
and sets
errno
to
EILSEQ,
if an invalid multibyte sequence was
encountered.
It returns
(size_t) -2
if it couldn't parse a complete multibyte
character, meaning that
n
should be increased.
ATTRIBUTES
Multithreading (see pthreads(7))
The
mbrtowc()
function is thread-safe with exceptions.
It is not thread-safe if called with a NULL ps parameter.
CONFORMING TO
C99.
NOTES
The behavior of
mbrtowc()
depends on the
LC_CTYPE
category of the
current locale.
SEE ALSO
mbsinit(3),
mbsrtowcs(3)
Index
- NAME
-
- SYNOPSIS
-
- DESCRIPTION
-
- RETURN VALUE
-
- ATTRIBUTES
-
- Multithreading (see pthreads(7))
-
- CONFORMING TO
-
- NOTES
-
- SEE ALSO
-
This document was created by
man2html,
using the manual pages.
Time: 02:55:03 GMT, September 18, 2014


Reports on cases where multiple methods of a class have names which differ only by case. Such method names may be very confusing.
Use the checkbox below to ignore methods overriding or implementing a method from a superclass.


People care about the balance between work and life. But what defines their personality and makes them unique roots in their life philosophy. I define mine is to find inner peace and chase after excitement at different situations. I love nature. I relish the moment when I climb the top of a mountain and feel the breeze touches my face. Oh geee, what a life! I can even hear my heart beating when I sense the inner peace.
However it is not all about enjoyment. I also love the feeling when the draneline rushes. That is the reason I work out in the gym and challenge myself. Lifting a heavier dumbbell or barbell gives me the sense of achivement for pushing me stronger and better.


I believe in utilizing web and visualization techniques to deliver a great user experience where a large number of people can directly benefit from it.
At the moment, I am employed as a Full Stack Web Developer at HCSolutionsGesmbH, working in the fields of Big Data, Data Engineering and Visualization. Since early 2016, I have been responsible designing and implementing the API as well as the UI/UX for a web-based Big Data analysis platform (see tomo-base.at) utilizing a broad tech stack: e.g. Angular, Typescript, Java, ElasticSearch, NoSQL. Over the course of the last four years, I was collaborating to different Scrum teams where I acquired advanced skills in multiple web technologies within rapidly growing environments.


To create the instance use Bulma.create
passing in the modal element.
--- layout: default title: Modal | BulmaJS Documentation ---
To create the instance use Bulma.create
passing in the modal element.
is-active
class is applied to the modal element.The modal plugin provides two methods for you to use. The first is open
this will open the modal.
Modal title
The second method is close
.
Modal title
| Method name | Parameters | Description |
|---|---|---|
| open() | None | This will open the modal. |
| close() | None | This will close the modal. |


--- layout: post title: How to make a lite version of an Android game date: 2011-04-07 22:51:03 -05:00 comments: true categories: posterous_id: 48833569 ---
I've discovered that no amount of screenshots or marketing speak will ever get someone past the $1.99 price point. So with a bit of research and rework a free version Thumb War is now available here.
For a while I thought the process of making 1 project into 2 was going to break the time bank, but after running into this article on the Android Developer site the pieces fit together quite nicely.
The secret is in one property setting of an Eclipse project which allows a project to be shared by another. The setting is "Is Library". Once enabled all classes and resources (drawable, layouts, strings, etc) are available to users of the library. The activities can be addressed in the manifest with absolute package names instead of the relative package names.
The best part of the whole thing is I don't need to create a separate jar build process to make it all work. Now, if you're the type that likes everything automated, I'm leaving that as an exercise to the reader.
After changing the original project a library, I did the following to get the paid version working again.
Surprisingly everything just worked.
The next step was to actually create the free project. This is pretty much the same as the paid project so I started with the paid project as the base.
This also worked. It was functionally the same as the paid project and the original pre-library-itized project and both were on my device at the same time. Which means it meets Androids unique package restrictions, too.
The final step in the free project was to add a few restrictions to it and add a few dialogs to encourage the players to purchase the paid version. That fortunately was the trivial work, phew! In case you're curious, I've restricted 3 of the 5 games and if a user selects a restricted game from the menu a dialog will tell them that it's unavailable in the lite and provides a button to go to the Android Market to purchase the full version.


| {{c.clubName}} | {{c.games}} | {{c.wins}} | {{c.draws}} | {{c.losses}} | {{c.goalsScored + '-' + c.goalsConceded}} | {{c.homeGames}} | {{c.homeWins}} | {{c.homeDraws}} | {{c.homeLosses}} | {{c.homeGoalsScored + '-' + c.homeGoalsConceded}} | {{c.awayGames}} | {{c.awayWins}} | {{c.awayDraws}} | {{c.awayLosses}} | {{c.awayGoalsScored + '-' + c.awayGoalsConceded}} |


Adapter.remove method allows to remove items from current uiScroll buffer. This method accepts 1 argument which is a predicate function applying to each item in the current buffer. If the return value is true, the item will be removed. In this demo we have pretty simple predicate:
{{predicateDescription}}
Here id is being received from the template as the id of the item the user ckicked on.
The very important thing is to syncronize our datasource with the changes we are making over the uiScroll buffer via Adapter.remove. Generally this is the App component responsibility, and in this demo it is being provided via doRemoveDatasource(id) method. It removes item with given id from the initial dataset, and decrements id of all items which ids are more than given one.


General
Challonge
smash.gg
smash.gg queue
Memes
Music
COVID-19
Admin
No Prefix
Commands loading, please hold...


Connect to CHEMISTRY-LPS in the Course Register.
CHEMISTRY
CHEM-054 GEN CHEM LAB II (LEC) 0 CU REGISTRATION REQUIRED FOR LEC, LAB ONLY OPEN TO LPS STUDENTS COLLEGE QUANTITATIVE DATA ANALYSIS REQ. 601 LEC R 5-6PM CHEM 102 MAEYER J MAX: 48 GEN CHEM LAB II 0.5 CU ONLY OPEN TO LPS STUDENTS COLLEGE QUANTITATIVE DATA ANALYSIS REQ. 602 LAB R 6-9PM TBA MAEYER J MAX: 48 CHEM-102 GENERAL CHEMISTRY II 1 CU REGISTRATION REQUIRED FOR LEC, REC ONLY OPEN TO LPS STUDENTS PHYSICAL WORLD SECTOR 601 LEC T 5:30-8:20PM CHEM 102 PIETROVITO A MAX: 80 RECITATION 0 CU ONLY OPEN TO LPS STUDENTS 602 REC T 8:30-9:20PM CHEM 102 PIETROVITO A MAX: 80 CHEM-242 ORGANIC CHEMISTRY II 1 CU 601 GUTIERREZ SANTA LEC T 6:30-9:30PM DRLB A4 MAX: 90 CHEM-245 EXPI ORGANIC CHEM I 1 CU REGISTRATION REQUIRED FOR LEC, LAB ONLY OPEN TO LPS STUDENTS 601 LEC R 5-6PM DRLB A6 WALSH P MAX: 80 EXPERIMTL ORGAN CHEM I 0 CU ONLY OPEN TO LPS STUDENTS 602 LAB R 6-10PM TBA WALSH P MAX: 52 CHEM-251 PRINC BIOLOGICAL CHEM 1 CU 601 LEC MW 7-8:30PM DRLB A6 MCLAUGHLIN S MAX: 70
Return to Course & Room Roster
Comments to:
Office of the University Registrar
University of Pennsylvania
Room 221 Franklin Building
3451 Walnut Street
Philadelphia, PA 19104-6291
Phone:<PHONE_NUMBER> Fax:<PHONE_NUMBER>
<EMAIL_ADDRESS>Updated: Sat Jan 17 08:30:02 2015


{% extends "mturk/experiments/filter_content_inst_content.html" %} {% block instructions_content_text %}
For this task, "rectified" means:
If a shape is almost rectified, don't select it. You should not see slanted lines or perspective effects in the image on the right. If you cannot decide on the correct answer, click the button "I can't tell" -- please don't guess.
{% comment %}Note that many of the images will be wrong; you should expect to only select a few items.
{% endcomment %}Tip: I find the fastest way to do the task is to do the following: (1) make sure the blue arrow points in the right direction, (2) make sure that patterns on the right are the same size, (3) make sure the grid is parallel to other lines in the image. If any of these are violated, don't click on the image and move on.
Please look at the examples to better understand what "rectified" means.
On the left: the thumbtack pin should point away from the surface.
On the right: the wood patterns are parallel. It should look like you are looking down towards the object.


acts_as_aln, or Acts as Abstract Layered Network, is a Ruby on Rails plug-in that provides an infrastructure for construction of enterprise information models. The Abstract Layered Network model is inspired by the network information models described in ITU M.3100, TMF 814 and Telecordia GR-1093-CORE that attempt to develop detailed object models that describe many of the attributes and state transitions of communication networks. In this vein the DMTF Common Information Model attempts to develop a model of the enterprise infrastructure. Of the previously stated references only DMTF has documentation in the public domain. Instead of following the path pursued by these efforts acts_as_aln only considers a few objects, the relations between the objects and a couple of attribute types, namely, the information that most strongly impacts the structure of an application built on the model. This greatly simplifies the information model and extends its domain of applicability. While the other models are limited to communications networks, and enterprise hardware and software in the case of DMTF-CIM because of their detail, acts_as_aln can be applied to these domains and possibly to seemingly unrelated domains such as project management, customer relationship management, human resource management and business intelligence.
acts_as_aln is a Ruby on Rails plugin that is installed in the vendor/plugins
directory of a Rails project. The source code may be obtained in any the ways listed below.
Download tar file from RubyForge project page.
With svn checkout into the vendor/plugins directory of your project,
svn co svn://rubyforge.org/var/svn/acts-as-aln/trunk acts_as_aln
Use the Rails plugin installer,
script/plugin install svn://rubyforge.org/var/svn/acts-as-aln/trunk
After installing the plugin the specs can be run by typing rake spec
in the installation directory. The database
connection is configured in test/rails_root/config/database.yml
.
acts_as_aln has a dependency on the plug-in has_ancestor.


This invoice is currently saved as a draft
When you publish an invoice, it will be made available for payment and will be sent to the customer according to your notification settings.
To publish the invoice, scroll down and choose "Publish" and then save the invoice.


Issue 2977: [Firebug Lite] HTTP parameters in the console
test markup
Steps to reproduce
- Load Firebug Lite
- Load jQuery
- Execute the following code:
$.post("post.php?param1=1", "param2=2", function(req, status) { if (status == "success") { // this line should be executed } });
Expected Result
- The marked line should be executed, that is, the "complete" callback function should be called
- There should be one log entry in the Console Panel
- There should be a parameter "param1" in the XHR Info "Params" Tab
- There should be a parameter "param2" in the XHR Info "Post" Tab


Welcome to the WTL Application Wizard
This wizard generates a WTL application project with the properties you specify.
Overview
Application Type
User Interface Features
These are the current project settings:
Click
Finish
from any window to accept the current settings.
After you create the project, examine the project's files for more information about the classes and resources that are generated.
F
inish
C
ancel
H
elp


This module handles the OpenSSL pseudo random number generator (PRNG) and declares the following:
This is a wrapper for the C function RAND_bytes.
This is a wrapper for the C function RAND_cleanup.
Whenever this exception is raised directly, it has a list of error messages
from the OpenSSL error queue, where each item is a tuple (lib,
function, reason)
. Here lib, function and reason
are all strings, describing where and what the problem is. See err(3)
for more information.


is a deep learning and reinforcement learning based question answering system that is trained for all 20 bAbi tasks.
Demo Chat
Tasks
Words
Words to build the context
Context
Question
Sample answer would come here
is a deep learning and reinforcement learning based question answering system that is trained for all 20 bAbi tasks.
Words to build the context
Sample answer would come here


| HOME | DOWNLOAD | DOCUMENTATION | FORUM | FAQ |
> Home > Documentation > Spherical Harmonic Transformations
DHAJ(1) SHTOOLS 2.6 DHAJ(1)
DHaj
DHaj - Compute the latitudinal weights used in the Driscoll and Healy (1994) spherical harmonic transform.
SYNOPSIS
SUBROUTINE DHaj ( N, AJ ) REAL*8 AJ(N) INTEGER N
DESCRIPTION
DHaj will calculate the latitudinal weights used in the spherical harmonic transform of Driscoll and Healy (1994; equation 9). The number of samples N must be even, and the transform and its inverse are implemented as SHExpandDH and MakeGridDH, respectively. It is noted that the first element, corresponding to the north pole, is always zero. The element corresponding to the south pole is not included.
ARGUMENTS
N (input) INTEGER The number of samples in latitude used in the spherical harmonic transform. This must be EVEN. AJ (output) REAL*8, DIMENSION (N) The latitudinal weights used in the spherical harmonic transform.
SEE ALSO
shexpanddh(1), makegriddh(1) <http://www.ipgp.jussieu.fr/~wieczor/SHTOOLS/SHTOOLS.html>
REFERENCES
Driscoll, J.R. and D.M. Healy, Computing Fourier transforms and convolutions on the 2-sphere, Adv. Appl. Math., 15, 202-250, 1994.
COPYRIGHT AND LICENSE
Copyright 2005, 2006 by Mark Wieczorek<EMAIL_ADDRESS>This is free software; you can distribute and modify it under the terms of the revised BSD license. SHTOOLS 2.6 2009-08-18 DHAJ(1)
> Home > Documentation > Spherical Harmonic Transformations
| Centre National de la Recherche Scientifique | Institut de Physique du Globe de Paris | © 2011 Mark Wieczorek |


Goodbye, Clara. Father Christmas. Santa Claus. Or, as I’ve always known him, Jeff. Geronimo! Brave heart, Clara. Please tell me I didn't get old. Anything but old. I was young! Oh... is he grey? Yes, well, it's a brilliant noise. I love that noise. Frightened people. Give me a Dalek any day. Oh, I always rip out the last page of a book. Then it doesn't have to end.  Look at me. No plans, no backup, no weapons worth a damn. Oh, and something else I don't have: anything to lose.  Remember every black day I ever stopped you and then, and then, do the smart thing. Let somebody else try first.


Address
64722-0200 Nairobi
About
O'neya Ink is a cooperation of top notch layout, web and graphic designers who work together to help you brand your business online which will in turn deliver more clients to you. We do not just sell websites, we build websites that sell.
We create stylish and responsive websites that allow businesses increase their digital presence and outreach to existing and potential customers. Do not lose a client(s) simply because they can not find information on your products or services or rather because you missed their call or they did not have the patience to call your office(s). Have that information up on the web 👍! It is super easy. You call us, tell us what you want and we work together to actualize it and advertise your business.
We also create personal websites for creatives like bloggers, artists, and any other creative to increase their digital presence and help them market themselves.
We use these techologies to create stylish front-end websites for you. However you want it.
Services
We provide quality services in designing, developing, editing and maintaining your personal or business websites at very affordable rates.
Here are our respective package costs.
Upto 4 Pages
Secure and Reliable Hosting
Free .co.ke Domain
Upto 7 Pages
Secure and Reliable Hosting
Free .co.ke Domain
Upto 10 Pages
Secure and Reliable Hosting
Free .co.ke Domain
1 Month Free Maintenance
Unlimited Pages
Secure and Reliable Hosting
Free .co.ke or .com Domain
2 Months Free Maintenance
Clients
Here are some organizations, artists and companies that have trusted us to deliver on our services.
Contact Us
64722-0200 Nairobi
+254-703248167
+254-735348387
<EMAIL_ADDRESS>oneya@miziziafriqa.co.ke


Action Pack – From request to response
Action Pack is a framework for handling and responding to web requests. It provides mechanisms for routing (mapping request URLs to actions), defining controllers that implement actions, and generating responses by rendering views, which are templates of various formats. In short, Action Pack provides the view and controller layers in the MVC paradigm.
It consists of several modules:
-
Action Dispatch, which parses information about the web request, handles routing as defined by the user, and does advanced processing related to HTTP such as MIME-type negotiation, decoding parameters in POST/PUT bodies, handling HTTP caching logic, cookies and sessions.
-
Action Controller, which provides a base controller class that can be subclassed to implement filters and actions to handle requests. The result of an action is typically content generated from views.
-
Action View, which handles view template lookup and rendering, and provides view helpers that assist when building HTML forms, Atom feeds and more. Template formats that Action View handles are ERB (embedded Ruby, typically used to inline short Ruby snippets inside HTML), and XML Builder.
With the Ruby on Rails framework, users only directly interface with the Action Controller module. Necessary Action Dispatch functionality is activated by default and Action View rendering is implicitly triggered by Action Controller. However, these modules are designed to function on their own and can be used outside of Rails.
A short rundown of some of the major features:
-
Actions grouped in controller as methods instead of separate command objects and can therefore share helper methods
class CustomersController < ActionController::Base def show @customer = find_customer end def update @customer = find_customer if @customer.update_attributes(params[:customer]) redirect_to :action => "show" else render :action => "edit" end end private def find_customer Customer.find params[:id] end end
-
ERB templates (static content mixed with dynamic output from ruby)
<% @posts.each do |post| %> Title: <%= post.title %> <% end %> All post titles: <%= @posts.collect{ |p| p.title }.join(", ") %> <% unless @person.is_client? %> Not for clients to see... <% end %>
-
“Builder” templates (great for XML content, like RSS)
xml.rss("version" => "2.0") do xml.channel do xml.title(@feed_title) xml.link(@url) xml.description "Basecamp: Recent items" xml.language "en-us" xml.ttl "40" @recent_items.each do |item| xml.item do xml.title(item_title(item)) xml.description(item_description(item)) xml.pubDate(item_pubDate(item)) xml.guid(@recent_items.url(item)) xml.link(@recent_items.url(item)) end end end end
-
Filters for pre- and post-processing of the response
class WeblogController < ActionController::Base # filters as methods before_filter :authenticate, :cache, :audit # filter as a proc after_filter { |c| c.response.body = Gzip::compress(c.response.body) } # class filter after_filter LocalizeFilter def index # Before this action is run, the user will be authenticated, the cache # will be examined to see if a valid copy of the results already # exists, and the action will be logged for auditing. # After this action has run, the output will first be localized then # compressed to minimize bandwidth usage end private def authenticate # Implement the filter with full access to both request and response end end
-
Helpers for forms, dates, action links, and text
<%= text_field_tag "post", "title", "size" => 30 %> <%= link_to "New post", :controller => "post", :action => "new" %> <%= truncate(post.title, :length => 25) %>
-
Layout sharing for template reuse
class WeblogController < ActionController::Base layout "weblog_layout" def hello_world end end Layout file (called weblog_layout): <%= yield %> Template for hello_world action:
Hello world
 Result of running hello_world action:
Hello world

-
Routing makes pretty URLs incredibly easy
match 'clients/:client_name/:project_name/:controller/:action' Accessing "/clients/37signals/basecamp/project/index" calls ProjectController#index with { "client_name" => "37signals", "project_name" => "basecamp" } in %xparams` From that action, you can write the redirect in a number of ways: redirect_to(:action => "edit") => /clients/37signals/basecamp/project/edit redirect_to(:client_name => "nextangle", :project_name => "rails") => /clients/extangle/rails/project/index
-
Easy testing of both controller and rendered template through ActionController::TestCase
class LoginControllerTest < ActionController::TestCase def test_failing_authenticate process :authenticate, :user_name => "nop", :password => "" assert flash.has_key?(:alert) assert_redirected_to :action => "index" end end
-
Automated benchmarking and integrated logging
Started GET "/weblog" for <IP_ADDRESS> at Fri May 28 00:41:55 Processing by WeblogController#index as HTML Rendered weblog/index.html.erb within layouts/application (25.7ms) Completed 200 OK in 29.3ms If Active Record is used as the model, you'll have the database debugging as well: Started POST "/posts" for <IP_ADDRESS> at Sat Jun 19 14:04:23 Processing by PostsController#create as HTML Parameters: {"post"=>{"title"=>"this is good"}} SQL (0.6ms) INSERT INTO posts (title) VALUES('this is good') Redirected to http://example.com/posts/5 Completed 302 Found in 221ms (Views: 215ms | ActiveRecord: 0.6ms) You specify a logger through a class method, such as: ActionController::Base.logger = Logger.new("Application Log") ActionController::Base.logger = Log4r::Logger.new("Application Log")
-
Caching at three levels of granularity (page, action, fragment)
class WeblogController < ActionController::Base caches_page :show caches_action :account def show # the output of the method will be cached as # ActionController::Base.page_cache_directory + "/weblog/show.html" # and the web server will pick it up without even hitting Rails end def account # the output of the method will be cached in the fragment store # but Rails is hit to retrieve it, so filters are run end def update List.update(params[:list][:id], params[:list]) expire_page :action => "show", :id => params[:list][:id] expire_action :action => "account" redirect_to :action => "show", :id => params[:list][:id] end end
-
Powerful debugging mechanism for local requests
All exceptions raised on actions performed on the request of a local user will be presented with a tailored debugging screen that includes exception message, stack trace, request parameters, session contents, and the half-finished response.
Simple example (from outside of Rails)
This example will implement a simple weblog system using inline templates and an Active Record model. So let’s build that WeblogController with just a few methods:
require 'action_controller' require 'post' class WeblogController < ActionController::Base layout "weblog/layout" def index @posts = Post.all end def show @post = Post.find(params[:id]) end def new @post = Post.new end def create @post = Post.create(params[:post]) redirect_to :action => "show", :id => @post.id end end WeblogController::Base.view_paths = [ File.dirname(__FILE__) ] WeblogController.process_cgi if $0 == __FILE__
The last two lines are responsible for telling ActionController where the template files are located and actually running the controller on a new request from the web-server (e.g., Apache).
And the templates look like this:
weblog/layout.html.erb:  <%= yield %>  weblog/index.html.erb: <% @posts.each do |post| %>
<%= link_to(post.title, :action => "show", :id => post.id) %>
 <% end %> weblog/show.html.erb:
 <%= @post.title %>
 <%= @post.content %>
 weblog/new.html.erb: <%= form "post" %>
This simple setup will list all the posts in the system on the index page, which is called by accessing /weblog/. It uses the form builder for the Active Record model to make the new screen, which in turn hands everything over to the create action (that’s the default target for the form builder when given a new model). After creating the post, it’ll redirect to the show page using an URL such as /weblog/5 (where 5 is the id of the post).
Download and installation
The latest version of Action Pack can be installed with RubyGems:
% [sudo] gem install actionpack
Source code can be downloaded as part of the Rails project on GitHub
License
Action Pack is released under the MIT license.
Support
API documentation is at
Bug reports and feature requests can be filed with the rest for the Ruby on Rails project here:


The striek strike tag puts strikethrough on the words inside of it. It is an obsolete tag and you should use <del> instead.
<del>


Between 12 and 13 August 2014, a total of 152 new cases of Ebola virus disease (laboratory-confirmed, probable, and suspect cases) as well as 76 deaths were reported from Guinea, Liberia, Nigeria and Sierra Leone.
On 13-14 August, some airlines and social media and traditional media vehicles expressed concern that air travel to and from affected countries was a high-risk activity for the spread of Ebola. To correct this misunderstanding, WHO called a press conference at the UN Palais des Nations in Geneva on 14 August. Dr Isabelle Nuttall, speaking on behalf of WHO, said, “Air travel, even from Ebola-affected countries, is low-risk for Ebola transmission.”
Dr Nuttall further clarified modes of transmission for Ebola and emphasized that the disease is not an airborne virus, unlike influenza or tuberculosis. The infection is transmitted to others through direct contact with the bodily fluids of a sick person, such as blood, vomit, sweat, and diarrhoea. Even if an individual infected with EVD travels by plane, the likelihood of other passengers and crew coming into contact with the individual’s bodily fluids is very low.
WHO does not recommend any travel or trade restrictions be applied except in cases where individuals have been confirmed or are suspected of being infected with EVD or where individuals have had contact with cases of EVD. (Contacts do not include properly-protected health-care workers and laboratory staff.) Temporary recommendations from the Emergency Committee with regard to actions to be taken by countries can be found at:
On 13 August, Heads of Global Information Systems (GIS) for WHO, UN agencies, intergovernmental agencies, and partners met to continue mapping the EVD crisis and create an interagency common operations picture. This will allow WHO and other organizations responding to the crisis in the affected countries to pinpoint where personnel and material should be concentrated for an effective end to the outbreak.
| New (1) | Confirmed | Probable | Suspect | Totals | |
| Guinea | |||||
| Cases | 9 | 376 | 133 | 10 | 519 |
| Deaths | 3 | 245 | 133 | 2 | 380 |
| Liberia | |||||
| Cases | 116 | 190 | 423 | 173 | 786 |
| Deaths | 58 | 154 | 190 | 69 | 413 |
| Nigeria | |||||
| Cases | 0 | 11 | 0 | 1 | 12 |
| Deaths | 1 | 4 | 0 | 0 | 4 |
| Sierra Leone | |||||
| Cases | 27 | 733 | 38 | 39 | 810 |
| Deaths | 14 | 309 | 34 | 5 | 348 |
| Totals | |||||
| Cases | 152 | 1310 | 594 | 223 | 2127 |
| Deaths | 76 | 712 | 357 | 76 | 1145 |
| (1) New cases were reported between 12 and 13 August 2014. |
The total number of cases is subject to change due to ongoing reclassification, retrospective investigation, and availability of laboratory results. Data reported in the Disease Outbreak News are based on official information reported by Ministries of Health.


Import transactions into the application by selecting one or more files:
The following files will be imported:


PM Imran to chair PTI's core committee meeting today
by https://www.facebook.com/dunyanewsISLAMABAD (Dunya News) - Prime Minister Imran Khan convened a meeting of Pakistan Tehreek-e-Insaf (PTI) core committee meeting to be held today (Friday) at the PM Office in Islamabad.
Prime Minister Imran Khan will chair the core committee meeting during which the prevailing political situation in the country will come under discussion.
Chief Ministers of Punjab and Khyber Pakhtunkhwa will also attend the meeting.
According to sources, removal of former prime minister Nawaz Sharif’s name from the Exit Control List (ECL) and Jamiat Ulema-e-Islam-Fazl’s (JUI-F) sit-in and its plan-B will also come under discussion.
Sources further said that inflation, current economic situation and increase in food prices will also be discussed as well as important decisions will also be taken in the meeting.


2 overrides of ObjectWriter
System.Management.Automation (2)
utils\ObjectStream.cs (2)
721
internal override PipelineWriter
ObjectWriter
1779
internal override PipelineWriter
ObjectWriter
5 references to ObjectWriter
System.Management.Automation (5)
engine\hostifaces\LocalPipeline.cs (4)
358
pipelineProcessor.ExternalSuccessOutput = OutputStream.
ObjectWriter
;
359
pipelineProcessor.ExternalErrorOutput = ErrorStream.
ObjectWriter
;
969
LocalRunspace.ExecutionContext.ExternalErrorOutput = ErrorStream.
ObjectWriter
;
970
LocalRunspace.ExecutionContext.ExternalSuccessOutput = OutputStream.
ObjectWriter
;
engine\hostifaces\pipelinebase.cs (1)
222
return InputStream.
ObjectWriter
;


| 1 | /* | |
| 2 | * Licensed to the Apache Software Foundation (ASF) under one or more | |
| 3 | * contributor license agreements. See the NOTICE file distributed with | |
| 4 | * this work for additional information regarding copyright ownership. | |
| 5 | * The ASF licenses this file to You under the Apache License, Version 2.0 | |
| 6 | * (the "License"); you may not use this file except in compliance with | |
| 7 | * the License. You may obtain a copy of the License at | |
| 8 | * | |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 | |
| 10 | * | |
| 11 | * Unless required by applicable law or agreed to in writing, software | |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, | |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 14 | * See the License for the specific language governing permissions and | |
| 15 | * limitations under the License. | |
| 16 | */ | |
| 17 | package org.apache.commons.collections4; | |
| 18 | ||
| 19 | import java.util.ArrayList; | |
| 20 | import java.util.List; | |
| 21 | import java.util.ListIterator; | |
| 22 | ||
| 23 | import org.easymock.EasyMock; | |
| 24 | import org.easymock.IExpectationSetters; | |
| 25 | ||
| 26 | /** | |
| 27 | * Provides utilities for making mock-based tests. Most notable is the generic "type-safe" | |
| 28 | * {@link #createMock(Class)} method, and {@link #replay()} and {@link #verify()} methods | |
| 29 | * that call the respective methods on all created mock objects. | |
| 30 | */ | |
| 31 | public abstract class MockTestCase { | |
| 32 | private final List<Object> mockObjects = new ArrayList<Object>(); | |
| 33 | ||
| 34 | @SuppressWarnings("unchecked") | |
| 35 | protected <T> T createMock(final Class<?> name) { | |
| 36 | final T mock = (T) EasyMock.createMock(name); | |
| 37 |
1
1. createMock : mutated return of Object value for org/apache/commons/collections4/MockTestCase::createMock to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return registerMock(mock); |
| 38 | } | |
| 39 | ||
| 40 | private <T> T registerMock(final T mock) { | |
| 41 | mockObjects.add(mock); | |
| 42 |
1
1. registerMock : mutated return of Object value for org/apache/commons/collections4/MockTestCase::registerMock to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return mock; |
| 43 | } | |
| 44 | ||
| 45 | protected <T> IExpectationSetters<T> expect(final T t) { | |
| 46 |
1
1. expect : mutated return of Object value for org/apache/commons/collections4/MockTestCase::expect to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return EasyMock.expect(t); |
| 47 | } | |
| 48 | ||
| 49 | protected final void replay() { | |
| 50 |
1
1. replay : negated conditional → KILLED |
for (final Object o : mockObjects) { |
| 51 |
1
1. replay : removed call to org/easymock/EasyMock::replay → KILLED |
EasyMock.replay(o); |
| 52 | } | |
| 53 | } | |
| 54 | ||
| 55 | protected final void verify() { | |
| 56 |
1
1. verify : negated conditional → SURVIVED |
for (final ListIterator<Object> i = mockObjects.listIterator(); i.hasNext();) { |
| 57 | try { | |
| 58 |
1
1. verify : removed call to org/easymock/EasyMock::verify → SURVIVED |
EasyMock.verify(i.next()); |
| 59 | } catch (final AssertionError e) { | |
| 60 |
1
1. verify : Replaced integer addition with subtraction → NO_COVERAGE |
throw new AssertionError(i.previousIndex() + 1 + "" |
| 61 | + e.getMessage()); | |
| 62 | } | |
| 63 | } | |
| 64 | } | |
| 65 | } | |
Mutations | ||
| 37 |
1.1 |
|
| 42 |
1.1 |
|
| 46 |
1.1 |
|
| 50 |
1.1 |
|
| 51 |
1.1 |
|
| 56 |
1.1 |
|
| 58 |
1.1 |
|
| 60 |
1.1 |


Peking
Dashboard
User Profile
Wallet
Toggle navigation
Wallet
Change Password
Logout
Payment Form Widget
Select Payment Method
Credit Card
Net Banking
PayPal
Debit Card
Personal Information
EMAIL ADDRESS
FIRST NAME
Credit Card Info
NAME ON CARD
CARD NUMBER
EXPIRATION
CVV NUMBER
By checking this box, I agree to the Terms & Conditions & Privacy Policy.
Net Banking
Andhra Bank
Allahabad Bank
Bank of Baroda
Canara Bank
IDBI Bank
Icici Bank
Indian Overseas Bank
Punjab National Bank
South Indian Bank
State Bank Of India
City Union Bank
HDFC Bank
IndusInd Bank
Syndicate Bank
Deutsche Bank
Corporation Bank
UCO Bank
Indian Bank
Federal Bank
ING Vysya Bank
Continue
PayPal
Already Have A PayPal Account?
Login
Remember me?
Dedit Card Info
NAME ON CARD
CARD NUMBER
EXPIRATION
CVV NUMBER
By checking this box, I agree to the Terms & Conditions & Privacy Policy.
Username
Old Password
New Password
Retype Password
Change


Kalori
1531.60Kkal
equal with 3 glass milk
Karbohidrat
153Kkal
equal with 3 potatoes
Protein
153Kkal
equal with 3 eggs
Grilled Rolled Beef with Enoki mushrooms and balado mayo dressing
New Product
Best Seller
Recom-
mended
Rp 69.000
Now Only Rp 49.000


org.codehaus.xfire.client
Class XFireProxyFactory
java.lang.Object
org.codehaus.xfire.client.XFireProxyFactory
public class XFireProxyFactory
- extends java.lang.Object
Factory for creating XFire SOAP client stubs. The returned stub will call the remote object for all methods.
Service serviceModel = new ObjectServiceFactory().create(Echo.class);
String url = "http://localhost:8080/services/Echo");
Echo echo = (Echo) factory.create(serviceModel, url);
After creation, the stub can be like a regular Java class. Because it makes remote calls, it can throw more
exceptions than a Java class. In particular, it may throw protocol exceptions, and XFireFaults
- Author:
- Arjen Poutsma
- See Also:
XFireFault
|
Method Summary |
java.lang.Object |
create(Binding binding,
java.lang.String address)
|
java.lang.Object |
create(Client client)
|
java.lang.Object |
create(Endpoint endpoint)
|
java.lang.Object |
create(Service service,
java.lang.String url)
Creates a new proxy with the specified URL. |
java.lang.Object |
create(Service service,
Transport transport,
java.lang.String url)
Creates a new proxy with the specified URL. |
| Methods inherited from class java.lang.Object |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
XFireProxyFactory
public XFireProxyFactory()
XFireProxyFactory
public XFireProxyFactory(XFire xfire)
create
public java.lang.Object create(Service service,
java.lang.String url)
throws java.net.MalformedURLException
- Creates a new proxy with the specified URL. The returned object is a proxy with the interface specified by the
given service interface.
String url = "http://localhost:8080/services/Echo");
Echo echo = (Echo) factory.create(myService, url);
- Parameters:
service
- the service to create a client for.url
- the URL where the client object is located.
- Returns:
- a proxy to the object with the specified interface.
- Throws:
java.net.MalformedURLException
create
public java.lang.Object create(Service service,
Transport transport,
java.lang.String url)
throws java.net.MalformedURLException
- Creates a new proxy with the specified URL. The returned object is a proxy with the interface specified by the
given service interface.
String url = "http://localhost:8080/services/Echo");
Echo echo = (Echo) factory.create(transport, myService, url);
- Parameters:
transport
- The transport to use.url
- the URL where the client object is located.serviceInterface
- the service to create a client for.
- Returns:
- a proxy to the object with the specified interface.
- Throws:
java.net.MalformedURLException
create
public java.lang.Object create(Client client)
create
public java.lang.Object create(Endpoint endpoint)
throws java.net.MalformedURLException
- Throws:
java.net.MalformedURLException
create
public java.lang.Object create(Binding binding,
java.lang.String address)
throws java.net.MalformedURLException
- Throws:
java.net.MalformedURLException
Copyright © 2004-2006 Envoi Solutions LLC. All Rights Reserved.


Prompt for Wednesday, March 8
There has been a lot of talk about
2015
and
2016
murder rates in US cities. How do you know there's a crime wave?
Filtering
Models, other models, and reality
Sampling from Distributions
Context: Boring distributions