|
Astral ProjectionConsidering it took hundreds of millions of years to evolve these bodies of ours, you'd think people would want to stay close to them.Astral projection is the art, science or accident of detaching your consciousness from your body, in a context other than "death." From the true believer's point of view, it is a key element of mystical experience and is considered a popular technique for magicians and witches to do their occult work. From the skeptic's point of view, it's an unlikely and little-understood glitch in neurochemistry. Either way, it's weirdly intriguing. The experience likely predates recorded history. Terence McKenna has argued (semi-convincingly) that mankind's early development was influenced by the consumption of psychedelic mushrooms, which improved acuity of vision and stimulated the verbal cortex of the brain to encourage the development of language. While there's not a lot of documentary evidence to support this surprisingly rational notion, certainly drugs are the easiest method for detaching the experience of subjective consciousness from the body. And it's equally certain that astral projection is one of the oldest human experiences. The phenomenon shows up in some of humanity's earliest written records, mostly religious in nature. It's woven through the Judeo-Christian Bible and appears in other cultures as well. If you were of a mind, you could pose a chicken-and-egg argument about whether the experience of astral projection inspired humanity to invent religion to explain it, or if the idea of religion inspired humans to consider and seek out-of-body experiences. However, the former explanation is almost infinitely more likely than the latter. Even putting aside McKenna's notion of tripped-out neanderthals, there are plenty of mundane physical events which can cause an out-of-body experience to occur spontaneously. The most excruciatingly obvious of these include:
There is a primal issue that remains unresolved. Although you can almost always point to some physical event that provokes the experience, what causes the character of the experience? In other words, why do we see the particular things we see?
Near-Death ExperienceThis is one of the most frequently discussed experiences for two reasons: First, most people want to believe their souls will exist after death. Second, most of the reported experiences are amazingly consistent: they seem to be describing the same phenomenon.The classic NDE involves a person who is close to death, or clinically dead for some period of time. The person sees a light at the end of a long tunnel, and feels themselves being drawn toward the light. Usually, the light is experienced as a warm and positive energy. Often people report seeing dead loved ones or religious icons like Jesus Christ or whoever. Although the experience seems to be non-denominational (or rather, it conforms to the individual's denominational expectations), it does tend to have a very spiritual quality and is often considered a life-changing experience. Scientists believe that the light-tunnel effect may be caused by oxygen deprivation in the brain or the release of dimethyltriptamine (DMT), though skeptics argue that the voice of Grandma is strictly delusional. The fact that the experience closely corresponds to what religion teaches about death may simply be more chicken-and-egg stuff, i.e., the religious concept was designed to explain the physiological experience. Whatever you think about all that, people report a remarkably consistent set of responses after a near-death experience, including a strong interest in spirituality, reports of psychic powers, increased belief in an afterlife and a markedly reduced fear of death. If biology were the only factor in determining the shape of the experience, it can be argued that an evolutionary imperative would cause NDEs to be extremely unpleasant and to increase the person's aversion to death, which would presumably lead to better survival rates.
Drug-Based HallucinationThere is a considerable body of literature about how and why drug experiences affect the brain, but the bottom line is that there's a lot we still don't understand about hallucinogenic experiences. Almost any drug, when abused with sufficient excess, will lead to a hallucinatory experience, which can include an out-of-body aspect. But it's the hallucinogenic class of drugs that most consistently produces hallucinations (duh).Low-level hallucinogens have long been associated with religious and visionary experience. For example, medieval witches used "flying ointments" to access their occult powers of flight. Some of these ointments used hallucinogenic (and highly toxic) substances like mandrake or belladonna, presumably leading the user to experience flight in the "real world" or "astrally." Different sorts of drugs produce different sorts of hallucinations. Within the hallucinogen class, psilocybin-based drugs are among those most prone to causing the subjective experience of "astral projection," in which a person feels their spiritual essence transported out of their body. Although drug experiences tend to be much more varied than NDEs, there is a remarkable amount of consistency, especially when charted among the types of hallucinogens being used. For instance, certain types of mushrooms will often produce visions of a very "green" organic nature in which elf-like creatures are perceived living in a vaguely Gaian ecosphere. When smoked, the salvia divinorum leaf (a powerful and completely legal leaf hallucinogen) produces a fairly consistent experience of contact with an alien or plant-based intelligence. Ayahuasca, a brewed South American hallucinogen containing DMT (dimethyltryptamine), produces extremely distinct astral projection experiences which have a marked "out of body" component. There are often visions of aliens, spaceships and/or higher dimensions, which may explain the famous Mayan petroglyphs so often cited as evidence of "Ancient Astronauts". When you use synthetic DMT in a concentrated dose, the experience very consistently matches the "alien abduction" scenario reported in so many of our nation's fine trailer parks. Because DMT occurs naturally in the brain, there are theories that alien encounters are the result of biochemical imbalances in the brain which increase the brain's natural DMT to unusually high levels. Users refer to the astral realm visited as "DMT space," and most users seem to consider it a real place. Although they know they are taking a drug, there is a powerful and real conviction that the experience is meaningfully true (as with NDEs). Which leads us to the question of...
Astral Projection As Spiritual ExperienceAstral projection almost always carries a religious or spiritual component. The idea of an astral body (which may or may not be the same thing as your soul) is common to early religions, most of which were shamanistic in nature. Later, the idea became associated with Plato's idea that material things also existed as abstract ideal concepts.Shortly before the time of Christ, a series of religious texts called "apocalypses" began to describe astral travel in the company of angels. In the apocalypses (not to be confused with The Apocalypse), a prophet would be taken up to Heaven by an angel, who would show the prophet events from other times, events outside of time, symbolic representations of real events, or even the realm of God itself. Despite the fact that the notion was fairly well developed even by the time of Christ, other realms (such as the Underworld) were for centuries believed to exist somewhere geographically relative to the "real" world. So for instance, the Underworld was thought to be literally under the world. By the time of Dante, places like Heaven and Hell were beginning to be widely understood as existing on an "astral" plane. Dante's Divine Comedy is presented as a description of an astral trip through hell to heaven, similar to the apocalypses which were its antecedent. Around the same time, occultists started trying to interact with these astral realms, first through processes like demonology and later by reverting to shamanistic techniques in which the other realms are visited by the magician. Magicians using astral projection techniques usually take explicit steps to protect their bodies from harm while they're out and about. Usually, practitioners also visualize a silver cord leading back to their bodies to prevent getting lost on the astral planes. Whether the result of spontaneous angelic revelation, calculated occult machination or a nasty bump on the head, astral travel tends to have a powerful spiritual aspect -- an inescapable result of an experience in which one exists as pure spirit. While it may be powerful, the more interesting question is whether it's "real" in any meaningful sense.
So... Is It Real?That turns out to be a trickier question than you might expect. Part of the problem comes from the inability of science to define consciousness in any useful, specific way. From a scientific perspective, consciousness is like ugliness. You're sure you know it when you see it, but no two people see it in the same way.The closest thing modern science offers to a physical theory is that consciousness might be a Bose-Einstein condensate, which is a vibrating field of quantum particles -- a pleasantly scientific way of saying "it's magic, and we aren't sure exactly where you find it," and also "we don't know what it does, how it works or how it acts." So you can't prove exactly what it is, and you can't prove exactly where it is. Ipso facto, you cannot prohibit it from flying around the universe whenever it damn well pleases -- scientifically speaking. There is a very small subset of research on what is called the "locality" of consciousness, which is a thus-far completely confounding effort to determine "where" one's consciousness lives. One such study, for instance, deprived people from their main sensory apparatus and let them "see" only through a camera attached to a small robot. The subjects reported that it felt like their consciousness was "in" the robot instead of their bodies. You may be thinking, "Gee, that sounds cool, but what does it prove?" If so, you have cleverly identified the problem with such research. You can, of course, try the experiment on for size and see what you think. There are a number of meditative and/or magickal techniques which may or may not allow you to astrally project. While some of these techniques are conceptually sound, the fact of the matter is that they work a lot better if you are predisposed toward astral travel to begin with. You know you have the knack if you've done it by accident. If you haven't accidentally found yourself floating around outside your body, you'll probably need some drugs to kick-start the process. Most (but not all) of these drugs are illegal in the United States and the better part of Europe. Work out for yourself how much risk you can tolerate, and craft a strategy accordingly. Once you've astrally projected a few times, it gets easier, so a lifelong drug habit is not required. (Rotten.com does not recommend seeking out near-death experiences, but if you do happen to have a particularly gory one, we hope you'll send in a picture.) All this subjectivity aside, there are some fairly factual statements that can be made about astral projection. Despite a fair amount of research, there is no verifiable evidence that out-of-body experiences have any connection to the physical realm in which we spend most of our time. Laboratory efforts have consistently failed to produce any proof to support remote viewing, in which an astrally-traveling consciousness appears to see events happening in the "real" world. Extensive efforts have also failed to find any proof that an astrally traveling consciousness can accurately view something happening elsewhere in time, specifically the future. Anecdotally, of course, there are countless stories about this kind of thing happening when people are under great duress or really, really stoned. These things may well happen as they seem to the participants. Since the best guess is that consciousness is a quantum field, attempts to directly observe its behavior would -- in theory -- be susceptible to the Uncertainty Principle, which holds that the act of observing a quantum process changes the outcome of the process.  On the bright side, you can pretty much believe whatever you want about astral projection and rest easy knowing no one can legitimately say you're wrong.
|


Automating GIS processes -course - I have developed an openly available online course for learning to automatize various GIS-related tasks and analyses using Python programming language. The teaching utilizes cloud computing (CSC cPouta), GitHub Classrooms, and Sphinx for writing the online materials.


| |
Methods defined here:
- __init__(self)
- Instantiate deck instance.
- add_to_hiscore(self, player_name)
- Add result to highscore txt.
- check_cards(self)
- Check if players have less than or 4 cards.
- check_for_winner(self)
- Check if anyone won.
- draw(self)
- Draw cards and return them.
- get_players(self)
- Return all players created.
- round_winner(self, card1, card2)
- Give cards to winner, if equal call war, return string.
- set_player(self, playernum, name)
- Create a player.
- start(self)
- Create, shuffle and deal deck evenly.
- war(self, winner_cards)
- War function.
Class methods defined here:
- set_player_name(new_name, gamer) from builtins.type
- Change the name of the player.
- show_hiscore() from builtins.type
- Print highscore list.
Data descriptors defined here:
- __dict__
- dictionary for instance variables (if defined)
- __weakref__
- list of weak references to the object (if defined)
|


Texan Smokeshow Hope Beel Shows Off Toned Physique In Sports Bra And Biker Shorts At The Gym
November 21, 2019
Texan Smokeshow Hope Beel Shows Off Toned Physique In Sports Bra And Biker Shorts At The Gym
Hope Beel is working on her fitness in the latest video on her Instagram page and looking great while doing so. In the shared clip, the Texas-born model struts into the gym rocking a black sports bra and biker shorts emblazoned with the logo of the post’s sponsor, Bang Energy, a company known for its fitness energy drinks. With her dark brown hair in a low ponytail, Hope proceeds to train her upper body at a weight machine. Later, she’s captured doing a set of lunges right before the video ends.
Throughout the video, the workout footage is intercut with clips of Bang Energy’s Pre-Workout supplement, Master Blaster. At one point in the video, Hope pours a cup of the powder into a water bottle and shakes it while doing a goofy dance. Closeups on the product’s container reveal that she’s using Master Blaster’s lemon drop flavor.
In the comments, Hope’s fans seemed more focused on complimenting the model than discussing the benefits of the energy supplement.
“You’re sexy and beautiful babe and pretty too,” one infatuated fan wrote. ” I love you so much and you look amazing babe.”
“Very beautiful,” another admirer added.
The clip even inspired a wedding proposal.
“Will you marry me, beautiful,” the commenter asked.
“Such confidence and beauty,” a fourth fan wrote.
Loading...
Hope has shared clips of herself working out at the gym before. In a previous Instagram post, she’s seen working out at the rowing machine before moving on to some more heart rate accelerating cardio on a stationary bike.  That video was also sponsored by Bang Energy. In it, she’s promoting their protein energy bar, Zero Impact.
That clip has been watched more than 20,000 times. And, just like in her most recent post, Hope’s fans flooded the comments section with compliments.
The model is also known for showing off the gains that she’s earned in the gym via the plethora of bikini photos on her Instagram page. In one of her more recent posts, she’s sporting a black bikini with a floral pattern. Her hair is in a half-up ponytail leaving the rest of her tresses to hang past her shoulders in flowing curls. According to the post’s geo-tag, the photo was taken in the Turks and Caicos Islands.
The post has amassed over 24,000 likes and more than 250 comments.


Grunt
First of all, in order to use Grunt. You must have Node.js installed. Once you already install Node, you can type in the following command in the LOCAL terminal.
This will install any packages required to run Grunt properly in your system.
Working with Grunt is much more simpler then manually saving and uploading to AFS.
This allows you to get that done with just a click.
Now, in order to do this you
must go to Run then click on the play button Run.... If a windows opens
it means that you haven't install Grunt.
After clicking the play button you will see a small window with some options depending on which .html file you are editing. Just click on it to configure it to that page. Once you do that you don't have to repeat that for that specific .html file. However, if you want to be able to use this feature, you will have to do the same for the others .html files.
To use this feature you only have to click on the play button which you can find below the Webstorm tabs. If you want to open another .html file directly from the play button, you have to choose it frm the drop down options left side of the play button.


Kube
The Kube framework.
installing
Just Kube
$ git clone git@github.com:Kube-f/Kube.git
$ cd Kube
$ yarn install
Through yarn
soon tm
quickstart
import Kube from 'kube';
const myKube = new Kube();
const aNamespace = myKube.namespace('aNamespace');
aNamespace.def(function coolFunction(a) {
return a;
});
console.log(aNamespace.coolFunction('hello kube!')); //hello kube!
Docs
Kube()
The Kube object is the focus of this framework. It keeps track of the global state aswell as the namespaces you define on it. It has few functionalities, but the ones it does have are quite usefull.
the Kube
object should only be instantiated once across your application, this is to prevent
undefined behaviour when you try to access namespaces from other kubes. The Kube
object
can be instantiated like so:
const myKube = new Kube();
.namespace()
Within your Kube
object, you can instantiate so called namespaces. These namespaces serve
as a clean way to keep different parts of your application seperated from eachother. This being said,
it is also extremely easy to access different namespaces defined on the same Kube()
instance.
You can define a namespace like so:
const myNamespace = myKube.namespace('myNamespace'); //instantiating the namespace
const alsoMyNamespace = myKube.namespace('myNamespace'); //importing the namespace
As you can see, once a namespace is created, it cannot be redefined. This is done so you can import the namespace wherever you want once it is defined elsewhere and use the functions defined on it.
.def(fn)
.def(fn)
is a function that is present on all namespaces that allows you to define
a function on the namespace itself. This means that functions defined on a certain
namespace can only be used when the namespace is imported.
For example, this is how it can be used:
const myNamespace = myKube.namespace('myNamespace');
myNamespace.def(function myCoolFunction(a) {
return a;
});
console.log(myNamespace.myCoolFunction('hello kube!')); //logs "hello kube!"
.def()
does require you to provide a named function, this means that the following example
will yield an Function name not defined
error. This error will be thrown by kube itself.
const myNamespace = myKube.namespace('myNamespace');
myNamespace.def(function (a) {
return a;
}); //throws "Function name not defined" error


We make your bike see!
This hopefully keeps you alive! :)
Preorder now for 150€. takemymoney@bikesight.ml


