1)
Mrs. Parker bought one
eggs from the supermarket. (dozen)
dozen
2)
There were several
(man) waiting at the bus stop.
men
3)
African village
(chief) agreed to end the war amongst them.
chiefs
4)
The English teacher was correcting
(essay) written by second grade students.
essays
5)
Canaries
6)
Deer
7)
The children put all their
(crayon) in their
(box) after the drawing class.
crayons
boxes
8)
The tour organiser carried packed
(lunch) for the day trip visit to the castle.
lunches


Seeded crackers for cheese recipe
by Xanthe ClayThere are some excellent ready-made crackers available (Peter’s Yard are my particular weakness), but there’s still something special about home-made ones, particularly if you present them with a whole soft cheese, or a good sized chunk of stilton or cheddar.
Prep time: 25 minutes | Cooking time: 15 minutes
MAKES
About 36 crackers
INGREDIENTS
- 100g wholemeal flour
- 100g plain white flour
- 30g rye flour
- 10g salt
- 100ml water
- 3 tbsp olive oil
- 200g mixed seeds – I use pumpkin, sunflower, sesame and linseed
- 3 tbsp poppy seeds (optional)
METHOD
- Preheat the oven to 200C/180C fan/Gas 6. In a large bowl, mix all three flours, the salt, water, olive oil, and most of the mixed seeds (save two tablespoons for scattering over the top). Knead lightly to make a dough.
- Roll out half to a 30 x 30cm square on a piece of non-stick parchment. It will be crumbly – all those seeds – so trim the edges to a neatish square and use the trimmings to patch any cracks. Still on the paper, cut into six long strips, and then across into three, making 18 roughly 5 x 10cm crackers.
- Brush with water and sprinkle with half the reserved seeds and the poppy seeds, if you are using them. Slide the crackers, still on the paper, on to a large baking sheet. Repeat with the other half of the dough.
- Bake for 15 minutes, turning the baking sheets halfway through, until the crackers are pale gold.
- Slide on to a cooling rack, and once cool break into separate crackers. Store in an airtight container.


In battlereport page the bf3stats.com button takes you to the pc version of the match report. This is true to at least ps3 matches.
For example:
http://battlelog.battlefield.com/bf3/battlereport/show/50773486/4/425035268/
The button links to:
http://bf3stats.com/report/pc/50773486
Should be
http://bf3stats.com/report/ps3/50773486


001 package org.codemonkey.util; 002 003 /** 004 * Interface for marking objects as datagram decoders. An encoded strings is a string that contains a number that denotes the length of a 005 * value followed by the value itself. Lists are prepended with the number of items in that list followed by a separator. 006 * 007 * @author Benny Bottema 008 * @since 1.0 009 */ 010 public interface DatagramDecoder { 011 012 /** 013 * Populates the current implementation instance fields with values decoded from the given string (binary packet / datagram) of the 014 * current server response. 015 * 016 * @param encodedString The string that can be decoded into a concrete class instance. 017 */ 018 void decode(StringBuilder encodedString); 019 }


