Creators will sometimes sometimes try to make it sound like something is positively ancient by stating that it is ten thousand years old. One common example is the supposed sinking of Atlantis. Many cultures have a distinct word for 10,000 that is often used to refer to any indefinite large number — in English, for example, it's "myriad". Currently, the development of agriculture is estimated as having occurred ten thousand years ago. And the earliest example of print is much younger than 8,000 BC.
Compare Thousand-Year Reign. May be a case of Sci-Fi Writers Have No Sense of Scale.
Examples
- First Comics' Mars by Mark Wheatley and Marc Hempel has the advance team of terraformers lose contact with Earth, and decide to let their robots reshape the planet Mars on automatic while they place themselves in stasis pods for ten thousand years, in hopes that Mars will be habitable by then.
- Aladdin
- Genie states that he's been trapped in his lamp for 10,000 years. Who or what made the lamp 10,000 years ago is never explained.

- Genie's first words upon his release are given a Meaningful Echo later on when Jafar is turned into a genie and trapped in his own lamp.
Genie: 10,000 years in the Cave of Wonders ought to chill him out!
- Genie states that he's been trapped in his lamp for 10,000 years. Who or what made the lamp 10,000 years ago is never explained.
- Isaac Asimov's Foundation Series:
- The Galactic Empire of Trantor has lasted for 12,069 years before the establishment of Terminus, and survives many years afterwards.
- A prophecy is made by Hari Seldon that after the Galactic Empire collapses into chaos, said chaos would last for thirty thousand years before another Galactic Empire took control, longer than the duration of the ancient first Empire. It is in an effort to avert this extremely long anarchy that he establishes his 1,000 year plan.
- Frank Herbert's Dune: The series begins in the year 10,191 AG, after the Spacing Guild was founded and the Imperium established.
- Robert A. Heinlein's Magic, Inc.: Ditworth is sentenced to ten thousand years of imprisonment by Satan for being defeated with white magic. Fraser notes that it's like the demonic equivalent of six months in prison.
- John Norman's Gor: Years on the planet Gor are measured by locally significant events such as Year X of King Y's reign. For the sake of stability, many locations also date their years in CA, "Contassa Ar" or "from the founding of Ar" (Gor's largest city-State). In the first book, it is 10,119 CA.
- Babylon 5: When Delenn explains the Shadows and the First Ones to Sheridan, she tells him the last time they made open war with each other was 10,000 years ago. The last war fought by the younger races against the Shadows, on the other hand, was a "mere" 1,000 years ago.
- Power Rangers:
- In Mighty Morphin' Power Rangers, Rita Repulsa was locked up for 10,000 years in a "Space Dumpster" on the moon, as she helpfully reminds viewers in the Opening Narration sequence before every season 1 episodenote .
- Power Rangers Jungle Fury's backstory also goes back to a great war 10,000 years ago; Wild Mass Guessing regarding whether the two incidences are in fact one and the same, and 10,000 years ago is just a rough estimate, was initially very popular.
- In Stargate Atlantis the Earth-Atlantis Expedition returns to Atlantis and the Pegasus Galaxy 10,000 years after the Lanteans lost the Wraith war, sank Atlantis, and retreated back through the Stargate to Earth.
- Star Trek: Deep Space Nine gives two figures for the Dominion's age. One is ten thousand, the other is a 'mere' over-two-thousand years (given the context, it's possible it simply took the Founders some eight millennia to get from planning the Dominion to actually implementing the Dominion).
- In the song "I Was Born Ten Thousand Years Ago" the narrator claims to have been born 10,000 years ago, claiming to have witnessed much of the Bible's history.
I was born about 10,000 years ago
There ain't nothing in this world that I don't know
I saw Peter, Paul and Moses
Playing Ring Around the Roses
And I'll lick the man who says it isn't so - They Might Be Giants: "Reprehensible" is about a man who is visited in his dreams by reminders of "10,000 years of unerasable acts / and permanent facts".
- The events of the Magic: The Gathering Return to Ravnica block take place around the Decamillennial (i.e. 10,000 year anniversary) celebration of the signing of the Guildpact - the event that began the period of relative stability in Ravnica's history.
- Mindjammer takes place 10,000 years after Old Earth started sending out Sleeper Starships to colonize distant stars. And two centuries after Earth discovered 2-space drive and began recontacting those colonies.
- The more recent catastrophic events in Warhammer 40,000 happened around the thirtieth millennium, 10,000 years earlier (the Fall of the Eldar and the rise of Chaos). The people who were alive back then (Asdrubael Vect, Ezekyle Abaddon) are noted to be among the most dangerous people in the galaxy.
- In Chrono Cross, you learn at Chronopolis that the El Nido triangle was created out of open sea by researchers 10,000 years ago.
- Knights of the Old Republic: You encounter a droid on Dantooine that claims to be the remnant of an ancient empire. When you ask how long it's been there, its answer indicates at least 20,000 years, long before the Republic came into existence... Except, as established in the original Star Wars, the Republic was founded over twenty-one millennia before the time of Knights of the Old Republic. Somebody's mind slipped here, whether in-universe or out.
- The Legend of Zelda: Breath of the Wild: Calamity Ganon was sealed away for 10,000 years by a previous Link and Zelda.
- Mass Effect 2: The Gunnery Sargent who dubs Sir Isaac Newton "The Deadliest Son Of A Bitch in Space", while driving home how shots fired keep going notes how a wild shot could go into deep space and hit something ten thousand years later.
- Vanguard Princess: Lilith's victory quote is "You're ten thousand Years Too Early!"
- Warcraft: The first time the demonic Burning Legion invaded Azeroth was ten thousand years ago, during the War of the Ancients. This also became an important date for many related characters, including the entire night elven race (who were immortal and have been alive since then). Illidan Stormrage's time spent since the War of the Ancients was a little bit different and defines his character, as he had been imprisoned in a lightless prison since then. He tells us this himself during the cinematic:
Imprisoned for ten thousand years. Banished from my own homeland.  You are not prepared.
- Orion's Arm currently covers up to 10,600 years of the future.
- xkcd: After Cueball issues a call for the sheeple to "wake up", his wish is granted literally in the form of sheep-headed men erupting from the ground:
- Avatar: The Last Airbender
- The number 10,000 is used in many different contexts as a stand-in for the infinite. For example, Wan Shi Tong, the guardian of the Spirit Library, describes himself as "he who knows ten thousand things" (which is, in fact, the translation of his name).
- In the sequel series, The Legend of Korra, Harmonic Convergence is an event that occurs once every 10,000 years. During this the spirit of light Raava and the spirit of darkness Vaatu battle to decide whether the next 10,000 years will be those of light or those of darkness. Vaatu also claims Harmonic Convergence is something they've expected at least 10,000 times.
- In The New Scooby-Doo Movies episode with Jeannie and Babu, the evil djinn had Jeannie trapped behind a glass wall. She told her friends that he intended to keep her there for 10,000 years.
- Many East Asian languages use the phrase "ten thousand years" to wish another person or thing a long life (the English version is "Long live..."). The Japanese version of this is "Banzai!".
- Ten-thousand years ago in Earth history was referred to as the Neolithic or "New Stone Age", which lasted from approximately 10,000 BC to between 4,500 and 2,000 BC. Some of the most notable advancements in human civilization of the time were the development of agriculture, the domestication of animals and livestock, the construction of permanent buildings and settlements, and the making of pottery.


Alita: Battle Angel
The movie has a February 14, 2019 release date directed by Robert Rodriguez, produced by James Cameron, starring Rosa Salazar as Alita, Eiza González as Nyssiana, Michelle Rodriguez as Gelda, Jennifer Connelly as Chiren, with Christoph Waltz as Dr. Dyson Ido, Jeff Fahey as McTeague, Ed Skrein as Zapan, Mahershala Ali as Vector, Casper Van Dien as Amok, Lana Condor as Koyomi and Jackie Earle Haley.