This is a simple hero unit, a simple jumbotron-style component for calling extra attention to featured content or information.
It uses utility classes for typography and spacing to space content out within the larger container.
$ 0
Coming Soon


Write a valid port number
Port where KrakenD listens to connections, defaults to 8080
. The port can also be specified at startup time with the flag -p
Maximum duration for reading the entire HTTP request, including the body.
Maximum duration before timing-out writes of the response
Maximum amount of time to wait for the next request when keepalives are enabled
Maximum time spent to read headers


Enables your users to type Amharic Directly with out having to ... you know - installing software or write some where and paste. Check my Blog for detailed info. this is just like alpha-alpha test realse so please let me know what should go in and what should go out at "samiabera@gmail.com"


Promo Section
As pampers expression beer company, our solar farm generates renewable electricity to brew our beers. Pampers expressions is brewing with 100% renewable electricity.
Sustainability is a big part of our business. We (our carbon neutral breweries) support local farms. We encourage bars and retailers we work with to decrease their co2 impact. We increase our sustainability goals every year and our greenhouse emission data and climate related risk management strategies are reviewed by our professional team.
Social Media Section
Facebook
Instagram
SUBSCRIBE FOR UPDATES


This keyboard is created for the miluk, hanis, shaʼyuushtlʼa, quuiich, and alsea languages. It includes upper and lower case versions of all characters. In addition to your keys responding when pressed on their own, all keys have additional outputs when holding down the shift key. These represent the different sounds that are found in these three languages. Notably, labialized consonants, ejectives, and geminant consonants are accessed via the shift key.
Default Keyboard layout.
Keyboard Layout with ALT-Key held
Mobile Keyboard Layout
For the mobile keyboard, additional characters can be accessed by holding down (AKA longpressing) the different default keys.
Hold q for: qߴ, qߴw, and qw.
Hold e for: ei and eu.
Hold r for r̊.
Hold t for: tߴ, ts, tsߴ, tɬ, and tɬߴ.
Hold u for: uu.
Hold i for: ii.
Hold ə for: o and ou.
Hold p for: pߴ.
Hold a for: æ, ai, and au.
Hold s for: sh
Hold d for: dl and dz.
Hold g for: g̣, g̣w, gh, and gw.
Hold h for: hw.
Hold k for: kߴ, kw, and kߴw.
Hold l for: ll and ɬ.
Hold x for: xw, x̣, and x̣w.
Hold c for: ch and chߴ.
Hold n for: nn.
Hold m for: mm.


{% autoescape true %}
That's where Datebot comes in. We're changing the landscape of online dating once and for all.
Get Started
Thumbnail caption...


Mesos is built using the same principles as the Linux kernel, only
at a different level of abstraction. The Mesos
kernel runs on
every machine and provides applications (e.g., Hadoop, Spark, Kafka,
Elasticsearch) with API’s for
resource management and scheduling
across entire datacenter and cloud environments.
Industry proven to easily scale to 10,000s of nodes.
Fault-tolerant replicated master and agents using Zookeeper. Non-disruptive upgrades.
Native support for launching containers with Docker and AppC images.
First class isolation support for CPU, memory, disk, ports, GPU, and modules for custom resource isolation.
Support for running cloud native and legacy applications in the same cluster with pluggable scheduling policies.
HTTP APIs for developing new distributed applications, for operating the cluster, and for monitoring.
Built-in Web UI for viewing cluster state and navigating container sandboxes.
Runs on Linux, OSX and Windows. Cloud provider agnostic.


Hi, i'm Mikołaj. I like programming, physics, swimming, and karate. A
link to a few of my platform profiles can be found below, alongside some
of my current projects.
cdoku - GitHub
cdoku is a sudoku solver implementation in C, using Knuth's Algorith X.
It can read arbitrary size grids (in a specific text format) and solve
them. It implements the dancing links optimisation, and can solve a
3x3 grid in around 10-20 ms.
HyperMan
I am current working as part of the University of Manchester Hyperloop
team, working on the software engineering team. I am working on an
embedded control system for the pod written in C++ with a test-driven
approach.
NetSharp - GitHub
NetSharp is a (relatively) low-level networking library written in C#.
I am writing it using the Event-driven Asynchronous Pattern (EAP) to
get as high a bandwidth as possible.
clfs-bootstrap - GitHub
This is my custom Linux "distribution". I wrote it following the "Cross
Linux From Scratch" guide (found here),
but have since refactored the build script and updated the packages used.
StarSim - GitHub
StarSim was my A-Level computer science coursework, and is a 3D N-Body
simulator using the Barnes-Hutt algorithm. It also features a backing
database so that created systems can be exported, or imported to simulate.