Game 1: Golden State Warriors at Houston Rockets
My Pick:
Houston Rockets
Why I'm Rolling with them:
The Rockets have looked a lot better since getting rid of Melo, and while I don't think he's the reason for it (Harden and Paul have stepped up) I also don't think it's just an anomaly. The Rockets are starting to figure out their defense, only allowing 1 team to score more than 100 points in their last 6 games, and that 1 game came in a win against the Pacers. Golden State has looked vulnerable without Steph Curry in the rotation, and the Rockets should look to capitalize on that at home. Rockets, 110-105.
Game 2: Atlanta Hawks at Denver Nuggets
My Pick:
Denver Nuggets
Why I'm Rolling with them:
Denver has lost their last 4 games in a row, and look to turn it around against this Atlanta team. Jokic should be able to thrive against a team with a weak interior like this Atlanta squad, who have lost five straight against some good and bad teams. Trae Young is producing an incredible number of assists for a rookie, throwing up 8.2 assists per game (he's at almost double the next highest rookie in assists) and scoring 17.5 points as well. This Atlanta team can definitely come out and surprise some teams, I just don't think this strong Denver lineup is one of those teams. Nuggets win this one 119-109.
Game 3: San Antonio Spurs at Los Angeles Clippers
My Pick:
Los Angeles Clippers
Why I'm Rolling with them:
The Spurs looked lackluster against Phoenix last night, and this Clippers roster looked really good against a Golden State squad. Harrell has been on fire lately, averaging 23 points a game over his last 3 games. The Spurs are going to be tired, on the road, and won't have the intensity needed to deal with this physical Clippers squad. DeRozan has played well against Bradley in the past, so I'll be curious to see if San Antonio goes with the three guard lineup they ran against the Suns and the Kings. Either way, Clippers win 113-107.


How To Download And Install Java Jre Java Runtime Environment On Windows 10 Youtube
Jdk 6 Download For Windows 10 D0wnloadjames
40501 Sas 9 2 Requires Jre 1 6 0 14 32 Bit On Microsoft Windows 7 System And Jre 1 6 0 23 32 Bit On Microsoft Windows Server 2008 R2 System
Java 5 Update 6 Download Renewshots
Java Runtime Environment Download
Java 動作環境 Jre の導入 インストール Ver 6 みっちーわーるど
Java Runtime Environment Download
Java Jreだけ欲しい 実行環境だけ At Softelメモ
Java 6 Update 29 Offline Installer Omahaeasysite
How To Download And Install Jdk 1 6 On Windows Downlinko
Download Java Runtime Environment 64 Bit Majorgeeks
How To Download And Install Jdk 1 6 On Windows Downlinko
Download And Install Java 11 Openjdk And Oracle Jdk
How To Resolve A Java Runtime Environment Jre Or Java Development Kit Jdk Must Be Available In Order To Run Sapnetweaverdeveloperstudio No Java Virtual Machine Was Found After Searching The Following Locations
Java Download Version 6 Update 37
Java Runtime Not Recognized Stack Overflow
Sqlcoffee Oracle Jre 7 Update 51 64 Bit Or Higher Is Required


Table of Contents
The Java Virtual Machine dynamically loads, links and initializes classes and interfaces.
Loading is the process of finding the binary representation of a class or interface type with a particular name and
creating a class or interface from that binary representation.
Linking is the process of taking a class or interface and combining it into the run-time state of the Java Virtual Machine so that it can be executed.
Initialization of a class or interface consists of executing the class or interface initialization method <clinit>
(§2.9).
In this chapter, §5.1
describes how the Java Virtual Machine derives symbolic references from the binary representation of a class or interface.
§5.2
explains how the processes of loading, linking, and initialization are first initiated by the Java Virtual Machine.
笔记：这里总的来说loading、linking和initialization
§5.3
specifies how binary representations of classes and interfaces are loaded by class loaders and how classes
and interfaces are created.
笔记：这里分着来说loading
Linking is described in §5.4.
§5.5
details how classes and interfaces are initialized.
§5.6
introduces the notion of binding native methods.
Finally,
§5.7
describes when a Java Virtual Machine exits.
The Java Virtual Machine maintains a per-type constant pool
(§2.5.5),
a run-time data structure that serves many of the purposes of the symbol table of a conventional programming language implementation.
笔记：constant pool的作用相当于其它编程语言中的symbol table
The constant_pool
table
(§4.4)
in the binary representation of a class or interface
is used to construct the run-time constant pool upon class or interface creation
(§5.3).
笔记：constant pool --> runtime constant pool
All references in the run-time constant pool are initially symbolic.
The symbolic references in the run-time constant pool
are derived from structures in the binary representation of the class or interface as follows:
A symbolic reference to a class or interface is derived from a CONSTANT_Class_info
structure
(§4.4.1)
in the binary representation of a class or interface.
Such a reference gives the name of the class or interface in the form returned by the
Class.getName
method, that is:
For a nonarray class or an interface, the name is the binary name (§4.2.1) of the class or interface.
For an array class of n dimensions, the name begins with n occurrences of the ASCII "[" character followed by a representation of the element type:
Whenever this chapter refers to the name of a class or interface,
it should be understood to be in the form returned by the Class.getName
method.
A symbolic reference to a field of a class or an interface
is derived from a CONSTANT_Fieldref_info
structure
(§4.4.2)
in the binary representation of a class or interface.
Such a reference gives the name and descriptor of the field,
as well as a symbolic reference to the class or interface in which the field is to be found.
A symbolic reference to a method of a class
is derived from a CONSTANT_Methodref_info
structure
(§4.4.2)
in the binary representation of a class or interface.
Such a reference gives the name and descriptor of the method,
as well as a symbolic reference to the class in which the method is to be found.
A symbolic reference to a method of an interface
is derived from a CONSTANT_InterfaceMethodref_info
structure
(§4.4.2)
in the binary representation of a class or interface.
Such a reference gives the name and descriptor of the interface method,
as well as a symbolic reference to the interface in which the method is to be found.
A symbolic reference to a method handle
is derived from a CONSTANT_MethodHandle_info
structure
(§4.4.8)
in the binary representation of a class or interface.
Such a reference gives a symbolic reference to
a field of a class or interface,
or a method of a class,
or a method of an interface,
depending on the kind of the method handle.
A symbolic reference to a method type
is derived from a CONSTANT_MethodType_info
structure
(§4.4.9)
in the binary representation of a class or interface.
Such a reference gives a method descriptor
(§4.3.3).
A symbolic reference to a call site specifier
is derived from a CONSTANT_InvokeDynamic_info
structure
(§4.4.10)
in the binary representation of a class or interface. Such a reference gives:
a symbolic reference to a method handle, which will serve as a bootstrap method for an invokedynamic instruction (§invokedynamic);
a sequence of symbolic references (to classes, method types, and method handles), string literals, and run-time constant values which will serve as static arguments to a bootstrap method;
In addition, certain run-time values
which are not symbolic references
are derived from items found in the constant_pool
table:
A string literal is a reference
to an instance of class String
,
and is derived from a CONSTANT_String_info
structure
(§4.4.3)
in the binary representation of a class or interface.
The CONSTANT_String_info
structure
gives the sequence of Unicode code points constituting the string literal.
The Java programming language requires that
identical string literals
(that is, literals that contain the same sequence of code points)
must refer to the same instance of class String
(JLS §3.10.5).
In addition, if the method String.intern
is called on any string,
the result is a reference
to the same class instance
that would be returned if that string appeared as a literal.
Thus, the following expression must have the value true
:
("a" + "b" + "c").intern() == "abc"
To derive a string literal, the Java Virtual Machine examines the sequence of code points
given by the CONSTANT_String_info
structure.
If the method String.intern
has previously been called
on an instance of class String
containing a sequence of Unicode code points identical to
that given by the CONSTANT_String_info
structure,
then the result of string literal derivation is a reference
to that same instance of class String
.
Otherwise, a new instance of class String
is created containing the sequence of Unicode code points
given by the CONSTANT_String_info
structure;
a reference
to that class instance is the result of string literal derivation.
Finally, the intern
method of the new String
instance is invoked.
Run-time constant values are derived from
CONSTANT_Integer_info
,
CONSTANT_Float_info
,
CONSTANT_Long_info
,
or CONSTANT_Double_info
structures
(§4.4.4,
§4.4.5)
in the binary representation of a class or interface.
Note that CONSTANT_Float_info
structures
represent values in IEEE 754 single format and
CONSTANT_Double_info
structures
represent values in IEEE 754 double format
(§4.4.4,
§4.4.5).
The run-time constant values derived from these structures must thus be values
that can be represented using IEEE 754 single and double formats, respectively.
The remaining structures in the constant_pool
table of the binary representation of a class or interface -
the CONSTANT_NameAndType_info
and CONSTANT_Utf8_info
structures
(§4.4.6,
§4.4.7)
- are only used indirectly when deriving symbolic references to classes, interfaces, methods, fields, method types, and method handles,
and when deriving string literals and call site specifiers.
The Java Virtual Machine starts up by creating an initial class,
which is specified in an implementation-dependent manner, using the bootstrap class loader
(§5.3.1).
The Java Virtual Machine then links the initial class, initializes it,
and invokes the public
class method void main(String[])
.
The invocation of this method drives all further execution.
Execution of the Java Virtual Machine instructions constituting the main
method
may cause linking (and consequently creation) of additional classes and interfaces, as well as invocation of additional methods.
In an implementation of the Java Virtual Machine, the initial class could be provided as a command line argument.
Alternatively, the implementation could provide an initial class that sets up a class loader which in turn loads an application.
Other choices of the initial class are possible
so long as they are consistent with the specification given in the previous paragraph.
Creation of a class or interface C denoted by the name N
consists of the construction in the method area of the Java Virtual Machine
(§2.5.4)
of an implementation-specific internal representation of C.
Class or interface creation is triggered by another class or interface D,
which references C through its run-time constant pool.
Class or interface creation may also be triggered by D
invoking methods in certain Java SE platform class libraries
(§2.12)
such as reflection.
If C is not an array class,
it is created by loading a binary representation of C
(§4
(The class
File Format))
using a class loader.
Array classes do not have an external binary representation;
they are created by the Java Virtual Machine rather than by a class loader.
There are two kinds of class loaders:
the bootstrap class loader supplied by the Java Virtual Machine,
and user-defined class loaders.
Every user-defined class loader is an instance of a subclass of the abstract class ClassLoader
.
Applications employ user-defined class loaders in order to extend the manner
in which the Java Virtual Machine dynamically loads and thereby creates classes.
User-defined class loaders can be used to create classes that originate from user-defined sources.
For example, a class could be downloaded across a network, generated on the fly, or extracted from an encrypted file.
A class loader L
may create C
by defining it directly or by delegating to another class loader.
If L
creates C directly,
we say that L
defines C
or, equivalently, that L
is the defining loader of C.
笔记：这里介绍defining loader的概念
When one class loader delegates to another class loader,
the loader that initiates the loading is not necessarily the same loader
that completes the loading and defines the class.
If L
creates C,
either by defining it directly or by delegation,
we say that L
initiates loading of C or, equivalently,
that L
is an initiating loader of C.
笔记：这里介绍initiating loader的概念
At run time, a class or interface is determined not by its name alone, but by a pair:
its binary name (§4.2.1)
and its defining class loader.
Each such class or interface belongs to a single run-time package.
The run-time package of a class or interface is determined by the package name and defining class loader of the class or interface.
笔记：这里介绍run-time package的概念
The Java Virtual Machine uses one of three procedures to create class or interface C denoted by N
:
If N
denotes a nonarray class or an interface,
one of the two following methods is used to load and thereby create C:
Otherwise N
denotes an array class.
An array class is created directly by the Java Virtual Machine
(§5.3.3),
not by a class loader.
However, the defining class loader of D is used in the process of creating array class C.
If an error occurs during class loading,
then an instance of a subclass of LinkageError
must be thrown at a point in the program
that (directly or indirectly) uses the class or interface being loaded.
If the Java Virtual Machine ever attempts to load a class C during verification
(§5.4.1)
or resolution
(§5.4.3)
(but not initialization
(§5.5)),
and the class loader that is used to initiate loading of C throws an instance of ClassNotFoundException
,
then the Java Virtual Machine must throw an instance of NoClassDefFoundError
whose cause is the instance of ClassNotFoundException
.
(A subtlety here is that recursive class loading to load superclasses is performed as part of resolution
(§5.3.5,
step 3).
Therefore, a ClassNotFoundException
that results from a class loader
failing to load a superclass must be wrapped in a NoClassDefFoundError
.)
A well-behaved class loader should maintain three properties:
Given the same name, a good class loader should always return the same Class
object.
If a class loader L1
delegates loading of a class C to
another loader L2
,
then for any type T that
occurs as the direct superclass or a direct superinterface of C,
or as the type of a field in C,
or as the type of a formal parameter of a method or constructor in C,
or as a return type of a method in C,
L1
and L2
should return the same Class
object.
If a user-defined classloader prefetches binary representations of classes and interfaces,
or loads a group of related classes together,
then it must reflect loading errors only at points in the program
where they could have arisen without prefetching or group loading.
笔记：在报错方法，应该尽量晚
We will sometimes represent a class or interface using the notation <
N
,
Ld
>
,
where N
denotes the name of the class or interface and
Ld
denotes the defining loader of the class or interface.
笔记：第1种表示方式
We will also represent a class or interface using the notation
N
Li
,
where N
denotes the name of the class or interface and
Li
denotes an initiating loader of the class or interface.
笔记：第2种表示方式
The following steps are used to load and thereby create the nonarray class or interface C
denoted by N
using the bootstrap class loader.
First, the Java Virtual Machine determines
whether the bootstrap class loader has already been recorded as an initiating loader of a class or interface denoted by N
.
If so, this class or interface is C, and no class creation is necessary.
笔记：第1种情况，该Class已经被加载
Otherwise, the Java Virtual Machine passes the argument N
to
an invocation of a method on the bootstrap class loader to
search for a purported representation of C in a platform-dependent manner.
Typically, a class or interface will be represented using a file in a hierarchical file system,
and the name of the class or interface will be encoded in the pathname of the file.
笔记：第2种情况，该Class还没有被加载，将要去加载它
Note that there is no guarantee that
a purported representation found is valid or is a representation of C.
This phase of loading must detect the following error:
笔记：出现异常的情况，.class文件当中包含的bytecode可能并不是想要的Class类。
Then the Java Virtual Machine attempts to derive a class denoted by N
using the bootstrap class loader from the purported representation using the algorithm found in
§5.3.5.
That class is C.
The following steps are used to load and thereby create
the nonarray class or interface C
denoted by N
using a user-defined class loader L
.
First, the Java Virtual Machine determines
whether L
has already been recorded as an initiating loader of a class or interface
denoted by N
.
If so, this class or interface is C, and no class creation is necessary.
笔记：第1种情况，该Class已经被加载
Otherwise, the Java Virtual Machine invokes loadClass(
on N
)L
.
The value returned by the invocation is the created class or interface C.
The Java Virtual Machine then records that
L
is an initiating loader of C
(§5.3.4).
The remainder of this section describes this process in more detail.
笔记：第2种情况，该Class还没有被加载，需要去加载。
When the loadClass
method of the class loader L
is invoked
with the name N
of a class or interface C to be loaded,
L
must perform one of the following two operations in order to load C:
笔记：当调用loadClass()的时候，会发生以下二选一的选择处理方式
The class loader L
can create an array of bytes representing C
as the bytes of a ClassFile
structure
(§4.1);
it then must invoke the method defineClass
of class ClassLoader
.
Invoking defineClass
causes the Java Virtual Machine to derive a class or interface
denoted by N
using L
from the array of bytes using the algorithm found in
§5.3.5.
笔记：第1种选择，先找到byte[]，再调用defineClass()方法。
The class loader L
can delegate the loading of C to some other class loader L
'.
This is accomplished by passing the argument N
directly or indirectly
to an invocation of a method on L
'
(typically the loadClass
method).
The result of the invocation is C.
笔记：第2种选择，让别的ClassLoader来加载。
In either (1) or (2),
if the class loader L
is unable to load a class or interface denoted by N
for any reason,
it must throw an instance of ClassNotFoundException
.
笔记：异常情况。如果以上两种选择，加载不到，就抛出异常。
Since JDK release 1.1,
Oracle’s Java Virtual Machine implementation has invoked the loadClass
method of a class loader
in order to cause it to load a class or interface.
The argument to loadClass
is the name of the class or interface to be loaded.
There is also a two-argument version of the loadClass
method,
where the second argument is a boolean
that indicates whether the class or interface is to be linked or not.
Only the two-argument version was supplied in JDK release 1.0.2,
and Oracle’s Java Virtual Machine implementation relied on it to link the loaded class or interface.
From JDK release 1.1 onward,
Oracle’s Java Virtual Machine implementation links the class or interface directly, without relying on the class loader.
笔记：版本差异。关注点是loadClass()方法，它在JDK版本发展过程中也曾经变化过，应该关注它在JDK 1.1之后的情况。因为很少人会用JDK 1.1之前的版本。
The following steps are used to create the array class C
denoted by N
using class loader L
.
Class loader L
may be either the bootstrap class loader or a user-defined class loader.
笔记：这里是讲加载array class；而上面5.3.2是加载non-array class或interface
If L
has already been recorded as
an initiating loader of an array class with the same component type as N
,
that class is C,
and no array class creation is necessary.
笔记：第1种情况，如果已经加载，则不需要再加载
Otherwise, the following steps are performed to create C:
笔记：第2种情况，如果未加载，则需要再加载
If the component type is a reference
type,
the algorithm of this section
(§5.3)
is applied recursively
using class loader L
in order to load and thereby create the component type of C.
笔记：如果component type是reference type的情况
The Java Virtual Machine creates a new array class
with the indicated component type and number of dimensions.
If the component type is a reference
type,
C is marked as having been defined
by the defining class loader of the component type.
Otherwise, C is
marked as having been defined by the bootstrap class loader.
笔记：谁是defining class loader
In any case, the Java Virtual Machine then records that
L
is an initiating loader for C
(§5.3.4).
笔记：无论如何，L都是initiating class loader
If the component type is a reference
type,
the accessibility of the array class is determined by the accessibility of its component type.
Otherwise, the accessibility of the array class is public
.
笔记：这里讲array class的accessibility
Ensuring type safe linkage in the presence of class loaders requires special care.
It is possible that when two different class loaders initiate loading of a class or interface denoted by N
,
the name N
may denote a different class or interface in each loader.
笔记：因为有不同的class loader存在，这可能带来type safety linkage的问题。
When a class or interface
C = <
N1
, L1
>
makes a symbolic reference to a field or method of another class or interface
D = <
N2
,
L2
>
,
the symbolic reference includes a descriptor specifying
the type of the field, or the return and argument types of the method.
It is essential that
any type name N
mentioned in the field or method descriptor
denote the same class or interface
when loaded by L1
and when loaded by L2
.
To ensure this, the Java Virtual Machine imposes loading constraints of the form
N
L1
=
N
L2
during preparation
(§5.4.2)
and resolution
(§5.4.3).
To enforce these constraints,
the Java Virtual Machine will, at certain prescribed times (see
§5.3.1,
§5.3.2,
§5.3.3,
and §5.3.5),
record that a particular loader is an initiating loader of a particular class.
After recording that a loader is an initiating loader of a class,
the Java Virtual Machine must immediately check to see if any loading constraints are violated.
If so, the record is retracted,
the Java Virtual Machine throws a LinkageError
,
and the loading operation that caused the recording to take place fails.
Similarly, after imposing a loading constraint
(see §5.4.2,
§<IP_ADDRESS>,
§<IP_ADDRESS>,
and
§<IP_ADDRESS>),
the Java Virtual Machine must immediately check to see if any loading constraints are violated.
If so, the newly imposed loading constraint is retracted,
the Java Virtual Machine throws a LinkageError
,
and the operation that caused the constraint to be imposed
(either resolution or preparation, as the case may be) fails.
The situations described here are the only times
at which the Java Virtual Machine checks whether any loading constraints have been violated.
A loading constraint is violated if, and only if, all the following four conditions hold:
There exists a loader L
such that L
has been recorded by
the Java Virtual Machine as an initiating loader of a class C named N
.
There exists a loader L
'
such that L
' has been recorded
by the Java Virtual Machine as an initiating loader of
a class C ' named N
.
The equivalence relation defined by the (transitive closure of the) set of imposed constraints implies
N
L
=
N
L
'.
A full discussion of class loaders and type safety is beyond the scope of this specification.
For a more comprehensive discussion,
readers are referred to Dynamic Class Loading in the Java Virtual Machine by Sheng Liang and Gilad Bracha
(Proceedings of the 1998 ACM SIGPLAN Conference on Object-Oriented Programming Systems, Languages and Applications).
The following steps are used to derive a Class
object
for the nonarray class or interface C
denoted by N
using loader L
from a purported representation in class
file format.
笔记：使用class loader L，根据class name N，去加载目标类C
First, the Java Virtual Machine determines
whether it has already recorded that L
is an initiating loader of
a class or interface denoted by N
.
If so, this creation attempt is invalid and loading throws a LinkageError
.
笔记：第1种情况，这个类已经被加载
Otherwise, the Java Virtual Machine attempts to parse the purported representation.
However, the purported representation may not in fact be a valid representation of C.
笔记：第2种情况，这个类没有被加载，需要被加载
This phase of loading must detect the following errors:
笔记：在loading的过程当中，可能会遇到下面的错误
If the purported representation is not a ClassFile
structure
(§4.1,
§4.8),
loading throws an instance of ClassFormatError
.
笔记：第1种错误，文件格式不对
Otherwise, if the purported representation is not of a supported major or minor version
(§4.1),
loading throws an instance of UnsupportedClassVersionError
.
笔记：第2种错误，文件版本不对
UnsupportedClassVersionError
,
a subclass of ClassFormatError
,
was introduced to enable easy identification of a ClassFormatError
caused by an attempt to load a class
whose representation uses an unsupported version of the class
file format.
In JDK release 1.1 and earlier,
an instance of NoClassDefFoundError
or ClassFormatError
was thrown in case of an unsupported version,
depending on whether the class was being loaded
by the system class loader or a user-defined class loader.
Otherwise, if the purported representation does not actually represent a class named N
,
loading throws an instance of NoClassDefFoundError
or an instance of one of its subclasses.
笔记：第3种错误，文件里包含的类名不对
If C has a direct superclass,
the symbolic reference from C to its direct superclass is resolved using the algorithm of
§<IP_ADDRESS>.
Note that if C is an interface it must have Object
as its direct superclass,
which must already have been loaded.
Only Object
has no direct superclass.
笔记：加载当前类的superclass。
Any exceptions that can be thrown due to class or interface resolution
can be thrown as a result of this phase of loading.
In addition, this phase of loading must detect the following errors:
笔记：在加载superclass的过程中，可能遇到以下错误
If C has any direct superinterfaces,
the symbolic references from C to its direct superinterfaces are resolved using the algorithm of
§<IP_ADDRESS>.
笔记：加载当前类的superinterfaces。
Any exceptions that can be thrown due to class or interface resolution can be thrown as a result of this phase of loading.
In addition, this phase of loading must detect the following errors:
笔记：在加载superinterfaces的过程中，可能遇到以下错误
The Java Virtual Machine
marks C as
having L
as its defining class loader and
records that L
is an initiating loader of C
(§5.3.4).
笔记：将L标记为C的defining class loader和initiating class loader。
Linking a class or interface involves verifying and preparing that class or interface,
its direct superclass,
its direct superinterfaces,
and its element type (if it is an array type), if necessary.
Resolution of symbolic references in the class or interface is an optional part of linking.
笔记一：linking = verifying + preparing + resolution
笔记二：很明显，这里将verifying和preparing放置到一起，而resolution单独拿出来。
This specification allows an implementation flexibility as to when linking activities
(and, because of recursion, loading) take place,
provided that all of the following properties are maintained:
笔记：linking的时机是自由的，但要满足以下条件
A class or interface is completely loaded before it is linked.
A class or interface is completely verified and prepared before it is initialized.
Errors detected during linkage are thrown at a point in the program
where some action is taken by the program that might, directly or indirectly,
require linkage to the class or interface involved in the error.
笔记：报告错误的时机。只有在使用到的时候，才去报错。
For example, a Java Virtual Machine implementation may choose
to resolve each symbolic reference in a class or interface individually when it is used ("lazy" or "late" resolution),
or to resolve them all at once when the class is being verified ("eager" or "static" resolution).
This means that the resolution process may continue, in some implementations,
after a class or interface has been initialized.
Whichever strategy is followed, any error detected during resolution must be thrown at a point in the program
that (directly or indirectly) uses a symbolic reference to the class or interface.
笔记：无论是使用lazy resolution，还是eager resolution，报告error只在使用symbolic reference的时候才发生。
Because linking involves the allocation of new data structures,
it may fail with an OutOfMemoryError
.
笔记：在linking过程中，可能发生OutOfMemoryError错误
Verification
(§4.10)
ensures that the binary representation of a class or interface is structurally correct
(§4.9).
Verification may cause additional classes and interfaces to be loaded
(§5.3)
but need not cause them to be verified or prepared.
笔记：Verification会做什么
If the binary representation of a class or interface does not satisfy the static or structural constraints listed in
§4.9,
then a VerifyError
must be thrown at the point in the program that caused the class or interface to be verified.
笔记：如果不满足structural constraints，就会抛出VerifyError
If an attempt by the Java Virtual Machine to verify a class or interface fails
because an error is thrown that is an instance of LinkageError
(or a subclass),
then subsequent attempts to verify the class or interface always fail with the same error
that was thrown as a result of the initial verification attempt.
Preparation involves
creating the static fields for a class or interface and
initializing such fields to their default values
(§2.3,
§2.4).
This does not require the execution of any Java Virtual Machine code;
explicit initializers for static fields are executed as part of initialization
(§5.5),
not preparation.
笔记：Preparation会做什么
During preparation of a class or interface C,
the Java Virtual Machine also imposes loading constraints
(§5.3.4).
Let L1
be the defining loader of C.
For each method m
declared in C
that overrides
(§5.4.5)
a method declared in a superclass or superinterface
<
D, L2
>
,
the Java Virtual Machine imposes the following loading constraints:
Given that the return type of m
is Tr,
and that the formal parameter types of m
are
Tf1, ..., Tfn, then:
笔记：这里讲方法的return type和parameter type
If Tr not an array type,
let T0 be Tr;
otherwise, let T0 be the element type
(§2.4)
of Tr.
笔记：这里还是讲方法的return type
For i = 1 to n:
If Tfi is not an array type,
let Ti be Tfi;
otherwise, let Ti be the element type
(§2.4)
of Tfi.
笔记：这里还是讲方法的parameter type
Then
TiL1
=
TiL2
for i = 0 to n.
Furthermore, if C implements a method m
declared in a superinterface
<
I, L3
>
of C,
but C does not itself declare the method m
,
then let <
D, L2
>
be the superclass of C
that declares the implementation of method m
inherited by C.
The Java Virtual Machine imposes the following constraints:
Given that the return type of m
is Tr,
and that the formal parameter types of m
are
Tf1, ..., Tfn, then:
If Tr not an array type, let T0 be Tr; otherwise, let T0 be the element type (§2.4) of Tr.
For i = 1 to n: If Tfi is not an array type, let Ti be Tfi; otherwise, let Ti be the element type (§2.4) of Tfi.
Then
TiL2
=
TiL3
for i = 0 to n.
Preparation may occur at any time following creation but must be completed prior to initialization.
The Java Virtual Machine instructions
anewarray,
checkcast,
getfield,
getstatic,
instanceof,
invokedynamic,
invokeinterface,
invokespecial,
invokestatic,
invokevirtual,
ldc,
ldc_w,
multianewarray,
new,
putfield,
and putstatic
make symbolic references to the run-time constant pool.
Execution of any of these instructions requires resolution of its symbolic reference.
笔记：这些instruction会要求对symbolic reference进行resolution
Resolution is the process of
dynamically determining concrete values from symbolic references in the run-time constant pool.
笔记：Resolution会做什么
Resolution of the symbolic reference of one occurrence of an invokedynamic instruction
does not imply that
the same symbolic reference is considered resolved for any other invokedynamic instruction.
笔记：对invokedynamic进行特别说明。
For all other instructions above,
resolution of the symbolic reference of one occurrence of an instruction does imply that
the same symbolic reference is considered resolved for any other non-invokedynamic instruction.
笔记：其它的instruction只对symbolic reference解析一次。
(The above text implies that the concrete value determined by resolution for a specific invokedynamic instruction is a call site object bound to that specific invokedynamic instruction.)
Resolution can be attempted on a symbolic reference that has already been resolved.
An attempt to resolve a symbolic reference
that has already successfully been resolved
always succeeds trivially and always results in the same entity produced by the initial resolution of that reference.
笔记：可以对symbolic reference多次进行resolution操作，它们都返回同一个结果。
If an error occurs during resolution of a symbolic reference,
then an instance of IncompatibleClassChangeError
(or a subclass) must be thrown at a point in the program
that (directly or indirectly) uses the symbolic reference.
If an attempt by the Java Virtual Machine to resolve a symbolic reference fails
because an error is thrown that is an instance of LinkageError
(or a subclass),
then subsequent attempts to resolve the reference always fail with the same error
that was thrown as a result of the initial resolution attempt.
A symbolic reference to a call site
specifier by a specific invokedynamic instruction
must not be resolved prior to execution of that instruction.
笔记：解析call site的时机。
In the case of failed resolution of an invokedynamic instruction,
the bootstrap method is not re-executed on subsequent resolution attempts.
笔记：如果invokedynamic解析失败，就不会再进行解析。
Certain of the instructions above require additional linking checks when resolving symbolic references.
For instance, in order for a getfield instruction to successfully resolve the symbolic reference to the field
on which it operates,
it must not only complete the field resolution steps given in
§<IP_ADDRESS>
but also check that the field is not static
.
If it is a static
field, a linking exception must be thrown.
笔记：有些instruction需要additional linking checks。
Notably, in order for an invokedynamic instruction to successfully resolve the symbolic reference to a call site specifier,
the bootstrap method specified therein must complete normally and return a suitable call site object.
If the bootstrap method completes abruptly or returns an unsuitable call site object,
a linking exception must be thrown.
Linking exceptions
generated by checks that are specific to the execution of a particular Java Virtual Machine instruction
are given in the description of that instruction and
are not covered in this general discussion of resolution.
Note that such exceptions,
although described as part of the execution of Java Virtual Machine instructions rather than resolution,
are still properly considered failures of resolution.
笔记：有些instruction在执行过程中会造成linking exception。
The following sections describe the process of resolving a symbolic reference in the run-time constant pool
(§5.1)
of a class or interface D.
Details of resolution differ with the kind of symbolic reference to be resolved.
To resolve an unresolved symbolic reference from D
to a class or interface C
denoted by N
,
the following steps are performed:
The defining class loader of D is used to create a class or interface denoted by N
.
This class or interface is C.
The details of the process are given in
§5.3.
Any exception
that can be thrown as a result of failure of class or interface creation
can thus be thrown as a result of failure of class and interface resolution.
If C is an array class and its element type is a reference
type,
then a symbolic reference to the class or interface representing the element type is resolved by invoking the algorithm in
§<IP_ADDRESS>
recursively.
Finally, access permissions to C are checked.
If C is not accessible
(§5.4.4)
to D,
class or interface resolution throws an IllegalAccessError
.
笔记：访问权限不够。
This condition can occur, for example,
if C is a class that was originally declared to be public
but was changed to be non-public
after D was compiled.
If steps 1 and 2 succeed but step 3 fails,
C is still valid and usable.
Nevertheless, resolution fails, and D is prohibited from accessing C.
To resolve an unresolved symbolic reference from D to a field in a class or interface C,
the symbolic reference to C given by the field reference must first be resolved
(§<IP_ADDRESS>).
Therefore, any exception
that can be thrown as a result of failure of resolution of a class or interface reference
can be thrown as a result of failure of field resolution.
If the reference to C can be successfully resolved,
an exception relating to the failure of resolution of the field reference itself can be thrown.
When resolving a field reference,
field resolution first attempts to look up the referenced field in C and its superclasses:
If C declares a field with the name and descriptor
specified by the field reference, field lookup succeeds.
The declared field is the result of the field lookup.
笔记：第1种情况，在C类中查找到
Otherwise, field lookup is applied recursively to the direct superinterfaces of the specified class or interface C.
笔记：第2种情况，在C类的superinterfaces中查找到
Otherwise, if C has a superclass S,
field lookup is applied recursively to S.
笔记：第3种情况，在C类的superclass中查找到
If field lookup fails, field resolution throws a NoSuchFieldError
.
Otherwise, if field lookup succeeds but the referenced field is not accessible
(§5.4.4)
to D,
field resolution throws an IllegalAccessError
.
Otherwise, let <
E, L1
>
be the class or interface
in which the referenced field is actually declared and let L2
be the defining loader of D.
Given that the type of the referenced field is Tf, let T be Tf if Tf is not an array type, and let T be the element type (§2.4) of Tf otherwise.
The Java Virtual Machine must impose the loading constraint that
TL1
=
TL2
(§5.3.4).
To resolve an unresolved symbolic reference from D
to a method in a class C,
the symbolic reference to C given by the method reference is first resolved
(§<IP_ADDRESS>).
Therefore, any exception
that can be thrown as a result of failure of resolution of a class reference
can be thrown as a result of failure of method resolution.
If the reference to C can be successfully resolved,
exceptions relating to the resolution of the method reference itself can be thrown.
When resolving a method reference:
If C is an interface,
method resolution throws an IncompatibleClassChangeError
.
Otherwise, method resolution attempts to locate the referenced method in C and its superclasses:
If C declares exactly one method
with the name specified by the method reference,
and the declaration is a signature polymorphic method
(§2.9),
then method lookup succeeds.
All the class names mentioned in the descriptor are resolved
(§<IP_ADDRESS>).
The resolved method is the signature polymorphic method declaration.
It is not necessary for C
to declare a method with the descriptor specified by the method reference.
Otherwise, if C declares a method with the name and descriptor specified by the method reference, method lookup succeeds.
Otherwise, if C has a superclass, step 2 of method resolution is recursively invoked on the direct superclass of C.
Otherwise, method resolution attempts to locate the referenced method in the superinterfaces of the specified class C:
If the maximally-specific superinterface methods of C
for the name and descriptor
specified by the method reference include exactly one method
that does not have its ACC_ABSTRACT
flag set,
then this method is chosen and method lookup succeeds.
Otherwise, if any superinterface of C declares a method
with the name and descriptor specified by the method reference
that has neither its ACC_PRIVATE
flag
nor its ACC_STATIC
flag set,
one of these is arbitrarily chosen and method lookup succeeds.
A maximally-specific superinterface method of a class or interface C for a particular method name and descriptor is any method for which all of the following are true:
The method is declared in a superinterface (direct or indirect) of C.
The method is declared with the specified name and descriptor.
The method has neither its ACC_PRIVATE
flag
nor its ACC_STATIC
flag set.
Where the method is declared in interface I, there exists no other maximally-specific superinterface method of C with the specified name and descriptor that is declared in a subinterface of I.
The result of method resolution is determined by whether method lookup succeeds or fails:
If method lookup fails, method resolution throws a NoSuchMethodError
.
Otherwise, if method lookup succeeds and the referenced method is not accessible
(§5.4.4)
to D,
method resolution throws an IllegalAccessError
.
Otherwise, let <
E,
L1
>
be the class or interface
in which the referenced method m
is actually declared,
and let L2
be the defining loader of D.
Given that the return type of m
is Tr,
and that the formal parameter types of m
are Tf1,
..., Tfn, then:
If Tr is not an array type, let T0 be Tr; otherwise, let T0 be the element type (§2.4) of Tr.
For i = 1 to n: If Tfi is not an array type, let Ti be Tfi; otherwise, let Ti be the element type (§2.4) of Tfi.
The Java Virtual Machine must impose the loading constraints
TiL1
=
TiL2
for i = 0 to n
(§5.3.4).
When resolution searches for a method in the class's superinterfaces,
the best outcome is to identify a maximally-specific non-abstract
method.
It is possible that this method will be chosen by method selection,
so it is desirable to add class loader constraints for it.
Otherwise, the result is nondeterministic.
This is not new:
The Java® Virtual Machine Specification
has never identified exactly which method is chosen, and how "ties" should be broken.
Prior to Java SE 8, this was mostly an unobservable distinction.
However, beginning with Java SE 8,
the set of interface methods is more heterogenous,
so care must be taken to avoid problems with nondeterministic behavior. Thus:
Superinterface methods that are private
and static
are ignored by resolution.
This is consistent with the Java programming language,
where such interface methods are not inherited.
Any behavior controlled by the resolved method should not depend on
whether the method is abstract
or not.
Note that if the result of resolution is an abstract
method,
the referenced class C may be non-abstract
.
Requiring C to be abstract
would conflict with the nondeterministic choice of superinterface methods.
Instead, resolution assumes that the run time class of the invoked object has a concrete implementation of the method.
To resolve an unresolved symbolic reference from D to
an interface method in an interface C,
the symbolic reference to C given by the
interface method reference is first resolved
(§<IP_ADDRESS>).
Therefore, any exception
that can be thrown as a result of failure of resolution of an interface reference
can be thrown as a result of failure of interface method resolution.
If the reference to C can be successfully resolved,
exceptions relating to the resolution of the interface method reference itself can be thrown.
When resolving an interface method reference:
If C is not an interface,
interface method resolution throws an IncompatibleClassChangeError
.
笔记：如果C不是接口，就抛出错误
Otherwise, if C declares a method
with the name and descriptor specified by the interface method reference,
method lookup succeeds.
笔记：如果C是个接口，并且定义了这个方法，则查找成功
Otherwise, if the class Object
declares a method
with the name and descriptor specified by the interface method reference,
which has its ACC_PUBLIC
flag set and does not have its
ACC_STATIC
flag set, method lookup succeeds.
笔记：如果C是个接口，没有找到这个方法；那么，从Object类中查找，如果找到，则查找成功
Otherwise, if the maximally-specific superinterface methods
(§<IP_ADDRESS>)
of C for the name and descriptor specified by the method reference
include exactly one method that does not have its ACC_ABSTRACT
flag set,
then this method is chosen and method lookup succeeds.
笔记：如果是maximally-specific superinterface methods的情况，则查找成功
Otherwise, if any superinterface of C declares a method
with the name and descriptor specified by the method reference
that has neither its ACC_PRIVATE
flag nor
its ACC_STATIC
flag set,
one of these is arbitrarily chosen and method lookup succeeds.
笔记：如果C的superinterface上找到这个方法，则查找成功
The result of interface method resolution is determined by whether method lookup succeeds or fails:
If method lookup fails, interface method resolution throws a NoSuchMethodError
.
笔记：如果查找方法失败，则抛出异常
If method lookup succeeds and the referenced method is not accessible
(§5.4.4)
to D,
interface method resolution throws an IllegalAccessError
.
笔记：如果查找方法成功，但访问权限不对，则抛出异常
Otherwise, let <
E,
L1
>
be the class or interface
in which the referenced interface method m
is actually declared,
and let L2
be the defining loader of D.
Given that the return type of m
is Tr,
and that the formal parameter types of m
are Tf1,
..., Tfn, then:
If Tr is not an array type, let T0 be Tr; otherwise, let T0 be the element type (§2.4) of Tr.
For i = 1 to n: If Tfi is not an array type, let Ti be Tfi; otherwise, let Ti be the element type (§2.4) of Tfi.
The Java Virtual Machine must impose the loading constraints
TiL1
=
TiL2
for i = 0 to n
(§5.3.4).
The clause about accessibility is necessary
because interface method resolution may pick a private
method of interface C.
(Prior to Java SE 8, the result of interface method resolution
could be a non-public
method of class Object
or
a static
method of class Object
;
such results were not consistent with the inheritance model of the Java programming language, and are disallowed in Java SE 8 and above.)
To resolve an unresolved symbolic reference to a method type, it is as if resolution occurs of unresolved symbolic references to classes and interfaces (§<IP_ADDRESS>) whose names correspond to the types given in the method descriptor (§4.3.3).
Any exception that can be thrown as a result of failure of resolution of a class reference can thus be thrown as a result of failure of method type resolution.
The
result of successful method type resolution is a reference
to an
instance
of java.lang.invoke.MethodType
which represents the method descriptor.
Method type resolution occurs regardless of whether the run time constant pool actually contains symbolic references to classes and interfaces indicated in the method descriptor. Also, the resolution is deemed to occur on unresolved symbolic references, so a failure to resolve one method type will not necessarily lead to a later failure to resolve another method type with the same textual method descriptor, if suitable classes and interfaces can be loaded by the later time.
Resolution of an unresolved symbolic reference to a method handle is more complicated. Each method handle resolved by the Java Virtual Machine has an equivalent instruction sequence called its bytecode behavior, indicated by the method handle's kind. The integer values and descriptions of the nine kinds of method handle are given in Table <IP_ADDRESS>-A.
Symbolic references by an
instruction sequence to fields or methods are indicated
by C.x:T
, where x
and T
are the name and descriptor
(§4.3.2,
§4.3.3)
of the
field or method, and C
is the class or interface in
which the field or method is to be found.
Table <IP_ADDRESS>-A. Bytecode Behaviors for Method Handles
| Kind | Description | Interpretation |
|---|---|---|
| 1 | REF_getField |
getfield C.f:T |
| 2 | REF_getStatic |
getstatic C.f:T |
| 3 | REF_putField |
putfield C.f:T |
| 4 | REF_putStatic |
putstatic C.f:T |
| 5 | REF_invokeVirtual |
invokevirtual C.m:(A*)T |
| 6 | REF_invokeStatic |
invokestatic C.m:(A*)T |
| 7 | REF_invokeSpecial |
invokespecial C.m:(A*)T |
| 8 | REF_newInvokeSpecial |
new C; dup; invokespecial
C. |
| 9 | REF_invokeInterface |
invokeinterface C.m:(A*)T |
Let MH
be the symbolic
reference to a method handle (§5.1) being
resolved. Then:
Let R be the symbolic reference to the field or method
contained within MH
.
(R is derived from the CONSTANT_Fieldref
,
CONSTANT_Methodref
, or CONSTANT_InterfaceMethodref
structure
referred to by the reference_index
item of
the CONSTANT_MethodHandle
from which MH
is derived.)
Let T be the type of the field referenced by R, or the return type of the method referenced by R. Let A* be the sequence (perhaps empty) of parameter types of the method referenced by R.
(T and A* are derived from the CONSTANT_NameAndType
structure referred to by the
name_and_type_index
item in the
CONSTANT_Fieldref
, CONSTANT_Methodref
, or
CONSTANT_InterfaceMethodref
structure from which R is
derived.)
To resolve
MH
, all symbolic references to classes, interfaces, fields, and
methods in MH
's bytecode behavior are resolved, using the following
three steps:
Second, resolution occurs as if of unresolved symbolic references to classes and interfaces whose names correspond to each type in A*, and to the type T, in that order.
Third, a reference to an instance of java.lang.invoke.MethodType
is obtained as
if by resolution of an unresolved symbolic reference to a method
type that contains the method descriptor specified in
Table <IP_ADDRESS>-B
for the kind of MH
.
It is as if the symbolic reference to a method handle contains a symbolic reference to the method type that the resolved method handle will eventually have. The detailed structure of the method type is obtained by inspecting Table <IP_ADDRESS>-B.
In each step, any exception that can be thrown as a result of failure of resolution of a class or interface or field or method reference can be thrown as a result of failure of method handle resolution.
The intent is that resolving a method handle can be
done in exactly the same circumstances that the Java Virtual Machine would
successfully resolve the symbolic references in the bytecode
behavior. In particular, method handles to private
and protected
members can be created in exactly those classes for which the
corresponding normal accesses are legal.
Table <IP_ADDRESS>-B. Method Descriptors for Method Handles
| Kind | Description | Method descriptor |
|---|---|---|
| 1 | REF_getField |
(C)T |
| 2 | REF_getStatic |
()T |
| 3 | REF_putField |
(C,T)V |
| 4 | REF_putStatic |
(T)V |
| 5 | REF_invokeVirtual |
(C,A*)T |
| 6 | REF_invokeStatic |
(A*)T |
| 7 | REF_invokeSpecial |
(C,A*)T |
| 8 | REF_newInvokeSpecial |
(A*)C |
| 9 | REF_invokeInterface |
(C,A*)T |
The
result of successful method handle resolution is a reference
to an
instance of java.lang.invoke.MethodHandle
which represents the method
handle
MH
.
The
type descriptor of this java.lang.invoke.MethodHandle
instance is the
java.lang.invoke.MethodType
instance produced in the third step of method handle resolution
above.
The type descriptor of a method handle is such that
a valid call to invokeExact
in java.lang.invoke.MethodHandle
on the method handle
has exactly the same stack effects as the bytecode behavior. Calling
this method handle on a valid set of arguments has exactly the same
effect and returns the same result (if any) as the corresponding
bytecode behavior.
If the
method referenced by R has the ACC_VARARGS
flag set
(§4.6), then the
java.lang.invoke.MethodHandle
instance is a
variable arity method handle; otherwise, it is a fixed arity method
handle.
A
variable arity method handle performs argument list boxing (JLS
§<IP_ADDRESS>) when invoked via invoke
, while its behavior with
respect
to invokeExact
is as if the ACC_VARARGS
flag were not set.
Method
handle resolution throws an IncompatibleClassChangeError
if the method
referenced
by R has the ACC_VARARGS
flag set and either
A* is an empty sequence or the last
parameter type in A* is not an
array type. That is, creation of a variable arity method handle
fails.
An implementation of the
Java Virtual Machine is not required to intern method types or method handles. That
is, two distinct symbolic references to method types or method handles
which are structurally identical might not resolve to the same
instance of java.lang.invoke.MethodType
or java.lang.invoke.MethodHandle
respectively.
The java.lang.invoke.MethodHandles
class in the Java SE platform API allows creation of method handles with no
bytecode behavior. Their behavior is defined by the method of
java.lang.invoke.MethodHandles
that creates
them. For example, a method handle may, when invoked, first apply
transformations to its argument values, then supply the transformed
values to the invocation of another method handle, then apply a
transformation to the value returned from that invocation, then return
the transformed value as its own result.
To resolve an unresolved symbolic reference to a call site specifier involves three steps:
A call site specifier gives a symbolic reference to a method
handle which is to serve as the bootstrap
method for a dynamic call site
(§4.7.23). The method
handle is resolved
to obtain a reference
to an instance of java.lang.invoke.MethodHandle
(§<IP_ADDRESS>).
A call site specifier gives a method
descriptor, TD. A reference
to an instance of
java.lang.invoke.MethodType
is obtained as if by resolution
of a symbolic
reference to a method type with the same parameter and return
types as TD
(§<IP_ADDRESS>).
A call site specifier gives zero or more static
arguments, which communicate application-specific
metadata to the bootstrap method. Any static arguments which are
symbolic references to classes, method handles, or method types
are resolved, as if by invocation of the ldc
instruction
(§ldc), to obtain reference
s
to Class
objects, java.lang.invoke.MethodHandle
objects, and java.lang.invoke.MethodType
objects
respectively. Any static arguments that are string literals are
used to obtain reference
s to String
objects.
The result of call site specifier resolution is a tuple consisting of:
During resolution of the symbolic reference to the method handle in the call site specifier, or resolution of the symbolic reference to the method type for the method descriptor in the call site specifier, or resolution of a symbolic reference to any static argument, any of the exceptions pertaining to method type or method handle resolution may be thrown (§<IP_ADDRESS>).
A class or interface C is accessible to a class or interface D if and only if either of the following is true:
C and D are members of the same run-time package (§5.3).
A field or method R is accessible to a class or interface D if and only if any of the following is true:
R is protected
and is declared in a
class C, and D is
either a subclass of C or C itself.
Furthermore, if R is
not static
, then the symbolic reference to R must contain a
symbolic reference to a class T, such that T is either a
subclass of D, a superclass of D, or
D itself.
R is either protected
or has default
access (that is,
neither public
nor protected
nor
private
), and is declared
by a class in the same run-time package as D.
This discussion of access
control omits a related restriction on the target of a protected
field access or method invocation (the target must be of class D or
a subtype of D). That requirement is checked as part of the
verification process (§<IP_ADDRESS>);
it is not part of
link-time access control.
Initialization of a class or interface
consists of executing its class or interface initialization method
(§2.9).
笔记：Initialization要做什么。
A class or interface C may be initialized only as a result of:
The execution of any one of the Java Virtual Machine instructions new, getstatic, putstatic, or invokestatic that references C (§new, §getstatic, §putstatic, §invokestatic). These instructions reference a class or interface directly or indirectly through either a field reference or a method reference.
Upon execution of a new instruction, the referenced class is initialized if it has not been initialized already.
Upon execution of a getstatic, putstatic, or invokestatic instruction, the class or interface that declared the resolved field or method is initialized if it has not been initialized already.
The first invocation of a java.lang.invoke.MethodHandle
instance
which was the
result of method handle resolution
(§<IP_ADDRESS>) for a
method handle of kind 2
(REF_getStatic
), 4 (REF_putStatic
), 6
(REF_invokeStatic
),
or 8 (REF_newInvokeSpecial
).
This implies that the class of a bootstrap method is initialized when the bootstrap method is invoked for an invokedynamic instruction (§invokedynamic), as part of the continuing resolution of the call site specifier.
Invocation of certain reflective methods in the class library
(§2.12),
for example, in class Class
or
in package java.lang.reflect
.
If C is a class, the initialization of one of its subclasses.
If C is an interface that declares a non-abstract
,
non-static
method,
the initialization of a class that implements C directly or
indirectly.
If C is a class, its designation as the initial class at Java Virtual Machine startup (§5.2).
Prior to initialization, a class or interface must be linked, that is, verified, prepared, and optionally resolved.
Because
the Java Virtual Machine is multithreaded, initialization of a class or interface
requires careful synchronization, since some other thread may be
trying to initialize the same class or interface at the same
time. There is also the possibility that initialization of a class or
interface may be requested recursively as part of the initialization
of that class or interface. The implementation of the Java Virtual Machine is
responsible for taking care of synchronization and recursive
initialization by using the following procedure. It assumes that the
Class
object has already been verified and prepared, and that the
Class
object contains state that indicates one of four
situations:
For each class or interface C, there is a unique initialization lock
LC
. The mapping from C to LC
is left to the discretion of the
Java Virtual Machine implementation. For example, LC
could be the Class
object
for C, or the monitor associated with that Class
object. The
procedure for initializing C is then as follows:
Synchronize on the initialization lock, LC
, for C.
This
involves waiting until the current thread can acquire
LC
.
If the Class
object for C indicates that
initialization is
in progress for C by some other thread, then release LC
and
block the current thread until informed that the in-progress
initialization has completed, at which time repeat this
procedure.
Thread interrupt status is unaffected by execution of the initialization procedure.
If the Class
object for C indicates that
initialization is
in progress for C by the current thread, then this must be a
recursive request for initialization. Release LC
and complete
normally.
If the Class
object for C indicates that
C has already
been initialized, then no further action is required. Release
LC
and complete normally.
If the Class
object for C is in an
erroneous state, then
initialization is not possible. Release LC
and throw a
NoClassDefFoundError
.
Otherwise, record the fact that initialization of the Class
object for C is in progress by the current thread, and release
LC
.
Then, initialize each final
static
field of C with the
constant value in its ConstantValue
attribute
(§4.7.2),
in the order the fields appear
in the ClassFile
structure.
Next, if C is a class rather than an interface, and its
superclass has not yet been initialized, then let SC be its
superclass and let SI1,
..., SIn be all
superinterfaces of C (whether direct or indirect) that declare
at least one non-abstract
, non-static
method. The order of
superinterfaces is given by a recursive enumeration over the
superinterface hierarchy of each interface directly implemented
by C. For each interface I
directly implemented by C (in the order of
the interfaces
array of C), the
enumeration
recurs on I's superinterfaces (in the order of
the interfaces
array of I) before
returning
I.
For each S in the list [ SC, SI1, ..., SIn ], recursively perform this entire procedure for S. If necessary, verify and prepare S first.
If the initialization of S completes abruptly because of a
thrown exception, then acquire LC
, label the Class
object
for C as erroneous, notify all waiting threads, release LC
,
and complete abruptly, throwing the same exception that resulted
from initializing SC.
Next, determine whether assertions are enabled for C by querying its defining class loader.
Next, execute the class or interface initialization method of C.
If the execution of the class or interface initialization method
completes normally, then acquire LC
, label the Class
object
for C as fully initialized, notify all waiting threads,
release LC
, and complete this procedure normally.
Otherwise, the class or interface initialization method must
have completed abruptly by throwing some exception E. If the
class of E is not Error
or one of its
subclasses, then
create a new instance of the class ExceptionInInitializerError
with E as the argument, and use this object in place of E in
the following step. If a new instance of
ExceptionInInitializerError
cannot be created because an
OutOfMemoryError
occurs, then use an OutOfMemoryError
object in place of E in the
following step.
Acquire LC
, label the Class
object for
C as erroneous,
notify all waiting threads, release LC
, and complete this
procedure abruptly with reason E or its replacement as
determined in the previous step.
A Java Virtual Machine implementation may optimize this procedure by eliding the lock acquisition in step 1 (and release in step 4/5) when it can determine that the initialization of the class has already completed, provided that, in terms of the Java memory model, all happens-before orderings (JLS §17.4.5) that would exist if the lock were acquired, still exist when the optimization is performed.
Binding is the process
by which a function written in a language other than the Java programming language and
implementing a native
method is integrated into
the Java Virtual Machine so that it can be executed.
Although this process is traditionally referred to as linking,
the term binding is used in the
specification to avoid confusion with linking of classes or interfaces
by the Java Virtual Machine.
The Java Virtual Machine exits
when some thread invokes the exit
method of class Runtime
or class System
,
or the halt
method of class Runtime
,
and the exit
or halt
operation is permitted by the security manager.
In addition, the JNI (Java Native Interface) Specification describes termination of the Java Virtual Machine
when the JNI Invocation API is used to load and unload the Java Virtual Machine.


