Experience
{{ ms.game.prestigeManager.experience | format: true:6 }}
Spend your experience here. Experience spent are multiplied by
{{ ms.game.prestigeManager.prestigeMultiplier | format }}
{{ tab.name }}
{{ techExpanded ? tab.name : "" }}
Require
{{ PRESTIGE_TECH_UNLOCK | format }}
experience points spent on other categories.
You have spent
{{ ms.game.prestigeManager.totalSpent | format }}.
Technologies
Locked


Highlight different word forms. E.g. if you add a word cherry it will also highlight cherries.
Are you sure you want to delete this group? All words from it will be moved the default group.


x_processplatform_assemble_bam
State
Summary
Running
Organization
Category
Period
Count Start Task
Count Completed Task
Count Expired Task
Count Start Work
Count Completed Work
Count Expired Work


Javascript makes it possible to select html elements and make modifications. This page uses the querySelector method to select individual cells and change the background color. It uses querySelectorAll to select all the cells to reset the backgroundcolor to white.


|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |
| Packages that use GameContainer | |
|---|---|
| org.mini2Dx.core.game | |
| org.mini2Dx.core.screen | |
| org.mini2Dx.core.screen.transition | |
| org.mini2Dx.uats.common |
| Uses of GameContainer in org.mini2Dx.core.game |
|---|
| Subclasses of GameContainer in org.mini2Dx.core.game | |
|---|---|
class |
BasicGame
A simplified GameContainer for beginners to build upon |
class |
ScreenBasedGame
An implementation of GameContainer that allows for separation of a
game into multiple GameScreen s and provides support for
Transition s between such screens via a ScreenManager |
| Constructors in org.mini2Dx.core.game with parameters of type GameContainer | |
|---|---|
Mini2DxGame(GameContainer gc)
Constructor |
| Uses of GameContainer in org.mini2Dx.core.screen |
|---|
| Methods in org.mini2Dx.core.screen with parameters of type GameContainer | |
|---|---|
void |
GameScreen.initialise(GameContainer gc)
Initialises the game screen |
void |
Transition.postRender(GameContainer gc,
Graphics g)
|
void |
Transition.preRender(GameContainer gc,
Graphics g)
|
void |
ScreenManager.render(GameContainer gc,
Graphics g)
Renders the current GameScreen and any Transition that may be occurring |
void |
GameScreen.render(GameContainer gc,
Graphics g)
Renders the game screen |
void |
Transition.update(GameContainer gc,
float delta)
|
void |
ScreenManager.update(GameContainer gc,
float delta)
Updates the current GameScreen and any Transition that may be occurring |
void |
GameScreen.update(GameContainer gc,
ScreenManager screenManager,
float delta)
Updates the game screen |
| Uses of GameContainer in org.mini2Dx.core.screen.transition |
|---|
| Methods in org.mini2Dx.core.screen.transition with parameters of type GameContainer | |
|---|---|
void |
NullTransition.postRender(GameContainer gc,
Graphics g)
|
void |
FadeOutTransition.postRender(GameContainer gc,
Graphics g)
|
void |
FadeInTransition.postRender(GameContainer gc,
Graphics g)
|
void |
NullTransition.preRender(GameContainer gc,
Graphics g)
|
void |
FadeOutTransition.preRender(GameContainer gc,
Graphics g)
|
void |
FadeInTransition.preRender(GameContainer gc,
Graphics g)
|
void |
NullTransition.update(GameContainer gc,
float delta)
|
void |
FadeOutTransition.update(GameContainer gc,
float delta)
|
void |
FadeInTransition.update(GameContainer gc,
float delta)
|
| Uses of GameContainer in org.mini2Dx.uats.common |
|---|
| Subclasses of GameContainer in org.mini2Dx.uats.common | |
|---|---|
class |
GraphicsUAT
A GameContainer that allows visual user acceptance testing of
Graphics functionality |
class |
TiledMapUAT
A GameContainer that allows visual user acceptance testing of
TiledMap rendering |
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES |


--- layout: post title: "The Week in Predictions" date: 2017-06-03 09:50:00 +0000 tags: image: https://s3.amazonaws.com/contrafabulists/2017-06-03-predict.jpg imagecredits: https://www.flickr.com/photos/snarfel/4085226119 ---
As part of a new Contrafabulists’ project, we are monitoring predictions that technologists and marketers make each week:
“Voice-based computing will be everywhere, listening to what we say, learning from what we ask,” Buzzfeed predicts. There’s no date for this prediction – just the “not-too-distant future.”
The MIT Technology Review provides the results of a survey: “Experts Predict When Artificial Intelligence Will Exceed Human Performance.”
The experts predict that AI will outperform humans in the next 10 years in tasks such as translating languages (by 2024), writing high school essays (by 2026), and driving trucks (by 2027).
But many other tasks will take much longer for machines to master. AI won’t be better than humans at working in retail until 2031, able to write a bestselling book until 2049, or capable of working as a surgeon until 2053.
The experts are far from infallible. They predicted that AI would be better than humans at Go by about 2027. (This was in 2015, remember.) In fact, Google’s DeepMind subsidiary has already developed an artificial intelligence capable of beating the best humans. That took two years rather than 12. It’s easy to think that this gives the lie to these predictions.
The experts go on to predict a 50 percent chance that AI will be better than humans at more or less everything in about 45 years.
From The Economist: “A toolkit for predicting the future.” It’s not so much a toolkit but three pretty obvious places one should look in order to gauge what’s going to happen: the past, the present, and science fiction.
Painting: The Fortune Teller by Caravaggio