public class Collections extends Object
The methods of this class all throw a NullPointerException if the collections or class objects provided to them are null.
The documentation for the polymorphic algorithms contained in this class generally includes a brief description of the implementation. Such descriptions should be regarded as implementation notes, rather than parts of the specification. Implementors should feel free to substitute other algorithms, so long as the specification itself is adhered to. (For example, the algorithm used by sort does not have to be a mergesort, but it does have to be stable.)
The "destructive" algorithms contained in this class, that is, the algorithms that modify the collection on which they operate, are specified to throw UnsupportedOperationException if the collection does not support the appropriate mutation primitive(s), such as the set method. These algorithms may, but are not required to, throw this exception if an invocation would have no effect on the collection. For example, invoking the sort method on an unmodifiable list that is already sorted may or may not throw UnsupportedOperationException.
This class is a member of the Java Collections Framework.
Collection
,
Set
,
List
,
Map
| Modifier and Type | Field and Description |
|---|---|
static List |
EMPTY_LIST
The empty list (immutable).
|
static Map |
EMPTY_MAP
The empty map (immutable).
|
static Set |
EMPTY_SET
The empty set (immutable).
|
| Modifier and Type | Method and Description |
|---|---|
static <T> boolean |
addAll(Collection<? super T> c,
T... elements)
Adds all of the specified elements to the specified collection.
|
static <T> Queue<T> |
asLifoQueue(Deque<T> deque)
|
static <T> int |
binarySearch(List<? extends Comparable<? super T>> list,
T key)
Searches the specified list for the specified object using the binary
search algorithm.
|
static <T> int |
binarySearch(List<? extends T> list,
T key,
Comparator<? super T> c)
Searches the specified list for the specified object using the binary
search algorithm.
|
static <E> Collection<E> |
checkedCollection(Collection<E> c,
Class<E> type)
Returns a dynamically typesafe view of the specified collection.
|
static <E> List<E> |
checkedList(List<E> list,
Class<E> type)
Returns a dynamically typesafe view of the specified list.
|
static <K,V> Map<K,V> |
checkedMap(Map<K,V> m,
Class<K> keyType,
Class<V> valueType)
Returns a dynamically typesafe view of the specified map.
|
static <K,V> NavigableMap<K,V> |
checkedNavigableMap(NavigableMap<K,V> m,
Class<K> keyType,
Class<V> valueType)
Returns a dynamically typesafe view of the specified navigable map.
|
static <E> NavigableSet<E> |
checkedNavigableSet(NavigableSet<E> s,
Class<E> type)
Returns a dynamically typesafe view of the specified navigable set.
|
static <E> Queue<E> |
checkedQueue(Queue<E> queue,
Class<E> type)
Returns a dynamically typesafe view of the specified queue.
|
static <E> Set<E> |
checkedSet(Set<E> s,
Class<E> type)
Returns a dynamically typesafe view of the specified set.
|
static <K,V> SortedMap<K,V> |
checkedSortedMap(SortedMap<K,V> m,
Class<K> keyType,
Class<V> valueType)
Returns a dynamically typesafe view of the specified sorted map.
|
static <E> SortedSet<E> |
checkedSortedSet(SortedSet<E> s,
Class<E> type)
Returns a dynamically typesafe view of the specified sorted set.
|
static <T> void |
copy(List<? super T> dest,
List<? extends T> src)
Copies all of the elements from one list into another.
|
static boolean |
disjoint(Collection<?> c1,
Collection<?> c2)
Returns
true if the two specified collections have no
elements in common. |
static <T> Enumeration<T> |
emptyEnumeration()
Returns an enumeration that has no elements.
|
static <T> Iterator<T> |
emptyIterator()
Returns an iterator that has no elements.
|
static <T> List<T> |
emptyList()
Returns an empty list (immutable).
|
static <T> ListIterator<T> |
emptyListIterator()
Returns a list iterator that has no elements.
|
static <K,V> Map<K,V> |
emptyMap()
Returns an empty map (immutable).
|
static <K,V> NavigableMap<K,V> |
emptyNavigableMap()
Returns an empty navigable map (immutable).
|
static <E> NavigableSet<E> |
emptyNavigableSet()
Returns an empty navigable set (immutable).
|
static <T> Set<T> |
emptySet()
Returns an empty set (immutable).
|
static <K,V> SortedMap<K,V> |
emptySortedMap()
Returns an empty sorted map (immutable).
|
static <E> SortedSet<E> |
emptySortedSet()
Returns an empty sorted set (immutable).
|
static <T> Enumeration<T> |
enumeration(Collection<T> c)
Returns an enumeration over the specified collection.
|
static <T> void |
fill(List<? super T> list,
T obj)
Replaces all of the elements of the specified list with the specified
element.
|
static int |
frequency(Collection<?> c,
Object o)
Returns the number of elements in the specified collection equal to the
specified object.
|
static int |
indexOfSubList(List<?> source,
List<?> target)
Returns the starting position of the first occurrence of the specified
target list within the specified source list, or -1 if there is no
such occurrence.
|
static int |
lastIndexOfSubList(List<?> source,
List<?> target)
Returns the starting position of the last occurrence of the specified
target list within the specified source list, or -1 if there is no such
occurrence.
|
static <T> ArrayList<T> |
list(Enumeration<T> e)
Returns an array list containing the elements returned by the
specified enumeration in the order they are returned by the
enumeration.
|
static <T extends Object & Comparable<? super T>> |
max(Collection<? extends T> coll)
Returns the maximum element of the given collection, according to the
natural ordering of its elements.
|
static <T> T |
max(Collection<? extends T> coll,
Comparator<? super T> comp)
Returns the maximum element of the given collection, according to the
order induced by the specified comparator.
|
static <T extends Object & Comparable<? super T>> |
min(Collection<? extends T> coll)
Returns the minimum element of the given collection, according to the
natural ordering of its elements.
|
static <T> T |
min(Collection<? extends T> coll,
Comparator<? super T> comp)
Returns the minimum element of the given collection, according to the
order induced by the specified comparator.
|
static <T> List<T> |
nCopies(int n,
T o)
Returns an immutable list consisting of n copies of the
specified object.
|
static <E> Set<E> |
newSetFromMap(Map<E,Boolean> map)
Returns a set backed by the specified map.
|
static <T> boolean |
replaceAll(List<T> list,
T oldVal,
T newVal)
Replaces all occurrences of one specified value in a list with another.
|
static void |
reverse(List<?> list)
Reverses the order of the elements in the specified list.
|
static <T> Comparator<T> |
reverseOrder()
Returns a comparator that imposes the reverse of the natural
ordering on a collection of objects that implement the
Comparable interface. |
static <T> Comparator<T> |
reverseOrder(Comparator<T> cmp)
Returns a comparator that imposes the reverse ordering of the specified
comparator.
|
static void |
rotate(List<?> list,
int distance)
Rotates the elements in the specified list by the specified distance.
|
static void |
shuffle(List<?> list)
Randomly permutes the specified list using a default source of
randomness.
|
static void |
shuffle(List<?> list,
Random rnd)
Randomly permute the specified list using the specified source of
randomness.
|
static <T> Set<T> |
singleton(T o)
Returns an immutable set containing only the specified object.
|
static <T> List<T> |
singletonList(T o)
Returns an immutable list containing only the specified object.
|
static <K,V> Map<K,V> |
singletonMap(K key,
V value)
Returns an immutable map, mapping only the specified key to the
specified value.
|
static <T extends Comparable<? super T>> |
sort(List<T> list)
Sorts the specified list into ascending order, according to the
natural ordering of its elements.
|
static <T> void |
sort(List<T> list,
Comparator<? super T> c)
Sorts the specified list according to the order induced by the
specified comparator.
|
static void |
swap(List<?> list,
int i,
int j)
Swaps the elements at the specified positions in the specified list.
|
static <T> Collection<T> |
synchronizedCollection(Collection<T> c)
Returns a synchronized (thread-safe) collection backed by the specified
collection.
|
static <T> List<T> |
synchronizedList(List<T> list)
Returns a synchronized (thread-safe) list backed by the specified
list.
|
static <K,V> Map<K,V> |
synchronizedMap(Map<K,V> m)
Returns a synchronized (thread-safe) map backed by the specified
map.
|
static <K,V> NavigableMap<K,V> |
synchronizedNavigableMap(NavigableMap<K,V> m)
Returns a synchronized (thread-safe) navigable map backed by the
specified navigable map.
|
static <T> NavigableSet<T> |
synchronizedNavigableSet(NavigableSet<T> s)
Returns a synchronized (thread-safe) navigable set backed by the
specified navigable set.
|
static <T> Set<T> |
synchronizedSet(Set<T> s)
Returns a synchronized (thread-safe) set backed by the specified
set.
|
static <K,V> SortedMap<K,V> |
synchronizedSortedMap(SortedMap<K,V> m)
Returns a synchronized (thread-safe) sorted map backed by the specified
sorted map.
|
static <T> SortedSet<T> |
synchronizedSortedSet(SortedSet<T> s)
Returns a synchronized (thread-safe) sorted set backed by the specified
sorted set.
|
static <T> Collection<T> |
unmodifiableCollection(Collection<? extends T> c)
Returns an unmodifiable view of the specified collection.
|
static <T> List<T> |
unmodifiableList(List<? extends T> list)
Returns an unmodifiable view of the specified list.
|
static <K,V> Map<K,V> |
unmodifiableMap(Map<? extends K,? extends V> m)
Returns an unmodifiable view of the specified map.
|
static <K,V> NavigableMap<K,V> |
unmodifiableNavigableMap(NavigableMap<K,? extends V> m)
Returns an unmodifiable view of the specified navigable map.
|
static <T> NavigableSet<T> |
unmodifiableNavigableSet(NavigableSet<T> s)
Returns an unmodifiable view of the specified navigable set.
|
static <T> Set<T> |
unmodifiableSet(Set<? extends T> s)
Returns an unmodifiable view of the specified set.
|
static <K,V> SortedMap<K,V> |
unmodifiableSortedMap(SortedMap<K,? extends V> m)
Returns an unmodifiable view of the specified sorted map.
|
static <T> SortedSet<T> |
unmodifiableSortedSet(SortedSet<T> s)
Returns an unmodifiable view of the specified sorted set.
|
public static final Set EMPTY_SET
emptySet()
public static final List EMPTY_LIST
emptyList()
public static final Map EMPTY_MAP
emptyMap()
public static <T extends Comparable<? super T>> void sort(List<T> list)
Comparable
interface. Furthermore, all elements in the list must be
mutually comparable (that is, e1.compareTo(e2)
must not throw a ClassCastException
for any elements
e1
and e2
in the list).
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort.
The specified list must be modifiable, but need not be resizable.
T
- the class of the objects in the listlist
- the list to be sorted.ClassCastException
- if the list contains elements that are not
mutually comparable (for example, strings and integers).UnsupportedOperationException
- if the specified list's
list-iterator does not support the set
operation.IllegalArgumentException
- (optional) if the implementation
detects that the natural ordering of the list elements is
found to violate the Comparable
contractList.sort(Comparator)
public static <T> void sort(List<T> list, Comparator<? super T> c)
c.compare(e1, e2)
must not throw a ClassCastException
for any elements e1
and e2
in the list).
This sort is guaranteed to be stable: equal elements will not be reordered as a result of the sort.
The specified list must be modifiable, but need not be resizable.
T
- the class of the objects in the listlist
- the list to be sorted.c
- the comparator to determine the order of the list. A
null
value indicates that the elements' natural
ordering should be used.ClassCastException
- if the list contains elements that are not
mutually comparable using the specified comparator.UnsupportedOperationException
- if the specified list's
list-iterator does not support the set
operation.IllegalArgumentException
- (optional) if the comparator is
found to violate the Comparator
contractList.sort(Comparator)
public static <T> int binarySearch(List<? extends Comparable<? super T>> list, T key)
sort(List)
method) prior to making this
call. If it is not sorted, the results are undefined. If the list
contains multiple elements equal to the specified object, there is no
guarantee which one will be found.
This method runs in log(n) time for a "random access" list (which
provides near-constant-time positional access). If the specified list
does not implement the RandomAccess
interface and is large,
this method will do an iterator-based binary search that performs
O(n) link traversals and O(log n) element comparisons.
T
- the class of the objects in the listlist
- the list to be searched.key
- the key to be searched for.ClassCastException
- if the list contains elements that are not
mutually comparable (for example, strings and
integers), or the search key is not mutually comparable
with the elements of the list.public static <T> int binarySearch(List<? extends T> list, T key, Comparator<? super T> c)
sort(List, Comparator)
method), prior to making this call. If it is
not sorted, the results are undefined. If the list contains multiple
elements equal to the specified object, there is no guarantee which one
will be found.
This method runs in log(n) time for a "random access" list (which
provides near-constant-time positional access). If the specified list
does not implement the RandomAccess
interface and is large,
this method will do an iterator-based binary search that performs
O(n) link traversals and O(log n) element comparisons.
T
- the class of the objects in the listlist
- the list to be searched.key
- the key to be searched for.c
- the comparator by which the list is ordered.
A null value indicates that the elements'
natural ordering should be used.ClassCastException
- if the list contains elements that are not
mutually comparable using the specified comparator,
or the search key is not mutually comparable with the
elements of the list using this comparator.public static void reverse(List<?> list)
This method runs in linear time.
list
- the list whose elements are to be reversed.UnsupportedOperationException
- if the specified list or
its list-iterator does not support the set operation.public static void shuffle(List<?> list)
The hedge "approximately" is used in the foregoing description because default source of randomness is only approximately an unbiased source of independently chosen bits. If it were a perfect source of randomly chosen bits, then the algorithm would choose permutations with perfect uniformity.
This implementation traverses the list backwards, from the last element up to the second, repeatedly swapping a randomly selected element into the "current position". Elements are randomly selected from the portion of the list that runs from the first element to the current position, inclusive.
This method runs in linear time. If the specified list does not
implement the RandomAccess
interface and is large, this
implementation dumps the specified list into an array before shuffling
it, and dumps the shuffled array back into the list. This avoids the
quadratic behavior that would result from shuffling a "sequential
access" list in place.
list
- the list to be shuffled.UnsupportedOperationException
- if the specified list or
its list-iterator does not support the set operation.public static void shuffle(List<?> list, Random rnd)
This implementation traverses the list backwards, from the last element up to the second, repeatedly swapping a randomly selected element into the "current position". Elements are randomly selected from the portion of the list that runs from the first element to the current position, inclusive.
This method runs in linear time. If the specified list does not
implement the RandomAccess
interface and is large, this
implementation dumps the specified list into an array before shuffling
it, and dumps the shuffled array back into the list. This avoids the
quadratic behavior that would result from shuffling a "sequential
access" list in place.
list
- the list to be shuffled.rnd
- the source of randomness to use to shuffle the list.UnsupportedOperationException
- if the specified list or its
list-iterator does not support the set operation.public static void swap(List<?> list, int i, int j)
list
- The list in which to swap elements.i
- the index of one element to be swapped.j
- the index of the other element to be swapped.IndexOutOfBoundsException
- if either i or j
is out of range (i < 0 || i >= list.size()
|| j < 0 || j >= list.size()).public static <T> void fill(List<? super T> list, T obj)
This method runs in linear time.
T
- the class of the objects in the listlist
- the list to be filled with the specified element.obj
- The element with which to fill the specified list.UnsupportedOperationException
- if the specified list or its
list-iterator does not support the set operation.public static <T> void copy(List<? super T> dest, List<? extends T> src)
This method runs in linear time.
T
- the class of the objects in the listsdest
- The destination list.src
- The source list.IndexOutOfBoundsException
- if the destination list is too small
to contain the entire source List.UnsupportedOperationException
- if the destination list's
list-iterator does not support the set operation.public static <T extends Object & Comparable<? super T>> T min(Collection<? extends T> coll)
This method iterates over the entire collection, hence it requires time proportional to the size of the collection.
T
- the class of the objects in the collectioncoll
- the collection whose minimum element is to be determined.ClassCastException
- if the collection contains elements that are
not mutually comparable (for example, strings and
integers).NoSuchElementException
- if the collection is empty.Comparable
public static <T> T min(Collection<? extends T> coll, Comparator<? super T> comp)
This method iterates over the entire collection, hence it requires time proportional to the size of the collection.
T
- the class of the objects in the collectioncoll
- the collection whose minimum element is to be determined.comp
- the comparator with which to determine the minimum element.
A null value indicates that the elements' natural
ordering should be used.ClassCastException
- if the collection contains elements that are
not mutually comparable using the specified comparator.NoSuchElementException
- if the collection is empty.Comparable
public static <T extends Object & Comparable<? super T>> T max(Collection<? extends T> coll)
This method iterates over the entire collection, hence it requires time proportional to the size of the collection.
T
- the class of the objects in the collectioncoll
- the collection whose maximum element is to be determined.ClassCastException
- if the collection contains elements that are
not mutually comparable (for example, strings and
integers).NoSuchElementException
- if the collection is empty.Comparable
public static <T> T max(Collection<? extends T> coll, Comparator<? super T> comp)
This method iterates over the entire collection, hence it requires time proportional to the size of the collection.
T
- the class of the objects in the collectioncoll
- the collection whose maximum element is to be determined.comp
- the comparator with which to determine the maximum element.
A null value indicates that the elements' natural
ordering should be used.ClassCastException
- if the collection contains elements that are
not mutually comparable using the specified comparator.NoSuchElementException
- if the collection is empty.Comparable
public static void rotate(List<?> list, int distance)
For example, suppose list comprises [t, a, n, k, s]. After invoking Collections.rotate(list, 1) (or Collections.rotate(list, -4)), list will comprise [s, t, a, n, k].
Note that this method can usefully be applied to sublists to move one or more elements within a list while preserving the order of the remaining elements. For example, the following idiom moves the element at index j forward to position k (which must be greater than or equal to j):
Collections.rotate(list.subList(j, k+1), -1);To make this concrete, suppose list comprises [a, b, c, d, e]. To move the element at index 1 (b) forward two positions, perform the following invocation:
Collections.rotate(l.subList(1, 4), -1);The resulting list is [a, c, d, b, e].
To move more than one element forward, increase the absolute value of the rotation distance. To move elements backward, use a positive shift distance.
If the specified list is small or implements the RandomAccess
interface, this implementation exchanges the first
element into the location it should go, and then repeatedly exchanges
the displaced element into the location it should go until a displaced
element is swapped into the first element. If necessary, the process
is repeated on the second and successive elements, until the rotation
is complete. If the specified list is large and doesn't implement the
RandomAccess interface, this implementation breaks the
list into two sublist views around index -distance mod size.
Then the reverse(List)
method is invoked on each sublist view,
and finally it is invoked on the entire list. For a more complete
description of both algorithms, see Section 2.3 of Jon Bentley's
Programming Pearls (Addison-Wesley, 1986).
list
- the list to be rotated.distance
- the distance to rotate the list. There are no
constraints on this value; it may be zero, negative, or
greater than list.size().UnsupportedOperationException
- if the specified list or
its list-iterator does not support the set operation.public static <T> boolean replaceAll(List<T> list, T oldVal, T newVal)
T
- the class of the objects in the listlist
- the list in which replacement is to occur.oldVal
- the old value to be replaced.newVal
- the new value with which oldVal is to be
replaced.UnsupportedOperationException
- if the specified list or
its list-iterator does not support the set operation.public static int indexOfSubList(List<?> source, List<?> target)
source.subList(i, i+target.size()).equals(target)
,
or -1 if there is no such index. (Returns -1 if
target.size() > source.size()
)
This implementation uses the "brute force" technique of scanning over the source list, looking for a match with the target at each location in turn.
source
- the list in which to search for the first occurrence
of target.target
- the list to search for as a subList of source.public static int lastIndexOfSubList(List<?> source, List<?> target)
source.subList(i, i+target.size()).equals(target)
,
or -1 if there is no such index. (Returns -1 if
target.size() > source.size()
)
This implementation uses the "brute force" technique of iterating over the source list, looking for a match with the target at each location in turn.
source
- the list in which to search for the last occurrence
of target.target
- the list to search for as a subList of source.public static <T> Collection<T> unmodifiableCollection(Collection<? extends T> c)
The returned collection does not pass the hashCode and equals operations through to the backing collection, but relies on Object's equals and hashCode methods. This is necessary to preserve the contracts of these operations in the case that the backing collection is a set or a list.
The returned collection will be serializable if the specified collection is serializable.
T
- the class of the objects in the collectionc
- the collection for which an unmodifiable view is to be
returned.public static <T> Set<T> unmodifiableSet(Set<? extends T> s)
The returned set will be serializable if the specified set is serializable.
T
- the class of the objects in the sets
- the set for which an unmodifiable view is to be returned.public static <T> SortedSet<T> unmodifiableSortedSet(SortedSet<T> s)
The returned sorted set will be serializable if the specified sorted set is serializable.
T
- the class of the objects in the sets
- the sorted set for which an unmodifiable view is to be
returned.public static <T> NavigableSet<T> unmodifiableNavigableSet(NavigableSet<T> s)
subSet
, headSet
, or tailSet
views, result in
an UnsupportedOperationException
.The returned navigable set will be serializable if the specified navigable set is serializable.
T
- the class of the objects in the sets
- the navigable set for which an unmodifiable view is to be
returnedpublic static <T> List<T> unmodifiableList(List<? extends T> list)
The returned list will be serializable if the specified list
is serializable. Similarly, the returned list will implement
RandomAccess
if the specified list does.
T
- the class of the objects in the listlist
- the list for which an unmodifiable view is to be returned.public static <K,V> Map<K,V> unmodifiableMap(Map<? extends K,? extends V> m)
The returned map will be serializable if the specified map is serializable.
K
- the class of the map keysV
- the class of the map valuesm
- the map for which an unmodifiable view is to be returned.public static <K,V> SortedMap<K,V> unmodifiableSortedMap(SortedMap<K,? extends V> m)
The returned sorted map will be serializable if the specified sorted map is serializable.
K
- the class of the map keysV
- the class of the map valuesm
- the sorted map for which an unmodifiable view is to be
returned.public static <K,V> NavigableMap<K,V> unmodifiableNavigableMap(NavigableMap<K,? extends V> m)
subMap
, headMap
, or tailMap
views, result in
an UnsupportedOperationException
.The returned navigable map will be serializable if the specified navigable map is serializable.
K
- the class of the map keysV
- the class of the map valuesm
- the navigable map for which an unmodifiable view is to be
returnedpublic static <T> Collection<T> synchronizedCollection(Collection<T> c)
It is imperative that the user manually synchronize on the returned
collection when traversing it via Iterator
, Spliterator
or Stream
:
Collection c = Collections.synchronizedCollection(myCollection); ... synchronized (c) { Iterator i = c.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }Failure to follow this advice may result in non-deterministic behavior.
The returned collection does not pass the hashCode
and equals
operations through to the backing collection, but
relies on Object
's equals and hashCode methods. This is
necessary to preserve the contracts of these operations in the case
that the backing collection is a set or a list.
The returned collection will be serializable if the specified collection is serializable.
T
- the class of the objects in the collectionc
- the collection to be "wrapped" in a synchronized collection.public static <T> Set<T> synchronizedSet(Set<T> s)
It is imperative that the user manually synchronize on the returned set when iterating over it:
Set s = Collections.synchronizedSet(new HashSet()); ... synchronized (s) { Iterator i = s.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }Failure to follow this advice may result in non-deterministic behavior.
The returned set will be serializable if the specified set is serializable.
T
- the class of the objects in the sets
- the set to be "wrapped" in a synchronized set.public static <T> SortedSet<T> synchronizedSortedSet(SortedSet<T> s)
It is imperative that the user manually synchronize on the returned sorted set when iterating over it or any of its subSet, headSet, or tailSet views.
SortedSet s = Collections.synchronizedSortedSet(new TreeSet()); ... synchronized (s) { Iterator i = s.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }or:
SortedSet s = Collections.synchronizedSortedSet(new TreeSet()); SortedSet s2 = s.headSet(foo); ... synchronized (s) { // Note: s, not s2!!! Iterator i = s2.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }Failure to follow this advice may result in non-deterministic behavior.
The returned sorted set will be serializable if the specified sorted set is serializable.
T
- the class of the objects in the sets
- the sorted set to be "wrapped" in a synchronized sorted set.public static <T> NavigableSet<T> synchronizedNavigableSet(NavigableSet<T> s)
It is imperative that the user manually synchronize on the returned
navigable set when iterating over it or any of its subSet
,
headSet
, or tailSet
views.
NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet()); ... synchronized (s) { Iterator i = s.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }or:
NavigableSet s = Collections.synchronizedNavigableSet(new TreeSet()); NavigableSet s2 = s.headSet(foo, true); ... synchronized (s) { // Note: s, not s2!!! Iterator i = s2.iterator(); // Must be in the synchronized block while (i.hasNext()) foo(i.next()); }Failure to follow this advice may result in non-deterministic behavior.
The returned navigable set will be serializable if the specified navigable set is serializable.
T
- the class of the objects in the sets
- the navigable set to be "wrapped" in a synchronized navigable
setpublic static <T> List<T> synchronizedList(List<T> list)
It is imperative that the user manually synchronize on the returned list when iterating over it:
List list = Collections.synchronizedList(new ArrayList()); ... synchronized (list) { Iterator i = list.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }Failure to follow this advice may result in non-deterministic behavior.
The returned list will be serializable if the specified list is serializable.
T
- the class of the objects in the listlist
- the list to be "wrapped" in a synchronized list.public static <K,V> Map<K,V> synchronizedMap(Map<K,V> m)
It is imperative that the user manually synchronize on the returned map when iterating over any of its collection views:
Map m = Collections.synchronizedMap(new HashMap()); ... Set s = m.keySet(); // Needn't be in synchronized block ... synchronized (m) { // Synchronizing on m, not s! Iterator i = s.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }Failure to follow this advice may result in non-deterministic behavior.
The returned map will be serializable if the specified map is serializable.
K
- the class of the map keysV
- the class of the map valuesm
- the map to be "wrapped" in a synchronized map.public static <K,V> SortedMap<K,V> synchronizedSortedMap(SortedMap<K,V> m)
It is imperative that the user manually synchronize on the returned sorted map when iterating over any of its collection views, or the collections views of any of its subMap, headMap or tailMap views.
SortedMap m = Collections.synchronizedSortedMap(new TreeMap()); ... Set s = m.keySet(); // Needn't be in synchronized block ... synchronized (m) { // Synchronizing on m, not s! Iterator i = s.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }or:
SortedMap m = Collections.synchronizedSortedMap(new TreeMap()); SortedMap m2 = m.subMap(foo, bar); ... Set s2 = m2.keySet(); // Needn't be in synchronized block ... synchronized (m) { // Synchronizing on m, not m2 or s2! Iterator i = s.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }Failure to follow this advice may result in non-deterministic behavior.
The returned sorted map will be serializable if the specified sorted map is serializable.
K
- the class of the map keysV
- the class of the map valuesm
- the sorted map to be "wrapped" in a synchronized sorted map.public static <K,V> NavigableMap<K,V> synchronizedNavigableMap(NavigableMap<K,V> m)
It is imperative that the user manually synchronize on the returned
navigable map when iterating over any of its collection views, or the
collections views of any of its subMap
, headMap
or
tailMap
views.
NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap()); ... Set s = m.keySet(); // Needn't be in synchronized block ... synchronized (m) { // Synchronizing on m, not s! Iterator i = s.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }or:
NavigableMap m = Collections.synchronizedNavigableMap(new TreeMap()); NavigableMap m2 = m.subMap(foo, true, bar, false); ... Set s2 = m2.keySet(); // Needn't be in synchronized block ... synchronized (m) { // Synchronizing on m, not m2 or s2! Iterator i = s.iterator(); // Must be in synchronized block while (i.hasNext()) foo(i.next()); }Failure to follow this advice may result in non-deterministic behavior.
The returned navigable map will be serializable if the specified navigable map is serializable.
K
- the class of the map keysV
- the class of the map valuesm
- the navigable map to be "wrapped" in a synchronized navigable
mappublic static <E> Collection<E> checkedCollection(Collection<E> c, Class<E> type)
ClassCastException
. Assuming a collection
contains no incorrectly typed elements prior to the time a
dynamically typesafe view is generated, and that all subsequent
access to the collection takes place through the view, it is
guaranteed that the collection cannot contain an incorrectly
typed element.
The generics mechanism in the language provides compile-time (static) type checking, but it is possible to defeat this mechanism with unchecked casts. Usually this is not a problem, as the compiler issues warnings on all such unchecked operations. There are, however, times when static type checking alone is not sufficient. For example, suppose a collection is passed to a third-party library and it is imperative that the library code not corrupt the collection by inserting an element of the wrong type.
Another use of dynamically typesafe views is debugging. Suppose a
program fails with a ClassCastException
, indicating that an
incorrectly typed element was put into a parameterized collection.
Unfortunately, the exception can occur at any time after the erroneous
element is inserted, so it typically provides little or no information
as to the real source of the problem. If the problem is reproducible,
one can quickly determine its source by temporarily modifying the
program to wrap the collection with a dynamically typesafe view.
For example, this declaration:
Collection<String> c = new HashSet<>();
may be replaced temporarily by this one:
Collection<String> c = Collections.checkedCollection(
new HashSet<>(), String.class);
Running the program again will cause it to fail at the point where
an incorrectly typed element is inserted into the collection, clearly
identifying the source of the problem. Once the problem is fixed, the
modified declaration may be reverted back to the original.
The returned collection does not pass the hashCode and equals
operations through to the backing collection, but relies on
Object
's equals
and hashCode
methods. This
is necessary to preserve the contracts of these operations in the case
that the backing collection is a set or a list.
The returned collection will be serializable if the specified collection is serializable.
Since null
is considered to be a value of any reference
type, the returned collection permits insertion of null elements
whenever the backing collection does.
E
- the class of the objects in the collectionc
- the collection for which a dynamically typesafe view is to be
returnedtype
- the type of element that c
is permitted to holdpublic static <E> Queue<E> checkedQueue(Queue<E> queue, Class<E> type)
ClassCastException
. Assuming a queue contains
no incorrectly typed elements prior to the time a dynamically typesafe
view is generated, and that all subsequent access to the queue
takes place through the view, it is guaranteed that the
queue cannot contain an incorrectly typed element.
A discussion of the use of dynamically typesafe views may be
found in the documentation for the checkedCollection
method.
The returned queue will be serializable if the specified queue is serializable.
Since null
is considered to be a value of any reference
type, the returned queue permits insertion of null
elements
whenever the backing queue does.
E
- the class of the objects in the queuequeue
- the queue for which a dynamically typesafe view is to be
returnedtype
- the type of element that queue
is permitted to holdpublic static <E> Set<E> checkedSet(Set<E> s, Class<E> type)
ClassCastException
. Assuming a set contains
no incorrectly typed elements prior to the time a dynamically typesafe
view is generated, and that all subsequent access to the set
takes place through the view, it is guaranteed that the
set cannot contain an incorrectly typed element.
A discussion of the use of dynamically typesafe views may be
found in the documentation for the checkedCollection
method.
The returned set will be serializable if the specified set is serializable.
Since null
is considered to be a value of any reference
type, the returned set permits insertion of null elements whenever
the backing set does.
E
- the class of the objects in the sets
- the set for which a dynamically typesafe view is to be
returnedtype
- the type of element that s
is permitted to holdpublic static <E> SortedSet<E> checkedSortedSet(SortedSet<E> s, Class<E> type)
ClassCastException
. Assuming a sorted set
contains no incorrectly typed elements prior to the time a
dynamically typesafe view is generated, and that all subsequent
access to the sorted set takes place through the view, it is
guaranteed that the sorted set cannot contain an incorrectly
typed element.
A discussion of the use of dynamically typesafe views may be
found in the documentation for the checkedCollection
method.
The returned sorted set will be serializable if the specified sorted set is serializable.
Since null
is considered to be a value of any reference
type, the returned sorted set permits insertion of null elements
whenever the backing sorted set does.
E
- the class of the objects in the sets
- the sorted set for which a dynamically typesafe view is to be
returnedtype
- the type of element that s
is permitted to holdpublic static <E> NavigableSet<E> checkedNavigableSet(NavigableSet<E> s, Class<E> type)
ClassCastException
. Assuming a navigable set
contains no incorrectly typed elements prior to the time a
dynamically typesafe view is generated, and that all subsequent
access to the navigable set takes place through the view, it is
guaranteed that the navigable set cannot contain an incorrectly
typed element.
A discussion of the use of dynamically typesafe views may be
found in the documentation for the checkedCollection
method.
The returned navigable set will be serializable if the specified navigable set is serializable.
Since null
is considered to be a value of any reference
type, the returned navigable set permits insertion of null elements
whenever the backing sorted set does.
E
- the class of the objects in the sets
- the navigable set for which a dynamically typesafe view is to be
returnedtype
- the type of element that s
is permitted to holdpublic static <E> List<E> checkedList(List<E> list, Class<E> type)
ClassCastException
. Assuming a list contains
no incorrectly typed elements prior to the time a dynamically typesafe
view is generated, and that all subsequent access to the list
takes place through the view, it is guaranteed that the
list cannot contain an incorrectly typed element.
A discussion of the use of dynamically typesafe views may be
found in the documentation for the checkedCollection
method.
The returned list will be serializable if the specified list is serializable.
Since null
is considered to be a value of any reference
type, the returned list permits insertion of null elements whenever
the backing list does.
E
- the class of the objects in the listlist
- the list for which a dynamically typesafe view is to be
returnedtype
- the type of element that list
is permitted to holdpublic static <K,V> Map<K,V> checkedMap(Map<K,V> m, Class<K> keyType, Class<V> valueType)
ClassCastException
.
Similarly, any attempt to modify the value currently associated with
a key will result in an immediate ClassCastException
,
whether the modification is attempted directly through the map
itself, or through a Map.Entry
instance obtained from the
map's entry set
view.
Assuming a map contains no incorrectly typed keys or values prior to the time a dynamically typesafe view is generated, and that all subsequent access to the map takes place through the view (or one of its collection views), it is guaranteed that the map cannot contain an incorrectly typed key or value.
A discussion of the use of dynamically typesafe views may be
found in the documentation for the checkedCollection
method.
The returned map will be serializable if the specified map is serializable.
Since null
is considered to be a value of any reference
type, the returned map permits insertion of null keys or values
whenever the backing map does.
K
- the class of the map keysV
- the class of the map valuesm
- the map for which a dynamically typesafe view is to be
returnedkeyType
- the type of key that m
is permitted to holdvalueType
- the type of value that m
is permitted to holdpublic static <K,V> SortedMap<K,V> checkedSortedMap(SortedMap<K,V> m, Class<K> keyType, Class<V> valueType)
ClassCastException
.
Similarly, any attempt to modify the value currently associated with
a key will result in an immediate ClassCastException
,
whether the modification is attempted directly through the map
itself, or through a Map.Entry
instance obtained from the
map's entry set
view.
Assuming a map contains no incorrectly typed keys or values prior to the time a dynamically typesafe view is generated, and that all subsequent access to the map takes place through the view (or one of its collection views), it is guaranteed that the map cannot contain an incorrectly typed key or value.
A discussion of the use of dynamically typesafe views may be
found in the documentation for the checkedCollection
method.
The returned map will be serializable if the specified map is serializable.
Since null
is considered to be a value of any reference
type, the returned map permits insertion of null keys or values
whenever the backing map does.
K
- the class of the map keysV
- the class of the map valuesm
- the map for which a dynamically typesafe view is to be
returnedkeyType
- the type of key that m
is permitted to holdvalueType
- the type of value that m
is permitted to holdpublic static <K,V> NavigableMap<K,V> checkedNavigableMap(NavigableMap<K,V> m, Class<K> keyType, Class<V> valueType)
ClassCastException
.
Similarly, any attempt to modify the value currently associated with
a key will result in an immediate ClassCastException
,
whether the modification is attempted directly through the map
itself, or through a Map.Entry
instance obtained from the
map's entry set
view.
Assuming a map contains no incorrectly typed keys or values prior to the time a dynamically typesafe view is generated, and that all subsequent access to the map takes place through the view (or one of its collection views), it is guaranteed that the map cannot contain an incorrectly typed key or value.
A discussion of the use of dynamically typesafe views may be
found in the documentation for the checkedCollection
method.
The returned map will be serializable if the specified map is serializable.
Since null
is considered to be a value of any reference
type, the returned map permits insertion of null keys or values
whenever the backing map does.
K
- type of map keysV
- type of map valuesm
- the map for which a dynamically typesafe view is to be
returnedkeyType
- the type of key that m
is permitted to holdvalueType
- the type of value that m
is permitted to holdpublic static <T> Iterator<T> emptyIterator()
hasNext
always returns false
.next
always throws NoSuchElementException
.remove
always throws IllegalStateException
.Implementations of this method are permitted, but not required, to return the same object from multiple invocations.
T
- type of elements, if there were any, in the iteratorpublic static <T> ListIterator<T> emptyListIterator()
hasNext
and hasPrevious
always return false
.next
and previous
always throw NoSuchElementException
.remove
and set
always throw IllegalStateException
.add
always throws UnsupportedOperationException
.nextIndex
always returns
0
.previousIndex
always
returns -1
.Implementations of this method are permitted, but not required, to return the same object from multiple invocations.
T
- type of elements, if there were any, in the iteratorpublic static <T> Enumeration<T> emptyEnumeration()
hasMoreElements
always
returns false
.nextElement
always throws
NoSuchElementException
.Implementations of this method are permitted, but not required, to return the same object from multiple invocations.
T
- the class of the objects in the enumerationpublic static final <T> Set<T> emptySet()
This example illustrates the type-safe way to obtain an empty set:
Set<String> s = Collections.emptySet();
T
- the class of the objects in the setEMPTY_SET
public static <E> SortedSet<E> emptySortedSet()
This example illustrates the type-safe way to obtain an empty sorted set:
SortedSet<String> s = Collections.emptySortedSet();
E
- type of elements, if there were any, in the setpublic static <E> NavigableSet<E> emptyNavigableSet()
This example illustrates the type-safe way to obtain an empty navigable set:
NavigableSet<String> s = Collections.emptyNavigableSet();
E
- type of elements, if there were any, in the setpublic static final <T> List<T> emptyList()
This example illustrates the type-safe way to obtain an empty list:
List<String> s = Collections.emptyList();
T
- type of elements, if there were any, in the listEMPTY_LIST
public static final <K,V> Map<K,V> emptyMap()
This example illustrates the type-safe way to obtain an empty map:
Map<String, Date> s = Collections.emptyMap();
K
- the class of the map keysV
- the class of the map valuesEMPTY_MAP
public static final <K,V> SortedMap<K,V> emptySortedMap()
This example illustrates the type-safe way to obtain an empty map:
SortedMap<String, Date> s = Collections.emptySortedMap();
K
- the class of the map keysV
- the class of the map valuespublic static final <K,V> NavigableMap<K,V> emptyNavigableMap()
This example illustrates the type-safe way to obtain an empty map:
NavigableMap<String, Date> s = Collections.emptyNavigableMap();
K
- the class of the map keysV
- the class of the map valuespublic static <T> Set<T> singleton(T o)
T
- the class of the objects in the seto
- the sole object to be stored in the returned set.public static <T> List<T> singletonList(T o)
T
- the class of the objects in the listo
- the sole object to be stored in the returned list.public static <K,V> Map<K,V> singletonMap(K key, V value)
K
- the class of the map keysV
- the class of the map valueskey
- the sole key to be stored in the returned map.value
- the value to which the returned map maps key.public static <T> List<T> nCopies(int n, T o)
T
- the class of the object to copy and of the objects
in the returned list.n
- the number of elements in the returned list.o
- the element to appear repeatedly in the returned list.IllegalArgumentException
- if n < 0
List.addAll(Collection)
,
List.addAll(int, Collection)
public static <T> Comparator<T> reverseOrder()
Comparable
interface. (The natural ordering is the ordering
imposed by the objects' own compareTo
method.) This enables a
simple idiom for sorting (or maintaining) collections (or arrays) of
objects that implement the Comparable
interface in
reverse-natural-order. For example, suppose a
is an array of
strings. Then: Arrays.sort(a, Collections.reverseOrder());sorts the array in reverse-lexicographic (alphabetical) order.
The returned comparator is serializable.
T
- the class of the objects compared by the comparatorComparable
public static <T> Comparator<T> reverseOrder(Comparator<T> cmp)
null
, this method is
equivalent to reverseOrder()
(in other words, it returns a
comparator that imposes the reverse of the natural ordering on
a collection of objects that implement the Comparable interface).
The returned comparator is serializable (assuming the specified
comparator is also serializable or null
).
T
- the class of the objects compared by the comparatorcmp
- a comparator who's ordering is to be reversed by the returned
comparator or null
public static <T> Enumeration<T> enumeration(Collection<T> c)
T
- the class of the objects in the collectionc
- the collection for which an enumeration is to be returned.Enumeration
public static <T> ArrayList<T> list(Enumeration<T> e)
T
- the class of the objects returned by the enumeratione
- enumeration providing elements for the returned
array listEnumeration
,
ArrayList
public static int frequency(Collection<?> c, Object o)
c
- the collection in which to determine the frequency
of oo
- the object whose frequency is to be determinedc
equal to o
NullPointerException
- if c is nullpublic static boolean disjoint(Collection<?> c1, Collection<?> c2)
true
if the two specified collections have no
elements in common.
Care must be exercised if this method is used on collections that
do not comply with the general contract for Collection
.
Implementations may elect to iterate over either collection and test
for containment in the other collection (or to perform any equivalent
computation). If either collection uses a nonstandard equality test
(as does a SortedSet
whose ordering is not compatible with
equals, or the key set of an IdentityHashMap
), both
collections must use the same nonstandard equality test, or the
result of this method is undefined.
Care must also be exercised when using collections that have restrictions on the elements that they may contain. Collection implementations are allowed to throw exceptions for any operation involving elements they deem ineligible. For absolute safety the specified collections should contain only elements which are eligible elements for both collections.
Note that it is permissible to pass the same collection in both
parameters, in which case the method will return true
if and
only if the collection is empty.
c1
- a collectionc2
- a collectiontrue
if the two specified collections have no
elements in common.NullPointerException
- if either collection is null
.NullPointerException
- if one collection contains a null
element and null
is not an eligible element for the other collection.
(optional)ClassCastException
- if one collection contains an element that is
of a type which is ineligible for the other collection.
(optional)@SafeVarargs public static <T> boolean addAll(Collection<? super T> c, T... elements)
When elements are specified individually, this method provides a convenient way to add a few elements to an existing collection:
Collections.addAll(flavors, "Peaches 'n Plutonium", "Rocky Racoon");
T
- the class of the elements to add and of the collectionc
- the collection into which elements are to be insertedelements
- the elements to insert into cUnsupportedOperationException
- if c does not support
the add operationNullPointerException
- if elements contains one or more
null values and c does not permit null elements, or
if c or elements are nullIllegalArgumentException
- if some property of a value in
elements prevents it from being added to cCollection.addAll(Collection)
public static <E> Set<E> newSetFromMap(Map<E,Boolean> map)
Set
implementation corresponding to any Map
implementation. There
is no need to use this method on a Map
implementation that
already has a corresponding Set
implementation (such as HashMap
or TreeMap
).
Each method invocation on the set returned by this method results in exactly one method invocation on the backing map or its keySet view, with one exception. The addAll method is implemented as a sequence of put invocations on the backing map.
The specified map must be empty at the time this method is invoked, and should not be accessed directly after this method returns. These conditions are ensured if the map is created empty, passed directly to this method, and no reference to the map is retained, as illustrated in the following code fragment:
Set<Object> weakHashSet = Collections.newSetFromMap( new WeakHashMap<Object, Boolean>());
E
- the class of the map keys and of the objects in the
returned setmap
- the backing mapIllegalArgumentException
- if map is not emptypublic static <T> Queue<T> asLifoQueue(Deque<T> deque)
Deque
as a Last-in-first-out (Lifo)
Queue
. Method add is mapped to push,
remove is mapped to pop and so on. This
view can be useful when you would like to use a method
requiring a Queue but you need Lifo ordering.
Each method invocation on the queue returned by this method
results in exactly one method invocation on the backing deque, with
one exception. The addAll
method is
implemented as a sequence of addFirst
invocations on the backing deque.
T
- the class of the objects in the dequedeque
- the dequeDracula Javadoc Sample, Made with Allan Im.