Building a chat app is pretty complex. However, with a framework like Node.js, and libraries like Socket.io and Express, a basic chat app is achievable with just a couple lines of code. Using Node.js, we can write JavaScript for the server, and with Socket.io and Express, we can make use of websockets to push messages to users from the server in real-time.
We’re going to be creating a Node.js app, so make sure you have it installed.
To start:
npm init
. The will create a new package.json
file. (it will ask you name/version, etc.)npm install --save express
// a web framework for nodenpm install --save socket.io
// real-time module for our appNow that our dependencies are installed, let’s create our file structure:
server.js
filepublic
with the following files:
index.html
style.css
client.js
Open up the server.js
file. Here’s where we need to require express and socket.io, and create a new server. We also need to use app.get to deliver an HTML file easily. In addition, we have to let express know that all our static (html,css,js) files are in the public folder. Lastly, we need to open up a port on our localhost
hostname.
var express = require('express');
var app = express();
var server = require('http').createServer(app);
var io = require('socket.io')(server);
app.get('/', function(req, res, next) {
res.sendFile(__dirname + '/public/index.html')
});
app.use(express.static('public'));
server.listen(7777);
Now, open your index.html
file in the public folder. In there, we will need to create a normal HTML document with the following:
form
with two inputs
ul
with an id for the messages to go in/socket.io/socket.io.js
client.js