Blackjack Game Class¶
The game offers a large number of decisions to a player. This is different from Roulette, where the player’s choices are limited to a list of bets to place.
In Blackjack Game Analysis we’ll look at the game and how the state of play is going to be managed.
In Blackjack Collaboration we’ll look at the various player interactions. In Insurance Collaboration we’ll look at the insurance bet. In Filling the Hands we’ll look at the hit vs. stand decision. There are some additional decisions – like splitting – which require more interaction. We’ll look at this in Hand-Specific Decisions.
We’d like to segregate dealer rules from the rest of the game. This allows us to alter how a dealer fills their hand without breaking anything else. We’ll look at this in Dealer Rules.
This will require a stub class for a Blackjack Player. We’ll look at this design in BlackjackPlayer Class.
We’ll tweak the design for Card
in order to determine
if insurance should be offered. This covered in Card Rework.
We’ll also revisit the fundamental relationship between Game, Hand and Player. We’ll invert our viewpoint from the Player containing a number of Hands to the Hands sharing a common Player. This is the subject of Hand Rework.
We’ll provide the design for the game in BlackjackGame Class. In Blackjack Game Deliverables we’ll enumerate all of the deliverables.
Blackjack Game Analysis¶
The sequence of operations in the game of Blackjack is quite complex. We can describe the game in either of two modes: as a sequential procedure or as a series of state changes.
A sequential description means that the state is identified by the step that is next in the sequence.
The state change description involves a stream of events that change the sateof the game. We used this type of approach to describe Craps, see Craps Game Overview.
Additionally, we need to look at the various collaborations of the Game. We also need to address the question of handling the dealer’s rules.
Maintaining State. The sequential description of state, where the current state is defined by the step that is next, is the default description of state in many programming languages. While it seems obvious beyond repeating, it is important to note that each statement in a method changes the state of the application; either by changing state of the object that contains the method, or invoking methods of other, collaborating objects. In the case of an active class, this description of state as next statement is adequate. In the case of a passive class, this description of state doesn’t work out well because passive classes have their state changed by collaborating objects. For passive objects, instance variables and state objects are a useful way to track state changes.
In the case of Roulette, the cycle of betting and the game procedure were a simple sequence of actions. In the case of Craps, however, the game was only loosely tied to each the cycle of betting and throwing the dice. For Craps, the game state a passive part of the cycle of play. In the case of Blackjack, the cycle of betting and game procedure seem more like Roulette.
Most of a game of Blackjack is sequential in nature: the initial
offers of even money, insurance and splitting the hands are optional
steps that happen in a defined order. When filling the player’s Hand
instances,
there are some minor sub-states and state changes. When all
of the player’s Hand
instances are bust or standing pat, the dealer
fills their hand. Finally, the hands are resolved with no more player
intervention. There is a sequence to these steps that doesn’t seem
to benefit from the :strong:State design pattern.
Most of the game appears to be a sequence of offers from the
Game
instance to the BlackjackPlayer
instance; these are offers
to place bets, or accept cards, or a combination of the two, for each of
the player’s Hand
instances.
Blackjack Collaboration¶
In Craps and Roulette, the Player
object was the primary
collaborator with the game. In Blackjack, however, focus shifts from the Player
intance
to the individual Hand
objects. This changes the responsibilities of a BlackjackPlayer
:
the Hand
object can delegate certain offers to the BlackjackPlayer
instance
for a response. The BlackjackPlayer
object become a plug-in
strategy to the Hand
instances, providing responses to offers of
insurance, even money, splitting, doubling-down, hitting and standing
pat. The BlackjackPlayer
object’s response will change the states
of the the various Hand
instances in play. Some state changes involve getting a card,
and others involve placing a bet, and some involve a combination of the two.
Most of the time, there is a one-to-one relationship between the BlackjackPlayer
instance
and the Hand
instance in play. This changes where there is a split
and multiple Hand
instances are shared by a single BlackjackPlayer
instance.
We’ll use the procedure definition in A Walkthrough.
Following this procedure, we see the following methods that a Hand
object
and a BlackjackPlayer
object will need to respond to. These are the various
offers from the BlackjackGame
class. The first portion of the
game involves the BlackjackPlayer
object responding, the second portion
invovles one or more Hand
instances responding.
The collaboration is so intensive, it seems helpful to depict it in a swimlane table.
This table shows the operations each object must perform.
This will allow us to expand on the responsibiltiies of the Hand
and BlackjackTable
clases as well as define the interface for BlackjackPlayer
class.
BlackjackGame class |
Hand class |
BlackjackPlayer class |
BlackjackTable class |
|---|---|---|---|
calls BlackjackPlayer placeBet |
creates empty Hand, creates initial Ante Bet |
accepts the ante bet, associates with the Hand |
|
gets the initial Hand; deal 2 cards to Hand |
add cards |
returns the initial Hand |
|
deal 2 cards to dealer’s Hand |
add cards |
||
gets up card from dealer’s Hand; if this card requires insurance, do the insurance procedure |
return up card |
||
iterate through all Hand instances; is the given Hand splittable? |
return true if two cards of the same rank |
returns a list iterator |
|
if the Hand is splittable, offer a split bet |
get the BlackjackPlayer response; return it to the game |
to split: create a split bet, and an empty Hand; return the new Hand |
accept the split bet for the new Hand |
if splitting, move card and deal cards; continue looking for split offers |
take a card out; add a card |
||
iterate through all Hand; if the Hand is less than 21, do the fill-hand procedure |
returns a list iterator |
||
while the dealer’s point value is 16 or less, deal another card |
return point value of the Hand; add a card |
||
if the dealer busts, iterate through all Hand instances resolving the ante as a winner |
return point value of the Hand |
returns a list iterator |
resolve bet as winner and remove |
if the dealer does not bust, iterate through all Hand instances comparing against the dealer’s points, determining win, loss or push |
return point value of the hand |
returns a list iterator |
resolve bet and remove |
There are a few common variation in this procedure for play. We’ll set them aside for now, but will visit them in Variant Game Rules.
Insurance Collaboration¶
The insurance procedure involves additional interaction between Game
and the the Player
’s initial Hand
. The
following is done only if the dealer is showing an ace.
BlackjackGame class |
Hand class |
BlackjackPlayer class |
BlackjackTable class |
|---|---|---|---|
if BlackjackPlayer Hand imstamce is blackjack: offer even money |
return true if 2 cards, soft 21 |
to accept, return true |
|
if BlackjackPlayer accepted even money offer: change bet, resolve; end of game |
update bet; resolve and remove bet |
||
offer insurance |
to accept, create new bet; return true |
accept insurance bet |
|
if BlackjackPlayer accepted insurance offer: check dealer’s hand; if blackjack, insurance wins, ante loses, game over; otherwise insurance loses |
return point value |
resolve and remove bet |
Filling the Hands¶
The procedure for filling each Hand
involves additional
interaction between Game
and the the Player
’s initial
Hand
. An Iterator
used for perform the
following procedure for each individual player Hand
.
BlackjackGame class |
Hand class |
BlackjackPlayer class |
BlackjackTable class |
|---|---|---|---|
if BlackjackPlayer’s Hand instance is blackjack: resolve ante bet |
return true if 2 cards, soft 21 |
resolve and remove bet |
|
while points less than 21, offer play options of double or hit; rejecting both offers is a stand. |
return point value; pass offers to player |
to double, increase the bet for this hand and return true; to hit, return true |
update bet |
if over 21, the hand is a bust |
return point value |
resolve the ante as a loss |
There is some variation in this procedure for filling Hand
instances.
The most common variation only allows a double-down when the Hand
has two cards.
Hand-Specific Decisions¶
Some of the offers are directly to the BlackjackPlayer
instance,
while others require informing the BlackjackPlayer
object which of the
player’s Hand
instances is being referenced.
How do we identify a specific hand?
One choice is to have the
BlackjackGame
object make the offer to theHand
object. TheHand
instance can pass the offer to theBlackjackPlayer
object; theHand
includes a reference to itself.An alternative is to have the
BlackjackGame
object make the offer directly to theBlackjackPlayer
object, including a reference to the relevantHand
instance.
While the difference is
minor, it seems slightly more sensible for the BlackjackGame
object
to make offers directly to the BlackjackPlayer
object, including
a reference to the relevant Hand
instance.
Dealer Rules¶
In a sense, the dealer can be viewed as a special player. They have a fixed set of rules for hitting and standing. They are not actually offered an insurance bet, nor can they split or double down.
However, the dealer does participate in the hand-filling phase of the game, deciding to hit or stand pat.
The dealer’s rules are quite simple. Should the Dealer be a
special subclass of the BlackjackPlayer
class; one that implements
only the dealer’s rules?
Or, should the Dealer be a feature of the :class:BlackjackGame` class? In this case, the Game would maintain the dealer’s Hand and execute the card-filling algorithm.
Using an subclass of the BlackjackPlayer
class is an example
of Very Large Hammer design pattern. We only want a few
features of the BlackjackPlayer
class, why drive a small nail
with a huge hammer?
Refactoring.
To avoid over-engineering these classes, we could refactor the BlackjackPlayer
class into
two components. One component is an object that handles hand-filling, and the other component
is an object that handles betting strategies.
The dealer would only use the hand-filling component of a player.
Mutability. We can look at features that are likely to change. The dealer hand-filling rules seem well-established throughout the industry.
Further, a change to the hand-filling rules of the dealer would change the nature of the game enough that we would be hard-pressed to call in Blackjack. A different hand-filling rule would constitute a new kind of game.
We’re confident, then, that the dealer’s hand can be a feature of the
BlackjackGame
class.
BlackjackPlayer Class¶
-
class
BlackjackPlayer
¶ The
BlackjackPlayer
class is a subclass ofPlayer
that responds to the various queries and interactions with the game of Blackjack.
Fields¶
Constructors¶
-
BlackjackPlayer.
__init__
(self, table: Table) → None¶ - Parameters
table (
BlackjackTable
) – The table on which bets are placed
Uses the superclass to construct a basic
Player
. Uses thenewGame()
to create an empty List fot the hands.
Methods¶
-
BlackjackPlayer.
placeBets
(self) → None¶ Creates an empty
Hand
and adds it to the List ofHand
instances.Creates a new ante Bet. Updates the
Table
with thisBet
on the initialHand
.
-
BlackjackPlayer.
getFirstHand
(self) → None¶ Returns the initial
Hand
. This is used by the pre-split parts of the Blackjack game, where the player only has a singleHand
.
-
BlackjackPlayer.
__iter__
(self) → Iterator[Hand]¶ Returns an iterator over the List of
Hand
instances this player is currently holding.
-
BlackjackPlayer.
evenMoney
(self, hand: Hand) → bool¶ - Parameters
hand (
Hand
) – the hand which is offered even money
Returns
True
if this Player accepts the even money offer. The superclass always rejects this offer.
-
BlackjackPlayer.
insurance
(self, hand: Hand) → bool¶ - Parameters
hand (
Hand
) – the hand which is offered insurance
Returns
True
if this Player accepts the insurance offer. In addition to returning true, the Player must also create the InsuranceBet
and place it on theBlackjackTable
. The superclass always rejects this offer.
-
BlackjackPlayer.
split
(self, hand: Hand) → Hand¶ - Parameters
hand (
Hand
) – the hand which is offered an opportunity to split
If the hand has two cards of the same rank, it can be split. Different players will have different rules for determine if the hand should be split ot not.
If the player’s rules determine that it wil accepting the split offer for the given
Hand
,hand
, then the player willCreate a new Ante bet for this hand.
Create a new one-card
Hand
from the givenhand
and return that new hand.
If the player’s rules determine that it will not accept the split offer, then
None
is returned.If the hand is split, adding cards to each of the resulting hands is the responsibility of the Game. Each hand will be played out independently.
-
BlackjackPlayer.
doubleDown
(self, hand: Hand) → bool¶ - Parameters
hand (
Hand
) – the hand which is offered an opportunity to double down
Returns
True
if this Player accepts the double offer for thisHand
. The Player must also update theBet
associated with thisHand
. This superclass always rejects this offer.
-
BlackjackPlayer.
hit
(self, hand) → bool¶ - Parameters
hand (
Hand
) – the hand which is offered an opportunity to hit
Returns
True
if this Player accepts the hit offer for thisHand
. The superclass accepts this offer if the hand is 16 or less, and rejects this offer if the hand is 17 more more. This mimics the dealer’s rules.Failing to hit and failing to double down means the player is standing pat.
-
BlackjackPlayer.
__str__
(self) → str¶ Displays the current state of the player, and the various hands.
Card Rework¶
The Card
class must provide the :class:BlackjackGame` class some information required to
offer insurance bets.
We’ll need to add an offerInsurance()
method on the Card
class.
The Card
superclass must respond with False
. This means that
the FaceCard
subclass can inherit this and also respond with False
.
The AceCard
subclass, however, must respond with True
to
this method.
Hand Rework¶
The Hand
class should retain some additional hand-specific information.
Since some games allow resplitting of split hands, it’s helpful to
record whether or not a player has declined or accepted the offer of a split.
Fields¶
-
Hand.
player
¶ Holds a reference to the
Player
who owns this hand. Each of the various offers from theGame
are delegated to thePlayer
.
-
Hand.
splitDeclined
¶ Set to
True
if split was declined for a splittable hand. Also set toTrue
if the hand is not splittable. The split procedure will be done when all hands returnTrue
for split declined.
BlackjackGame Class¶
-
class
BlackjackGame
¶ BlackjackGame
is a subclass ofGame
that manages the sequence of actions that define the game of Blackjack.Note that a single cycle of play is one complete Blackjack game from the initial ante to the final resolution of all bets. Shuffling is implied before the first game and performed as needed.
Fields¶
Constructors¶
-
BlackjackGame.
__init__
(self, shoe: Shoe, table: BlackjackTable) → None¶ - Parameters
shoe (
Shoe
) – The dealer’s shoe, populated with the proper number of deckstable (
BlackjackTable
) – The table on which bets are placed
Constructs a new
BlackjackGame
, using a givenShoe
for dealingCard
instances and aBlackjackTable
for recordingBet
instances that are associated with specificHand
instances.
Methods¶
-
BlackjackGame.
cycle
(self) → None¶ A single game of Blackjack. This steps through the following sequence of operations.
Call
BlackjackPlayer.newGame()
to reset the player. CallBlackjackPlayer.getFirstHand()
to get the initial, emptyHand
. CallHand.add()
to deal two cards into the player’s initial hand.Reset the dealer’s hand and deal two cards.
Call
BlackjackGame.hand.getUpCard()
to get the dealer’s up card. If this card returnsTrue
for theCard.offerInsurance()
, then use theinsurance()
method.Only an instance fo the subclass
AceCard
will return true forofferInstance()
. All otherCard
classes will return false.Iterate through all
Hand
instances, assuring that no hand it splittable, or split has been declined for all hands. If a hand is splittable and split has not previously been declined, call theHand
’ssplit()
method.If the
split()
method returns a new hand, deal an additional Card to the original hand and the new split hand.Iterate through all
Hand
instances calling thefillHand()
method to check for blackjack, deal cards and check for a bust. This loop will finish with the hand either busted or standing pat.While the dealer’s hand value is 16 or less, deal another card. This loop will finish with the dealer either busted or standing pat.
If the dealer’s hand value is bust, resolve all ante bets as winners. The
OutcomeAnte
should be able to do this evaluation for a givenHand
compared against the dealer’s bust.Iterate through all hands with unresolved bets, and compare the hand total against the dealer’s total. The
OutcomeAnte
should be able to handle comparing the player’s hand and dealer’s total to determine the correct odds.
Note that there can be some variations to the steps in this cycle. A single, very long method body is a bad design. One of the key places where new functionality can be inserted is the final step determining of winning hands after the player and dealer’s hands have been filled and neither player has gone bust.
-
BlackjackGame.
insurance
(self) → None¶ Offers even money or insurance for a single game of blackjack. This steps through the following sequence of operations.
Get the player’s
BlackjackPlayer.getFirstHand()
. Is it blackjack?If the player holds blackjack, then call
BlackjackPlayer.evenMoney()
.If the even money offer is accepted, then move the ante bet to even money at 1:1. Resolve the bet as a winner. The bet will be removed, and the game will be over.
Call
BlackjackPlayer.insurance()
. If insurance declined, this method is done.If insurance was accepted by the player, then check the dealer’s hand. Is it blackjack?
If the dealer hold blackjack, the insurance bet is resolved as a winner, and the ante is a loser; the bets are removed and the game will be over.
If the dealer does not have blackjack, the insurance bet is resolved as a loser, and the ante remains.
If insurance was declined by the player, nothing is done.
-
BlackjackGame.
fillHand
(self, hand: Hand) → None¶ - Parameters
hand (Hand) – the hand which is being filled
Fills one of the player’s hands in a single game of Blackjack. This steps through the following sequence of operations.
While points are less than 21, call
BlackjackPlayer.doubleDown()
to offer doubling down. If accepted, deal one card, filling is done.If double down is declined, call
BlackjackPlayer.hit()
to offer a hit. If accepted, deal one card. If both double down and hit are declined, filling is done, the player is standing pat.If the points are over 21, the hand is bust, and is immediately resolved as a loser. The game is over.
-
BlackjackGame.
__str__
(self) → str¶ Displays the current state of the game, including the player, and the various hands.
Blackjack Game Deliverables¶
There are eight deliverables for this exercise.
The stub
BlackjackPlayer
class.A class which performs a unit test of the
BlackjackPlayer
class. Since this player will mimic the dealer, hitting a 16 and standing on a 17, the unit test can provide a variety ofHand
s and confirm which offers are accepted and rejected.The revised
Hand
class.A class which performs a unit tests of the
Hand
class. The unit test should create several instances ofCard
,FaceCard
andAceCard
, and add these to instances ofHand
, to create various point totals. Since this version ofHand
interacts with aBlackjackPlayer
, additional offers of split, double, and hit can be made to theHand
.The revised
Card
class.Revised unit tests to exercise the
Card.offerInsurance()
method.The revised
BlackjackGame
class.A class which performs a unit tests of the
BlackjackGame
class. The unit test will have to create aShoe
instance that produces cards in a known sequence, as well asBlackjackPlayer
. Thecycle()
method, as described in the design, is too complex for unit testing, and needs to be decomposed into a number of simpler procedures.
Looking Forward¶
We have all of the components in place to start looking at player strategies. The player has a number of decisions during the game, plus a betting strategy decision based on the outcome of each game. We’ll set the betting aside for a moment and focus on the Blackjack rules. In the next chapter, we’ll build a simple player that is able to work with the game and table.