This is where we sit down, grab a cup of coffee and dial in the details. Understanding the task at hand and ironing out the wrinkles is key.
Learn MoreNow that we've aligned the details, it's time to get things mapped out and organized. This part is really crucial in keeping the project in line to completion.
Learn MoreThe time has come to bring those ideas and plans to life. This is where we really begin to visualize your napkin sketches and make them into beautiful pixels.
Learn MoreWhether through commerce or just an experience to tell your brand's story, the time has come to start using development languages that fit your projects needs.
Learn MoreThe time has come to bring those ideas and plans to life. This is where we really begin to visualize your napkin sketches and make them into beautiful pixels.
Now that we've aligned the details, it's time to get things mapped out and organized. This part is really crucial in keeping the project in line to completion.
Learn MoreNow that your brand is all dressed up and ready to party, it's time to release it to the world. By the way, let's celebrate already.
Learn MoreWe get it, you're busy and it's important that someone keeps up with marketing and driving people to your brand. We've got you covered.
Learn MoreIt's important to stay detail oriented with every project we tackle. Staying focused allows us to turn every project we complete into something we love.
Learn MoreWe strive to embrace and drive change in our industry which allows us to keep our clients relevant and ready to adapt.
Learn More


Guillermo
About me.
Hi. I'm Guillermo. A Graphic Designer based in Los Angeles, California.
Projects I have worked on.