<title> Real Time Chat </title>
<meta name="viewport" content="width=device-width, initial-scale=1" />
<link rel="stylesheet" href="style.css" />

 Chat!

<form>
<input id="message" type="text" placeholder="message">
<input type="submit" value="Send">
</form>

Now, if you cd
into the file on your terminal, run node server.js
, and headover to localhost:7777
in your browser, you should see your HTML file being served.
Open up your client.js
file. At this point, we need to connect to our server using io.connect.
On connect, let us emit a message to confirm our connection with an event of join
.
var socket = io.connect('http://localhost:7777');
socket.on('connect', function(data) {
socket.emit('join', 'Hello server from client');
});
Then, we can open back up our server.js
file and log a message that the client is connected. Also, we can listen for the join
event we wrote earlier to log the data from the client. Here’s how it’ll work:
var express = require('express');
var app = express();
var server = require('http').createServer(app);
var io = require('socket.io')(server);
app.get('/', function(req, res, next) {
res.sendFile(__dirname + '/public/index.html')
});
app.use(express.static('public'));
io.on('connection', function(client) {
console.log('Client connected...');
client.on('join', function(data) {
console.log(data);
});
});
server.listen(7777);
Now, if you re-run the server.js file in your terminal (CTRL+C to exit) and refresh localhost:7777
in your browser, you should see the messages client connected...
& Hello server from client
in your terminal which confirms our connection!
Finally! Now that we have a connection, we can use it to emit and send messages. Here is what we need to do in our client.js
file:
thread
) that will recieve any messages emitted by ther servermessage
id (in our input)return false;
to prevent the from from it’s default action (refreshing page) // initializing socket, connection to server
var socket = io.connect('http://localhost:7777');
socket.on('connect', function(data) {
socket.emit('join', 'Hello server from client');
});
// listener for 'thread' event, which updates messages
socket.on('thread', function(data) {
$('#thread').append('
' + data + '
');
});
// sends message to server, resets & prevents default form action
$('form').submit(function() {
var message = $('#message').val();
socket.emit('messages', message);
this.reset();
return false;
});
However, before we have a functional application, we have to add our messages
event to our server and emit it to our thread event!
var express = require('express');
var app = express();
var server = require('http').createServer(app);
var io = require('socket.io')(server);
app.get('/', function(req, res, next) {
res.sendFile(__dirname + '/public/index.html')
});
app.use(express.static('public'));
io.on('connection', function(client) {
console.log('Client connected...');
client.on('join', function(data) {
console.log(data);
});
client.on('messages', function(data){
client.emit('thread', data);
client.broadcast.emit('thread', data);
});
});
server.listen(7777);
There you go! Our messages
event is listened for and once to server recieves it it is broadcasted to all the other clients using client.broadcast.emit
.
Before we finish, let’s style the app a bit. Open up the style.css
file and customize it to your liking!
html, body {
text-align: center;
font-family: 'Avenir Next', 'Helvetica', 'Arial', sans-serif;
}
html,body,li,form,ul {
padding: 0;
margin: 0;
}
form {
padding-bottom: 2%;
}
li {
list-style: none;
width: 100vw;
}
li:nth-child(odd) {
background: #eee;
}
Well, now you have a basic form of communication! If you open up multiple tabs, you’ll see the messages are being sent in real-time!


By generating a network-based representation of laws, regulations, policies and procedures (collectively defined here as "rulesets") that enables traversal of rules from their high-level origin through to the operational practices of government agencies, PolicyNet enables policy makers better understand the connective structure of their rulesets.
A myriad of laws, regulations, policies and procedures ("rulesets") governs how government agencies conduct their business practices and relate to the citizens they are charged with serving. These constantly evolving rulesets are so intertwined and interdependent that the operational impact of changes or additions to them are often poorly understood or appreciated at both the legislative and operational stage.
Thus, policy makers face significant difficulty in relaying information to the citizens in a timely, understanable fashion to gather feedback and identify conflicts that are not readily visible.
The above has resulted in citizens (and advocates) becoming increasingly frustrated by the ambiguity of rulesets, which are time consuming to understand and costly to comply.
Within the complex policy rulesets, interconnections and interdependencies exist between different rule types to link citizens, policy makers, and upper branches of government.
Thus, the ability to intuitively and efficienctly traverse these interdependencies requires the development of methodology to intelligently ingest, query, and present revelant portions of the overall network.


Web applications are rarely customizable—you can’t tailor interfaces, extend functionality, or publish your modifications. Daimio makes bottom-up change possible by expressing every action your application can perform in a dialect of a language, and making execution contexts that speak different subsets of that dialect accessible.
That means you can send raw code to the server. It means you can build extensions and share them. It means you can send code to other users for direct execution on their machines. And that means the server is merely one of potentially many trusted resources. Welcome to the world of programmable applications. Welcome to the world of universal computing. Welcome to Daimio.


| Home | Malls | Cinemas | Eateries |
Laser tag is a team or individual sport or recreational activity where players attempt to score points by tagging targets, typically with a hand-held infrared-emitting targeting device. Infrared-sensitive targets are commonly worn by each player and are sometimes integrated within the arena in which the game is played.Laser tag is popular with a wide range of ages. When compared to paintball, laser tag is painless because it uses no physical projectiles, and indoor versions may be considered less physically demanding because most indoor venues prohibit running or roughhousing.
Here is a list of Laser Tag places in Bangalore.
| Laser Tag Centres | Details |
|---|---|
LASER REPUBLICAddress: #1, 14th Main 17th Cross, HSR Layout Sector 7 Bangalore - 560102, India |
|
iAMGAME1.iAMGAME KoramangalaAddress:818,80 feet road, 8th block koramangala, bangalore 560095.2.iAMGAME KammanahalliAddress:315, 3rd floor, 7th main, HRBR layout, 2nd block, kammanahalli, bangalore 6500433.iAMGAME SarjapurAddress:75,central jail road, opposite silverwood regency apartments, kasavanahalli bangalore 560035. |
|
LASER CASTLEAddress:#3, 80 Feet Road,HAL 2nd Stage,Indiranagar,Bangalore, India. |
|
TALK TO THE HANDAddress:No. 653, 2nd Floor, HM Zeta, 11th Main,Sri Aurobindo Marg, 4th Block,Jayanagar (next to Mc Donalds),Bangalore, India 560011 |
Laser Tag is a multi player video game played in a theme based arena. Laser tag is a multiplayer game played in a dark arena. Players wear a battle vest and hold a laser gun to tag other players to accomplish a team mission. There are multiple game play missions as listed below. The most common being Team Death Match.
Address: #1, 14th Main 17th Cross, HSR Layout Sector 7 Bangalore - 560102, India
Email<EMAIL_ADDRESS>Phone: +91<PHONE_NUMBER>
Galt Entertainment PVT Ltd, Bangalore, created and owns the trade mark, iAMGAME.We are the ONLY country wide dealer, for Lazer Runner, the World's No 1, Laser Tag equipment manufacturer, based out of Canada.
1. iAMGAME Koramangala :
This is our first and fore-most state of the art gaming arena. We have 2 floors, of non-stop excitement. Our gaming arena, on the 2nd floor, has the cash/ reservation counter, café and the gaming arena, while our Laser tag arena takes up the entire 3rd floor.
Address:818,80 feet road, 8th block koramangala, bangalore 560095.
2. iAMGAME Kammanahalli :
This is our 2nd location, which is dedicated only for Laser Tag. We do not have any other games here.
Address:315, 3rd floor, 7th main, HRBR layout, 2nd block, kammanahalli, bangalore 650043
3. iAMGAME Sarjapur :
Our third location is part of large Day Out Arena, who is our host. Located in Sarjapur, spread over several acres, this place is good for a whole day out. The attractions include bowling, soccer and several other games, besides Laser Tag, which ofcourse, is everyone's favorite.
Address:75,central jail road, opposite silverwood regency apartments, kasavanahalli bangalore 560035.
Great activity for Employee Engagement or group sessions. Just like the latest computer games, guests will receive their mission briefing, intel on the enemy and tactics. You will Battle against others to fulfill your mission objectives as a team. There is no paint or projectiles involved, so no masks needed or big bills at the end of the session.
Address:#3, 80 Feet Road,HAL 2nd Stage,Indiranagar,Bangalore, India.
Phone: +91-9886-786039
Welcome to 'Talk to the Hand', an exciting Lazer Tag battledrome now open in Jayanagar, Bangalore.
What's more, state of the art gaming consoles and a hip cafe to hangout with your buddies or grab a bite while you wait your turn.
It's also a cool place to celebrate your birthday parties, organise team building activities and much more.
Address:No. 653, 2nd Floor, HM Zeta, 11th Main,Sri Aurobindo Marg, 4th Block,Jayanagar (next to Mc Donalds),Bangalore, India 560011
Phone: 099 45 406090


Surfer or profile plots are visualisations of 4 physical and chemical metrics along the Swan and Canning rivers. These metrics are, salinity, dissolved oxygen, chlorophyll and temperature and are interpolated along the river length to give a seamless visualisation.
Two sections of the Swan/Canning river system are monitored on a weekly basis. The Canning river estuary (between South Canning Bridge and Ellison drive) and the Swan river estuary (between Blackwall Reach and the Power Line crossing in West Swan).
The raw input to create these plots comes from sonde data recorders deployed on consecutive days each week. Due to the length of time needed sample either of the rivers, two vessels start at different locations to enable recording of data in the one day. Therefore the raw data for one day's sampling is two excel spreadsheets.
The functions to create the surfer plots are slightly different internally. It is important to note that these functions are very specific to the river and the expected inputs and parameters.
To run the functions make sure the package is loaded. The path variable is a character string of the file path to the locations of the sonde data for the day you wish to plot. As described above there should be two excel spreadsheets. Make sure that you have the right data for the right function. Sonde data has a "c" in the name for the Canning and a "s" for the Swan. Please ensure that if you copy and paste in a file path from a Windows OS you will need to either double up the backslashes or convert them to a single forward slash.
The other two parameters supplied to either function relate to the oxygenation status at two locations and are specific to each river. Permissable colours are green, blue and red.
When run the function will read in the sonde data, process the interpolations and generate the plots. The plots will be written to a directory created at the same location as the sonde data, called "plots". Examples below.
#load the package
library(rivRmon)
#Canning river - forward slash example
canning_surfR(path = "C:blah/blah/data_location", obac = "green", onic = "red")
#Swan river - backslash example
swan_surfR(path = "C:blah\\blah\\data_location", ovit = "blue", ocav = "red")
This plot was produced using the parameters as described above on data from 23/07/2019 using the canning_surfR()
function. Note that the block-like structure downstream of site KEN represents the Kent street weir in an open position. The function will interpret the status of the weir from the sonde data and plot it accordingly.
When the swan_surfR()
function is run, it produces two outputs. One is a visualisation of the whole river from the river mouth to the Power Lines and the other is a zoomed view from the Narrows to the Power Lines. This to enable a more detailed view of the shallower waters.
Again these examples are run using the parameters as described above. Note the blacked out portions at the beginning of the plot. Blacked out regions cover sections of the river where data was not collected on that date. The sites here (FP1 and FP7) are within the Port of Fremantle and data is sometimes provided. Other sections of the river may be blacked out from time to time and could be due to equipment malfunction or more generally an inability to hold station at a site due to conditions on the day (strong wind, strong current etc).
And here is an example of the middle and upper Swan showing greater detail.
The current functions can handle the outputs from YSI and EXO sondes and can handle most of the historical differences in metric naming conventions and output formats. It is recommended however that the current conventions in place for naming and editing the sonde outputs should be maintained. Any major deviations or additions will likely result in errors.
The rendering of the "river bottom" is designed around long term monitoring locations. If a new site needs to be added this will require some rewriting of various parts of the base code and internal data sets. If this need arises please contact the author.
The "river bottom" has been created by extracting depths from the Corporate bathymetry data along a reckoned navigation route that attempts to stick to the deepest sections of the river and intersects the sampling sites. Additional extraction points are generated at 100 meter intervals along this route.
When the canning_surfR()
function detects that the weir is closed (by the presence of cannoxy site data), it performs two interpolations to ensure that the weir is used as a barrier to the interpolations.
A thin plate spline is used to calculate the interpolation of data between the sampling sites.
Remember that this is a visualisation tool only. Obtaining precise measurements of metrics outside of sampling sites can only be obtained by physically sampling those areas. Any interpolation can only be an estimation, particularly with such sparse input data.


Pizza-Peddlers was founded in 2018 by Joan Wamuyu Kinyua. It has been 2 years and currently it is the biggest Pizza shop in Nairobi. It was first located in TRM Ground floor but later it branched to various towns around Nairobi. Last year it opened it's first branch in Kisumu and another branch will be opened soon in Mombasa city.
Pizza-Peddlers has offered employment to more than 500 youths around Nairobi, Kisumu and now Mombasa.
Pizza-Peddlers is a pizza shop that is driven with the following values:


| MATLAB 文件帮助: cv.stereoCalibrate | 查看 cv.stereoCalibrate 的代码 | Index |
stereoCalibrate Calibrates the stereo camera
S = cv.stereoCalibrate(objectPoints, imagePoints1, imagePoints2, imageSize)
[...] = cv.stereoCalibrate(..., 'OptionName', optionValue, ...)
{{[x,y,z], ..}, ...}
.{{[x,y], ..}, ...}
, observed by the first camera.{{[x,y], ..}, ...}
, observed by the second camera.[w,h]
.A = [fx1 0 cx1; 0 fy1 cy1; 0 0 1]
.[k1,k2,p1,p2,k3,k4,k5,k6,s1,s2,s3,s4]
of 4, 5, 8, or 12
elements. The output vector length depends on the options.A = [fx2 0 cx2; 0 fy2 cy2; 0 0 1]
. The parameter is similar to
cameraMatrix1
.distCoeffs1
.cameraMatrix1
,cameraMatrix2
and distCoeffs1
,
distCoeffs2
so that only R
, T
, E
, and F
matrices are
estimated. default true.fx1
,fx2
and fy1
,fy2
. default false.fy1
,fy2
and fix the ratio fx1/fy1
,
fx2/fy2
. default false.fx1=fx2
and fy1=fy2
. default false.UseIntrinsicGuess
is set, the coefficient from the supplied DistCoeffs
matrix is used.
Otherwise, it is set to 0. default false.k4
, k5
, and k6
. To provide the
backward compatibility, this extra flag should be explicitly specified
to make the calibration function use the rational model and return 8
coefficients. If the flag is not set, the function computes and
returns only 5 distortion coefficients. default false.s1
, s2
, s3
and s4
are enabled. To
provide the backward compatibility, this extra flag should be
explicitly specified to make the calibration function use the thin
prism model and return 12 coefficients. If the flag is not set, the
function computes and returns only 5 distortion coefficients.
default false.DistCoeffs
matrix is used. Otherwise,
it is set to 0. default falsestruct('type','Count+EPS', 'maxCount',30, 'epsilon',1e-6)
The function estimates transformation between two cameras making a stereo
pair. If you have a stereo camera where the relative position and
orientation of two cameras is fixed, and if you computed poses of an object
relative to the first camera and to the second camera, (R1,T1)
and
(R2,T2)
, respectively (this can be done with cv.solvePnP), then those
poses definitely relate to each other. This means that, given (R1,T1)
, it
should be possible to compute (R2,T2)
. You only need to know the position
and orientation of the second camera relative to the first camera. This is
what the described function does. It computes (R,T)
so that:
R2 = R * R1*T2 = R * T1 + T
Optionally, it computes the essential matrix E
:
E = [ 0 -T2 T1;
T2 0 -T0;
-T1 T0 0] * R
where Ti
are components of the translation vector T
: T = [T0,T1,T2]'
.
And the function can also compute the fundamental matrix F
:
F = inv(cameraMatrix2)' * E * inv(cameraMatrix1)
Besides the stereo-related information, the function can also perform a full calibration of each of two cameras. However, due to the high dimensionality of the parameter space and noise in the input data, the function can diverge from the correct solution. If the intrinsic parameters can be estimated with high accuracy for each of the cameras individually (for example, using cv.calibrateCamera), you are recommended to do so and then pass 'FixIntrinsic' flag to the function along with the computed intrinsic parameters. Otherwise, if all the parameters are estimated at once, it makes sense to restrict some parameters, for example, pass 'SameFocalLength' and 'ZeroTangentDist' flags, which is usually a reasonable assumption.
Similarly to cv.calibrateCamera, the function minimizes the total re-projection error for all the points in all the available views from both cameras. The function returns the final value of the re-projection error.


- Sweet Names as a Service
This is a quick little tool to generate silly/dumb names for your fantasy football team, hackathon team, or any other group that needs a moderately terrible name fast! There's also a new feature to generate your own terrible nicknames!
- Tabata Workout Generator
- A tool for generating tabata style workouts for a wide range of fitness levels and abilities.


Three Dots
Specs
Products
Contact
About me
Laptop for the future
The new 14 inch laptop is offering a 4k display with touch screen.
14Inch
Add To Cart


Two jointly launch project to protect the environment
by Dorothy Frances Ward, GNAAtwima (Ash), Nov. 19, GNA – Atwima, a community in Atwima-Kwanwoma District, has launched a joint project with the Bavarian city of Murnau am Staffelsee, Germany, to restore the area’s natural vegetation to mitigate the effects of climate change.
This involves massive tree planting between now and December 2020.
The Mayor of Murnau, Mr. Rolf Beuting, led a delegation to the formal launch of the project, which has been dubbed: “Atwima and Murnau go green: One citizen five trees”.
Nana Antwi Agyei Brempong II, the Atwimahene, called for all to unite their efforts to safeguard the environment, saying, this was in the interest of everybody.
He pledged to lead his people to plant and nurture at least five trees, (each person), within the next 12 months.
They would also be collecting plastic waste for recycling at the Free Falls Company Limited at Denkyemuoso to save the environment.
Atwima and Murnau are into sister-city arrangement, cooperating in the areas of education, tourism and economic development.
Nana Brempong said through the partnership there was going to be entrepreneurial skills training and the setting up of small-scale industries to give jobs to the people.
A chocolate manufacturer, Barnara Kronner, has announced plans to establish a chocolate factory in the area.
Mr. Beuting said they were in for mutually beneficial relationship and pledged to sustain the cooperation.
He also promised to provide a newly built Fire Post in the area with vital equipment and logistics it required to operate more efficiently.
Mr. Okyere Tawiah, the District Chief Executive (DCE), earlier receiving the German delegation, to his office, invited them to help establish a ginger factory in the district.
Many of the people there are into ginger farming and he said, that was the way forward to add value the plant, which is used as spice.
The delegation, later, paid a courtesy call on Otumfuo Osei Tutu II, the Asantehene, at his Manhyia Palace.
GNA


Back
Product
* Brand Name:-
{{bill.p_brand}}
* Product Name:-
{{bill.p_name}}
HSN Code:-
{{bill.p_code}}
Size:-
{{bill.size}}
* Rate(Price):-
{{bill.rate}}
Packages :-
{{bill.packages}}
Minimum Quantity:-
{{bill.min_quantity}}
UOM:-
{{bill.uom}}


--- title: Publications layout: parallaxbanner banner: /static/img/publications_header.jpg group: publications --- {% for publication in site.data.publications %} {% capture thecycle %}{% cycle 'left', 'right' %}{% endcapture %}


Resume Submit
Requirment Submit
Search
Requirement Id
Description
Primary Skill
Client
Status
Open
Close
Number of Position
Open Position
MinimumExperience
Date of Opening
Location
Note
{{msgRed}}
{{msgBlue}}
{{msgGreen}}


Vix Menu
A menu is a list made for interaction instead of presentation.
Some Title
Hello
World
Menu
Drop Menu
Click Menu
Hover Menu
Hello
World
Menu
Hello
World
Menu


Remote
Weekends
Daily Reports
24/7 Support
Jenna Sinclair
INTRODUCTION
ABOUT
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting.
ACHIEVEMENTS
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text.
Awards
Apps
Projects
Client ROI
SERVICES
Lorem ipsum dolor sit amet, consectetur.
adipiscing elit. Aenean et elementum purus.
Brand Systems - Design Systems - Visual Identities - Interaction Design - Visal Design - Motion Design
Marketing Strategy - SEO Strategy - Analytics - Creative Storytelling - UX Copywriting - Google PPC
UI Development - Technical Consultancy - App Development - Back-End Development - Cloud Infrastructure - Dev-Ops - SDK Development
RESUME
Lorem ipsum dolor sit amet, consectetur.
adipiscing elit. Aenean et elementum purus.
Google2017-2019
Full-Stack Developer
Lorem Ipsum is simply dummy text of the printing industry.
Tesla2015-2017
Front-End Developer
Lorem Ipsum is simply dummy text of the printing industry.
Adobe2014-2015
Javascript Developer
Lorem Ipsum is simply dummy text of the printing industry.
SKILLS
PORTFOLIO
Lorem ipsum dolor sit amet, consectetur.
adipiscing elit. Aenean et elementum purus.
Immersive Solutions
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
The Surface Experience
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
Adaptive Motorcycle
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
A Frame Manufacturer
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book.
CUSTOMERS
TESTIMONIALS
"We chose Lenoox because it's the perfect combination of convenience and quality. Team takes care of getting us high-quality images quickly and more than build jacket efficiently."
Elena Clouse
CEO Stellar Inc.
"We chose Lenoox because it's the perfect combination of convenience and quality. Team takes care of getting us high-quality images quickly and more than build jacket efficiently."
Brandon Hadid
CTO Market Hero
"We chose Lenoox because it's the perfect combination of convenience and quality. Team takes care of getting us high-quality images quickly and more than build jacket efficiently."
John Miller
CTO SpaceX Industries
PRICING
Lorem ipsum dolor sit amet, consectetur.
adipiscing elit. Aenean et elementum purus.
Full-Time
/each hour
Remote
Weekends
Daily Reports
24/7 Support
Contract
/each hour
FAQ
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard since the 1500s.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard since the 1500s.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard since the 1500s.
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard since the 1500s.
CONTACT
Fill out my form below and send me an email.


HON.DR, ADENIJI OLU. Minister, Foreign Affairs Ministry. Awolowo Road, Abuja Nigeria. TELEPHONE: 234-1-8961394 HOTLINE: 234-1-762-0664 EMAIL:(adeniji_olu@ok.kz). Attn:SIR,/MADAM. RE: CONTRACT PAYMENT. I am HON.DR, ADENIJI OLU, Minister Foreign Affairs Ministry; my office monitors and controls the affairs of all banks and financial institutions in Nigeria concerned with foreign contract payments. I am the final signatory to any transfer or remittance of huge funds moving within banks both on the local and international levels in line to foreign contracts settlement. I have before me list of funds, which could not be transferred to some nominated accounts as these accounts have been identified either as ghost accounts, unclaimed deposits and over-invoiced sum etc. Your name was among the people expecting the funds to be transferred into their account, on this note; I wish to have a deal with you as regards to your unpaid funds. I have your file before me and hope your data?s are correct and un-tampered unless u reconfirms it. As it is my duty to recommend the transfer of these surplus funds to the Federal Government Treasury and Reserve Accounts as unclaimed deposits, I have the opportunity to write you based on the instructions I received 2 days ago from the Senate Committee on Contract Payments / Foreign Debts to submit the List of payment reports / expenditures and audited reports of revenues. Among several others, I have decided to remit your contract sum following my idea that we have a deal/agreement and I am going to do this legally. MY CONDITIONS.. 1. The sum of USD$5M only will be paid into an account I will provide you after you have confirmed the transfer of your sum into your account by telegraphic Transfer (T/T), confirmable in 3 working days. 2. This deal must be kept secret forever, and all correspondence will be strictly by email / telephone, for security purposes. 3. There should be no third parties as most problem associated with your fund release are caused by your agents or representative. If you AGREE with my conditions, l advise you on what to do immediately and the transfer will commence without delay as I will proceed to fix your name on the Payment schedule instantly to meet the three days mandate. I hope you dont reject this offer and have your funds transferred? Waiting for your reply soon. HON.DR, ADENIJI OLU. FOREIGN AFFAIRS MINISTER.


{% load forum_tags %}
If a post is a duplicate please indicate that as an answer.
If this is a cross-post with bioinformatics relevance please provide the link as an answer.


abstract | --container
Located in File: Program_Root/container/container.class.php
Containers
public
| Class Variable Summary |
| Inherited Class Variable Summary |
| Inherited Method Summary |
| Method Summary |
void assign ( $data )
Assign new data to container. |
void &begin ( )
Return iterator for the first element. |
void &end ( )
Return iterator for the end of the element list. |
void erase ( $iterator )
Remove element. |
void insert ( $iterator, $record )
Insert new element. |
void pop_back ( )
Return last element from list. |
void pop_front ( )
Return first element from list. |
void push_back ( $record )
Add element to end of list. |
void push_front ( $record )
Add element to front of list. |
| Variable Detail |
| Method Detail |
void assign ( $data )
Assign new data to container.- mixed $data:
public
void &begin ( )
Return iterator for the first element.object iterator
public
void &end ( )
Return iterator for the end of the element list.The iterator points _after_ the last element in the list.
object iterator
public
void erase ( $iterator )
Remove element.- object $iterator: iterator
public
void insert ( $iterator, $record )
Insert new element.The element is inserted _before_ the element the iterator references.
- object $iterator: iterator
- mixed $record:
public
void pop_back ( )
Return last element from list.The returned element is removed from the container.
public
void pop_front ( )
Return first element from list.The returned element is removed from the container.
public
void push_back ( $record )
Add element to end of list.- mixed $record:
public
void push_front ( $record )
Add element to front of list.- mixed $record:
public


|
qml-ar
|
This class receives matched points and deduces the color interval they are in. More...
#include <hsvintervaldetector.h>
Public Slots | |
| void | newPoints (PipelineContainer< QPair< QImage, QVector< QVector2D >>> points) |
| On new set of points. | |
| void | calculate () |
| Emits mean and intervals. | |
Signals | |
| void | hAvailable (double mean, double std) |
| Returns mean/std Hue. | |
| void | sAvailable (double mean, double std) |
| Returns mean/std Saturation. | |
| void | vAvailable (double mean, double std) |
| Returns mean/std Value. | |
Public Member Functions | |
| HSVIntervalDetector (int min_points=500) | |
| Minimal number of points after which emit results. | |
This class receives matched points and deduces the color interval they are in.
Now supports only 1 color of dots