new MemoryStore(opts)
Constructor for Memory rule store.
This store keeps rules in memory only. Rules are not persisted across application reloads and therefore they have to be loaded early in the application start (initialization) phase.
Options
name
{string}, the name of the store. The default value is "memory". NOTE: every store is required to have a unique name within a manager.
This is the default store for authority and it doesn’t have to be explicitly configured unless it is used in conjunction with other stores.
Parameters:
| Name | Type | Argument | Description |
|---|---|---|---|
opts |
object |
<optional> |
Additional options. |
- Source:
Example
var authority = require("authority"); authority.setRules([{ name: "allow_managers_only", description: "Only managers can pass.", condition: { title: "Manager" } }, { name: "allow_teenagers_only", description: "Only users between 13 and 19 years old can pass.", condition: { age: { $gte: 13, $lte: 19 } } } ]);
Members
-
acls
-
The object that holds the references to all stored ACLs (Access Control Lists). NOTE: this member is not part of the Authority API and it is specific to this store only.
- Source:
-
name
-
The name of this store. The default value is "memory". NOTE: every store is required to have a unique name within a manager.
- Source:
-
rules
-
The object that holds the references to all stored rules. NOTE: this member is not part of the Authority API and it is specific to this store only.
- Source:
-
subjects
-
ACL reverse index. NOTE: this member is not part of the Authority API and it is specific to this store only.
- Source:
Methods
-
deleteAcls(names, done) → {null}
-
Removes the specified ACLs from the store.
Parameters:
Name Type Argument Description names
string | Array.<string> The name or an array of names to remove.
done
function <optional>
Optional callback function that will be called after the ACL(s) have been deleted. If the method is unsuccessful an error object will be passed as a single parameter to the callback. If the callback is omitted and the method is unsuccessful an error will be thrown.
- Source:
Returns:
- Type
- null
-
deleteRules(names, done) → {null}
-
Removes the specified rules from the store.
Parameters:
Name Type Argument Description names
string | Array.<string> The name or an array of names to remove.
done
function <optional>
Optional callback function that will be called after the rule(s) have been deleted. If the method is unsuccessful an error object will be passed as a single parameter to the callback. If the callback is omitted and the method is unsuccessful an error will be thrown.
- Source:
Returns:
- Type
- null
-
getAcl(name, done) → {null}
-
Retrieves the specified ACL from the store.
Parameters:
Name Type Description name
string The name of the ACL.
done
function The callback that handles the result. The first parameter will always be null for this store while the second parameter will contain the requested ACL or null if not found.
- Source:
Returns:
- Type
- null
-
getAclCount(done) → {null}
-
Gets the total count of ACLs present in the store.
Parameters:
Name Type Description done
function The callback that handles the result. The first parameter will always be null for this store while the second parameter will contain a number representing the total count of ACLs.
- Source:
Returns:
- Type
- null
-
getAclNames(start, count, match, done) → {null}
-
Retrieves the names and descriptions of the ACLs present in the store and matching the specified criteria.
All parameters are required.
Parameters:
Name Type Description start
number The index at wich to begin retrieving names. The index of the first element is 0.
count
number The number of names to retrieve.
0
denotes all remaining.match
string Wildcard expression to match names.
null
denotes any name. Example:allow_*
done
function The callback that handles the result. The first parameter will always be null for this store while the second parameter will contain an array of matched objects
{ name: "string", description: "string" }
.- Source:
Returns:
- Type
- null
-
getRule(name, done) → {null}
-
Retrieves the specified rule from the store.
Parameters:
Name Type Description name
string The name of the rule.
done
function The callback that handles the result. The first parameter will always be null for this store while the second parameter will contain the requested rule or null if not found.
- Source:
Returns:
- Type
- null
-
getRuleCount(done) → {null}
-
Gets the total count of rules present in the store.
Parameters:
Name Type Description done
function The callback that handles the result. The first parameter will always be null for this store while the second parameter will contain a number representing the total count of rules.
- Source:
Returns:
- Type
- null
-
getRuleNames(start, count, match, done) → {null}
-
Retrieves the names and descriptions of the rules present in the store and matching the specified criteria.
All parameters are required.
Parameters:
Name Type Description start
number The index at wich to begin retrieving names. The index of the first element is 0.
count
number The number of names to retrieve.
0
denotes all remaining.match
string Wildcard expression to match names.
null
denotes any name. Example:allow_*
done
function The callback that handles the result. The first parameter will always be null for this store while the second parameter will contain an array of matched objects
{ name: "string", description: "string" }
.- Source:
Returns:
- Type
- null
-
setAcls(acls, override, done) → {null}
-
Adds one or more ACL (Access Control List) to the store.
An ACL entry has the following structure:
Parameters:
Name Type Argument Description acls
object | Array.<object> The ACL or an array of ACLs to be added to the store.
override
boolean <optional>
Specifies whether existing ACLs should be replaced by the ones provided to this method. ACLs are matched by their name. If this parameter is not specified or is false and there is a name conflict an error will be returned or thrown depending on the usage of the method.
done
function <optional>
Optional callback function that will be called after the ACL(s) have been added. If the method is unsuccessful an error object will be passed as a single parameter to the callback. If the callback is omitted and the method is unsuccessful an error will be thrown.
- Source:
Returns:
- Type
- null
Example
{ // Represents a primary key for the ACL and it is the field that binds the ACL to a resource. name: "unique resource identifier", description: "optional ACL description", // Represents a collection of posible operations such as CRUD. operation: { // operation view: { // permission allow: { // subject (role, user, agent etc.) everyone: true }, deny: {} }, modify: { allow: { contributers: true, maintainers: true }, deny: { anonymous: true } }, "delete": { allow: { contributers: true, maintainers: true }, deny: { anonymous: true } } } }
-
setRules(rules, override, done) → {null}
-
Adds one or more rules to the store.
Parameters:
Name Type Argument Description rules
object | Array.<object> The rule or an array of rules to be added to the store.
override
boolean <optional>
Specifies whether existing rules should be replaced by the ones provided to this method. Rules are matched by their name. If this parameter is not specified or is false and there is a name conflict an error will be returned or thrown depending on the usage of the method.
done
function <optional>
Optional callback function that will be called after the rule(s) have been added. If the method is unsuccessful an error object will be passed as a single parameter to the callback. If the callback is omitted and the method is unsuccessful an error will be thrown.
- Source:
Returns:
- Type
- null
-
subjectIndex(pattern, done) → {null}
-
This method is used to quickly find or browse through all effective permissions for a given subject.
The index represents four levels deep nested collections in the following form: [subject].[permission].[operation].[resource]
Parameters:
Name Type Argument Description pattern
string <optional>
The pattern to match. If omitted, all elements at the first level (subjects) will be returned.
done
function The callback that handles the result. The first parameter will always be null for this store while the second parameter will contain an array of keys that are direct members of the matching element.
- Source:
Returns:
- Type
- null
Example
var authority = require("authority"), store = authority.stores.acl; store.subjectIndex(function(err, res) { // res -> ["contributers", "maintainers", "everyone", "anonymous"] }); store.subjectIndex("maintainers", function(err, res) { // res -> ["allow", "deny"] }); store.subjectIndex("maintainers.allow", function(err, res) { // res -> ["modify", "delete", "change_permissions", "approve_content"] }); store.subjectIndex("maintainers.allow.approve_content", function(err, res) { // res -> ["wiki", "blogs", "pages"] }); store.subjectIndex("maintainers.allow.approve_content.wiki", function(err, res) { // res -> true });


This is some text
This is some text
This is some text
Set with value 3
Set with value 100
This is 100%
This is 50%


Suzlon Energy's Sep-quarter net loss at Rs 777 cr on subdued operations
The company's total expenses were at Rs 1,551.16 crore as against Rs 1,850.28 crore in the same period of preceding fiscal.
by Press Trust of IndiaSuzlon Energy on Thursday reported widening of its consolidated net loss to Rs 777.52 crore in the quarter ended September 30, 2019.
The company had reported a net loss of Rs 625.76 crore in the corresponding quarter last fiscal, Suzlon Energy said in a BSE filing.
Its revenue from operations fell to Rs 803.09 crore during the quarter under review as against Rs 1,194.99 crore in the year-ago period.
The company's total expenses were at Rs 1,551.16 crore as against Rs 1,850.28 crore in the same period of preceding fiscal.
"The sector is witnessing issues on project execution due to some policy issues but there has been some healthy growth in installations over the last year. Wind capacities added in India in H1 2019-20 was at 1,304 MW as compared to 569 MW in H1 2018-19," Suzlon Group CEO J P Chalasani said in a separate statement.
"Our operations are at a subdued level with minimal allocation of funding as we are trying to fix our capital structure," he added.


An API to use the new command UI introduced in Minecraft 1.13
Super basic usage
- Download version 1.0 and add it to your build path
- Add the plugin as a dependent in the plugin.yml (
depend: [CommandAPI]
)
- (Make sure the CommandAPI.jar file is included in the plugins folder when running any servers)
- Create a new instance of the CommandAPI
CommandAPI commandRegister = new CommandAPI();
- Create a
LinkedHashMap<String, ArgumentType>
to store your arguments LinkedHashMap<String, ArgumentType> arguments = new LinkedHashMap<>();
- Register the command via the command register
commandRegister.register("COMMAND_NAME", arguments, (sender, args) -> {});
For an example of this in action, view the example class!
Examples
Multiple arguments with separate outcomes:
CommandAPI commandRegister = new CommandAPI();
LinkedHashMap<String, ArgumentType> arguments = new LinkedHashMap<>();
arguments.put("speed", ArgumentType.FLOAT);
commandRegister.register("walkspeed", arguments, (sender, args) -> {
if(sender instanceof Player) {
Player player = (Player) sender;
player.setWalkSpeed((float) args[0]);
} else {
sender.sendMessage("You must be a player to use this command");
}
});
arguments.put("target", ArgumentType.STRING);
commandRegister.register("walkspeed", arguments, (sender, args) -> {
Bukkit.getPlayer((String) args[1]).setWalkSpeed((float) args[0]);
});


Depending on the speed and capacity needs of your system, the following table provides a guideline to Fujitec’s recommended machine type application. Fujitec can modify each to provide the most energy efficient solution possible.
Fujitec engineers and manufactures PMGL machines that reduce energy consumption with a wide range of applications, flexible installation solutions and improved ride quality.
Our highest energy efficient technology meets or exceeds requirements set forth by consultants, engineers and architects for modernization or new installation projects.
Fujitec can customize needs for fluctuations in shaft sizes, fixture packages & performance features
1) Up to 3500lb: Up to 500 fpm
2) Up to 5000lb at 300 fpm
Compact motor & mechanical drive improves space efficiency. Rear & side counterweight options available.
Fujitec's Viridian MRL incorporates a permanent magnet gearless (PMGL) motor that minimizes energy consumption when compared to traditional systems.
Eco-friendly installation; Exceptional performance Long-term equipment life; Up to 60% energy savings Enhanced ride-quality; Reduced noise levels
Fujitec’s Geared Viridian product is ideal for low to mid-rise applications and offers a myriad of standard options, allowing design flexibility while meeting short lead times. Fujitec’s geared product utilizes the same advanced technology as the high-speed gearless elevators, surpassing Fujitec’s own high standards for quality, performance and reliability.
Careful attention given to the design of Fujitec’s Viridian geared product ensures a smooth, safe, quiet ride quality.
Pre-engineered specifically for low to mid-rise applications. Great solution for tight budgets and aggressive deadlines.
Geared elevators are an older yet proven technology that bridges a monetary gap between MRL and gearless machines. Units are best applied in niche scenarios where speeds do not exceed 350 fpm.
Freight cars
Parking garage
Side or adjacent machine locations
While hydraulic elevators were popular for low-rise buildings in the 20th century, newer applications are available to improve efficiency and costs for buildings with such needs. Though the industry is moving toward newer/eco-friendly technology such as MRL’s, Fujitec provides a variety of solutions for in-ground, holeless and roped applications. While considered dated and limited in its’ capabilities, Fujitec is happy to educate and provide you the most effective solution for any situation.
Fujitec developed webEMIS to improve building safety and elevator efficiency. Real-time operations are monitored and adjusted from one or more locations, providing valuable traffic analysis in an effort to improve building efficiency during up-peak and down-peak traffic times.
webEMIS exchanges real-time data with an elevator’s control system to determine operational status and floor location. Status is controlled by the client and programmed to satisfy ‘normal group operation’ or ‘out of service’ scenarios. webEMIS also handles a variety of specialized requests such as ‘VIP dispatch’ or ‘special assistance’ operations.
Assign a unit to service specific floors/locations within a building
Assign a unit to accommodate special needs tenants by adjusting door operating speeds and increased landing durations for boarding
Fujitec’s webEMIS is available on new or existing Fujitec Millennium and Viridian equipment. Software communicates through an independent/secure server (supplied by Fujitec) via the building’s network, and includes a dedicated client computer (supplied by Fujitec) for monitoring and operation.
Using Sharp’s Plasmacluster™ technology, Fujitec IONFUL® splits water molecules into positively and negatively charged ions to cleanse air.
Eliminates microscopic pollutants traditional filters cannot trap
Replicates nature’s cleansing process using water vapor to create ions
Refreshes air without perfumes or chemicals
As we continue to search for ways to improve Fujitec products, safety is at the forefront of our goal which includes passenger health. Cab interiors can be a safe haven for airborne viruses and allergens, Fujitec’s Ionful® incorporates technology from the Sharp Corporation to address these issues.
Specifically designed for cab interiors, IONFUL® transports ions via generator through the ventilation system where they attach, surround and break down potentially harmful particles, releasing purified water vapor as the byproduct.
IONFUL® is energy efficient and operates when movement is detected inside the cab.
Adding a “Re-Generative Drive” to your system, acts as a line-power inverter by capturing energy produced by the elevator during over-hauling load conditions and recycling it back into the building’s power grid. Fujitec offers this option to further reduce energy consumption.
*NOTE: Reducing your system’s energy consumption can provide points toward LEED certification at usbc.org


Every Macro Project Needs a Developer!
More content coming soon...
Currently I am a Data Scientist learning to build webpages to represent data.
Uploaded this via command line to AWS.
Coming to the end of Week 1, much of the information is starting to come together. I have been reading the book Data Science for Business. The topic has followed scenarios such as customer churn and account write-off. In thinking about predictive analytics, which attributes coorelate to the target value.
Back in the class room we dabled in using the Terminal to look at parts of the information. However I was most excited to start practicing some decision tree logic. We used a scatter matrix to begin to look at the data. I took the analysis further by beginning to practice the Shannon's Entropy Formula to determine which attribute has the most information gain. Next I would like to build my own python funciton to provide me with information gain as a chart.
The below is a set of charts created using Python3 and matplotlib. One line is the equation y=3x+0.5 and the other line y = 5 * sqrt(x). I used np.arrange(0, 5, 0.01) to create an array to calculate the y-values. With a equal set of values, the plot is ready to be displayed:


GEO1007
Export my track
GeoJSON
KML
Import geometry
Search
Upload your geometry file
×
Currently only GeoJSON is supported, more file types will be added in the future.


This is a header. This is the first list item. This is the second list item. Here's some example code: return shell_exec("echo $input | $markdown_script");
Here's some example code:
return shell_exec("echo $input | $markdown_script");


Demo Data
This page provides a summary of the demo data so you can submit your mocked up timesheet and know what to ask the bot about.
Projects
| Code | Description |
|---|
This page provides a summary of the demo data so you can submit your mocked up timesheet and know what to ask the bot about.
| Code | Description |
|---|


{% extends 'base.html' %}
{% block title %}All CodeCatz Members{% endblock %}
{% block content%}
This page will tell a bit more about CodeCatz members.Who is who?
About Kitten 1:Fun, ragdoll Gizmo boots feel caturday home whisker. Kitten, family run buddy curiosity furball sleeping boots. Backyard kitten friend's long pillow cat sunbathe beautiful petting kittens siam tabby dog baby lady cute disapproval belly her. Siam spoon buddy house smile feed me this spoon home cats fire cat meet.
Links to FB, git... skype...
Links to active projects
About Kitten 2:I LOVE KIT KAT s feel caturday home whisker. Kitten, family run buddy curiosity furball sleeping boots. Backyard kitten friend's long pillow cat sunbathe beautiful petting kittens siam tabby dog baby lady cute disapproval belly her. Siam spoon buddy house smile feed me this spoon home cats fire cat meet.
Links to FB(boycott!!!), git... skype...
Links to active projects


Other details for advanced users¶
Note
Some additional information might be available from the command line:
python -m friendly -h
Where the output is written?¶
By default, friendly tracebacks are written to sys.stderr
.
However, it is possible to override this choice, as follows:
friendly.set_stream(stream)
Thus, the default amounts to:
friendly.set_stream(sys.stderr)
A special option exists to capture the output as a string:
friendly.set_stream("capture")
Later, this captured output can be retrieved using:
output = friendly.get_output()
# equivalent to
output = friendly.get_output(flush=True)
The value shown for the flush
parameter is the default; this means that
the output will be cleared once it has been retrieved. If this is not the
desired behaviour, simply use flush=False
.
Language used¶
The language used can be explicitly set as follows:
friendly.set_lang("fr") # two-letter code for French
The language currently used can be obtained using:
lang = friendly.get_lang()
If the language requested does not exist, no error is raised nor any warning given, but the choice reverts to the default (English). More information on the choice of language (localization) can be found in the section about design.
As an exception hook¶
When “installing” friendly, one can use various optional parameters:
friendly.install(lang="fr", redirect="capture", include="explain")
This is equivalent to writing:
friendly.install()
friendly.set_lang("fr")
friendly.set_stream("capture")
friendly.set_include("explain")
Catching exception locally¶
As mentioned before, another way to use friendly is to catch exceptions where they are expected to arise, such as:
try:
# Some code
except Exception:
friendly.explain_traceback()
This uses the default of writing to sys.stderr
.
One can also temporarily redirect the output to any stream:
try:
# Some code
except Exception:
friendly.explain_traceback(redirect=stream)
By default, friendly takes its information from sys.exc_info()
.
It may happen that this is not what we want to show.
For example, the showtraceback method in Python’s code.py replaces one of the items prior to
showing the traceback to the user; we currently also do something similar in
friendly’s own console.
Finally, if one wishes to temporarily change some other option mentioned above, it can be done as in the following example:
try:
# Some code
except Exception:
lang = friendly.get_lang()
friendly.set_lang("fr")
friendly.explain_traceback()
friendly.set_lang(lang)
Running another script¶
We have already given an example of running another script:
$ python -m friendly demos/hello.py
Hello world!
Running as main!
What if the separate script has its own command line arguments?
If they are simply positional arguments, you can simply tack them
on at the end of the argument list. An example can be found
in the demos/
directory, which can be run directly or using
friendly.
$ python demos/adder.py 1 2 3
The sum is 6
$ python -m friendly demos/adder.py 1 2 3
The sum is 6.0
Note that this works even if you specify command line arguments that are specific to friendly:
$ python -m friendly --lang fr demos/adder.py 1 2 3
The sum is 6.0
However, what if one wants to run a script that uses optional named arguments
similarly to how friendly can use --lang
and other optional
arguments? In this case, use --
to separate the list of arguments
to be used by the script from those written previously and
intended to be used by friendly:
$ python -m friendly --lang fr demos/adder.py -- --to_int 1 2 3
The sum is 6
An alterative is to use either a sitecustomize.py
or a usercustomize.py
file, as described in the
Python documentation.
For example, you can use the following approach.
Create a
usercustomize.py
file whose content is the following:import friendly friendly.install() # specify other desired options here
Set the
PYTHONPATH
environment variable to that directory. On Windows, this can be done by navigating to that directory and writing:set PYTHONPATH=%CD%
You can now run your script normally: friendly exception handling will be used by default on it.


QML Modules
A QML module provides versioned types and JavaScript resources in a type namespace which may be used by clients who import the module. The types which a module provides may be defined in C++ within a plugin, or in QML documents. Modules make use of the QML versioning system which allows modules to be independently updated.
Defining of a QML module allows:
- The sharing of common QML types within a project - for example, a group of UI components that are used by different windows
- The distribution of QML-based libraries
- The modularization of distinct features, so that applications only load the libraries necessary for their individual needs
- Versioning of types and resources so that the module can be updated safely without breaking client code
Defining a QML Module
A module is defined by a module definition qmldir file. Each module has an associated type namespace, which is the module's identifier. A module can provide QML object types (defined either by QML documents or via a C++ plugin) and JavaScript resources, and may be imported by clients.
To define a module, a developer should gather together the various QML documents, JavaScript resources and C++ plugins which belong in the module into a single directory, and write an appropriate module definition qmldir file which should also be placed into the directory. The directory can then be installed into the QML import path as a module.
Note that defining a module is not the only way to share common QML types within a project - a simple QML document directory import may also be used for this purpose.
Supported QML Module Types
There are two different types of modules supported by QML:
- Identified Modules
- Legacy Modules (deprecated)
Identified modules explicitly define their identifier and are installed into QML import path. Identified modules are more maintainable (due to type versioning) and are provided with type registration guarantees by the QML engine which are not provided to legacy modules. Legacy modules are only supported to allow legacy code to continue to work with the latest version of QML, and should be avoided by clients if possible.
Clients may import a QML module from within QML documents or JavaScript files. Please see the documentation about importing a QML module for more information on the topic.
Providing Types and Functionality in a C++ Plugin
An application which has a lot of logic implemented in C++, or which defines types in C++ and exposes them to QML, may wish to implement a QML plugin. A QML extension module developer may wish to implement some types in a C++ plugin (as opposed to defining them via QML documents) to achieve better performance or for greater flexibility.
Every C++ plugin for QML has an initialiatization function which is called by the QML engine when it loads the plugin. This initialization function must register any types that the plugin provides, but must not do anything else (for example, instantiating QObjects is not allowed).
See Creating C++ Plugins For QML for more information.


Man killed in motorcycle crash in Vancouver’s downtown
Police said this was the city’s twelfth motor vehicle death of the year
by Katya SlepianA 44-year-old Vancouver man was killed in a motorcycle crash downtown on Sunday, according to police.
Vancouver police said the man was headed east on Nelson Street, near Granville Street, around noon when he lost control of his motorcycle and hit a tree. Police do not know why the man lost control but speed is being considered a factor in the crash.
Police said this was the city’s twelfth motor vehicle death of the year.
Anyone who saw the crash is asked to call<PHONE_NUMBER>.


| Path::Class::Dir - Objects representing directories |
Path::Class::Dir - Objects representing directories
version 0.35
use Path::Class; # Exports dir() by default my $dir = dir('foo', 'bar'); # Path::Class::Dir object my $dir = Path::Class::Dir->new('foo', 'bar'); # Same thing # Stringifies to 'foo/bar' on Unix, 'foo\bar' on Windows, etc. print "dir: $dir\n"; if ($dir->is_absolute) { ... } if ($dir->is_relative) { ... } my $v = $dir->volume; # Could be 'C:' on Windows, empty string # on Unix, 'Macintosh HD:' on Mac OS $dir->cleanup; # Perform logical cleanup of pathname $dir->resolve; # Perform physical cleanup of pathname my $file = $dir->file('file.txt'); # A file in this directory my $subdir = $dir->subdir('george'); # A subdirectory my $parent = $dir->parent; # The parent directory, 'foo' my $abs = $dir->absolute; # Transform to absolute path my $rel = $abs->relative; # Transform to relative path my $rel = $abs->relative('/foo'); # Relative to /foo print $dir->as_foreign('Mac'); # :foo:bar: print $dir->as_foreign('Win32'); # foo\bar
# Iterate with IO::Dir methods: my $handle = $dir->open; while (my $file = $handle->read) { $file = $dir->file($file); # Turn into Path::Class::File object ... } # Iterate with Path::Class methods: while (my $file = $dir->next) { # $file is a Path::Class::File or Path::Class::Dir object ... }
The Path::Class::Dir
class contains functionality for manipulating
directory names in a cross-platform way.
Creates a new Path::Class::Dir
object and returns it. The
arguments specify names of directories which will be joined to create
a single directory object. A volume may also be specified as the
first argument, or as part of the first argument. You can use
platform-neutral syntax:
my $dir = dir( 'foo', 'bar', 'baz' );
or platform-native syntax:
my $dir = dir( 'foo/bar/baz' );
or a mixture of the two:
my $dir = dir( 'foo/bar', 'baz' );
All three of the above examples create relative paths. To create an absolute path, either use the platform native syntax for doing so:
my $dir = dir( '/var/tmp' );
or use an empty string as the first argument:
my $dir = dir( '', 'var', 'tmp' );
If the second form seems awkward, that's somewhat intentional - paths
like /var/tmp
or \Windows
aren't cross-platform concepts in the
first place (many non-Unix platforms don't have a notion of a "root
directory"), so they probably shouldn't appear in your code if you're
trying to be cross-platform. The first form is perfectly natural,
because paths like this may come from config files, user input, or
whatever.
As a special case, since it doesn't otherwise mean anything useful and
it's convenient to define this way, Path::Class::Dir->new()
(or
dir()
) refers to the current directory (File::Spec->curdir
).
To get the current directory as an absolute path, do <
dir()-
absolute >>.
Finally, as another special case dir(undef)
will return undef,
since that's usually an accident on the part of the caller, and
returning the root directory would be a nasty surprise just asking for
trouble a few lines later.
This method is called internally when a Path::Class::Dir
object is
used in a string context, so the following are equivalent:
$string = $dir->stringify; $string = "$dir";
Returns the volume (e.g. C:
on Windows, Macintosh HD:
on Mac OS,
etc.) of the directory object, if any. Otherwise, returns the empty
string.
Returns the last directory name of the path as a string.
Returns a boolean value indicating whether this object represents a
directory. Not surprisingly, the Path::Class::File manpage objects always
return false, and Path::Class::Dir
objects always return true.
Returns true or false depending on whether the directory refers to an
absolute path specifier (like /usr/local
or \Windows
).
Returns true or false depending on whether the directory refers to a
relative path specifier (like lib/foo
or ./dir
).
Performs a logical cleanup of the file path. For instance:
my $dir = dir('/foo//baz/./foo')->cleanup; # $dir now represents '/foo/baz/foo';
Performs a physical cleanup of the file path. For instance:
my $dir = dir('/foo//baz/../foo')->resolve; # $dir now represents '/foo/foo', assuming no symlinks
This actually consults the filesystem to verify the validity of the path.
Returns a the Path::Class::File manpage object representing an entry in $dir
or one of its subdirectories. Internally, this just calls <
Path::Class::File-
new( @_ ) >>.
Returns a new Path::Class::Dir
object representing a subdirectory
of $dir
.
Returns the parent directory of $dir
. Note that this is the
logical parent, not necessarily the physical parent. It really
means we just chop off entries from the end of the directory list
until we cain't chop no more. If the directory is relative, we start
using the relative forms of parent directories.
The following code demonstrates the behavior on absolute and relative directories:
$dir = dir('/foo/bar'); for (1..6) { print "Absolute: $dir\n"; $dir = $dir->parent; } $dir = dir('foo/bar'); for (1..6) { print "Relative: $dir\n"; $dir = $dir->parent; } ########### Output on Unix ################ Absolute: /foo/bar Absolute: /foo Absolute: / Absolute: / Absolute: / Absolute: / Relative: foo/bar Relative: foo Relative: . Relative: .. Relative: ../.. Relative: ../../..
Returns a list of the Path::Class::File manpage and/or Path::Class::Dir
objects listed in this directory, or in scalar context the number of
such objects. Obviously, it is necessary for $dir
to
exist and be readable in order to find its children.
Note that the children are returned as subdirectories of $dir
,
i.e. the children of foo will be foo/bar and foo/baz, not
bar and baz.
Ordinarily children()
will not include the self and parent
entries .
and ..
(or their equivalents on non-Unix systems),
because that's like I'm-my-own-grandpa business. If you do want all
directory entries including these special ones, pass a true value for
the all
parameter:
@c = $dir->children(); # Just the children @c = $dir->children(all => 1); # All entries
In addition, there's a no_hidden
parameter that will exclude all
normally "hidden" entries - on Unix this means excluding all entries
that begin with a dot (.
):
@c = $dir->children(no_hidden => 1); # Just normally-visible entries
Returns a Path::Class::Dir
object representing $dir
as an
absolute path. An optional argument, given as either a string or a
Path::Class::Dir
object, specifies the directory to use as the base
of relativity - otherwise the current working directory will be used.
Returns a Path::Class::Dir
object representing $dir
as a
relative path. An optional argument, given as either a string or a
Path::Class::Dir
object, specifies the directory to use as the base
of relativity - otherwise the current working directory will be used.
subsumes($other)
Returns true if this directory spec subsumes the other spec, and false
otherwise. Think of "subsumes" as "contains", but we only look at the
specs, not whether $dir
actually contains $other
on the
filesystem.
The $other
argument may be a Path::Class::Dir
object, a
the Path::Class::File manpage object, or a string. In the latter case, we
assume it's a directory.
# Examples: dir('foo/bar' )->subsumes(dir('foo/bar/baz')) # True dir('/foo/bar')->subsumes(dir('/foo/bar/baz')) # True dir('foo/bar' )->subsumes(dir('bar/baz')) # False dir('/foo/bar')->subsumes(dir('foo/bar')) # False
contains($other)
Returns true if this directory actually contains $other
on the
filesystem. $other
doesn't have to be a direct child of $dir
,
it just has to be subsumed.
as_foreign($type)
Returns a Path::Class::Dir
object representing $dir
as it would
be specified on a system of type $type
. Known types include
Unix
, Win32
, Mac
, VMS
, and OS2
, i.e. anything for which
there is a subclass of File::Spec
.
Any generated objects (subdirectories, files, parents, etc.) will also retain this type.
Returns a Path::Class::Dir
object representing $dir
as it would
be specified on a system of type $type
. Known types include
Unix
, Win32
, Mac
, VMS
, and OS2
, i.e. anything for which
there is a subclass of File::Spec
.
The arguments in @args
are the same as they would be specified in
new()
.
Returns the list of strings internally representing this directory
structure. Each successive member of the list is understood to be an
entry in its predecessor's directory list. By contract, <
Path::Class-
new( $dir->dir_list ) >> should be equivalent to $dir
.
The semantics of this method are similar to Perl's splice
or
substr
functions; they return LENGTH
elements starting at
OFFSET
. If LENGTH
is omitted, returns all the elements starting
at OFFSET
up to the end of the list. If LENGTH
is negative,
returns the elements from OFFSET
onward except for -LENGTH
elements at the end. If OFFSET
is negative, it counts backward
OFFSET
elements from the end of the list. If OFFSET
and
LENGTH
are both omitted, the entire list is returned.
In a scalar context, dir_list()
with no arguments returns the
number of entries in the directory list; dir_list(OFFSET)
returns
the single element at that offset; dir_list(OFFSET, LENGTH)
returns
the final element that would have been returned in a list context.
Identical to c<dir_list()>. It exists because there's an analogous
method dir_list()
in the Path::Class::File
class that also
returns the basename string, so this method lets someone call
components()
without caring whether the object is a file or a
directory.
open()
Passes $dir
to IO::Dir->open
and returns the result as an
the IO::Dir manpage object. If the opening fails, undef
is returned and
$!
is set.
Passes all arguments, including $dir
, to File::Path::mkpath()
and returns the result (a list of all directories created).
Passes all arguments, including $dir
, to File::Path::rmtree()
and returns the result (the number of files successfully deleted).
remove()
Removes the directory, which must be empty. Returns a boolean value
indicating whether or not the directory was successfully removed.
This method is mainly provided for consistency with
Path::Class::File
's remove()
method.
An interface to the File::Temp manpage's tempfile()
function. Just like
that function, if you call this in a scalar context, the return value
is the filehandle and the file is unlink
ed as soon as possible
(which is immediately on Unix-like platforms). If called in a list
context, the return values are the filehandle and the filename.
The given directory is passed as the DIR
parameter.
Here's an example of pretty good usage which doesn't allow race conditions, won't leave yucky tempfiles around on your filesystem, etc.:
my $fh = $dir->tempfile; print $fh "Here's some data...\n"; seek($fh, 0, 0); while (<$fh>) { do something... }
Or in combination with a fork
:
my $fh = $dir->tempfile; print $fh "Here's some more data...\n"; seek($fh, 0, 0); if ($pid=fork()) { wait; } else { something($_) while <$fh>; }
next()
A convenient way to iterate through directory contents. The first
time next()
is called, it will open()
the directory and read the
first item from it, returning the result as a Path::Class::Dir
or
the Path::Class::File manpage object (depending, of course, on its actual
type). Each subsequent call to next()
will simply iterate over the
directory's contents, until there are no more items in the directory,
and then the undefined value is returned. For example, to iterate
over all the regular files in a directory:
while (my $file = $dir->next) { next unless -f $file; my $fh = $file->open('r') or die "Can't read $file: $!"; ... }
If an error occurs when opening the directory (for instance, it
doesn't exist or isn't readable), next()
will throw an exception
with the value of $!
.
Calls the given callback for the root, passing it a continuation function which, when called, will call this recursively on each of its children. The callback function should be of the form:
sub { my ($child, $cont, @args) = @_; # ... }
For instance, to calculate the number of files in a directory, you can do this:
my $nfiles = $dir->traverse(sub { my ($child, $cont) = @_; return sum($cont->(), ($child->is_dir ? 0 : 1)); });
or to calculate the maximum depth of a directory:
my $depth = $dir->traverse(sub { my ($child, $cont, $depth) = @_; return max($cont->($depth + 1), $depth); }, 0);
You can also choose not to call the callback in certain situations:
$dir->traverse(sub { my ($child, $cont) = @_; return if -l $child; # don't follow symlinks # do something with $child return $cont->(); });
traverse with additional "should I visit this child" callback. Particularly useful in case examined tree contains inaccessible directories.
Canonical example:
$dir->traverse_if( sub { my ($child, $cont) = @_; # do something with $child return $cont->(); }, sub { my ($child) = @_; # Process only readable items return -r $child; });
Second callback gets single parameter: child. Only children for which it returns true will be processed by the first callback.
Remaining parameters are interpreted as in traverse, in particular
traverse_if(callback, sub { 1 }, @args
is equivalent to
traverse(callback, @args)
.
Iterates through this directory and all of its children, and all of
its children's children, etc., calling the callback
subroutine for
each entry. This is a lot like what the the File::Find manpage module does,
and of course File::Find
will work fine on the Path::Class manpage objects,
but the advantage of the recurse()
method is that it will also feed
your callback routine Path::Class
objects rather than just pathname
strings.
The recurse()
method requires a callback
parameter specifying
the subroutine to invoke for each entry. It will be passed the
Path::Class
object as its first argument.
recurse()
also accepts two boolean parameters, depthfirst
and
preorder
that control the order of recursion. The default is a
preorder, breadth-first search, i.e. depthfirst => 0, preorder => 1
.
At the time of this writing, all combinations of these two parameters
are supported except depthfirst => 0, preorder => 0
.
callback
is normally not required to return any value. If it
returns special constant Path::Class::Entity::PRUNE()
(more easily
available as $item-
PRUNE>), no children of analyzed
item will be analyzed (mostly as if you set $File::Find::prune=1
). Of course
pruning is available only in preorder
, in postorder return value
has no effect.
stat()
Invokes File::stat::stat()
on this directory and returns a
File::stat
object representing the result.
lstat()
Same as stat()
, but if $file
is a symbolic link, lstat()
stats the link instead of the directory the link points to.
file_class()
Returns the class which should be used to create file objects.
Generally overridden whenever this class is subclassed.
Ken Williams<EMAIL_ADDRESS>the Path::Class manpage, the Path::Class::File manpage, the File::Spec manpage
| Path::Class::Dir - Objects representing directories |


InvestLakeBasin
First Item
Second Item
Third Item
Potential Investors
Lavender Aluju
Subtitle
This is what the investor will offer you. You can choose to decline this or accept it as it is.
Accept
Decline
Joseph Njogu
Subtitle
This is what the investor will offer you. You can choose to decline this or accept it as it is.
Accept
Decline


CHINESE BOX (1997)
Rating: 2.5 stars (out of 4.0) ******************************** Key to rating system: 2.0 stars - Debatable 2.5 stars - Some people may like it 3.0 stars - I liked it 3.5 stars - I am biased in favor of the movie 4.0 stars - I felt the movie's impact personally or it stood out *********************************
Directed by: Wayne Wang
Written by: Jean-Claude Carriere and Larry Gross.
Starring: Jeremy Irons, Gong Li, Maggie Cheung, Ruben Blades
Ingredients: Dying photojournalist, 1997 Hong Kong hand over, street waif, friend, lover
Synopsis: John, a British author who has adopted Hong Kong as his home, suddenly finds out he is dying of leukemia six months before the hand over of Hong Kong to China. He quits his job and tries to explore the meaning of Hong Kong by wandering the streets with a video camera. Since John is a character of internal feelings and few words, John's roommate Jim (Ruben Blades) occasionally acts as the movie's mouthpiece.
What is Hong Kong before the hand over?  Is Hong Kong like the scrappy street waif Jean (Maggie Cheung), cast off by a former boyfriend, who hustles to survive? Is it like a business, merely getting a change of management? Or like a defiant animal in the marketplace? A woman in blue jeans vowing to start life anew?
CHINESE BOX explores these metaphorical images and more, and leaves the answer unresolved, letting us come to our own conclusions. The only thing we know for sure is that a tumultuous change is occurring before our eyes, accompanied by an intensity of feeling similar to time spent with a dying lover.
Opinion: When Vivian compares herself to Hong Kong and the dying John (Jeremy Irons) wonders to himself, "I wonder if I can last as long as the British" six months before the 1997 hand over, you can bet this film is not about leukemia, but a metaphor trying to establish the meaning of Hong Kong.
One of the weaknesses of the story is that it has very little story. After quitting his job a dying John basically wanders around the city with his video camera capturing images and occasionally falling into weakness or frustration. His thoughts remain confused until the end of the movie. This is likely to disappoint fans of strong storylines.
On the other hand, CHINESE BOX is powerful from the artistic point of view. In one scene, John's friend Jim takes a projector, and projects the videotaped face of the talking street waif onto John's face, creating an interesting effect. From images of jade and bloody hands to a man beheading a chicken, to a scene where the street waif confronts a British childhood boyfriend who abandoned her, CHINESE BOX offers us an unending stream of metaphors for the complicated feelings that abound in real life Hong Kong. Perhaps the strongest image (shown twice) is the close up of the still-beating heart on a faceless chopped fish in the marketplace. CHINESE BOX is also one of the few films in which the soundtrack completely and perfectly matches the imagery, whether it's the sound of traffic or the sound of silence.
Gong Li doesn't get many lines, (mostly gets to show emotions) but she does a fabulous job within that limitation. Ruben Blades and Maggie Cheung are outstanding, and Jeremy Irons puts in a solid characterization of a man trying to come to grips with complicated feelings.
Reviewed May 31, 1998
Copyright © 1998 by David Sunga This review and others like it can be found at THE CRITIC ZOO: http://www.criticzoo.com email<EMAIL_ADDRESS>The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


Consvin1052.github.io
Aermec Fcw Installationsanleitung.
View and Download AERMEC Omnia UL 11 N use and installation manual online. FAN COIL FOR UNIVERSAL INSTALLATION WITH ELECTRONIC THERMOSTAT. Omnia UL 11 N Heater pdf manual download. Also for: Omnia ul 16 n, Omnia ul 26 n, Omnia AERMEC Omnia UL 11 N Use And Installation Manual.


About us
The main member is Bertus Fourie, a SACNASP registered Professional Natural Scientist in the field of Ecology. See his work experience here. We are a multifaceted team of connected specialists to ensure that we provide a full range of services to our clients. Our core functions are aquatic ecosystem with a focus on terrestrial components. We are up to date with the newest biodiversity regulations and can advise on all aspects of authorisations processes. Water use licenses are a big part of our company processes and we are adequately qualified and equipped to resolve any issues arising during the application process.
The monitoring of construction related impacts as required by environment authorisations and compliance monitoring are part and parcel of our daily activities. We can advise on correct mythologies and application time periods. We are also SASS 5 accredited and biomonitoring can easily be done in house. Compliance to authorisations including water use licenses through a basic auditing process are at our core of monitoring.
Contact us
LIMNOLOGY PTY LTD
Company registration: 2015/295861/07
Director: AJ. Fourie
cell: +27 82 921 5445
email: limnologysa@gmail.com


NP screen overlay
Overlay mode
Full screen overlay with logo
Timer
Presenter hint
Transparent
Timer settings
Minutes
Now
Up Next
Send
Displayed now:
Presenter settings
Presenter
Presentation title
Send
Displayed now:


HOME
ABOUT US
REVIEW
CONTACT
Activity Buddy
Study Buddy
Carpool Buddy
© Vikram | Priyanka. All rights reserved.


{% extends "library/base.html" %} {% load i18n %} {% block head_title %}Library{% endblock %} {% block body_class %}library{% endblock %} {% block hero %}
DEV NOTE: The page currently lists text groups and provides filtering to quickly narrow down to what you want. What other information should be shown for each text group other than label? Should we filter or even group by other facets such as time period, language, geography? Should we show most popular works in each text group and enable immediate jumping to that work?


Satelytics Viewer
A viewer to demonstrate Satelytics.io processing capability
All the processing on completed on the fly using landsa 8 data stored on Amazon AWS
This is based on viewer.remotepixel.ca
HowTo
- Click on the blue tile of your choice
- Select the image you want to display on bottom list
- Select the processing algorithm to view rendered data
At Satelytics we provides even more:
- methane, oil and water leakage detection
- right-of-way encroachment and intrusion detection
- land movement monitoring
- green infrastructure monitoring
- and many more in higher resolution....
Loading


Does the following look familiar (under default Ocean theme in Metal LAF)?
The menu doesn't look good, with jagged items all over the place. The common solution in
this scenario is to use a transparent icon on those menu items that don't have one. There
are a few problems with this approach:
- What happens if you add another menu item with slightly wider icon? You will have to
adjust all other icons accordingly.
- What happens with JCheckBoxMenuItems and JRadioButtonMenuItems? Once you
have those, it's almost impossible to get it done correctly, especially if they have icons
themselves.
- There is no JMenu constructor that gets an icon. You'll have to call setIcon().
- The last, but most certainly the most annoying - why should you even bother to do this?
The answer to the last question lies in the BasicMenuItemUI class that does the
actual layout and rendering - it's looking at one menu item at a time. It's not
even aware that the specific menu item is a part of visual group, so it happily hacks
(and quite ugly) at the corresponding menu item, and the result is far from perfect:
(the above is Windows LAF from JDK).
To the rescue come custom look-and-feels. JGoodies
Looks comes equiped with custom menu item renderer. It keeps track of the maximum
text offset on the menu item parent (JPopupMenu in our case), and once the rendering
should be done, the offset is taken from the parent (client property). The result is much
more satisfying (see this issue
and Karsten's comment below regarding the layout JCheckBoxMenuItems and
JRadioButtonMenuItems with icons - the check marks are drawn underneath the icons):
Substance LAF takes a different approach,
inheriting from BasicMenuItemUI and overriding the function that computes the
text offset. It does the same as JGoodies, but for every menu item, it goes over all
entries in the parent component (JPopupMenu) and computes the maximal text offset.
This approach is more time consuming but also more dynamic. The result is:
This also works on "real" application, such as NetBeans:
Before
After


The policy for a Java™ programming language application
environment (specifying which permissions are available for code
from various sources, and executing as various principals) is
represented by a Policy object. More specifically, it is
represented by a Policy
subclass providing an
implementation of the abstract methods in the Policy
class (which is in the java.security
package).
The source location for the policy information utilized by the Policy object is up to the Policy implementation. The Policy reference implementation obtains its information from static policy configuration files.
The rest of this document pertains to the Policy reference implementation and the syntax that must be used in policy files it reads. For information about using the Policy Tool to create a policy file (without needing to know the required syntax), see the Policy Tool documentation (for Solaris, Linux, or Mac OS X) (for Windows).
Here is an outline for the rest of this document:
A policy file can be composed via a simple text editor, or via the graphical Policy Tool utility.
There is by default a single system-wide policy file, and a single (optional) user policy file.
The Policy reference implementation is initialized the first
time its getPermissions
method is called, or whenever
its refresh
method is called. Initialization involves
parsing the policy configuration file(s) (see Policy File Syntax), and then populating the
Policy object.
As mentioned previously, there is by default a single system-wide policy file, and a single user policy file.
The system policy file is by default located at
java.home/lib/security/java.policy (Solaris, Linux, or Mac OS X) java.home\lib\security\java.policy (Windows)
Note: java.home
refers to the value
of the system property named "java.home
", which
specifies the directory that houses the runtime environment --
either the jre directory in the Java SE Development Kit
(JDK) or the top-level directory of the Java SE Runtime Environment
(JRE).
The system policy file is meant to grant system-wide code
permissions. The java.policy
file installed with the
JDK grants all permissions to standard extensions, allows anyone to
listen on un-privileged ports, and allows any code to read certain
"standard" properties that are not security-sensitive, such as the
"os.name
" and "file.separator
"
properties.
The user policy file is by default located at
user.home/.java.policy (Solaris, Linux, or Mac OS X) user.home\.java.policy (Windows)
Note: user.home
refers to the value
of the system property named "user.home
", which
specifies the user's home directory.
When the Policy is initialized, the system policy is loaded in first, and then the user policy is added to it. If neither policy is present, a built-in policy is used. This built-in policy is the same as the java.policy file installed with the JRE.
Policy file locations are specified in the security properties file, which is located at
java.home/lib/security/java.security (Solaris, Linux, or Mac OS X) java.home\lib\security\java.security (Windows)As noted above,
java.home
indicates the
directory that houses the runtime environment--either the
jre directory in the JDK or the top-level directory of the
JRE. The policy file locations are specified as the values of
properties whose names are of the form
policy.url.nwhere
n
is a number. You specify each such
property value in a line of the following form:
policy.url.n=URLHere,
URL
is a URL specification.
For example, the default system and user policy files are defined in the security properties file as
policy.url.1=file:${java.home}/lib/security/java.policy policy.url.2=file:${user.home}/.java.policy
(See Property Expansion for
information about specifying property values via a special syntax,
such as specifying the java.home
property value
via ${java.home}
.)
You can actually specify a number of URLs (including ones of the
form "http://
"), and all the designated policy files
will get loaded. You can also comment out or change the second one
to disable reading the default user policy file.
The algorithm starts at policy.url.1
, and keeps
incrementing until it does not find a URL. Thus if you have
policy.url.1
and policy.url.3
,
policy.url.3
will never be read.
It is also possible to specify an additional or a different
policy file when invoking execution of an application. This can be
done via the "-Djava.security.policy
" command line
argument, which sets the value of the
java.security.policy
property. For example, if
you use
java -Djava.security.manager -Djava.security.policy=someURL SomeAppwhere
someURL
is a URL specifying the location
of a policy file, then the specified policy file will be loaded in
addition to all the policy files that are specified in the security
properties file.
Notes:
java -Djava.security.manager -Djava.security.policy=mypolicy SomeApp
-Djava.security.manager
" argument ensures
that the default security manager is installed, and thus the
application is subject to policy checks. It is not required if the
application SomeApp
installs a security
manager.If you use
java -Djava.security.manager -Djava.security.policy==someURL SomeApp(note the double equals) then just the specified policy file will be used; all the ones indicated in the security properties file will be ignored.
If you want to pass a policy file to the appletviewer, then use
a "-J-Djava.security.policy
" argument as follows:
appletviewer -J-Djava.security.policy=someURL myAppletNote: The "
-Djava.security.policy
" policy file
value will be ignored (for both java
and
appletviewer
commands) if the
"policy.allowSystemProperty
" property in the security
properties file is set to false. The default is true.
An alternative policy class can be given to replace the Policy
reference implementation class, as long as the former is a subclass
of the abstract Policy class and implements the
getPermissions
method (and other methods as
necessary).
The Policy reference implementation can be changed by editing
the security properties file, which is the
java.security
file in the lib/security
directory of the JDK or JRE.
One of the types of properties you can set in
java.security
is of the following form:
policy.provider=PolicyClassName
PolicyClassName
must specify the fully
qualified name of the desired Policy
implementation
class. The default security properties file entry for this property
is the following:
policy.provider=sun.security.provider.PolicyFile
To customize, you can change the property value to specify another class, as in
policy.provider=com.mycom.MyPolicy
The policy configuration file(s) for a JDK or JRE installation specifies what permissions (which types of system resource accesses) are granted to code from a specified code source, and executed as a specified principal.
For an applet (or an application running under a security manager) to be allowed to perform secured actions (such as reading or writing a file), the applet (or application) must be granted permission for that particular action. In the Policy reference implementation, that permission must be granted by a grant entry in a policy configuration file. See below and the "Java Security Architecture Specification" for more information. (The only exception is that code always automatically has permission to read files from its same (URL) location, and subdirectories of that location; it does not need explicit permission to do so.)
A policy configuration file essentially contains a list of entries. It may contain a "keystore" entry, and contains zero or more "grant" entries.
A keystore is a database of private keys and their associated digital certificates such as X.509 certificate chains authenticating the corresponding public keys. The keytool utility (for Solaris, Linux, or Mac OS X) (for Windows) is used to create and administer keystores. The keystore specified in a policy configuration file is used to look up the public keys of the signers specified in the grant entries of the file. A keystore entry must appear in a policy configuration file if any grant entries specify signer aliases, or if any grant entries specify principal aliases (see below).
At this time, there can be only one
keystore
/keystorePasswordURL
entry
in the policy file (other entries following the first one are
ignored). This entry can appear anywhere outside the file's grant
entries. It has the following syntax:
keystore "some_keystore_url", "keystore_type", "keystore_provider"; keystorePasswordURL "some_password_url";
some_keystore_url
specifies the URL location of the
keystore, some_password_url
specifies the URL location
of the keystore password, keystore_type
specifies the
keystore type, and keystore_provider
specifies the
keystore provider. Note that the input stream from
some_keystore_url
is passed to the
KeyStore.load
method. If NONE
is
specified as the URL, then a null stream is passed to the
KeyStore.load
method. NONE
should be
specified if the KeyStore
is not file-based, for
example, if it resides on a hardware token device.
The URL is relative to the policy file location. Thus if the policy file is specified in the security properties file as:
policy.url.1=http://foo.example.com/fum/some.policyand that policy file has an entry:
keystore ".keystore";then the keystore will be loaded from:
http://foo.example.com/fum/.keystoreThe URL can also be absolute.
A keystore type defines the storage and data format of the keystore information, and the algorithms used to protect private keys in the keystore and the integrity of the keystore itself. The default type supported by Sun Microsystems is a proprietary keystore type named "JKS". Thus, if the keystore type is "JKS", it does not need to be specified in the keystore entry.
Code being executed is always considered to come from a
particular "code source" (represented by an object of type
CodeSource
). The code source includes not only the
location (URL) where the code originated from, but also a reference
to the certificate(s) containing the public key(s) corresponding to
the private key(s) used to sign the code. Certificates in a code
source are referenced by symbolic alias names from the user's
keystore. Code is also considered to be executed as a particular
principal (represented by an object of type
Principal
), or group of principals.
Each grant entry includes one or more "permission
entries" preceded by optional codeBase
,
signedBy
, and principal name/value pairs that specify
which code you want to grant the permissions. The basic format of a
grant entry is the following:
grant signedBy "signer_names", codeBase "URL", principal principal_class_name "principal_name", principal principal_class_name "principal_name", ... { permission permission_class_name "target_name", "action", signedBy "signer_names"; permission permission_class_name "target_name", "action", signedBy "signer_names"; ... };All non-italicized items above must appear as is (although case doesn't matter and some are optional, as noted below). Italicized items represent variable values.
A grant entry must begin with the word grant
.
SignedBy
, Principal
, and
CodeBase
FieldsThe signedBy
, codeBase
, and
principal
values are optional, and the order of these
fields does not matter.
A signedBy
value indicates the alias for a
certificate stored in the keystore. The public key within that
certificate is used to verify the digital signature on the code;
you grant the permission(s) to code signed by the private key
corresponding to the public key in the keystore entry specified by
the alias.
The signedBy
value can be a comma-separated list of
multiple aliases. An example is "Adam,Eve,Charles", which means
"signed by Adam and Eve and Charles"; the relationship is AND, not
OR. To be more exact, a statement like "Code signed by Adam" means
"Code in a class file contained in a JAR which is signed using the
private key corresponding to the public key certificate in the
keystore whose entry is aliased by Adam".
The signedBy
field is optional in that, if it is
omitted, it signifies "any signer". It doesn't matter whether the
code is signed or not or by whom.
A principal value specifies a
class_name
/principal_name
pair which must
be present within the executing thread's principal set. The
principal set is associated with the executing code by way of a
Subject.
The principal_class_name
may be set to the wildcard
value, *, which allows it to match any Principal
class. In addition, the principal_name
may also be set
to the wildcard value, *, allowing it to match any
Principal
name. When setting the
principal_class_name
or principal_name
to
*, do not surround the * with quotes. Also, if you specify a
wildcard principal class, you must also specify a wildcard
principal name.
The principal field is optional in that, if it is omitted, it signifies "any principals".
Note on KeyStore Alias Replacement:
If the principal class_name/principal_name pair is specified as
a single quoted string, it is treated as a keystore alias. The
keystore is consulted and queried (via the alias) for an X509
Certificate. If one is found, the principal class_name is
automatically treated as
javax.security.auth.x500.X500Principal
, and the
principal_name
is automatically treated as the subject
distinguished name from the certificate. If an X509 Certificate
mapping is not found, the entire grant entry is ignored.
A codeBase
value indicates the code source
location; you grant the permission(s) to code from that location.
An empty codeBase
entry signifies "any code"; it
doesn't matter where the code originates from.
Note: a codeBase
value is a URL and thus
should always utilize slashes (never backslashes) as the directory
separator, even when the code source is actually on a Windows
system. Thus, if the source location for code on a Windows system
is actually C:\somepath\api\
, then the policy
codeBase
entry should look like:
grant codeBase "file:/C:/somepath/api/" { ... };The exact meaning of a
codeBase
value depends on the
characters at the end. A codeBase
with a trailing "/"
matches all class files (not JAR files) in the specified directory.
A codeBase
with a trailing "/*" matches all files
(both class and JAR files) contained in that directory. A
codeBase
with a trailing "/-" matches all files (both
class and JAR files) in the directory and recursively all files in
subdirectories contained in that directory. The following table
illustrates the different cases.
| Codebase URL of Downloaded Code | Codebase URL in Policy | Match? |
|---|---|---|
| www.example.com/people/gong/ | www.example.com/people/gong | Y |
| www.example.com/people/gong/ | www.example.com/people/gong/ | Y |
| www.example.com/people/gong/ | www.example.com/people/gong/* | Y |
| www.example.com/people/gong/ | www.example.com/people/gong/- | Y |
| www.example.com/people/gong/appl.jar | www.example.com/people/gong/ | N |
| www.example.com/people/gong/appl.jar | www.example.com/people/gong/- | Y |
| www.example.com/people/gong/appl.jar | www.example.com/people/gong/* | Y |
| www.example.com/people/gong/appl.jar | www.example.com/people/- | Y |
| www.example.com/people/gong/appl.jar | www.example.com/people/* | N |
| www.example.com/people/gong/ | www.example.com/people/- | Y |
| www.example.com/people/gong/ | www.example.com/people/* | N |
A permission entry must begin with the word
permission
. The word
permission_class_name
in the template above
would actually be a specific permission type, such as
java.io.FilePermission
or
java.lang.RuntimePermission
.
The "action
" is required for many permission
types, such as java.io.FilePermission
(where it
specifies what type of file access is permitted). It is not
required for categories such as
java.lang.RuntimePermission
where it is not
necessary--you either have the permission specified by the
"target_name
" value following the
permission_class_name
or you don't.
The signedBy
name/value pair for a permission entry
is optional. If present, it indicates a signed permission. That is,
the permission class itself must be signed by the given alias(es)
in order for the permission to be granted. For example, suppose you
have the following grant entry:
grant { permission Foo "foobar", signedBy "FooSoft"; };
Then this permission of type Foo is granted if the
Foo.class
permission was placed in a JAR file and the
JAR file was signed by the private key corresponding to the public
key in the certificate specified by the "FooSoft" alias, or if
Foo.class
is a system class, since system classes are
not subject to policy restrictions.
Items that appear in a permission entry must appear in the
specified order (permission
,
permission_class_name, "target_name",
"action", and signedBy
"signer_names").
An entry is terminated with a semicolon.
Case is unimportant for the identifiers
(permission
, signedBy
,
codeBase
, etc.) but is significant for the
permission_class_name or for any string that is passed in as
a value.
Note: When you are specifying a
java.io.FilePermission
, the
"target_name
" is a file path. On Windows
systems, whenever you directly specify a file path in a string (but
not in a codeBase URL), you need to include two backslashes for
each actual single backslash in the path, as in
grant { permission java.io.FilePermission "C:\\users\\cathy\\foo.bat", "read"; };The reason this is necessary is because the strings are processed by a tokenizer (
java.io.StreamTokenizer
), which allows
"\
" to be used as an escape string (for example,
"\n
" to indicate a new line) and which thus requires
two backslashes to indicate a single backslash. After the tokenizer
has processed the above file path string, converting double
backslashes to single backslashes, the end result is
"C:\users\cathy\foo.bat"
An example of two entries in a policy configuration file is
// If the code is signed by "Duke", grant it read/write access to all // files in /tmp: grant signedBy "Duke" { permission java.io.FilePermission "/tmp/*", "read,write"; }; // Grant everyone the following permission: grant { permission java.util.PropertyPermission "java.vendor", "read"; };
The contents of another sample policy configuration file appear below.
grant signedBy "sysadmin", codeBase "file:/home/sysadmin/*" { permission java.security.SecurityPermission "Security.insertProvider.*"; permission java.security.SecurityPermission "Security.removeProvider.*"; permission java.security.SecurityPermission "Security.setProperty.*"; };This specifies that only code that satisfies the following conditions can call methods in the Security class to add or remove providers or to set Security properties:
/home/sysadmin/
" directory on the local file
system.Either component of the code source (or both) may be missing. An
example where codeBase
is missing is:
grant signedBy "sysadmin" { permission java.security.SecurityPermission "Security.insertProvider.*"; permission java.security.SecurityPermission "Security.removeProvider.*"; };If this policy is in effect, code that comes in a JAR File signed by "sysadmin" can add/remove providers, regardless of where the JAR File originated from.
An example without a signer is:
grant codeBase "file:/home/sysadmin/-" { permission java.security.SecurityPermission "Security.insertProvider.*"; permission java.security.SecurityPermission "Security.removeProvider.*"; };In this case, code that comes from anywhere beneath the "
/home/sysadmin/
" directory on the local filesystem
can add/remove providers. The code does not need to be signed.
An example where neither codeBase
nor
signedBy
is included is:
grant { permission java.security.SecurityPermission "Security.insertProvider.*"; permission java.security.SecurityPermission "Security.removeProvider.*"; };Here, with both code source components missing, any code (regardless of where it originated from, or whether or not it is signed, or who signed it) can add/remove providers.
The following represents a principal-based entry.
grant principal javax.security.auth.x500.X500Principal "cn=Alice" { permission java.io.FilePermission "/home/Alice", "read, write"; };This permits any code executing as the X500Principal, "
cn=Alice
", permission to read and write to
"/home/Alice
".
The following represents a principal-based entry with a wildcard value.
grant principal javax.security.auth.x500.X500Principal * { permission java.io.FilePermission "/tmp", "read, write"; };This permits any code executing as an X500Principal (regardless of the distinguished name), permission to read and write to "
/tmp
".
The following example shows a grant statement with both codesource and principal information.
grant codebase "http://www.games.example.com", signedBy "Duke", principal javax.security.auth.x500.X500Principal "cn=Alice" { permission java.io.FilePermission "/tmp/games", "read, write"; };This allows code downloaded from "
www.games.example.com
", signed by
"Duke
", and executed by "cn=Alice
",
permission to read and write into the "/tmp/games
"
directory.
The following example shows a grant statement with KeyStore alias replacement:
keystore "http://foo.example.com/blah/.keystore"; grant principal "alice" { permission java.io.FilePermission "/tmp/games", "read, write"; };"
alice
" will be replaced by
javax.security.auth.x500.X500Principal "cn=Alice"assuming the X.509 certificate associated with the keystore alias,
alice
, has a subject distinguished name of
"cn=Alice
". This allows code executed by the
X500Principal "cn=Alice
" permission to read and write
into the "/tmp/games
" directory.
Property expansion is similar to expanding variables in a shell. That is, when a string like
${some.property}appears in a policy file, or in the security properties file, it will be expanded to the value of the system property. For example,
permission java.io.FilePermission "${user.home}", "read";will expand "
${user.home}
" to use the value of the
"user.home" system property. If that property's value is
"/home/cathy
", then the above is equivalent to
permission java.io.FilePermission "/home/cathy", "read";In order to assist in platform-independent policy files, you can also use the special notation of "
${/}
", which is a
shortcut for "${file.separator}
". This allows things
like
permission java.io.FilePermission "${user.home}${/}*", "read";If the value of the "
user.home
" property is
/home/cathy
, and you are on Solaris, Linux, or Mac OS X, the above
gets converted to:
permission java.io.FilePermission "/home/cathy/*", "read";If on the other hand the "
user.home
" value is
C:\users\cathy
and you are on a Windows system, the
above gets converted to:
permission java.io.FilePermission "C:\users\cathy\*", "read";Also, as a special case, if you expand a property in a codebase, such as
grant codeBase "file:${java.home}/lib/ext/"then any file.separator characters will be automatically converted to
/
's. Thus on a Windows system, the above would get
converted to
grant codeBase "file:C:/jdk1.4/jre/lib/ext/"even if "
java.home
" is set to
C:\jdk1.4\jre
. Thus you don't need to use
${/}
in codebase strings (and you shouldn't).
Property expansion takes place anywhere a double quoted string
is allowed in the policy file. This includes the
"signer_names
", "URL
",
"target_name
", and "action
"
fields.
Whether or not property expansion is allowed is controlled by
the value of the "policy.expandProperties
" property in
the security properties file. If the value of this property is true
(the default), expansion is allowed.
Note: You can't use nested properties; they will not work. For example,
"${user.${foo}}"doesn't work, even if the "
foo
" property is set to
"home
". The reason is the property parser doesn't
recognize nested properties; it simply looks for the first
"${
", and then keeps looking until it finds the first
"}
" and tries to interpret the result (in this case,
"${user.$foo}
") as a property, but fails if there is
no such property.
Note: If a property can't be expanded in a grant entry,
permission entry, or keystore entry, that entry is ignored. For
example, if the system property "foo
" is not defined
and you have:
grant codeBase "${foo}" { permission ...; permission ...; };then all the permissions in this grant entry are ignored. If you have
grant { permission Foo "${foo}"; permission Bar "barTarget"; };then only the "
permission Foo...
" entry is ignored.
And finally, if you have
keystore "${foo}";then the keystore entry is ignored.
grant { permission java.io.FilePermission "C:\\users\\cathy\\foo.bat", "read"; };This is because the strings are processed by a tokenizer (
java.io.StreamTokenizer
), which allows
"\
" to be used as an escape string (e.g.,
"\n
" to indicate a new line) and which thus requires
two backslashes to indicate a single backslash. After the tokenizer
has processed the above file path string, converting double
backslashes to single backslashes, the end result is
"C:\users\cathy\foo.bat"Expansion of a property in a string takes place after the tokenizer has processed the string. Thus if you have the string
"${user.home}\\foo.bat"then first the tokenizer processes the string, converting the double backslashes to a single backslash, and the result is
"${user.home}\foo.bat"Then the
${user.home}
property is expanded and the end
result is
"C:\users\cathy\foo.bat"assuming the "
user.home
" value is
C:\users\cathy
. Of course, for platform independence,
it would be better if the string was initially specified without
any explicit slashes, i.e., using the ${/}
property
instead, as in
"${user.home}${/}foo.bat"
${{protocol:protocol_data}}If such a string occurs in a permission name, then the value in protocol determines the exact type of expansion that should occur, and protocol_data is used to help perform the expansion. protocol_data may be empty, in which case the above string should simply take the form:
${{protocol}}
There are two protocols supported in the default policy file implementation:
${{self}}
The protocol, self
, denotes a replacement of
the entire string, ${{self}}
, with one or more
principal class/name pairs. The exact replacement performed depends
upon the contents of the grant clause to which the permission
belongs.
If the grant clause does not contain any principal information,
the permission will be ignored (permissions containing
${{self}}
in their target names are only valid in the
context of a principal-based grant clause). For example,
BarPermission
will always be ignored in the following
grant clause:
grant codebase "www.example.com", signedby "duke" { permission BarPermission "... ${{self}} ..."; };If the grant clause contains principal information,
${{self}}
will be replaced with that same principal
information. For example, ${{self}}
in
BarPermission
will be replaced with
javax.security.auth.x500.X500Principal
"cn=Duke"
in the following grant clause:
grant principal javax.security.auth.x500.X500Principal "cn=Duke" { permission BarPermission "... ${{self}} ..."; };If there is a comma-separated list of principals in the grant clause, then
${{self}}
will be replaced by the same
comma-separated list or principals. In the case where both the
principal class and name are wildcarded in the grant clause,
${{self}}
is replaced with all the principals
associated with the Subject
in the current
AccessControlContext
.
The following example describes a scenario involving both
self
and KeyStore
alias replacement
together:
keystore "http://foo.example.com/blah/.keystore"; grant principal "duke" { permission BarPermission "... ${{self}} ..."; };In the above example, "
duke
" will first be expanded
into javax.security.auth.x500.X500Principal
"cn=Duke"
assuming the X.509 certificate associated with
the KeyStore
alias, "duke
", has a subject
distinguished name of "cn=Duke
". Next,
${{self}}
will be replaced with the same principal
information that was just expanded in the grant clause:
javax.security.auth.x500.X500Principal
"cn=Duke"
.${{alias:alias_name}}
The protocol, alias
, denotes a
java.security.KeyStore alias substitution. The
KeyStore
used is the one specified in the KeyStore
entry. alias_name
represents an alias into the KeyStore
.
${{alias:alias_name}}
is replaced with
javax.security.auth.x500.X500Principal "DN"
,
where DN
represents the subject distinguished
name of the certificate belonging to
alias_name
. For example:
keystore "http://foo.example.com/blah/.keystore"; grant codebase "www.example.com" { permission BarPermission "... ${{alias:duke}} ..."; };In the above example the X.509 certificate associated with the alias,
duke
, is retrieved from the
KeyStore
,
foo.example.com/blah/.keystore
. Assuming duke's
certificate specifies "o=dukeOrg, cn=duke
" as the
subject distinguished name, then ${{alias:duke}}
is
replaced with javax.security.auth.x500.X500Principal
"o=dukeOrg, cn=duke"
.
The permission entry is ignored under the following error conditions:
alias_name
is not providedalias_name
can not be
retrieved


Overview
Package
Class
Use
Tree
Deprecated
Index
Help
PREV LETTER
NEXT LETTER
FRAMES
NO FRAMES
All Classes
A
B
C
D
E
F
G
I
J
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
G
gauss2DTable(int)
- Static method in class tools.
MyMath
calculate the first quadrant (x:0 -5 ,y:0 - 5) of a 2dim Table from standart Normal Distrubution Values
getAllComps()
- Method in class view.swing.
PositionEditor
getAllCompsFromObs()
- Method in class controller.
ObservationSeries
getAllCompsFromObs(Observation[])
- Method in class view.swing.
PositionEditor
getBgColor()
- Method in class view.
ObservationImage
getBrightness()
- Method in class model.
MaserComponent
getBrightness(Color)
- Static method in class tools.
MyImage
getCaption()
- Method in class view.
ColorCodeImage
getCaption()
- Method in class view.
GridImage
getCelestialObject()
- Method in class controller.
ObservationSeries
getCelestialObject()
- Method in class model.
Observation
Getter of the property
celestialObject
getCelestialObjectTextImg()
- Method in class view.
ObservationImage
getCelestialObjectTextImgX()
- Method in class view.
ObservationImage
getCelestialObjectTextImgY()
- Method in class view.
ObservationImage
getCelObject()
- Method in class model.
Observation
getColorCodeImg()
- Method in class view.
ObservationImage
getColorCodeImgX()
- Method in class view.
ObservationImage
getColorCodeImgY()
- Method in class view.
ObservationImage
getColorImg()
- Method in class view.
ColorCodeImage
getComponent(int)
- Method in class model.
Observation
getComponentRowByName(String)
- Method in class model.
Unit
getComponentRowByUniqueKey(int, String)
- Method in class model.
MaserComponent
getComponents()
- Method in class model.
Observation
getConn()
- Method in class model.
DataBase
getCreateStatement()
- Method in class model.
DBTable
getCurrentMethodName()
- Static method in class tools.
ToolBox
getDataBase1()
- Method in class model.
DBTable
Getter of the property
dataBase1
getDataMap()
- Method in class model.
CelestialObject
getDataMap()
- Method in class model.
MaserComponent
getDataMap()
- Method in class model.
Observation
getDataMap()
- Method in class model.
Unit
getDate()
- Method in class model.
Observation
getDbAlias()
- Method in class model.
DataBase
getDBTable()
- Method in class model.
DataBase
Getter of the property
dBTable
getDBTableRow(Date, int)
- Method in class model.
Observation
getDBTableRowById(int)
- Method in class model.
Observation
getDeclination()
- Method in class model.
CelestialObject
getDopplerColorRange()
- Method in class view.
MaserComponentsImage
getFgColor()
- Method in class view.
ObservationImage
getFormatPattern()
- Method in class tools.
DateCalculator
getGridImg()
- Method in class view.
GridImage
getGridImg()
- Method in class view.
ObservationImage
getGridImgX()
- Method in class view.
ObservationImage
getGridImgY()
- Method in class view.
ObservationImage
getHeight()
- Method in class view.
ObservationImage
getHeight()
- Method in class view.
TextDataImage
getHSB(Color)
- Static method in class tools.
MyImage
getHSBbyKey(Color, char)
- Static method in class tools.
MyImage
getHue(Color)
- Static method in class tools.
MyImage
getID()
- Method in class model.
CelestialObject
getID()
- Method in class model.
MaserComponent
getID()
- Method in class model.
Observation
getID()
- Method in class model.
Unit
getIdentity()
- Method in class model.
DBTable
getInputDir()
- Method in class controller.
MaserJ
getInputFiles()
- Method in class controller.
MaserJ
getInstrument()
- Method in class model.
Observation
getIntensity()
- Method in class model.
MaserComponent
getIntensityRange()
- Method in class view.
MaserComponentsImage
getInterpolated()
- Method in class model.
Observation
getJdStartDate()
- Method in class tools.
DateCalculator
getKeyOrder()
- Method in class model.
CelestialObject
getKeyOrder()
- Method in class model.
MaserComponent
getKeyOrder()
- Method in class model.
Observation
getMaserImg()
- Method in class view.
ObservationImage
getMaserImgX()
- Method in class view.
ObservationImage
getMaserImgY()
- Method in class view.
ObservationImage
getMaxLengthStringFromMap(HashMap<String, Object>)
- Method in class view.
TextDataImage
getMethodName(Object)
- Static method in class tools.
ToolBox
getName()
- Method in class model.
CelestialObject
getName()
- Method in class model.
MaserComponent
getName()
- Method in class model.
Unit
getNoise()
- Method in class model.
Observation
getObjectId()
- Method in class model.
Observation
getObseravtion(int)
- Method in class model.
CelestialObject
getObseravtions()
- Method in class model.
CelestialObject
getObseravtionsFromDB()
- Method in class model.
CelestialObject
fetch all rows from DBTable"OBSERVATIONS" with this Object_id and
getObservation()
- Method in class controller.
ObservationImageBuilder
getObservation()
- Method in class model.
CelestialObject
Getter of the property
observation
getObservation()
- Method in class model.
MaserComponent
getObservations()
- Method in class controller.
ObservationSeries
getObservationsDates()
- Method in class controller.
ObservationSeries
getObservationTextImg()
- Method in class view.
ObservationImage
getObservationTextImgX()
- Method in class view.
ObservationImage
getObservationTextImgY()
- Method in class view.
ObservationImage
getObservationValuesByKey(String)
- Method in class controller.
ObservationSeries
getObservationValuesRange(String)
- Method in class controller.
ObservationSeries
getObsImg()
- Method in class controller.
ObservationImageBuilder
getRightAscension()
- Method in class model.
CelestialObject
getRows()
- Method in class model.
DBTable
get all Rows from Table
getRowsByWhereCondition(String)
- Method in class model.
DBTable
get Rows from Table with whereCondition
getRowsOrderByID()
- Method in class model.
DBTable
get all Rows from Table
getSaturation(Color)
- Static method in class tools.
MyImage
getScaleImg()
- Method in class view.
ColorCodeImage
getTableStruct()
- Method in class model.
DBTable
getTableStructAsContainerMap()
- Method in class model.
DBTable
translate tableStruct to HashMap
getUnitRange()
- Method in class view.
ColorCodeImage
getUnitStr()
- Method in class view.
ColorCodeImage
getUnitStr()
- Method in class view.
GridImage
getValue()
- Method in class model.
Unit
getVelocity()
- Method in class model.
MaserComponent
getVelocityRange()
- Method in class view.
MaserComponentsImage
getWidth()
- Method in class view.
TextDataImage
getXMLTag(String, String)
- Static method in class tools.
ToolBox
getXMLTagByPos(String, String, int)
- Static method in class tools.
ToolBox
getXMLTagContent(String, String)
- Static method in class tools.
ToolBox
getXMLTagContentByPos(String, String, int)
- Static method in class tools.
ToolBox
getXMLTagContentList(String, String)
- Static method in class tools.
ToolBox
getXMLTagList(String, String, String)
- Static method in class tools.
ToolBox
getXOffset()
- Method in class model.
MaserComponent
getYOffset()
- Method in class model.
MaserComponent
GridImage
- Class in
view
GridImage(int, int)
- Constructor for class view.
GridImage
GridImageTest
- Class in
view
GridImageTest()
- Constructor for class view.
GridImageTest
groundClasses
- Static variable in class controller.
MaserJ
Overview
Package
Class
Use
Tree
Deprecated
Index
Help
PREV LETTER
NEXT LETTER
FRAMES
NO FRAMES
All Classes
A
B
C
D
E
F
G
I
J
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y


The whole life changing experience started when my older brother came down form college for a week break. He had brought some psilocybin mushrooms down from the beautiful Colorado mountains. My brother having tried these many time knew it would be a wounderful experiance for me so he decided to give me some for free. It had been snowing for about three days and we got 43 inches of snow when it finally stopped snowing that moonlit night.  I had ate them inside my house and waited 30 minutes and put on my snow gear.
The second I stepped out side I new I was in for a great trip. About twenty minutes later I knew there was no turning back and it had already begun. The first thing I noticed it appeared almost like it was day and the sun was in full flare this was probably caused from the moon reflecting off the snow, of course the mushrooms played a huge part in this. Another thing a noticed was I could not stop laughing as the tall trees above me, there was a slight breeze that night which made them sway back and forth but to me it looked liked they were floppy sea weed in the night sky. Some snow had got in my eye's when watching this happend so i closed my eyes. This is when I discovered closed eye visuals, I had no idea I could see so many colors and patters by closing my eyes, this is just unexplainable and my favorite effect of mushrooms. I had no idea how much time I have been out there maybe it was hourse or just a few minutes but I never wanted this to end.
Experience Reports are the writings and opinions of the individual authors who submit them.
Some of the activities described are dangerous and/or illegal and none are recommended by Erowid.


UX-designer - Cat lover - Gamer
User Experience Designer & Web Designer
My heart beats a little extra for video games, new technologies and design. I also love to travel and get to know explore the surroundings for amazing experiences. Games and travels are my biggest inspirations as you go on adventures where you are able to explore your surroundings and take decisions on where to go next.
I currently work as a UX consultant. Before that I worked at a startup called Virtual Stores where I did a bit of this and that as a frontend-developer, UX-designer, operations technician and project manager. I've also worked for Viaplay and their (T)VOD-service as an interaction- and UX-designer.
During my three years at Södertörn University I have somehow learnt pretty neat stuff about UX-, interaction design, web development, informatics and media by learning how to prototype, conduct research and user testing and building websites. Wow, I actually have a degree, Bachelor of Science in Media Technology.


That is the reason why we offer a variety of toppings and crusts and a wide array of choices made from natural ingredients, balancing a nutritional diet with splendid taste.
Pasta cooked to perfection tossed with milk, vegetables, potatoes, poultry, 100% pure mutton, and cheese - and in creating nutritious and tasty meals to maintain good health.
Sandwizza cooked to perfection tossed with bread, milk, vegetables, potatoes, poultry, 100% pure mutton, and cheese - and in creating nutritious and tasty meals to maintain good health.
Rate : $30
Ingredients : onions, garden-veggies & tomatoes.
Rate : $34
Ingredients : onions, paneer & tomatoes.
Rate : $64
Ingredients : onions, grilled chicken, chicken salami & tomatoes.


The following diagrams show the required virtual machine (VM) states and task states for various commands issued by the user:
digraph states { node [fontsize=10 fontname="Monospace"] /* states */ building [label="BUILDING"] active [label="ACTIVE"] paused [label="PAUSED"] suspended [label="SUSPENDED"] stopped [label="STOPPED"] rescued [label="RESCUED"] resized [label="RESIZED"] soft_deleted [label="SOFT_DELETED"] deleted [label="DELETED"] error [label="ERROR"] /* apis */ create [shape="rectangle"] create -> active create -> error building -> create delete [shape="rectangle"] delete -> deleted building -> delete paused -> delete suspended -> delete stopped -> delete rescued -> delete soft_deleted -> delete error -> delete soft_delete [shape="rectangle"] soft_delete -> soft_deleted soft_delete -> error active -> soft_delete stopped -> soft_delete restore [shape="rectangle"] restore -> active restore -> error soft_deleted -> restore pause [shape="rectangle"] pause -> paused pause -> error active -> pause unpause [shape="rectangle"] unpause -> active unpause -> error paused -> unpause suspend [shape="rectangle"] suspend -> suspended suspend -> error active -> suspend resume [shape="rectangle"] resume -> active resume -> error suspended -> resume start [shape="rectangle"] start -> active start -> error stopped -> start stop [shape="rectangle"] stop -> stopped stop -> error active -> stop error -> stop rescue [shape="rectangle"] rescue -> rescued rescue -> error active -> rescue stopped -> rescue unrescue [shape="rectangle"] unrescue -> active rescued -> unrescue resize [shape="rectangle"] resize -> resized resize -> error active -> resize stopped -> resize confirm_resize [shape="rectangle"] confirm_resize -> active confirm_resize -> error resized -> confirm_resize confirm_resize [shape="rectangle"] revert_resize -> active revert_resize -> error resized -> revert_resize snapshot [shape="rectangle"] snapshot -> active snapshot -> stopped snapshot -> error active -> snapshot stopped -> snapshot backup [shape="rectangle"] backup -> active backup -> stopped backup -> error active -> backup stopped -> backup rebuild [shape="rectangle"] rebuild -> active rebuild -> error active -> rebuild stopped -> rebuild set_admin_password [shape="rectangle"] set_admin_password -> active set_admin_password -> error active -> set_admin_password reboot [shape="rectangle"] reboot -> active reboot -> error active -> reboot stopped -> reboot rescued -> reboot live_migrate [shape="rectangle"] live_migrate -> active live_migrate -> error active -> live_migrate }
The following diagram shows the sequence of VM states, task states, and power states when a new VM instance is created.