Daily UI Challenge is not squeezing out one UI design everyday. It is taking your time everyday to work on a good quality UI design.
DailyUI - Day 30: Pricing
Daily UI - Day 29: Map
DailyUI - Day 28: Contact Us
DailyUI - Day 27: Dropdown
DailyUI - Day 26: Subscribe
DailyUI - Day 25: TV App
DailyUI - Day 24: Boarding Pass
DailyUI - Day 23: Onboarding
DailyUI - Day 22: Search
DailyUI - Day 21: Home Monitoring Dashboard
DailyUI - Day 20: Location Tracker
DailyUI - Day 19: Leaderboard
DailyUI - Day 18: Analytics Chart
DailyUI - Day 17: Email Receipt
DailyUI - Day 16: Pop-Up / Overlay
Daily UI - Day 15: On/Off Switch
DailyUI - Day 14: Countdown Timer
DailyUI - Day 13: Direct Messaging
DailyUI - Day 12: E-Commerce Shop (Single Item)
DailyUI - Day 11: Flash Message
DailyUI - Day 10: Social Share
DailyUI - Day 09: Music Player
DailyUI - Day 08: 404 Page
DailyUI - Day 07: Settings
DailyUI - Day 06: User Profile
DailyUI - Day 05: App Icon
Daily UI - Day 04: Calculator
Daily UI - Day 03: Landing Page
Daily UI - Day 02: Credit Card Checkout
Daily UI - Day 01: Sign Up