[§501-243] Dual recording involving leasehold time share interests. Nothing in this part shall prevent or prohibit the registration of an instrument which assigns or affects both:
(1) One or more leasehold time share interests; and
(2) One or more interests in registered land other than a leasehold time share interest. [L 1998, c 219, pt of §1]


Welcome to ExpeditioNA!
With ExpeditioNA, planning your road trip will be easier than ever. Try our Route Planner, where you are able to map out a route to your destination. There is also our Travel Stops service, which allows you to find a multitude of different amenities relative to your location. Finally, there's the Itinerary feature, where you can list all the places you want to visit on your road trip.
Let's Go!


Alice`s adventures in wonderland
By Levis Carroll
The millennium fulcrum edition 3.0
H2O
Contents
- LinkDown the Rabbit-Hole
- The Pool of Tears
- A Caucus-Race and a Long Tale
- The Rabbit Sends in a Litle Bill
- Advice from a Caterpillar
- Pig and Pepper
- A Mad Tea-Party
- The Queen`s Croquet-Ground
- The Mock Turtle`s Story
- The Lobster Quadrille
- Who Stole the Tarts?
- Alice`s Evidence


This sample shows how you can inject a file into the publish process by specifying it as a publish profile file.


We make websites, applications, strategies, that help people solve problems.
We collaborate because no matter how talented he or she may be, no single individual will ever build something cooler than a great team.
We celebrate the idea of unexpected design insights that within constraints.
We are a connected company.
A connected what now?
Seven Heads Design is a distributed network of independent friends. We live all over the world, so we are used to working remotely but love getting together whenever work and play permit. Seven Heads is a connected company, which is to say a company based on the crazy idea that when brilliant people have autonomy they crank out their best work, but when those same people collaborate in teams they truly innovate. We are an organic network, forming, growing, and dissipating as needed.


The FluentConfigurator uses a the Fluent Interface style as described by Martin Fowler.
To wire up the configuration programmatically rather than having to use dwr.xml
, you'll need to:
org.directwebremoting.fluent.FluentConfigurator
which implements the configure()
method.customConfigurator
' to the DWR servlet in web.xml
to point at your new class.The implementation of configure()
will look something like this:
public void configure() { withConverterType("dog", "com.yourcompany.beans.Dog"); withCreatorType("ejb", "com.yourcompany.dwr.creator.EJBCreator"); withCreator("new", "ApartmentDAO") .addParam("scope", session) .addParam("class", "com.yourcompany.dao.ApartmentDAO") .exclude("saveApartment") .withAuth("method", "role"); withCreator("struts", "DogDAO") .addParam("clas", "com.yourcompany.dao.DogDAO") .include("getDog") .include("getColor"); withConverter("dog", "*.Dog") .addParam("name", "value"); withSignature() .addLine("import java.util.List;") .addLine("import com.example.Check;") .addLine("Check.setLotteryResults(List<Integer> nos);"); }
Please see the dwr.xml configuration page for more information on how to configure creators and converters.
For more information see the JavaDoc for FluentConfigurator
DWR's fluent configurator was originally contributed by Aaron Johnson and is part of the dwr-noncla.jar.


What to Do
Validate all input before it is passed to the database.
Why
Unvalidated input can lead to persistent cross-site scripting, SQL injection, and other vulnerabilities which would allow an attacker to gain unauthorized access to sensitive data.
When
If your application uses a backend database server.
How
To properly validate input passed to database:
- Identify application inputs. Potential sources of input include:
- URL based parameters
- Form based parameters
- Hidden fields
- Cookies
- Local filesystem
- JavaScript variables
- Identify database entry points. Find all the locations in the system where data is pushed into the database, either directly via queries, or indirectly (via log entries, etc). Trace all database entry points to find all the paths which can contain external input.
- Create a set of validators. Build a set of validators that work with the data in question and fit into the system architecture, including your general validation scheme for other data and the way the system interacts with the database. Centralize the validators as it helps strengthen your code by limiting the amount of scattered validation code throughout the system, and allows for easy auditing. Place the validators along the database input paths, ideally as close to the initial data input as possible. All data should pass through the validators before being transmitted to the database servers.
- Use Type-Safe parameters in SQL statements. Stored procedures and Parameterized queries improve your application's robustness against SQL injection based attacks.
- Audit your entry paths. Before going into production, have a reviewer who was not responsible for the development of the code in question check all the input paths to ensure that the validators are correctly implemented, that they are correctly applied, and that all input paths are checked.


Below you'll find popular objects you've visited while surfing the web.
You'll also find other domains/articles related to your surf habits.
Write something general about recommending and
Semantic Technologies here. Would be nice!


Placeholder 1
View
Search
Placeholder 2
Log in
Forgot Password?
Invalid username or password
Enter your login details
Keep me signed in
Sign In