| Home | Trees | Index | Help |
|---|
| Package svnmailer :: Package settings :: Module _typedstruct :: Class StructCreator |
|
object
--+
|
StructCreator
| Method Summary | |
|---|---|
Initialization | |
Descriptor |
Returns a new Descriptor instance |
MetaClass |
Returns a new MetaClass instance |
Private |
Returns a new Private instance |
| callable |
Returns the __call__ method |
| callable |
Returns __eq__/__ne__ descriptor |
| callable |
Returns the __getitem__ method |
| dict |
Generates the members descriptors |
| callable |
Returns the __repr__ method |
| callable |
Returns the __setitem__ method |
| dict |
Generates the special methods |
| tuple |
Prepares the member specs for later processing |
Struct |
Creates a new struct with extended properties |
| Inherited from object | |
x.__delattr__('name') <==> del x.name... | |
x.__getattribute__('name') <==> x.name... | |
x.__hash__() <==> hash(x)... | |
helper for pickle... | |
helper for pickle... | |
x.__repr__() <==> repr(x)... | |
x.__setattr__('name', value) <==> x.name = value... | |
x.__str__() <==> str(x)... | |
| Inherited from type | |
T.__new__(S, ...) -> a new object with type S, a subtype of T... |
| Instance Variable Summary | |
|---|---|
| dict | _aliases : The member aliases. |
MetaClass |
_cls : The struct class to use |
| dict | _eqignore : Member names to be ignored in EQ comparisons
(dict for faster lookup) |
| dict | _members : The prepared members
({('name', 'alias', 'alias', ...): (spec, param), ...}) |
| tuple | _names : The member names as tuple (without aliases) |
| Class Variable Summary | |
|---|---|
MetaClass |
_BASESTRUCT = svnmailer.settings._typedstruct.Struct |
Member |
_DEFAULTMEMBER = svnmailer.settings._typedstruct.Member |
Struct |
_DEFAULTSTRUCT = svnmailer.settings._typedstruct.Struct |
| Method Details |
|---|
__init__(self,
members,
cls=None,
aliases=None,
typemap=None,
eqignore=None)
Initialization |
_createDescriptor(self, name, private, member)Returns a newDescriptor instance
|
_createMetaClass(self, name, bases, cdict)Returns a newMetaClass instance
|
_createPrivate(self)Returns a newPrivate instance
|
_generateCall(self, private)Returns the __call__ method
|
_generateEq(self, private, iseq=True)Returns __eq__/__ne__ descriptor
|
_generateGetItem(self, private)Returns the __getitem__ method
|
_generateMembers(self, private, maps, arg)Generates the members descriptors
|
_generateRepr(self, private)Returns the __repr__ method
|
_generateSetItem(self, private)Returns the __setitem__ method
|
_generateSpecials(self, private)Generates the special methods
|
_prepareMembers(self, members, typemap)Prepares the member specs for later processing
|
create(self, maps=None, arg=None, initkw=None)Creates a new struct with extended properties
|
| Instance Variable Details |
|---|
_aliasesThe member aliases. ({'alias': 'real', ...})
|
_clsThe struct class to use
|
_eqignoreMember names to be ignored in EQ comparisons (dict for faster lookup)
|
_membersThe prepared members ({('name', 'alias', 'alias', ...): (spec, param), ...})
|
_namesThe member names as tuple (without aliases)
|
| Home | Trees | Index | Help |
|---|
| Generated by Epydoc 2.0 on Sun Sep 25 20:49:13 2005 | http://epydoc.sf.net |


{% extends 'base.html' %} {% load bootstrap3 %} {% block main %}
Yes! In Porter v Bowen (2007), vote swapping websites were ruled legal, at least in the 9th circuit.
On the merits, we hold that [California] violated Appellants’ First Amendment rights. The websites’ vote-swapping mechanisms as well as the communication and vote swaps they enabled were constitutionally protected.
For more background, please read "The Ninth Circuit ruled that vote-swapping is legal. Let’s use it to stop Trump" by Scott Aaronson, or electionlawblog.org's coverage of the ruling.
After the election, while the surprisingly high third-party turnout is still on everyone's minds, we can start a dialogue on changing our election process to use ranked choice voting, aka instant runoff elections.
This system of voting lets you write down your candidates in order, so if your first choice doesn't win, your vote goes to your second choice, and so on. This allows votes for third parties (or fourth, or fifth, or ...) to not be wasted and let the least favored candidate win.
Ranked choice voting is used around the world: cities and states in the United States, congressional elections in Australia, and for various elections in India, New Zealand, Ireland, and the United Kingdom.
Ranked choice voting is not without its flaws, but they can be addressed by using the Condorcet method to count votes. Condorcet voting prevents a few counter-intuitive outcomes of ranked choice voting, and should be our preferred method.


Sign In
fashion
beauty
art & lifestyle
runway
media
sign in
Top Stories
Fashion Trends
16 Beachwear Trends to Know Now
By Ella Parson
Fashion Trends
You need this activewear in your life
By Lee Chen
Fashion Trends
Summer Accessories for Every Occasion
By Ana Jones
Beauty
The Skin Care Line You've Been Waiting For
By Sara Petersson
Travel
12 Beaches to Visit in Italy
By Sam Ford
Travel
Where we're travelling in 2022
By Aadya Ram
Work & Careers
Saying goodbye to imposter syndrome
By Lucía Garcia