gamejs/thread
gamejs.worker makes it more convinient to work with W3C WebWorkers by providing a way to run
CommonJs modules inside of them. GameJs also provides the typically gamejs.ready()
and
event loop to facilitate communication between workers and the main application.
See the examples/workers
directory for a running example.
Create a worker with the main module "foo-worker" (see below for how the worker's module looks like):
var fooWorker = new Worker('./foo-worker');
// Send a message to your worker.
// The Message doesn't have to be a string but it
// must be `JSON.stringify()`-able
fooWorker.post("foobar");
You can also recieve messages from the worker:
// recieve events from the worker
fooWorker.onEvent(function(event) {
if(event.timestamp > ...)
});
And this is how the above referenced "foo-worker" module would looke like. As usual, we need a
gamejs.ready()
to get started and within that we bind an event handler:
var gamejs = require('gamejs');
gamejs.ready(function() {
gamejs.event.onEvent(function(event) {
var plaintext = fastCrack(event.password)
....
});
});
Our event worker could do expensive calculations (seperate and not blocking the main game) when
recieving an event. Once the result is caculated, it can be sent back to the main application
with gamejs.thread.post()
:
gamejs.thread.post({
info: "important message from worker",
timestamp:<PHONE_NUMBER>4
});
The main application would in turn recieve an event posted like this from fooWorker.onEvent
, as seen above.
This module is useful for expensive algorithms where the result does not have to available instantiously
(e.g., path-finding) or for continous logic which can be
calculated seperately from the rendering loop, and which only needs to feed back into the model of the rendering every
now and then (e.g. physics) The main draw back of the Worker
model is that
you can only communicate with them via text messages (typically JSON.stringify()ed messages).
Worker (moduleId)
The Worker
constructor takes only one argument: a module id. This module
will be executed inside the newly created Worker. It is effectively the
main module of the Worker.
Inside a Worker, you can use require()
to import other scripts or
GameJs modules.
Note: A Worker does not have access to the browser's document
. So
a lot of GameJs modules - everything related to drawing to the canvas -
do not work in the Worker.
You can use gamejs.time.*
, gamejs.utils.*
, gamejs.event.*
and probably others
(as well as any module you write yourself for this purpose, of course).
Parameters
| String | moduleId | The Worker's main module id. The main module will be executed in the worker |
Worker.prototype.post (data)
Send a message to the worker
Parameters
| Object | data | Payload object which gets sent to the Worker |
_EVENTS
ignore
inWorker
true if this GameJs instance is being executed within a WebWorker
post (data)
Send an event back to the main script.
Parameters
| Object | data | to be sent back to main script |


{{if oas}} {{each oas}}
| Enclosure | ${oa.enclosure_info.enclosureName} |
| Rack | ${oa.enclosure_info.rackName} |
| Power Supplies | ${oa.enclosure_info.powerSuppliesPresent} of ${oa.enclosure_info.powerSupplyBays} |
| Fans | ${oa.enclosure_info.fansPresent} of ${oa.enclosure_info.fanBays} |
| Power Consumed | ${oa.power.powerConsumed} W |


Selenium is a powerful open-source framework for automated web testing. From 2.x, it offers two APIs: the Selenium API (backwards compatible with Selenium 1.x) and the new WebDriver API. Both APIs are available from the same 2.x dependencies, so JBehave Web Selenium module supports both. When we talk about Selenium, we usually intend the framework, while if we need to distinguish between the APIs we'll specifically refer to the Selenium API and WebDriver API.
Let's see how we can easily use Selenium to run web-based stories. The objective in creating a DSL is to represent the business-domain functionality whilst abstracting away the details of the implementation, in this case the access to the web layer via a specific testing tool, such as Selenium. The same DSL should be re-usable with different testing tools.
As usual, examples speak louder than words:
Scenario: User searches for a single step Given user is on Home page When user opens Find Steps page Then Find Steps page is shown When user searches for "Given a threshold of 10.0" Then search returns: "Given a threshold of $threshold" When user views with methods Then search returns: "Given a threshold of $threshold, [org.jbehave.web.examples.trader.steps.TraderSteps.aThreshold(double)]" And steps instances include: "TraderSteps,StockExchangeSteps"
The TraderWebSteps class is just like any other JBehave steps class:
The new element here is that we are using Page Objects to abstract the Selenium behaviour behind pages that specify the user interaction in more meaningful ways. The page objects is where the Selenium magic happens. Note that the use of pages have so far enabled us not to commit to a specific API, either Selenium API or WebDriver API.
As always, we configure JBehave to several different ways. One is to have an embeddable runnable class, e.g.the JUnit-runnable TraderWebStories. This is where the choice of API comes into play.
The @BeforeStories and @AfterStories annotations in the PerStoriesSeleniumSteps methods allow to start and stop the selenium server before and after stories are run. Users can of course override the default behaviour, but generally don't need to bother for most use cases. There are also a PerStory and PerScenario implementation.
The @BeforeStories and @AfterStories annotations in the PerStoriesWebDriverSteps methods allow to start and stop the WebDriver before and after stories are run. Users can of course override the default behaviour, but generally don't need to bother for most use cases. There are also a PerStory and PerScenario implementation.
NOTE: To get the Selenium based tests running in an automated way, you need to run both a webapp server, e.g. Jetty, and the Selenium server (only for the Selenium API, as the WebDriver API does not need it). See the trader runner selenium example and trader runner webdriver example for a way to do this using Maven.


Anthony Joshua Speaks On Andy Ruiz Jnr. Beating Him Again
by Faderera FaladeAnthony Joshua has said the first defeat he faced with Andy Ruiz Jr. was because he lacked experience, adding that he had become a “smarter” fighter ahead of December’s rematch.
Recall Mexican-American Ruiz had defeated Joshua, the previously undefeated world heavyweight champion with a seventh-round stoppage at New York’s Madison Square Garden in June.
“It wasn’t burnout. The issues I faced in the last camp, it’s just down to lack of experience. Even though it was at a high level, we were still finding experience. Andy Ruiz is good but I don’t think he should beat me twice.
I used to hear guys say you have to take a loss and I would think ‘why’? Now I can understand it and know what it takes. I have more understanding now and my ears are open to new information so that’s making me smarter as a fighter,” Joshua said while speaking with newsmen in a new interview.
The WBA, IBF and WBO heavyweight title rematch dubbed the ‘Clash on the Dunes’, is set to take place in Saudi Arabia on December 7 after former Olympic Champion Joshua triggered a rematch clause.
“The blessing is I have a second chance and here we are,” the 30-year-old said.


Charlie K.Charlie started his career when he began working for Verdeeco, a smart-grid data analytics startup company. As the company expanded, Charlie transitioned from a software developer to development operations. He currently is a coordinator between the devops and development teams. |
Dawit A.As an IT and customer service representative at the CATLab of Georgia State University, Dawit spends his time maintaining and overlooking the handling of technical equipment reserved in the CATLab. Due to his time at the university, his communicating, team building, and social skills have strengthened. |
Juwan S.As a student at Georgia State University, Juwan is a junior computer science major. Being skilled in Java and knowing relevant knowledge in front-end development, relevant courses that he has taken to strengthen is skills include Data Structures and Systems Programming. |
Jiawei S.Jiawei is a graduate student of Georgia State University whom majored in Computer Science. Currently a research assistant, focusing on modeling and simulation, he is knowledgeable in Java, C and some front-end languages. Relevant coursework he has studied includes Automata, and Modeling and Stimulation Theory and Application. |
Ashanti R.Ashanti is a senior computer science major at Georgia State. As a designer, she is experienced in front-end development and design as well as having some experience with Java. Studying to become an UI/UX designer, relevant coursework that she has taken includes Data Mining and Digital Image Processing.. |


| Monday (9/30) | Tuesday (10/1) | Wednesday (10/2) | Thursday (10/3) | Friday (10/4) |
|---|---|---|---|---|
| SCAM | ICSME | |||
| VISSOFT | ||||
| Doctoral |
2019-09-19 |
2019-07-25 |
2019-07-18 |
2019-07-17 |
2019-07-13 |
2019-06-11 |
2019-05-25 |
The International Conference on Software Maintenance and Evolution (ICSME) is the premier international forum for researchers and practitioners from academia, industry, and government to present, discuss, and debate the most recent ideas, experiences, and challenges in software maintenance and evolution.
Cleveland is located in northeast Ohio on the shores of Lake Erie. The greater Cleveland Akron metropolitan area has a population of over 2 million and Cleveland proper has a population of approximately 400 thousand. Historically it has been a strong manufacturing center and currently is host to a number of different industries that rely on software. The greater Cleveland area is also home to many major universities and the NASA Glen research center.
Cleveland has an important musical history and a top rated orchestra. This is why we have chosen the Rock & Roll Hall of Fame as a venue to host one of our social gatherings. While visiting, attendees may take the opportunity to both dine and explore the largest collection of Rock memorabilia in the world. Keeping with the musical theme, our other social event will offer live music and dinner at the House of Blues.


Poxy (http://poxy.ws) is a web application that captures web requests to let you do fun stuff with them.
Fun things like proxying, forwarding, emailing and some sort of processing (soon!).
In order to use it first you'll need to create an account into the site.
Add this line to your application's Gemfile:
gem 'poxy_client'
And then execute:
$ bundle
$ gem install poxy_client
There are a few different ways to use the client.
The distribution includes an executable file that you can use. It requires a .config file.
Or, you can implement your own client suited to your particular needs. Take a look at the executable file, or check the code documentation.
Courtesy of the great service Apiary.io, here it is: (http://docs.poxy.apiary.io/)
In the /lib folder of the distribution, there's a file named {file:bin/poxyd.rb poxyd.rb} which you can run from the commandline.
It requires a mandatory config file (included in the distribution you'll find a sample one, here {file:poxy.conf ./poxy.conf}).
You can use that as a start (it points to a test endpoint in the poxy api).
Optionally, you can pass a -d parameter, and the executable will run as a daemon.
Sample run:
$ ruby poxyd.rb -c poxy.conf -d
Being poxy.conf a config file with your own API and Bucket keys.
The code for {PoxyClient poxy_client} it's pretty straightforward.
The {PoxyClient.perform perform} method encapsulates the 3 important operations the client does.
git checkout -b my-new-feature
)git commit -am 'Added some feature'
)git push origin my-new-feature
)


|
About
Resources
Download
|
|
Lucene Sandbox
|
Lucene project also contains a workspace, Lucene Sandbox, that is open to all Lucene committers, as well
as a few other developers. The purpose of the Sandbox is to host various third party contributions,
and to serve as a place to try out new ideas and prepare them for inclusion into the core Lucene
distribution.
Users are free to experiment with the components developed in the Sandbox, but Sandbox components will
not necessarily be maintained, particularly in their current state.
You can access the Lucene Sandbox repository at
http://svn.apache.org/repos/asf/lucene/java/trunk/contrib/.
|
WordNet/Synonyms
|
The Lucene WordNet code consists of a single class which parses a prolog file
from the WordNet site that contains a list of English words and synonyms.
The class builds a Lucene index from the synonyms file. Your querying code could
hit this index to build up a set of synonyms for the terms in the
search query.
More information on the Lucene WordNet package.
WordNet is an online database of English language words that contains
synonyms, definitions, and various relationships between synonym sets.
The
repository for the WordNet module.
|
|
|
High Frequency Terms
|
The miscellaneous package is for classes that don't fit anywhere else. The only class in it right now determines
what terms occur the most inside a Lucene index. This could be useful for analyzing which terms may need to go
into a custom stop word list for better search results.
The
repository for miscellaneous classes.
|
|
|
|
|


{% extends "base.html" %} {% load static i18n %} {% block content %}
The ReproGenomics Viewer (RGV) is a multi- and cross-species genomic database for the visualization, mining and comparison of published omics data sets for the reproductive science community. It was developed to assist scientists in the mining of a wide range of ultra-high-throughput reprogenomics data, including RNA and DNA sequencing data. RGV allows hosting, visualization, and direct comparison of users’ data to published genomics studies as well as to relevant genetic variations linked to reproduction. The ReproGenomics Viewer database currently hosts several landmark datasets in the field of reproductive biology from several model organisms. Data sets have been curated, processed and conveniently organized into several categories including biological topics, technologies, species and publications. These standardized data analysis procedures within the reproductive science community greatly facilitate comparisons of data sets.
Considerable worries have recently been raised regarding the lack of reproducibility of biomedical research.
Funding agencies, such as the National Institutes of Health (NIH), share this concern and discuss ways to enhance reproducibility by notably providing greater transparency of the data.
Journals and public funding agencies have thus begun to make public availability of raw data but also analyzed data a condition of publication or funding, respectively.
In addition, we believe that it is also a matter of give and take, so to speak as making reprogenomics data available to the community:
1- it will facilitate data comparison and the development of innovative tools;
2- and, on the other hand, it will make your reprogenomics studies and publications more visible (as investigators will be able to compare their own data with yours) and it will thus boost citations of your scientific articles.
Of course it isn't! RGV neither intends to archive raw data such as GEO, nor to replace existing reprogenomics resources. Instead, it aims at complementing them by acting as a distribution hub in which scientists can actively submit and share their highthroughput data with the community.
In the near future we will extend the scope of the RGV to keep pace with rapid technological, bioinformatics/genomic and biological/clinical advances in the reproductive sciences.
In concrete terms, we are currently planning four separate actions:
1- we will gather other relevant data sets from a wide range of species in RGV to cover other reproductive biological topics. In this context, we encourage data submission from colleagues.
2- we will be adding other genetic information related to reproductive disorders (such as GWAS and Quantitative trait loci information from diverse sources and diverse model organisms).
3- we plan to develop community tools that will greatly facilitate collaborative work and stimulate the emergence of novel forms of collaboration in our research field.


Preparation time
1-2 hours
Cooking time
less than 10 mins
Serves
Serves 4
For the brill, season the brill fillets with salt and freshly ground black pepper then sprinkle the top of the fillets with the sesame seeds, pressing them firmly into the fish.
Heat a large frying pan over moderately high heat, add the oil and butter and, when the butter is foaming, put in the fish fillets, sesame seed-side down.
Fry for about five minutes, turn carefully with a fish slice and cook for a further three minutes, or until cooked through. Remove from the pan and keep warm. Garnish with the chives before serving.
For the dressing, place both of the mustards, sugar, vinegar and soy into a bowl and whisk together until the sugar has dissolved.
Gradually whisk in the oil until emulsified.
For the coleslaw, in a ceramic or stainless steel bowl, combine all of the ingredients except for the coriander and spring onions.
Allow to marinate for at least one hour (or up to 2-3 hours if you have time).
Just before serving, lightly strain the excess liquid off, and stir in the coriander and spring onions.
For the wontons, heat a deep fat fryer to 180C/350F or until a small cube of bread sizzles and turns golden when dropped into it. (CAUTION: hot oil can be dangerous. Do not leave unattended.)
Separate the wonton, or spring roll wrappers, and cut into fairly fine strips.
Fry until crisp and golden-brown.
Remove with a slotted spoon, drain on kitchen paper and season generously with salt.
To serve, place each brill fillet onto the side of a serving plate. Spoon the coleslaw alongside the brill and top with the crispy wontons. Spoon the dressing around the plate and over the fish.


When we write automated acceptance tests we often need to perform some initial tasks to prepare test data or set up the test environment. Likewise, when a test finishes, we often need to tidy up the database or put the environment into a clean state. With Serenity BDD and Cucumber, there are several ways to perform these setup and teardown tasks.
Setting up data in the Background step
For example, suppose we are writing a Todo application, and we have a scenario like the following:
Scenario Outline: Viewing the items by status
Given that Jane has a todo list containing <tasks>
And she has completed the task called 'Walk the dog'
When she filters her list to show only <filter> tasks
Then her todo list should contain <expected>
Examples:
| tasks | filter | expected |
| Buy some milk, Walk the dog | Active | Buy some milk |
| Buy some milk, Walk the dog | Completed | Walk the dog |
To perform this test, we might need Jane to have an account, and have already logged on to the application. We could use the Background
step for this, as illustrated here:
Background:
Given Jane has a Super Todo List App account
And Jane is on the application home page
Background steps are implemented just like any other Cucumber step. Using the Action Classes pattern, the step definitions might look something like this:
@Steps
AccountActions accountManager;
@Steps
LogonActions logon;
@Steps
NavigateActions navigate;
@Given("^(.*) has a Super Todo List App account$")
public void openAnAccount(String name) {
accountManager.opensAnAccountFor(name);
}
@Given("^(.*) is on the application home page$")
public void navigateToHomePageAs(String user) {
logon.as(user);
navigate.toTheHomePage();
}
Background steps are run before each scenario, including each example, so sometimes the test code might need to check whether a particular setup action has already been completed. For example, the opensAnAccountFor()
method might be able to check whether an account for Jane already exists, and if it does simply clear any relevant data for this account. Naturally this kind of logic will depend on the nature of your application.
The steps in a background section also appear in the test reports, which can be useful if the steps are relevant to understanding the scenario from a business perspective, but less so if they are simply about setting up test date. If your setup steps are more technical, or less directly relevant to the scenarios being tested, the @Before
hook might be a better choice.
Using the @Before hook
The @Before
hook marks a method that is run before each scenario.
Suppose we just need to open the application on the home page, and don’t need to set up a specific user account.
In this case, the initial step, "Given Jane is on the application home page", is not very interesting from a business perspective. We could place it inside a @Before
method as shown below:
@Steps
NavigateActions navigate;
@Before
public void openTheApplication() {
navigate.toTheHomePage();
}
@Given("^that (?:.*) has a todo list containing (.*)$")
public void has_a_list_containing(List<String> tasks) throws Exception {
tasks.forEach(
task -> todoUser.adds_a_task(task)
);
}
Ordering @Before hook methods
Sometimes you need to run @Before
methods in a specific order. For example, if you are using Screenplay, you need to set the stage with an online cast before you can do any web interactions. Cucumber allows you to define the execution order of hook methods with the order
attribute. So your code might look more like this:
@Before(order=1)
public void set_the_stage() {
OnStage.setTheStage(new OnlineCast());
}
@Before(order=2)
public void openApplication() {
OnStage.aNewActor().attemptsTo(
OpenTheTodoMVCApplication.onTheHomePage()
);
}
@Given("^that (.*) has a todo list containing (.*)$")
public void has_a_todo_list(String actorName, String itemList) {
List<String> items = split(itemList);
theActorCalled(actorName).wasAbleTo(
AddTodoItems.called(items)
);
}
Selectively running @Before hook methods
You can also use tags to define which of the @Before
hook methods you need to run for a given scenario.
For example, you might only need to create a cast of Selenium-enabled actors for web tests. One approach to this would be to add a special tag (say, @web
) to the scenarios that use web interactions, e.g.
@web
Scenario Outline: Viewing the items by status
Given that Jane has a todo list containing <tasks>
And she has completed the task called 'Walk the dog'
When she filters her list to show only <filter> tasks
Then her todo list should contain <expected>
Examples:
| tasks | filter | expected |
| Buy some milk, Walk the dog | Active | Buy some milk |
| Buy some milk, Walk the dog | Completed | Walk the dog |
Then, you can ensure that the UI-test hook methods web tests are only executed for UI-based scenarios:
@Before(value="@web", order=1)
public void set_the_stage() {
OnStage.setTheStage(new OnlineCast());
}
Tidying up with the @After hook
The Cucumber @After
hook is executed after each scenarios.
For example, the following code deletes all of the todo items created during a scenario. This allows us to keep the same browser open for the entire feature, which can improve test performance.
@After
public void tidyUp() {
theActorInTheSpotlight().attemptsTo(DeleteAll.items());
}
Note that for performance and reliability reasons, cleanup operations are generally best done via backend methods (e.g. via REST or JDBC calls) rather than through the UI.


Description
These characters represent letters. The case of letters is significant.
Example
The identifier a is different than the identifier A


--- layout: page title: Training - communicating finance permalink: /training/communicating-finance/ main_image_path: main_image_caption: aside: true _options: layout: hidden: true image: width: 1200 height: 1200 resize_style: contain mime_type: image/jpeg _comments: ---
Do you find it difficult to understand what finance people mean? Do people 'switch off' when you talk about finance?
Many NGOs claim that communication between their finance staff and non-finance staff is not effective because:
John specialises in group training, one-to-one coaching and consultancy for those who need to improve their dialogue between non-finance and finance staff, and with partners, donors and other stakeholders in a jargon free and non-technical way.
Contact John to discuss your individual needs.
Click here for details of communicating finance training in French


Emotional Intelligence is a collection of skills - the ability to be aware of your own feelings - identifying your emotions, how you think and act on those emotions. How you relate to others and social communication. There are three steps of Emotional Intelligence including;
EI is about the emotions and how you feel, thinking about those emotions and how you act consciously with those emotions. IQ is based on visual processing, working memory, fluid & quantitative reasoning.
It is important to learn the EI skills to be the best version of yourself and to operate in an optimal state. Your mind, body and soul to be in alignment, which can cultivate a clear, calm mind to deal with everyday life. To be aware of your emotions and how acting consciously through them and using them as a tool to relate to others is very helpful in difficult situations. In the workplace the three benefits that are achieved through learning EI skills are; Stellar performance, Outstanding Leadership, and Happiness. This helps and benefits yourself and everyone in the workplace environment.


--- layout: article_list ---
Seeing a bear in the wild is a special treat for any visitor to a national park. While it is an exciting moment, it is important to remember that bears in national parks are wild and can be dangerous.Running away or climbing a tree can activate the bear's hunting instincts and lead to it perceiving the human as prey. If a bear does charge, persons are advised to hold their ground, as most bear charges are bluffs. Finally, if a bear does attack, the usual advice is to curl into a fetal position so as to shield vital organs and appear non-threatening.
Be aware. Be alert while on the trail, and always be on the lookout for bears. Keep an eye out for fresh tracks, scat, other signs (torn up logs, digging, fresh claw marks on trees), and carrion (carcasses) in the area.
Every year when mid-winter arrives, snow can blanket the northern Great Plains, temperatures can drop well below zero, and the winds can howl unmercifully, and yet bison remain alive and well on the hostile landscape. Indeed, bison have evolved digestive, physiological, and behavioral strategies that allow them to survive some of the harshest weather in North America.
A pollinator is anything that helps carry pollen from the male part of the flower (stamen) to the female part of the same or another flower (stigma). The movement of pollen must occur for the the plant to become fertilized and produce fruits, seeds, and young plants. Some plants are self-pollinating, while others may be fertilized by pollen carried by wind or water. Still, other flowers are pollinated by insects and animals - such as bees, wasps, moths, butterflies, birds, flies and small mammals, including bats.


References
Class Summary
| Static Public Class Summary | ||
| public |
The FilterBuilderCtrl class provides a controller for the
|
|
| public |
The |
|
| public |
The |
|
| public |
The |
Function Summary
| Static Public Function Summary | ||
| public |
filterBuilder(): * |
Variable Summary
| Static Public Variable Summary | ||
| public |
MAP_ICONS: * |
|
| public |
MAP_SETTINGS: * |
|
| public |
campusMap: * |
|
| public |
|
|
| public |
filterInput: * |
|
| public |
templates: * |


I walked in the door at 10:00, and down the pills by 10:10. My friend advised me to take roughly 18 pills (900mg) based upon his experience, so I did so. This was not a good idea.
I started off, talking on the phone for about a half hour to forty five minutes with my girlfriend. As I began to feel the effects of it, I felt quite heavy and out of place. Thoughts were not sticking in my head and I felt very drowsy. My normal speech impediment was worsened severely.
At first, things started to take on a 3D effect and things slowly morphed and moved all around me. I decided it'd be a good idea to lay down on my bed with the black light on, and just stare at the stuff move. So, I sat around and wanted the fuzzy stuff on my blanket move quickly around in circles. That part of the experience was a lot of fun. Then somewhere in the back of my head something willed it to be a spider...and it became a spider. Soon my room was being swamped with spiders, millipedes and thousands of other gross things. One thing in particular, a millipede of some sort was on my bar, and I crushed it with a VHS tape. As the part I hit squished and started to leak out, the rest of it kept trying to pull at itself and get away. This bothered me, because when I looked back, it was completely gone.  I wasn't having very much fun, either. I felt very heavy and clumsy and unsure of my actions.
Some time went on and I started to get scared of things and the trip only got worse. I started having completely lucid hallucinations of my girlfriend and I guess that's when I started fully dreaming. The dream went on and I interacted with her and there's a whole story behind it...but I'm not getting into that. The amazing part is that when you touch them, they disappear.
Unfortunately, I was unable to control myself (first time using such a drug) and begin to become violent and upset over what I was seeing. I started to interact badly with the hallucinations (e.g. pouring soda over the hallucination of my girlfriend.)
I started dreaming she was in the car with a few of my friends and some other odd stuff. I then thought it time for the imaginary girlfriend to go home. Then I started dreaming she cheated on me, and the guy was right there with her and they were doing it in front of me. At this point I simply lost my mind and as they strolled off down my street, I went back inside to grab my knife and headed off at 2:30 in the morning after them.
I must have ran up a local street by me, looking for them about 3 times, and not finding them once.
I wouldn't suggest this drug to ANYONE who is has not had some experience tripping before. This is not a fun drug in any sense and isn't something I'd recommend.
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.


Home
All Post
Links
About
Penelitian
Ikhwan
Elyas
All Post
Links
About
Penelitian
Home
All Post
Links
About
Penelitian
A-Z Linux Command Line with Examples
07 Dec 2017 | Linux


Created: {{ task.created | date:'medium' }}
It looks as if no form has been defined for the task.
Use the form below to add variables that will be be passed onto the process instance upon task completion.


ASP.NET is the next generation of web-server applications that run under IIS (Internet Information Server) on Microsoft Windows. In order to call the Amzi! Logic Server from ASP.NET you use the Logic Server .NET Wrapper Class in amzinet.dll.
Visual Basic Pets - This sample uses the simple Pets expert system and calls amzinet.dll from an ASP.NET page.


THE ABSENT-MINDED PROFESSOR A film review by Steve Rhodes Copyright 1998 Steve Rhodes
RATING (0 TO ****): ** 1/2
As Disney's 1961 film THE ABSENT-MINDED PROFESSOR opens, the two questions are whether the professor will "solve the mysteries of the universe" and whether he will forget his wedding for the third time, the former being the more likely of the two.
Disney's recent movie called FLUBBER -- an underrated film that critics, except me, generally loathed but kids loved -- is a remake of THE ABSENT-MINDED PROFESSOR starring Fred MacMurray as Professor Ned Brainard. After seeing and liking Robin Williams in FLUBBER, our family decided to check out the original.
The original's simple humor looks remarkably tired compared with the story's energetic and much more inventive remake. Moreover, the performances in the original, except those of Fred MacMurray and Keenan Wynn, as the villain Alonzo Hawk, are wooden. The professor's intended, Nancy Olson, for example, is played lethargically by Betsy Carlisle in the original. And although MacMurray did a fine job, Williams brought much more to the role.
The professor has a very expressive dog named Charlie, who can speak volumes without a single bark just in the way he raises his ears. Then again, WEEBO, the professor's companion in the remake outclasses poor Charlie and garners an order of magnitude more laughs.
The basis of the story is that the professor invents flying rubber, which he calls "flubber." The question confronting the professor, and the script writers, is "What can you do with flubber?" In both film versions, the substance is used in a basketball game and as an alternative fuel for the professor's car. In the original the professor and Charlie go soaring into a bank of cumulus clouds, which looks especially handsome in the film's black and white cinematography.
John Hughes did the script for FLUBBER, based on the original script by Bill Walsh and the book by Samuel W. Taylor. In the remake they simply find many more imaginative and comical things to do with flubber, not the least of which is a magical, synchronized dance number. Even the parts that are the same in the two versions are so much more realistic, funny, and involving in FLUBBER. Even the simplest things are done particularly poorly in the original. The sounds effects during the big basketball game sound less like a real crowd than a swarm of droning bees.
The talky comedy has less humor than it should and relatively few sight gags, amazing given the possibilities of flying rubber. The romance and chemistry between the two leads are close to non-existent.
The visuals of the flying tin lizzie are sweet, and the ending, where they finally put the bad guy in his place, does have the imagination that the rest of the picture too often lacks. Although it is a genuinely charming comedy, THE ABSENT-MINDED PROFESSOR is that rare original movie that made me yearn for its remake.
THE ABSENT-MINDED PROFESSOR runs 1:37. It is not rated, but would be a G and is suitable for all ages.
My son Jeffrey, age 8, thoughts it was a "really good movie." He gave it ***, and said he thought it was tied with FLUBBER. He went on to comment that he liked the way that neither version was bloody.
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


|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object org.apache.tools.ant.ProjectComponent org.apache.tools.ant.Task org.apache.ws.jaxme.generator.XJCTask
public class XJCTask
An Ant task for running JaxMe, designed to be JAXB compatible.
This task supports the following attributes:
| Name | Description | Required/Default |
|---|---|---|
| schema | Name of a schema file being compiled | This or nested <schema> elements are required |
| binding | An external binding file being applied to the schema file | No |
| force | Setting this option to true forces the up-to-date check to fail. This option is mainly useful while working on the JaxMe generator. For JaxMe users, which only change schema files, this option isn't of much use. It is designed for JaxMe developers. | No, false |
| package | Specifies the generated Java sources package name. Overrides package specifications in the schema bindings, if any. | No, a package may be specified in the schema bindings. |
| target | Specifies the target directory for generated Java source files. A package structure will be created below that directory. For example, with target="src" and package="org.acme", you will have files being created in "src/org/acme". | No, defaults to the current directory |
| resourceTarget | Specifies the target directory for generated resource files. A package structure will be created below that directory. For example, with target="src" and package="org.acme", you will have files being created in "src/org/acme". | No, defaults to the "target" directory |
| readonly | Generated Java source files are in read-only mode, if true is specified | No, defaults to false |
| extension | If set to true, the XJC binding compiler will run in the extension mode. Otherwise, it will run in the strict conformance mode. | No, defaults to false |
| stackSize | Specify the thread stack size for the XJC binding compiler (J2SE SDK v1.4 or higher).
The XJC binding compiler can fail to compile large schemas with StackOverflowError and,
in that case, this option can be used to extend the stack size. If unspecified, the default
VM size is used. The format is equivalent to the -Xss command-line argument for Sun Microsystems JVM.
This value can be specified in bytes (stackSize="2097152"), kilobytes (stackSize="2048kb"),
or megabytes (stackSize="2mb"). This attribute is ignored by the JaxMe ant task and present for compatibility reasons only. |
No, defaults to false |
| removeOldOutput | If one or more nested <produces> elements are specified and this attribute is set to true, then the Ant task will ensure that only generated files will remain. In other words, if you had removed an element named "Foo" from the previous schema version, then the Ant task will remove "Foo.java". | No, defaults to false |
| validating | Sets whether the XML schema parser is validating. By default it isn't. | No, defaults to false |
Besides the attributes, the ant task also supports the following nested elements:
| Name | Description | Required/Multiplicity |
|---|---|---|
| schema | Multiple schema files may be compiled in one or more nested <schema> elements. The element syntax is equivalent to a nested <fileset>. Use of a nested <schema> element is mutually exclusive with the use of a "schema" attribute. | 0 - Unbounded |
| binding | Multiple external binding files may be specified. The element syntax is equivalent to a nested <fileset>. Use of a nested <binding> element is mutually exclusive with the use of a "binding" attribute. | 0 - Unbounded |
| classpath | This nested element is ignored by the JaxMe ant task and exists for compatibility to the JAXB ant task only. In the case of JAXB it specifies a classpath for loading user defined types (required in the case of a <javaType> customization) | 0 - Unbounded |
| arg | This nested element is ignored by the JaxMe ant task and exists for compatibility
to the JAXB ant task only. In the case of JAXB it specifies additional command line
arguments being passed to the XJC. For details about the syntax, see the relevant
section in the Ant manual. This nested element can be used to specify various options not natively supported in the xjc Ant task. For example, currently there is no native support for the following xjc command-line options:
|
0 - Unbounded |
| dtd | If this nested element is used to specify, that the input files aren't instances of XML Schema, but DTD's. The nested element may have an attribute "targetNamespace", which specifies an optional target namespace. | No |
| depends | By default the JaxMe Ant tasks up-to-date check considers the specified schema
and binding files only. This is insufficient, if other schema files are included,
imported or redefined. The nested <depends> element allows to specify additional files to consider for the up-to-date check. Typically these are the additional schema files. Syntactically the <depends> element specifies a nested <fileset>. |
0 - Unbounded |
| produces | Specifies the set of files being created by the JaxMe ant task. These files are considered as targets for the up-to-date check. The syntax of the <produces> element is equivalent to a nested <fileset>. However, you typically do not need to set the "dir" attribute, because it defaults to the target directory. | 0 - Unbounded |
| property | Sets a property value. These properties may be used by the various source generators to configure the behaviour. For example, the JDBC schema reader uses the options "jdbc.driver", "jdbc.url", "jdbc.user", and "jdbc.password" to configure the database connection. Each property must have attributes "name" (the property name) and "value" (the property value). | 0 - Unbounded |
| schemaReader | Configures the schema reader to use. Defaults to "org.apache.ws.jaxme.generator.sg.impl.JAXBSchemaReader", which is the JAXB compliant schema reader. An alternative schema readers is, for example, "org.apache.ws.jaxme.generator.sg.impl.JaxMeSchemaReader" (a subclass of JAXBSchemaReader with JaxMe specific extensions). | 0 - 1 |
| sgFactoryChain | If the schema reader is an instance of
JAXBSchemaReader , then you may
add instances of SGFactoryChain to
the schema generation process. For example, such chains are used to create
the persistency layer. The best example is the
JaxMeJdbcSG , which is able to
populate the schema with tables and columns read from a database via
JDBC metadata. |
0 - Unbounded |
| xmlCatalog | Adds an XML catalog to our internal catalog, which is used to resolve external entities and URI's. See the Ant documentation for details on XML catalogs. | 0 - Unbounded |
By default, the JaxMe ant task will always run the generator and create new files. This is typically inappropriate for an ant script where your desire is to have as little modifications as possible, because new files also need to be recompiled, which is slow and time consuming.
To achieve a better behaviour, use the nested <produces> and <depends> elements. If one or more <produces> element is specified, then an up-to-date check is performed as follows:
| Nested Class Summary | |
|---|---|
static class |
XJCTask.ClassType
|
static class |
XJCTask.Dtd
This class is used to store the nested element "dtd". |
class |
XJCTask.MyClassLoader
|
static class |
XJCTask.Property
|
| Field Summary |
|---|
| Fields inherited from class org.apache.tools.ant.Task |
|---|
taskName, taskType, wrapper |
| Fields inherited from class org.apache.tools.ant.ProjectComponent |
|---|
description, location, project |
| Constructor Summary | |
|---|---|
XJCTask()
|
| Method Summary | |
|---|---|
void |
addArg(org.apache.tools.ant.types.Commandline.Argument pArg)
This nested element is ignored by the JaxMe ant task and exists for compatibility to the JAXB ant task only. |
void |
addBinding(org.apache.tools.ant.types.FileSet pBindings)
Multiple external binding files may be specified. |
void |
addClasspath(org.apache.tools.ant.types.Path pClasspath)
This nested element is ignored by the JaxMe ant task and exists for compatibility to the JAXB ant task only. |
void |
addConfiguredXMLCatalog(org.apache.tools.ant.types.XMLCatalog pXmlCatalog)
Adds an XML catalog to our internal catalog. |
void |
addDepends(org.apache.tools.ant.types.FileSet pDepends)
By default the JaxMe Ant tasks up-to-date check considers the specified schema and binding files only. |
void |
addSchema(org.apache.tools.ant.types.FileSet pSchemas)
Multiple schema files may be compiled in one or more nested <schema> elements. |
XJCTask.Dtd |
createDtd()
Creates a nested element "dtd". |
org.apache.tools.ant.types.FileSet |
createProduces()
Specifies the set of files being created by the JaxMe ant task. |
XJCTask.Property |
createProperty()
Sets a property value. |
XJCTask.ClassType |
createSchemaReader()
Configures the schema reader to use. |
XJCTask.ClassType |
createSGFactoryChain()
Configures a new instance of SGFactoryChain being included into
the schema generation process. |
void |
execute()
|
void |
finish()
|
java.io.File |
getBinding()
Returns an external binding file being applied to the schema file. |
org.apache.tools.ant.types.FileSet[] |
getBindings()
Multiple external binding files may be specified. |
org.apache.tools.ant.types.FileSet[] |
getDepends()
By default the JaxMe Ant tasks up-to-date check considers the specified schema and binding files only. |
java.lang.String |
getDescription()
Returns the ant tasks description. |
XJCTask.Dtd |
getDtd()
Returns the nested element "dtd". |
java.lang.String |
getPackage()
Returns the generated Java sources package name. |
org.apache.tools.ant.types.FileSet[] |
getProduces()
Returns the set of files being created by the JaxMe ant task. |
XJCTask.Property[] |
getProperties()
Returns the configured property values. |
java.io.File |
getResourceTarget()
Returns the target directory for generating resource files. |
java.io.File |
getSchema()
Returns the name of the schema file being compiled. |
SchemaReader |
getSchemaReader()
Returns the configured schema reader to use. |
org.apache.tools.ant.types.FileSet[] |
getSchemas()
Multiple schema files may be compiled in one or more nested <schema> elements. |
XJCTask.ClassType[] |
getSGFactoryChains()
Returns the array of configured instances of SGFactoryChain . |
java.lang.String |
getStackSize()
Returns the thread stack size for the XJC binding compiler (J2SE SDK v1.4 or higher). |
java.io.File |
getTarget()
Returns the target directory for generating Java source files. |
void |
init()
Initialize internal instance of XMLCatalog |
LoggerFactory |
initLogging()
|
boolean |
isExtension()
Returns, whether the XJC binding compiler will run in the extension mode. |
boolean |
isForce()
Setting this option to true forces the up-to-date check to fail. |
boolean |
isReadOnly()
Returns, whether generated Java source files are in read-only mode. |
boolean |
isRemoveOldOutput()
If one or more nested <produces> elements are specified and this attribute is set to true, then the Ant task will ensure that only generated files will remain. |
boolean |
isSettingLoggerFactory()
Returns whether the ant task is setting the LoggerFactory . |
boolean |
isUpToDate(java.io.File[] pSchemaFiles,
java.io.File[] pBindingFiles,
java.io.File[] pDependsFiles,
java.util.List pProducesList)
|
boolean |
isValidating()
Returns whether the XML schema parser is validating. |
void |
setBinding(java.io.File pBinding)
Sets an external binding file being applied to the schema file. |
void |
setExtension(boolean pExtension)
Sets, whether the XJC binding compiler will run in the extension mode. |
void |
setForce(boolean pForce)
Setting this option to true forces the up-to-date check to fail. |
void |
setPackage(java.lang.String pPackageName)
Sets the generated Java sources package name. |
void |
setPackageName(java.lang.String pPackageName)
Deprecated. Use setPackage(String) . |
void |
setReadOnly(boolean pReadOnly)
Sets, whether generated Java source files are in read-only mode. |
void |
setRemoveOldOutput(boolean pRemoveOldOutput)
If one or more nested <produces> elements are specified and this attribute is set to true, then the Ant task will ensure that only generated files will remain. |
void |
setResourceTarget(java.io.File pTarget)
Sets the target directory for generating resource files. |
void |
setSchema(java.io.File pSchema)
Sets the name of the schema file being compiled. |
void |
setSettingLoggerFactory(boolean pIsSettingLoggerFactory)
Sets whether the ant task is setting the LoggerFactory . |
void |
setStackSize(java.lang.String pStackSize)
Sets the thread stack size for the XJC binding compiler (J2SE SDK v1.4 or higher). |
void |
setTarget(java.io.File pTarget)
Sets the target directory for generating Java source files. |
void |
setValidating(boolean pValidating)
Sets whether the XML schema parser is validating. |
void |
stopLogging(LoggerFactory pFactory)
|
| Methods inherited from class org.apache.tools.ant.Task |
|---|
bindToOwner, getOwningTarget, getRuntimeConfigurableWrapper, getTaskName, getTaskType, getWrapper, handleErrorFlush, handleErrorOutput, handleFlush, handleInput, handleOutput, isInvalid, log, log, log, log, maybeConfigure, perform, reconfigure, setOwningTarget, setRuntimeConfigurableWrapper, setTaskName, setTaskType |
| Methods inherited from class org.apache.tools.ant.ProjectComponent |
|---|
clone, getLocation, getProject, setDescription, setLocation, setProject |
| Methods inherited from class java.lang.Object |
|---|
equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public XJCTask()
| Method Detail |
|---|
public XJCTask.Property createProperty()
Sets a property value. These properties may be used by the various source generators to configure the behaviour. For example, the JDBC schema reader uses the options "jdbc.driver", "jdbc.url", "jdbc.user", and "jdbc.password" to configure the database connection. Each property must have attributes "name" (the property name) and "value" (the property value).
public XJCTask.Property[] getProperties()
Returns the configured property values. These properties may be used by the various source generators to configure the behaviour. For example, the JDBC schema reader uses the options "jdbc.driver", "jdbc.url", "jdbc.user", and "jdbc.password" to configure the database connection. Each property must have attributes "name" (the property name) and "value" (the property value).
public XJCTask.ClassType createSchemaReader()
Configures the schema reader to use. Defaults to "org.apache.ws.jaxme.generator.sg.impl.JAXBSchemaReader", which is the JAXB compliant schema reader. An alternative schema readers is, for example, "org.apache.ws.jaxme.generator.sg.impl.JaxMeSchemaReader" (a subclass of JAXBSchemaReader with JaxMe specific extensions).
public SchemaReader getSchemaReader()
Returns the configured schema reader to use. Defaults to "org.apache.ws.jaxme.generator.sg.impl.JAXBSchemaReader", which is the JAXB compliant schema reader. An alternative schema readers is, for example, "org.apache.ws.jaxme.generator.sg.impl.JaxMeSchemaReader" (a subclass of JAXBSchemaReader with JaxMe specific extensions).
public XJCTask.ClassType createSGFactoryChain()
Configures a new instance of
SGFactoryChain
being included into
the schema generation process. This option is valid only, if the schema reader
is an instance of JAXBSchemaReader
, because its method
JAXBSchemaReader.addSGFactoryChain(Class)
must be invoked.
The order of the chain elements may be significant. The schema reader itself will always be the last element in the chain.
public XJCTask.ClassType[] getSGFactoryChains()
Returns the array of configured instances of
SGFactoryChain
. The order of
the array is significant. The schema reader itself will always be the
last element in the chain. Therefore, it is not present in the array.
public java.lang.String getDescription()
Returns the ant tasks description.
getDescription
in class org.apache.tools.ant.ProjectComponent
public void setValidating(boolean pValidating)
Sets whether the XML schema parser is validating.
public boolean isValidating()
Returns whether the XML schema parser is validating.
public boolean isForce()
Setting this option to true forces the up-to-date check to fail. This option is mainly useful while working on the JaxMe generator. For JaxMe users, which only change schema files, this option isn't of much use. It is designed for JaxMe developers.
public void setForce(boolean pForce)
Setting this option to true forces the up-to-date check to fail. This option is mainly useful while working on the JaxMe generator. For JaxMe users, which only change schema files, this option isn't of much use. It is designed for JaxMe developers.
public boolean isSettingLoggerFactory()
Returns whether the ant task is setting the LoggerFactory
. This
option is only useful, if you are using the Ant task from another Java class
and not from within Ant.
public void setSettingLoggerFactory(boolean pIsSettingLoggerFactory)
Sets whether the ant task is setting the LoggerFactory
. This
option is only useful, if you are using the Ant task from another Java class
and not from within Ant.
public java.io.File getBinding()
Returns an external binding file being applied to the schema file.
public void setBinding(java.io.File pBinding)
Sets an external binding file being applied to the schema file.
public boolean isExtension()
Returns, whether the XJC binding compiler will run in the extension mode. By default, it will run in the strict conformance mode.
public void setExtension(boolean pExtension)
Sets, whether the XJC binding compiler will run in the extension mode. By default, it will run in the strict conformance mode.
public java.lang.String getPackage()
Returns the generated Java sources package name. A non-null package specification overrides package specifications in the schema bindings, if any.
public void setPackage(java.lang.String pPackageName)
Sets the generated Java sources package name. A non-null package specification overrides package specifications in the schema bindings, if any.
public void setPackageName(java.lang.String pPackageName)
setPackage(String)
.
public boolean isReadOnly()
Returns, whether generated Java source files are in read-only mode.
public void setReadOnly(boolean pReadOnly)
Sets, whether generated Java source files are in read-only mode.
public boolean isRemoveOldOutput()
If one or more nested <produces> elements are specified and this attribute is set to true, then the Ant task will ensure that only generated files will remain. In other words, if you had removed an element named "Foo" from the previous schema version, then the Ant task will remove "Foo.java".
public void setRemoveOldOutput(boolean pRemoveOldOutput)
If one or more nested <produces> elements are specified and this attribute is set to true, then the Ant task will ensure that only generated files will remain. In other words, if you had removed an element named "Foo" from the previous schema version, then the Ant task will remove "Foo.java".
public java.io.File getSchema()
Returns the name of the schema file being compiled.
public void setSchema(java.io.File pSchema)
Sets the name of the schema file being compiled.
public java.lang.String getStackSize()
Returns the thread stack size for the XJC binding compiler (J2SE SDK v1.4 or higher). The XJC binding compiler can fail to compile large schemas with StackOverflowError and, in that case, this option can be used to extend the stack size. If unspecified, the default VM size is used. The format is equivalent to the -Xss command-line argument for Sun Microsystems JVM. This value can be specified in bytes (stackSize="2097152"), kilobytes (stackSize="2048kb"), or megabytes (stackSize="2mb").
This attribute is ignored by the JaxMe ant task and present for compatibility reasons only.
public void setStackSize(java.lang.String pStackSize)
Sets the thread stack size for the XJC binding compiler (J2SE SDK v1.4 or higher). The XJC binding compiler can fail to compile large schemas with StackOverflowError and, in that case, this option can be used to extend the stack size. If unspecified, the default VM size is used. The format is equivalent to the -Xss command-line argument for Sun Microsystems JVM. This value can be specified in bytes (stackSize="2097152"), kilobytes (stackSize="2048kb"), or megabytes (stackSize="2mb").
This attribute is ignored by the JaxMe ant task and present for compatibility reasons only.
public java.io.File getTarget()
public void setTarget(java.io.File pTarget)
public java.io.File getResourceTarget()
public void setResourceTarget(java.io.File pTarget)
public void addSchema(org.apache.tools.ant.types.FileSet pSchemas)
Multiple schema files may be compiled in one or more nested <schema> elements. The element syntax is equivalent to a nested <fileset>. Use of a nested <schema> element is mutually exclusive with the use of a "schema" attribute.
public org.apache.tools.ant.types.FileSet[] getSchemas()
Multiple schema files may be compiled in one or more nested <schema> elements. The element syntax is equivalent to a nested <fileset>. Use of a nested <schema> element is mutually exclusive with the use of a "schema" attribute.
public void addBinding(org.apache.tools.ant.types.FileSet pBindings)
Multiple external binding files may be specified. The element syntax is equivalent to a nested <fileset>. Use of a nested <binding> element is mutually exclusive with the use of a "binding" attribute.
public org.apache.tools.ant.types.FileSet[] getBindings()
Multiple external binding files may be specified. The element syntax is equivalent to a nested <fileset>. Use of a nested <binding> element is mutually exclusive with the use of a "binding" attribute.
public void addClasspath(org.apache.tools.ant.types.Path pClasspath)
This nested element is ignored by the JaxMe ant task and exists for compatibility to the JAXB ant task only. In the case of JAXB it specifies a classpath for loading user defined types (required in the case of a <javaType> customization)
public void addArg(org.apache.tools.ant.types.Commandline.Argument pArg)
This nested element is ignored by the JaxMe ant task and exists for compatibility
to the JAXB ant task only. In the case of JAXB it specifies additional command line
arguments being passed to the XJC. For details about the syntax, see the relevant
section in the Ant manual.
This nested element can be used to specify various options not natively supported in
the xjc Ant task. For example, currently there is no native support for the following
xjc command-line options:
public void addDepends(org.apache.tools.ant.types.FileSet pDepends)
By default the JaxMe Ant tasks up-to-date check considers the specified schema
and binding files only. This is insufficient, if other schema files are included,
imported or redefined.
The nested <depends> element allows to specify additional files to consider
for the up-to-date check. Typically these are the additional schema files.
Syntactically the <depends> element specifies a nested <fileset>.
public org.apache.tools.ant.types.FileSet[] getDepends()
By default the JaxMe Ant tasks up-to-date check considers the specified schema
and binding files only. This is insufficient, if other schema files are included,
imported or redefined.
The nested <depends> element allows to specify additional files to consider
for the up-to-date check. Typically these are the additional schema files.
Syntactically the <depends> element specifies a nested <fileset>.
public org.apache.tools.ant.types.FileSet createProduces()
Specifies the set of files being created by the JaxMe ant task. These files are considered as targets for the up-to-date check. The syntax of the <produces> element is equivalent to a nested <fileset>.
public org.apache.tools.ant.types.FileSet[] getProduces()
Returns the set of files being created by the JaxMe ant task. These files are considered as targets for the up-to-date check. The syntax of the <produces> element is equivalent to a nested <fileset>.
public XJCTask.Dtd createDtd()
public XJCTask.Dtd getDtd()
public void finish()
public boolean isUpToDate(java.io.File[] pSchemaFiles, java.io.File[] pBindingFiles, java.io.File[] pDependsFiles, java.util.List pProducesList)
public void stopLogging(LoggerFactory pFactory)
public LoggerFactory initLogging()
public void init()
init
in class org.apache.tools.ant.Task
public void addConfiguredXMLCatalog(org.apache.tools.ant.types.XMLCatalog pXmlCatalog)
xmlCatalog
- the XMLCatalog instance to use to look up DTDspublic void execute()
execute
in class org.apache.tools.ant.Task
|
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | ||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |


If you want a quick way to let the user select one or even multiple items of a given dataset you can use the ListDialog.
Use the SetOnTouch method of the ListDialog object to set the name of a function you want to be called every times a list item is selected. The selected item is passed that function as parameter.
Example - Basic
function OnStart()
{
dlg = app.CreateListDialog( "Choices", "Add,Remove,Delete" );
dlg.SetOnTouch( dlg_OnTouch );
dlg.Show();
}
function dlg_OnTouch( item )
{
app.ShowPopup( item );
}
ou can use the “Multi” option to create a ListDialog with check boxes against each item. This allows multiple list items to be selected. An extra parameter isChecked is passed to the OnTouch callback function when a check box is checked or unchecked.
Example - Multi
function OnStart()
{
dlg = app.CreateListDialog( "Days", "Mon,Tues,Wed,Thurs,Fri,Sat,Sun", "Multi" );
dlg.SetOnTouch( dlg_OnTouch );
dlg.Show();
}
function dlg_OnTouch( item, isChecked )
{
app.ShowPopup( item + " isChecked = " + isChecked );
}
Methods
The following methods are available on the ListDialog object:
number
string
number: -180..180
number: -100..100
number: 0..100
string:
hexadecimal: “#rrggbb”, “#aarrggbb”
colourName: “red”, “green”, ...
string: path to file or folder ( “/absolute/...” or “relative/...” )
string: comma “,” separated: “Multi” or “?”
string: “repeat”
string: “px” or “sp” or “dip” or “dp” or “mm” or “pt”
list: boolean,char,byte,short,int,long,float,double,String,CharSequence,...
function(
title,
checked
)
ldg.AdjustColor
Adjust the visual color effect of the control by setting the Hue (by angle in degrees in a color circle), the saturation, brightness and contrast of the control.
ldg.Dismiss
Hide the control and remove it from the screen.
ldg.GetType
Returns the control class name.
ldg.Hide
Hide the control but keep the layout space free.
ldg.MethodAllows access to other functions defined on the object in Java via reflection.
Note: This function is a premium feature. Please consider subscribing to Premium to use this feature and support DroidScript in its further development.
ldg.SetBackColor
Changes the background color of the control.
ldg.SetBackground
Changes the background to an image which can be repeated using the repeat option.
An image which is often used with that option is '/res/drawable/pattern_carbon' - try it out!
ldg.SetOnTouch
Define a callback function that is called when the user touches a list item.
ldg.SetSize
Change the size of the control in either screen relative values or in pixels if the px option was given.
ldg.SetTextColor
Change the text color of the contained text.
ldg.SetTitle
Change the dialog title.
ldg.Show
Set the visibility of the control to “Show”.


Postal Code
Node.js API for Japanese postal code
Make a request
Send
Show response here
Fork me on
GitHub