|
CS130_Team13
|
Public Member Functions | |
| IEnumerator | InitializeGame (string name) |
| void | SendPlayerCommands_ToServer (string commands) |
| Send the current player's command inputs to the server. More... | |
| void | EndCurrentGame_ToServer () |
| Connect to the server and tell it that the game has ended. More... | |
| string | GetOpponentCommands () |
| Returns the opponent's current commands Returns NULL if opponents have not submitted their commands, or there are no new commands More... | |
| string | GetOpponentName () |
| bool | GetGameStarted () |
| Returns a boolean that describes if the game has started true: client has received gameplay event, game has started false: client has been initialized but have not connected to server or no opponent has been found yet More... | |
| int | GetPlayerNumber () |
| Returns an int that describes the player's order number null : the players is not a valid player 1 or player 2, likely because there are already 2 players 1 : this user is player 1 2 : this user is player 2 Should not be called unless the game has started (GetGameStarted returns true) More... | |
| double | GetRandomSeed () |
| bool | GetGameEnded () |
| void | SetCurrentState (GameManager.GameState state) |
| void RemoteController.EndCurrentGame_ToServer | ( | ) |
Connect to the server and tell it that the game has ended.
This should be called by C# functions within Unity, and it should call Socket.IO-related functions within RemoteController.
Implements Opponent.
| bool RemoteController.GetGameEnded | ( | ) |
Implements Opponent.
| bool RemoteController.GetGameStarted | ( | ) |
Returns a boolean that describes if the game has started true: client has received gameplay event, game has started false: client has been initialized but have not connected to server or no opponent has been found yet
Implements Opponent.
| string RemoteController.GetOpponentCommands | ( | ) |
Returns the opponent's current commands Returns NULL if opponents have not submitted their commands, or there are no new commands
Implements Opponent.
| string RemoteController.GetOpponentName | ( | ) |
Implements Opponent.
| int RemoteController.GetPlayerNumber | ( | ) |
Returns an int that describes the player's order number null : the players is not a valid player 1 or player 2, likely because there are already 2 players 1 : this user is player 1 2 : this user is player 2 Should not be called unless the game has started (GetGameStarted returns true)
Implements Opponent.
| double RemoteController.GetRandomSeed | ( | ) |
Implements Opponent.
| IEnumerator RemoteController.InitializeGame | ( | string | name | ) |
Implements Opponent.
| void RemoteController.SendPlayerCommands_ToServer | ( | string | commands | ) |
Send the current player's command inputs to the server.
This should be called by C# functions within Unity, and it should call Socket.IO-related functions within RemoteController.
| commands | the player's commands, to be sent to the server |
Implements Opponent.
| void RemoteController.SetCurrentState | ( | GameManager.GameState | state | ) |
Implements Opponent.


HOOK (PG)
Directed by Steven Spielberg Running Time: 144 minutes Originally Released: December 11, 1991
Reviewed by E. Benjamin Kelsey
* * * ½ (out of four)
"Magical" may be a good word to describe quite a few of Steven Spielberg's films. He's notorious for elaborately done flicks, which are often fresh and visually superior to the run-of-the-mill movies coming out all the time. "Magical" can also be used to describe the world of fairy tales and legends we've all come to know and love as children. So what happens when the two meet? HOOK - and it's a delightful result.
HOOK asks the question, "what if Peter Pan grew up?" Simple, to the point, and very intriguing. HOOK begins in modern-day America as Peter Blanning (Robin Williams, excellently cast), a workaholic father of two, is taking his family back to London where he grew up. No, it's not a vacation, and we soon learn that it probably never would be since Peter can't get away from the demands of his office. The real reason they are heading across seas is to attend a special dinner in honor of Wendy Darling (Maggie Smith), the "mother" of orphaned Peter and several others. We also quickly learn that Peter's family relationship has suffered considerably due to his 25 hour business days. He misses his son's soccer games, he pays more attention to his cellular phone than his daughter's performance in a play, and although it's never addressed, he probably hasn't made love to his wife in months.
While in London, the temperatures continue to rise (metaphorically speaking). Even on the other side of the Atlantic, Peter can't get away from pressing business matters and non-stop phone calls. Nonetheless, Peter, his wife Moira (Caroline Goodall), and Granny Wendy head off to the award banquet, leaving the two children in care of some no name maid (or something - Hell, I don't know). While they're gone, tragedy strikes. Jack and Maggie (Charlie Korsmo and Amber Scott respectively), the two kids, get kidnapped by none other than Captain James Hook (Dustin Hoffman).
Naturally everybody freaks out and Phil Collins shows up playing a police officer. Sorry folks, no rock video forms here. The only evidence left behind is a note nailed, well actually "sworded" to the bedroom door from Captain Hook. It seems ole' Hook wants a rematch with his "only worthy opponent", and he's going to use the kids to make sure he gets it!
This is where things get interesting: Granny Wendy *is* the Wendy from the beloved fairytales! And, as she explains to Peter, he *is* actually thee Peter Pan.  But because Peter became Peter Blanning and blacked out that part of his memory, it's as much as shock to him as it is to us (in theory). And so, with nothing more to really be done, Peter ends up flying the friendly skies back to Never-Never Land to reclaim his children.
HOOK is actually quite an admirable film and, with a couple of exceptions, couldn't have been cast better. Williams plays both Blanning and Pan to a T. They could *not* have found a better man (or woman for that matter - think Mary Martin). Hoffman *is* Captain Hook, mixing the perfect amount of evil and cowardice to the role while Smith, Korsmo, Scott, and Bob Hoskins as Smee are all wonderful and damn-near flawless. It's Julia Roberts as Tinkerbell that really sinks and stinks.  Then again, when most of your lines are spoken to yourself, it could be mighty hard to play off of.
The sets and effects here are another delight. Seemingly simplistic at first, the Never-Never Land sets add quite a bit of depth and realism to the film, making it fun to watch as Peter re-discovers his true homeland. And while the special effects are not those of flashy sci-fi movies, they are quite well done and a pleasure to watch.
HOOK doesn't quite hold enough to be deemed a classic, but it does rise high above mediocrity with it's dynamic acting, captivating cinematography, and an enchanting musical score by John Williams. All of that tops off a richly intriguing plot with a definitive hook (pun heavily intended). If you're looking for some good family fare, this might just do you in!
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