stan/jdk-24
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge

Browse Source
This commit is contained in:
Serguei Spitsyn 2016-05-06 20:36:12 +00:00
commit 55e2b30835
21 changed files with 1168 additions and 333 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
jdk/src/java.base/share/classes/java/time/format/DateTimeFormatterBuilder.java
View File

@ -1527,12 +1527,9 @@ public final class DateTimeFormatterBuilder {
* ss 2 appendValue(ChronoField.SECOND_OF_MINUTE, 2)
*
* S..S 1..n appendFraction(ChronoField.NANO_OF_SECOND, n, n, false)
* A 1 appendValue(ChronoField.MILLI_OF_DAY)
* A..A 2..n appendValue(ChronoField.MILLI_OF_DAY, n)
* n 1 appendValue(ChronoField.NANO_OF_SECOND)
* n..n 2..n appendValue(ChronoField.NANO_OF_SECOND, n)
* N 1 appendValue(ChronoField.NANO_OF_DAY)
* N..N 2..n appendValue(ChronoField.NANO_OF_DAY, n)
* A..A 1..n appendValue(ChronoField.MILLI_OF_DAY, n, 19, SignStyle.NOT_NEGATIVE)
* n..n 1..n appendValue(ChronoField.NANO_OF_SECOND, n, 19, SignStyle.NOT_NEGATIVE)
* N..N 1..n appendValue(ChronoField.NANO_OF_DAY, n, 19, SignStyle.NOT_NEGATIVE)
* </pre>
* <p>
* <b>Zone ID</b>: Pattern letters to output {@code ZoneId}.
@ -1850,6 +1847,11 @@ public final class DateTimeFormatterBuilder {
case 'g':
appendValue(field, count, 19, SignStyle.NORMAL);
break;
case 'A':
case 'n':
case 'N':
appendValue(field, count, 19, SignStyle.NOT_NEGATIVE);
break;
default:
if (count == 1) {
appendValue(field);

657
jdk/src/java.base/share/classes/java/util/ImmutableCollections.java Normal file
View File

@ -0,0 +1,657 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation. Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
package java.util;
import java.io.IOException;
import java.io.InvalidObjectException;
import java.io.ObjectInputStream;
import java.io.ObjectStreamException;
import java.io.Serializable;
/**
* Container class for immutable collections. Not part of the public API.
* Mainly for namespace management and shared infrastructure.
*
* Serial warnings are suppressed throughout because all implementation
* classes use a serial proxy and thus have no need to declare serialVersionUID.
*/
@SuppressWarnings("serial")
class ImmutableCollections {
/**
* A "salt" value used for randomizing iteration order. This is initialized once
* and stays constant for the lifetime of the JVM. It need not be truly random, but
* it needs to vary sufficiently from one run to the next so that iteration order
* will vary between JVM runs.
*/
static final int SALT;
static {
SALT = new Random().nextInt();
}
/** No instances. */
private ImmutableCollections() { }
/**
* The reciprocal of load factor. Given a number of elements
* to store, multiply by this factor to get the table size.
*/
static final double EXPAND_FACTOR = 2.0;
// ---------- List Implementations ----------
static final class List0<E> extends AbstractList<E> implements RandomAccess, Serializable {
List0() { }
@Override
public int size() {
return 0;
}
@Override
public E get(int index) {
Objects.checkIndex(index, 0); // always throws IndexOutOfBoundsException
return null; // but the compiler doesn't know this
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
return new CollSer(CollSer.IMM_LIST);
}
}
static final class List1<E> extends AbstractList<E> implements RandomAccess, Serializable {
private final E e0;
List1(E e0) {
this.e0 = Objects.requireNonNull(e0);
}
@Override
public int size() {
return 1;
}
@Override
public E get(int index) {
Objects.checkIndex(index, 1);
// assert index == 0
return e0;
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
return new CollSer(CollSer.IMM_LIST, e0);
}
}
static final class List2<E> extends AbstractList<E> implements RandomAccess, Serializable {
private final E e0;
private final E e1;
List2(E e0, E e1) {
this.e0 = Objects.requireNonNull(e0);
this.e1 = Objects.requireNonNull(e1);
}
@Override
public int size() {
return 2;
}
@Override
public E get(int index) {
Objects.checkIndex(index, 2);
if (index == 0) {
return e0;
} else { // index == 1
return e1;
}
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
return new CollSer(CollSer.IMM_LIST, e0, e1);
}
}
static final class ListN<E> extends AbstractList<E> implements RandomAccess, Serializable {
private final E[] elements;
@SafeVarargs
ListN(E... input) {
// copy and check manually to avoid TOCTOU
@SuppressWarnings("unchecked")
E[] tmp = (E[])new Object[input.length]; // implicit nullcheck of input
for (int i = 0; i < input.length; i++) {
tmp[i] = Objects.requireNonNull(input[i]);
}
this.elements = tmp;
}
@Override
public int size() {
return elements.length;
}
@Override
public E get(int index) {
Objects.checkIndex(index, elements.length);
return elements[index];
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
return new CollSer(CollSer.IMM_LIST, elements);
}
}
// ---------- Set Implementations ----------
static final class Set0<E> extends AbstractSet<E> implements Serializable {
Set0() { }
@Override
public int size() {
return 0;
}
@Override
public boolean contains(Object o) {
return super.contains(Objects.requireNonNull(o));
}
@Override
public Iterator<E> iterator() {
return Collections.emptyIterator();
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
return new CollSer(CollSer.IMM_SET);
}
}
static final class Set1<E> extends AbstractSet<E> implements Serializable {
private final E e0;
Set1(E e0) {
this.e0 = Objects.requireNonNull(e0);
}
@Override
public int size() {
return 1;
}
@Override
public boolean contains(Object o) {
return super.contains(Objects.requireNonNull(o));
}
@Override
public Iterator<E> iterator() {
return Collections.singletonIterator(e0);
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
return new CollSer(CollSer.IMM_SET, e0);
}
}
static final class Set2<E> extends AbstractSet<E> implements Serializable {
private final E e0;
private final E e1;
Set2(E e0, E e1) {
Objects.requireNonNull(e0);
Objects.requireNonNull(e1);
if (e0.equals(e1)) {
throw new IllegalArgumentException("duplicate element: " + e0);
}
if (SALT >= 0) {
this.e0 = e0;
this.e1 = e1;
} else {
this.e0 = e1;
this.e1 = e0;
}
}
@Override
public int size() {
return 2;
}
@Override
public boolean contains(Object o) {
return super.contains(Objects.requireNonNull(o));
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
private int idx = 0;
@Override
public boolean hasNext() {
return idx < 2;
}
@Override
public E next() {
if (idx == 0) {
idx = 1;
return e0;
} else if (idx == 1) {
idx = 2;
return e1;
} else {
throw new NoSuchElementException();
}
}
};
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
return new CollSer(CollSer.IMM_SET, e0, e1);
}
}
/**
* An array-based Set implementation. The element array must be strictly
* larger than the size (the number of contained elements) so that at
* least one null is always present.
* @param <E> the element type
*/
static final class SetN<E> extends AbstractSet<E> implements Serializable {
private final E[] elements;
private final int size;
@SafeVarargs
@SuppressWarnings("unchecked")
SetN(E... input) {
size = input.length; // implicit nullcheck of input
elements = (E[])new Object[(int)Math.ceil(EXPAND_FACTOR * input.length)];
for (int i = 0; i < input.length; i++) {
E e = Objects.requireNonNull(input[i]);
int idx = probe(e);
if (idx >= 0) {
throw new IllegalArgumentException("duplicate element: " + e);
} else {
elements[-(idx + 1)] = e;
}
}
}
@Override
public int size() {
return size;
}
@Override
public boolean contains(Object o) {
Objects.requireNonNull(o);
return probe(o) >= 0;
}
@Override
public Iterator<E> iterator() {
return new Iterator<E>() {
private int idx = 0;
@Override
public boolean hasNext() {
while (idx < elements.length) {
if (elements[idx] != null)
return true;
idx++;
}
return false;
}
@Override
public E next() {
if (! hasNext()) {
throw new NoSuchElementException();
}
return elements[idx++];
}
};
}
// returns index at which element is present; or if absent,
// (-i - 1) where i is location where element should be inserted
private int probe(Object pe) {
int idx = Math.floorMod(pe.hashCode() ^ SALT, elements.length);
while (true) {
E ee = elements[idx];
if (ee == null) {
return -idx - 1;
} else if (pe.equals(ee)) {
return idx;
} else if (++idx == elements.length) {
idx = 0;
}
}
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
Object[] array = new Object[size];
int dest = 0;
for (Object o : elements) {
if (o != null) {
array[dest++] = o;
}
}
return new CollSer(CollSer.IMM_SET, array);
}
}
// ---------- Map Implementations ----------
static final class Map0<K,V> extends AbstractMap<K,V> implements Serializable {
Map0() { }
@Override
public Set<Map.Entry<K,V>> entrySet() {
return Set.of();
}
@Override
public boolean containsKey(Object o) {
return super.containsKey(Objects.requireNonNull(o));
}
@Override
public boolean containsValue(Object o) {
return super.containsValue(Objects.requireNonNull(o));
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
return new CollSer(CollSer.IMM_MAP);
}
}
static final class Map1<K,V> extends AbstractMap<K,V> implements Serializable {
private final K k0;
private final V v0;
Map1(K k0, V v0) {
this.k0 = Objects.requireNonNull(k0);
this.v0 = Objects.requireNonNull(v0);
}
@Override
public Set<Map.Entry<K,V>> entrySet() {
return Set.of(new KeyValueHolder<>(k0, v0));
}
@Override
public boolean containsKey(Object o) {
return super.containsKey(Objects.requireNonNull(o));
}
@Override
public boolean containsValue(Object o) {
return super.containsValue(Objects.requireNonNull(o));
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
return new CollSer(CollSer.IMM_MAP, k0, v0);
}
}
/**
* An array-based Map implementation. There is a single array "table" that
* contains keys and values interleaved: table[0] is kA, table[1] is vA,
* table[2] is kB, table[3] is vB, etc. The table size must be even. It must
* also be strictly larger than the size (the number of key-value pairs contained
* in the map) so that at least one null key is always present.
* @param <K> the key type
* @param <V> the value type
*/
static final class MapN<K,V> extends AbstractMap<K,V> implements Serializable {
private final Object[] table; // pairs of key, value
private final int size; // number of pairs
MapN(Object... input) {
Objects.requireNonNull(input);
if ((input.length & 1) != 0) {
throw new InternalError("length is odd");
}
size = input.length >> 1;
int len = (int)Math.ceil(EXPAND_FACTOR * input.length);
len = (len + 1) & ~1; // ensure table is even length
table = new Object[len];
for (int i = 0; i < input.length; i += 2) {
@SuppressWarnings("unchecked")
K k = Objects.requireNonNull((K)input[i]);
@SuppressWarnings("unchecked")
V v = Objects.requireNonNull((V)input[i+1]);
int idx = probe(k);
if (idx >= 0) {
throw new IllegalArgumentException("duplicate key: " + k);
} else {
int dest = -(idx + 1);
table[dest] = k;
table[dest+1] = v;
}
}
}
@Override
public boolean containsKey(Object o) {
return probe(Objects.requireNonNull(o)) >= 0;
}
@Override
public boolean containsValue(Object o) {
return super.containsValue(Objects.requireNonNull(o));
}
@Override
@SuppressWarnings("unchecked")
public V get(Object o) {
int i = probe(o);
if (i >= 0) {
return (V)table[i+1];
} else {
return null;
}
}
@Override
public int size() {
return size;
}
@Override
public Set<Map.Entry<K,V>> entrySet() {
return new AbstractSet<Map.Entry<K,V>>() {
@Override
public int size() {
return MapN.this.size;
}
@Override
public Iterator<Map.Entry<K,V>> iterator() {
return new Iterator<Map.Entry<K,V>>() {
int idx = 0;
@Override
public boolean hasNext() {
while (idx < table.length) {
if (table[idx] != null)
return true;
idx += 2;
}
return false;
}
@Override
public Map.Entry<K,V> next() {
if (hasNext()) {
@SuppressWarnings("unchecked")
Map.Entry<K,V> e =
new KeyValueHolder<>((K)table[idx], (V)table[idx+1]);
idx += 2;
return e;
} else {
throw new NoSuchElementException();
}
}
};
}
};
}
// returns index at which the probe key is present; or if absent,
// (-i - 1) where i is location where element should be inserted
private int probe(Object pk) {
int idx = Math.floorMod(pk.hashCode() ^ SALT, table.length >> 1) << 1;
while (true) {
@SuppressWarnings("unchecked")
K ek = (K)table[idx];
if (ek == null) {
return -idx - 1;
} else if (pk.equals(ek)) {
return idx;
} else if ((idx += 2) == table.length) {
idx = 0;
}
}
}
private void readObject(ObjectInputStream in) throws IOException, ClassNotFoundException {
throw new InvalidObjectException("not serial proxy");
}
private Object writeReplace() {
Object[] array = new Object[2 * size];
int len = table.length;
int dest = 0;
for (int i = 0; i < len; i += 2) {
if (table[i] != null) {
array[dest++] = table[i];
array[dest++] = table[i+1];
}
}
return new CollSer(CollSer.IMM_MAP, array);
}
}
}
// ---------- Serialization Proxy ----------
/**
* Serialization proxy class for immutable collections.
*/
final class CollSer implements Serializable {
private static final long serialVersionUID = 6309168927139932177L;
static final int IMM_LIST = 1;
static final int IMM_SET = 2;
static final int IMM_MAP = 3;
private final int flags;
private final Object[] array;
CollSer(int f, Object... a) {
flags = f;
array = a;
}
private Object readResolve() throws ObjectStreamException {
try {
if (array == null) {
throw new InvalidObjectException("null array");
}
// use low order 8 bits to indicate "kind"
// ignore high order bits
switch (flags & 0xff) {
case IMM_LIST:
return List.of(array);
case IMM_SET:
return Set.of(array);
case IMM_MAP:
if (array.length == 0) {
return new ImmutableCollections.Map0<>();
} else if (array.length == 2) {
return new ImmutableCollections.Map1<>(array[0], array[1]);
} else {
return new ImmutableCollections.MapN<>(array);
}
default:
throw new InvalidObjectException(String.format("invalid flags 0x%x", flags));
}
} catch (NullPointerException|IllegalArgumentException ex) {
InvalidObjectException ioe = new InvalidObjectException("invalid object");
ioe.initCause(ex);
throw ioe;
}
}
}

95
jdk/src/java.base/share/classes/java/util/List.java
View File

@ -765,7 +765,7 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of() {
return Collections.emptyList();
return new ImmutableCollections.List0<>();
}
/**
@ -781,7 +781,7 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of(E e1) {
return Collections.singletonList(Objects.requireNonNull(e1));
return new ImmutableCollections.List1<>(e1);
}
/**
@ -798,9 +798,7 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of(E e1, E e2) {
return Collections.unmodifiableList(
Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2)));
return new ImmutableCollections.List2<>(e1, e2);
}
/**
@ -818,10 +816,7 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3) {
return Collections.unmodifiableList(
Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3)));
return new ImmutableCollections.ListN<>(e1, e2, e3);
}
/**
@ -840,11 +835,7 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4) {
return Collections.unmodifiableList(
Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4)));
return new ImmutableCollections.ListN<>(e1, e2, e3, e4);
}
/**
@ -864,12 +855,7 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5) {
return Collections.unmodifiableList(
Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5)));
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5);
}
/**
@ -890,13 +876,8 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
return Collections.unmodifiableList(
Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5),
Objects.requireNonNull(e6)));
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
e6);
}
/**
@ -918,14 +899,8 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
return Collections.unmodifiableList(
Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5),
Objects.requireNonNull(e6),
Objects.requireNonNull(e7)));
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
e6, e7);
}
/**
@ -948,15 +923,8 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
return Collections.unmodifiableList(
Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5),
Objects.requireNonNull(e6),
Objects.requireNonNull(e7),
Objects.requireNonNull(e8)));
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
e6, e7, e8);
}
/**
@ -980,16 +948,8 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
return Collections.unmodifiableList(
Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5),
Objects.requireNonNull(e6),
Objects.requireNonNull(e7),
Objects.requireNonNull(e8),
Objects.requireNonNull(e9)));
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
e6, e7, e8, e9);
}
/**
@ -1014,17 +974,8 @@ public interface List<E> extends Collection<E> {
* @since 9
*/
static <E> List<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
return Collections.unmodifiableList(
Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5),
Objects.requireNonNull(e6),
Objects.requireNonNull(e7),
Objects.requireNonNull(e8),
Objects.requireNonNull(e9),
Objects.requireNonNull(e10)));
return new ImmutableCollections.ListN<>(e1, e2, e3, e4, e5,
e6, e7, e8, e9, e10);
}
/**
@ -1055,10 +1006,16 @@ public interface List<E> extends Collection<E> {
@SafeVarargs
@SuppressWarnings("varargs")
static <E> List<E> of(E... elements) {
elements = elements.clone(); // throws NPE if es is null
for (E e : elements) {
Objects.requireNonNull(e);
Objects.requireNonNull(elements);
switch (elements.length) {
case 0:
return new ImmutableCollections.List0<>();
case 1:
return new ImmutableCollections.List1<>(elements[0]);
case 2:
return new ImmutableCollections.List2<>(elements[0], elements[1]);
default:
return new ImmutableCollections.ListN<>(elements);
}
return Collections.unmodifiableList(Arrays.asList(elements));
}
}

139
jdk/src/java.base/share/classes/java/util/Map.java
View File

@ -1282,7 +1282,7 @@ public interface Map<K, V> {
* @since 9
*/
static <K, V> Map<K, V> of() {
return Collections.emptyMap();
return new ImmutableCollections.Map0<>();
}
/**
@ -1299,7 +1299,7 @@ public interface Map<K, V> {
* @since 9
*/
static <K, V> Map<K, V> of(K k1, V v1) {
return Collections.singletonMap(Objects.requireNonNull(k1), Objects.requireNonNull(v1));
return new ImmutableCollections.Map1<>(k1, v1);
}
/**
@ -1319,13 +1319,7 @@ public interface Map<K, V> {
* @since 9
*/
static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2) {
Map<K, V> map = new HashMap<>(3); // specify number of buckets to avoid resizing
map.put(Objects.requireNonNull(k1), Objects.requireNonNull(v1));
map.put(Objects.requireNonNull(k2), Objects.requireNonNull(v2));
if (map.size() != 2) {
throw new IllegalArgumentException("duplicate keys");
}
return Collections.unmodifiableMap(map);
return new ImmutableCollections.MapN<>(k1, v1, k2, v2);
}
/**
@ -1347,14 +1341,7 @@ public interface Map<K, V> {
* @since 9
*/
static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3) {
Map<K, V> map = new HashMap<>(5); // specify number of buckets to avoid resizing
map.put(Objects.requireNonNull(k1), Objects.requireNonNull(v1));
map.put(Objects.requireNonNull(k2), Objects.requireNonNull(v2));
map.put(Objects.requireNonNull(k3), Objects.requireNonNull(v3));
if (map.size() != 3) {
throw new IllegalArgumentException("duplicate keys");
}
return Collections.unmodifiableMap(map);
return new ImmutableCollections.MapN<>(k1, v1, k2, v2, k3, v3);
}
/**
@ -1378,15 +1365,7 @@ public interface Map<K, V> {
* @since 9
*/
static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4) {
Map<K, V> map = new HashMap<>(6); // specify number of buckets to avoid resizing
map.put(Objects.requireNonNull(k1), Objects.requireNonNull(v1));
map.put(Objects.requireNonNull(k2), Objects.requireNonNull(v2));
map.put(Objects.requireNonNull(k3), Objects.requireNonNull(v3));
map.put(Objects.requireNonNull(k4), Objects.requireNonNull(v4));
if (map.size() != 4) {
throw new IllegalArgumentException("duplicate keys");
}
return Collections.unmodifiableMap(map);
return new ImmutableCollections.MapN<>(k1, v1, k2, v2, k3, v3, k4, v4);
}
/**
@ -1412,16 +1391,7 @@ public interface Map<K, V> {
* @since 9
*/
static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5) {
Map<K, V> map = new HashMap<>(7); // specify number of buckets to avoid resizing
map.put(Objects.requireNonNull(k1), Objects.requireNonNull(v1));
map.put(Objects.requireNonNull(k2), Objects.requireNonNull(v2));
map.put(Objects.requireNonNull(k3), Objects.requireNonNull(v3));
map.put(Objects.requireNonNull(k4), Objects.requireNonNull(v4));
map.put(Objects.requireNonNull(k5), Objects.requireNonNull(v5));
if (map.size() != 5) {
throw new IllegalArgumentException("duplicate keys");
}
return Collections.unmodifiableMap(map);
return new ImmutableCollections.MapN<>(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5);
}
/**
@ -1450,17 +1420,8 @@ public interface Map<K, V> {
*/
static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
K k6, V v6) {
Map<K, V> map = new HashMap<>(9); // specify number of buckets to avoid resizing
map.put(Objects.requireNonNull(k1), Objects.requireNonNull(v1));
map.put(Objects.requireNonNull(k2), Objects.requireNonNull(v2));
map.put(Objects.requireNonNull(k3), Objects.requireNonNull(v3));
map.put(Objects.requireNonNull(k4), Objects.requireNonNull(v4));
map.put(Objects.requireNonNull(k5), Objects.requireNonNull(v5));
map.put(Objects.requireNonNull(k6), Objects.requireNonNull(v6));
if (map.size() != 6) {
throw new IllegalArgumentException("duplicate keys");
}
return Collections.unmodifiableMap(map);
return new ImmutableCollections.MapN<>(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5,
k6, v6);
}
/**
@ -1491,18 +1452,8 @@ public interface Map<K, V> {
*/
static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
K k6, V v6, K k7, V v7) {
Map<K, V> map = new HashMap<>(10); // specify number of buckets to avoid resizing
map.put(Objects.requireNonNull(k1), Objects.requireNonNull(v1));
map.put(Objects.requireNonNull(k2), Objects.requireNonNull(v2));
map.put(Objects.requireNonNull(k3), Objects.requireNonNull(v3));
map.put(Objects.requireNonNull(k4), Objects.requireNonNull(v4));
map.put(Objects.requireNonNull(k5), Objects.requireNonNull(v5));
map.put(Objects.requireNonNull(k6), Objects.requireNonNull(v6));
map.put(Objects.requireNonNull(k7), Objects.requireNonNull(v7));
if (map.size() != 7) {
throw new IllegalArgumentException("duplicate keys");
}
return Collections.unmodifiableMap(map);
return new ImmutableCollections.MapN<>(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5,
k6, v6, k7, v7);
}
/**
@ -1535,19 +1486,8 @@ public interface Map<K, V> {
*/
static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
K k6, V v6, K k7, V v7, K k8, V v8) {
Map<K, V> map = new HashMap<>(11); // specify number of buckets to avoid resizing
map.put(Objects.requireNonNull(k1), Objects.requireNonNull(v1));
map.put(Objects.requireNonNull(k2), Objects.requireNonNull(v2));
map.put(Objects.requireNonNull(k3), Objects.requireNonNull(v3));
map.put(Objects.requireNonNull(k4), Objects.requireNonNull(v4));
map.put(Objects.requireNonNull(k5), Objects.requireNonNull(v5));
map.put(Objects.requireNonNull(k6), Objects.requireNonNull(v6));
map.put(Objects.requireNonNull(k7), Objects.requireNonNull(v7));
map.put(Objects.requireNonNull(k8), Objects.requireNonNull(v8));
if (map.size() != 8) {
throw new IllegalArgumentException("duplicate keys");
}
return Collections.unmodifiableMap(map);
return new ImmutableCollections.MapN<>(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5,
k6, v6, k7, v7, k8, v8);
}
/**
@ -1582,20 +1522,8 @@ public interface Map<K, V> {
*/
static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9) {
Map<K, V> map = new HashMap<>(13); // specify number of buckets to avoid resizing
map.put(Objects.requireNonNull(k1), Objects.requireNonNull(v1));
map.put(Objects.requireNonNull(k2), Objects.requireNonNull(v2));
map.put(Objects.requireNonNull(k3), Objects.requireNonNull(v3));
map.put(Objects.requireNonNull(k4), Objects.requireNonNull(v4));
map.put(Objects.requireNonNull(k5), Objects.requireNonNull(v5));
map.put(Objects.requireNonNull(k6), Objects.requireNonNull(v6));
map.put(Objects.requireNonNull(k7), Objects.requireNonNull(v7));
map.put(Objects.requireNonNull(k8), Objects.requireNonNull(v8));
map.put(Objects.requireNonNull(k9), Objects.requireNonNull(v9));
if (map.size() != 9) {
throw new IllegalArgumentException("duplicate keys");
}
return Collections.unmodifiableMap(map);
return new ImmutableCollections.MapN<>(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5,
k6, v6, k7, v7, k8, v8, k9, v9);
}
/**
@ -1632,21 +1560,8 @@ public interface Map<K, V> {
*/
static <K, V> Map<K, V> of(K k1, V v1, K k2, V v2, K k3, V v3, K k4, V v4, K k5, V v5,
K k6, V v6, K k7, V v7, K k8, V v8, K k9, V v9, K k10, V v10) {
Map<K, V> map = new HashMap<>(14); // specify number of buckets to avoid resizing
map.put(Objects.requireNonNull(k1), Objects.requireNonNull(v1));
map.put(Objects.requireNonNull(k2), Objects.requireNonNull(v2));
map.put(Objects.requireNonNull(k3), Objects.requireNonNull(v3));
map.put(Objects.requireNonNull(k4), Objects.requireNonNull(v4));
map.put(Objects.requireNonNull(k5), Objects.requireNonNull(v5));
map.put(Objects.requireNonNull(k6), Objects.requireNonNull(v6));
map.put(Objects.requireNonNull(k7), Objects.requireNonNull(v7));
map.put(Objects.requireNonNull(k8), Objects.requireNonNull(v8));
map.put(Objects.requireNonNull(k9), Objects.requireNonNull(v9));
map.put(Objects.requireNonNull(k10), Objects.requireNonNull(v10));
if (map.size() != 10) {
throw new IllegalArgumentException("duplicate keys");
}
return Collections.unmodifiableMap(map);
return new ImmutableCollections.MapN<>(k1, v1, k2, v2, k3, v3, k4, v4, k5, v5,
k6, v6, k7, v7, k8, v8, k9, v9, k10, v10);
}
/**
@ -1683,15 +1598,21 @@ public interface Map<K, V> {
@SafeVarargs
@SuppressWarnings("varargs")
static <K, V> Map<K, V> ofEntries(Entry<? extends K, ? extends V>... entries) {
Map<K, V> map = new HashMap<>(entries.length * 4 / 3 + 1); // throws NPE if entries is null
for (Entry<? extends K, ? extends V> e : entries) {
// next line throws NPE if e is null
map.put(Objects.requireNonNull(e.getKey()), Objects.requireNonNull(e.getValue()));
Objects.requireNonNull(entries);
if (entries.length == 0) {
return new ImmutableCollections.Map0<>();
} else if (entries.length == 1) {
return new ImmutableCollections.Map1<>(entries[0].getKey(),
entries[0].getValue());
} else {
Object[] kva = new Object[entries.length << 1];
int a = 0;
for (Entry<? extends K, ? extends V> entry : entries) {
kva[a++] = entry.getKey();
kva[a++] = entry.getValue();
}
return new ImmutableCollections.MapN<>(kva);
}
if (map.size() != entries.length) {
throw new IllegalArgumentException("duplicate keys");
}
return Collections.unmodifiableMap(map);
}
/**

127
jdk/src/java.base/share/classes/java/util/Set.java
View File

@ -444,7 +444,7 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of() {
return Collections.emptySet();
return new ImmutableCollections.Set0<>();
}
/**
@ -459,7 +459,7 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of(E e1) {
return Collections.singleton(Objects.requireNonNull(e1));
return new ImmutableCollections.Set1<>(e1);
}
/**
@ -476,12 +476,7 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of(E e1, E e2) {
Set<E> set = new HashSet<>(Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2)));
if (set.size() != 2) {
throw new IllegalArgumentException("duplicate elements");
}
return Collections.unmodifiableSet(set);
return new ImmutableCollections.Set2<>(e1, e2);
}
/**
@ -499,13 +494,7 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of(E e1, E e2, E e3) {
Set<E> set = new HashSet<>(Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3)));
if (set.size() != 3) {
throw new IllegalArgumentException("duplicate elements");
}
return Collections.unmodifiableSet(set);
return new ImmutableCollections.SetN<>(e1, e2, e3);
}
/**
@ -524,14 +513,7 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of(E e1, E e2, E e3, E e4) {
Set<E> set = new HashSet<>(Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4)));
if (set.size() != 4) {
throw new IllegalArgumentException("duplicate elements");
}
return Collections.unmodifiableSet(set);
return new ImmutableCollections.SetN<>(e1, e2, e3, e4);
}
/**
@ -551,15 +533,7 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5) {
Set<E> set = new HashSet<>(Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5)));
if (set.size() != 5) {
throw new IllegalArgumentException("duplicate elements");
}
return Collections.unmodifiableSet(set);
return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5);
}
/**
@ -580,16 +554,8 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6) {
Set<E> set = new HashSet<>(Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5),
Objects.requireNonNull(e6)));
if (set.size() != 6) {
throw new IllegalArgumentException("duplicate elements");
}
return Collections.unmodifiableSet(set);
return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5,
e6);
}
/**
@ -611,17 +577,8 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7) {
Set<E> set = new HashSet<>(Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5),
Objects.requireNonNull(e6),
Objects.requireNonNull(e7)));
if (set.size() != 7) {
throw new IllegalArgumentException("duplicate elements");
}
return Collections.unmodifiableSet(set);
return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5,
e6, e7);
}
/**
@ -644,18 +601,8 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8) {
Set<E> set = new HashSet<>(Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5),
Objects.requireNonNull(e6),
Objects.requireNonNull(e7),
Objects.requireNonNull(e8)));
if (set.size() != 8) {
throw new IllegalArgumentException("duplicate elements");
}
return Collections.unmodifiableSet(set);
return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5,
e6, e7, e8);
}
/**
@ -679,19 +626,8 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9) {
Set<E> set = new HashSet<>(Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5),
Objects.requireNonNull(e6),
Objects.requireNonNull(e7),
Objects.requireNonNull(e8),
Objects.requireNonNull(e9)));
if (set.size() != 9) {
throw new IllegalArgumentException("duplicate elements");
}
return Collections.unmodifiableSet(set);
return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5,
e6, e7, e8, e9);
}
/**
@ -716,20 +652,8 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
static <E> Set<E> of(E e1, E e2, E e3, E e4, E e5, E e6, E e7, E e8, E e9, E e10) {
Set<E> set = new HashSet<>(Arrays.asList(Objects.requireNonNull(e1),
Objects.requireNonNull(e2),
Objects.requireNonNull(e3),
Objects.requireNonNull(e4),
Objects.requireNonNull(e5),
Objects.requireNonNull(e6),
Objects.requireNonNull(e7),
Objects.requireNonNull(e8),
Objects.requireNonNull(e9),
Objects.requireNonNull(e10)));
if (set.size() != 10) {
throw new IllegalArgumentException("duplicate elements");
}
return Collections.unmodifiableSet(set);
return new ImmutableCollections.SetN<>(e1, e2, e3, e4, e5,
e6, e7, e8, e9, e10);
}
/**
@ -759,15 +683,18 @@ public interface Set<E> extends Collection<E> {
* @since 9
*/
@SafeVarargs
@SuppressWarnings("varargs")
static <E> Set<E> of(E... elements) {
for (E e : elements) { // throws NPE if es is null
Objects.requireNonNull(e);
Objects.requireNonNull(elements);
switch (elements.length) {
case 0:
return new ImmutableCollections.Set0<>();
case 1:
return new ImmutableCollections.Set1<>(elements[0]);
case 2:
return new ImmutableCollections.Set2<>(elements[0], elements[1]);
default:
return new ImmutableCollections.SetN<>(elements);
}
@SuppressWarnings("varargs")
Set<E> set = new HashSet<>(Arrays.asList(elements));
if (set.size() != elements.length) {
throw new IllegalArgumentException("duplicate elements");
}
return Collections.unmodifiableSet(set);
}
}

9
jdk/src/java.desktop/share/native/libawt/java2d/loops/FourByteAbgr.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -191,4 +191,11 @@ typedef jubyte FourByteAbgrDataType;
COMP_PREFIX ## A, COMP_PREFIX ## R, \
COMP_PREFIX ## G, COMP_PREFIX ## B)
/*
* SrcOver ## TYPE ## BlendFactor
* Returns appropriate blend value for use in blending calculations.
*/
#define SrcOverFourByteAbgrBlendFactor(dF, dA) \
(dA)
#endif /* FourByteAbgr_h_Included */

9
jdk/src/java.desktop/share/native/libawt/java2d/loops/FourByteAbgrPre.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2008, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -217,4 +217,11 @@ typedef jubyte FourByteAbgrPreDataType;
(pRas)[4*(x)+3] = (jubyte) COMP_PREFIX ## R; \
} while (0)
/*
* SrcOver ## TYPE ## BlendFactor
* Returns appropriate blend value for use in blending calculations.
*/
#define SrcOverFourByteAbgrPreBlendFactor(dF, dA) \
(dF)
#endif /* FourByteAbgrPre_h_Included */

9
jdk/src/java.desktop/share/native/libawt/java2d/loops/IntArgb.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -208,4 +208,11 @@ typedef jint IntArgbDataType;
COMP_PREFIX ## A = (COMP_PREFIX ## A << 8) + COMP_PREFIX ## A; \
} while (0)
/*
* SrcOver ## TYPE ## BlendFactor
* Returns appropriate blend value for use in blending calculations.
*/
#define SrcOverIntArgbBlendFactor(dF, dA) \
(dA)
#endif /* IntArgb_h_Included */

9
jdk/src/java.desktop/share/native/libawt/java2d/loops/IntArgbBm.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2001, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2001, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -206,4 +206,11 @@ typedef jint IntArgbBmDataType;
COMP_PREFIX ## A = (COMP_PREFIX ## A << 8) + COMP_PREFIX ## A; \
} while (0)
/*
* SrcOver ## TYPE ## BlendFactor
* Returns appropriate blend value for use in blending calculations.
*/
#define SrcOverIntArgbBmBlendFactor(dF, dA) \
(dA)
#endif /* IntArgbBm_h_Included */

9
jdk/src/java.desktop/share/native/libawt/java2d/loops/IntArgbPre.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -216,4 +216,11 @@ typedef jint IntArgbPreDataType;
COMP_PREFIX ## G, \
COMP_PREFIX ## B)
/*
* SrcOver ## TYPE ## BlendFactor
* Returns appropriate blend value for use in blending calculations.
*/
#define SrcOverIntArgbPreBlendFactor(dF, dA) \
(dF)
#endif /* IntArgbPre_h_Included */

86
jdk/src/java.desktop/share/native/libawt/java2d/loops/LoopMacros.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2000, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -1668,31 +1668,83 @@ void NAME_SOLID_DRAWGLYPHLIST(DST)(SurfaceDataRasInfo *pRasInfo, \
} \
} while (0);
/*
* Antialiased glyph drawing results in artifacts around the character edges
* when text is drawn ontop of translucent background color. The standard
* blending equation for two colors:
* destColor = srcColor * glyphAlpha + destColor * (1 - glyphAlpha)
* works only when srcColor and destColor are opaque. For translucent srcColor
* and destColor, the respective alpha components in each color will influence
* the visibility of the color and the visibility of the color below it. Hence
* the equation for blending is given as:
* resA = srcAlpha + dstAlpha * (1 - srcAlpha)
* resCol = (srcColor * srcAlpha + destColor * destAlpha * (1- srcAlpha))/resA
* In addition, srcAlpha is multiplied with the glyphAlpha- that indicates the
* grayscale mask value of the glyph being drawn. The combined result provides
* smooth antialiased text on the buffer without any artifacts. Since the
* logic is executed for every pixel in a glyph, the implementation is further
* optimized to reduce computation and improve execution time.
*/
#define GlyphListAABlend4ByteArgb(DST, GLYPH_PIXELS, PIXEL_INDEX, DST_PTR, \
FG_PIXEL, PREFIX, SRC_PREFIX) \
do { \
DeclareAlphaVarFor4ByteArgb(dstA) \
DeclareCompVarsFor4ByteArgb(dst) \
do { \
DeclareAlphaVarFor4ByteArgb(resA) \
DeclareCompVarsFor4ByteArgb(res) \
jint mixValSrc = GLYPH_PIXELS[PIXEL_INDEX]; \
if (mixValSrc) { \
if (mixValSrc < 255) { \
jint mixValDst = 255 - mixValSrc; \
Load ## DST ## To4ByteArgb(DST_PTR, pix, PIXEL_INDEX, \
dstA, dstR, dstG, dstB); \
dstA = MUL8(dstA, mixValDst) + \
MUL8(SRC_PREFIX ## A, mixValSrc); \
MultMultAddAndStore4ByteArgbComps(dst, mixValDst, dst, \
mixValSrc, SRC_PREFIX); \
if (!(DST ## IsOpaque) && \
!(DST ## IsPremultiplied) && dstA && dstA < 255) { \
DivideAndStore4ByteArgbComps(dst, dst, dstA); \
if (mixValSrc != 0xff) { \
PromoteByteAlphaFor4ByteArgb(mixValSrc); \
resA = MultiplyAlphaFor4ByteArgb(mixValSrc, SRC_PREFIX ## A); \
} else { \
resA = SRC_PREFIX ## A; \
} \
if (resA != MaxValFor4ByteArgb) { \
DeclareAndInvertAlphaVarFor4ByteArgb(dstF, resA) \
DeclareAndClearAlphaVarFor4ByteArgb(dstA) \
DeclareCompVarsFor4ByteArgb(dst) \
DeclareCompVarsFor4ByteArgb(tmp) \
MultiplyAndStore4ByteArgbComps(res, resA, SRC_PREFIX); \
if (!(DST ## IsPremultiplied)) { \
Load ## DST ## To4ByteArgb(DST_PTR, pix, PIXEL_INDEX, \
dstA, dstR, dstG, dstB); \
Store4ByteArgbCompsUsingOp(tmp, =, dst); \
} else { \
Declare ## DST ## AlphaLoadData(DstPix) \
jint pixelOffset = PIXEL_INDEX * (DST ## PixelStride); \
DST ## DataType *pixelAddress = PtrAddBytes(DST_PTR, \
pixelOffset); \
LoadAlphaFrom ## DST ## For4ByteArgb(pixelAddress, \
DstPix, \
dst); \
Postload4ByteArgbFrom ## DST(pixelAddress, \
DstPix, \
tmp); \
} \
if (dstA) { \
DeclareAlphaVarFor4ByteArgb(blendF) \
dstA = MultiplyAlphaFor4ByteArgb(dstF, dstA); \
resA += dstA; \
blendF = SrcOver ## DST ## BlendFactor(dstF, dstA); \
if (blendF != MaxValFor4ByteArgb) { \
MultiplyAndStore4ByteArgbComps(tmp, \
blendF, \
tmp); \
} \
Store4ByteArgbCompsUsingOp(res, +=, tmp); \
} \
Store ## DST ## From4ByteArgbComps(DST_PTR, pix, \
PIXEL_INDEX, dst); \
} else { \
Store ## DST ## PixelData(DST_PTR, PIXEL_INDEX, \
FG_PIXEL, PREFIX); \
break; \
} \
if (!(DST ## IsOpaque) && \
!(DST ## IsPremultiplied) && resA && \
resA < MaxValFor4ByteArgb) \
{ \
DivideAndStore4ByteArgbComps(res, res, resA); \
} \
Store ## DST ## From4ByteArgbComps(DST_PTR, pix, \
PIXEL_INDEX, res); \
} \
} while (0);

24
jdk/src/java.httpclient/share/classes/java/net/http/AsyncSSLDelegate.java
View File

@ -144,13 +144,9 @@ public class AsyncSSLDelegate implements Closeable, AsyncConnection {
sslParameters = Utils.copySSLParameters(sslp);
if (alpn != null) {
sslParameters.setApplicationProtocols(alpn);
Log.logSSL("Setting application protocols: " + Arrays.toString(alpn));
} else {
Log.logSSL("No application protocols proposed");
}
logParams(sslParameters);
engine.setSSLParameters(sslParameters);
engine.setEnabledCipherSuites(sslp.getCipherSuites());
engine.setEnabledProtocols(sslp.getProtocols());
this.lowerOutput = lowerOutput;
this.client = client;
this.channelInputQ = new Queue<>();
@ -560,24 +556,26 @@ public class AsyncSSLDelegate implements Closeable, AsyncConnection {
return sslParameters;
}
static void printParams(SSLParameters p) {
System.out.println("SSLParameters:");
static void logParams(SSLParameters p) {
if (!Log.ssl())
return;
Log.logSSL("SSLParameters:");
if (p == null) {
System.out.println("Null params");
Log.logSSL("Null params");
return;
}
for (String cipher : p.getCipherSuites()) {
System.out.printf("cipher: %s\n", cipher);
Log.logSSL("cipher: {0}\n", cipher);
}
for (String approto : p.getApplicationProtocols()) {
System.out.printf("application protocol: %s\n", approto);
Log.logSSL("application protocol: {0}\n", approto);
}
for (String protocol : p.getProtocols()) {
System.out.printf("protocol: %s\n", protocol);
Log.logSSL("protocol: {0}\n", protocol);
}
if (p.getServerNames() != null)
for (SNIServerName sname : p.getServerNames()) {
System.out.printf("server name: %s\n", sname.toString());
for (SNIServerName sname : p.getServerNames()) {
Log.logSSL("server name: {0}\n", sname.toString());
}
}

11
jdk/src/java.httpclient/share/classes/java/net/http/HttpClientImpl.java
View File

@ -110,7 +110,10 @@ class HttpClientImpl extends HttpClient implements BufferHandler {
this.proxySelector = builder.proxy;
authenticator = builder.authenticator;
version = builder.version;
sslParams = builder.sslParams;
if (builder.sslParams == null)
sslParams = getDefaultParams(sslContext);
else
sslParams = builder.sslParams;
connections = new ConnectionPool();
connections.start();
timeouts = new LinkedList<>();
@ -129,6 +132,12 @@ class HttpClientImpl extends HttpClient implements BufferHandler {
selmgr.start();
}
private static SSLParameters getDefaultParams(SSLContext ctx) {
SSLParameters params = ctx.getSupportedSSLParameters();
params.setProtocols(new String[]{"TLSv1.2"});
return params;
}
/**
* Wait for activity on given exchange (assuming blocking = false).
* It's a no-op if blocking = true. In particular, the following occurs

2
jdk/src/java.httpclient/share/classes/java/net/http/SSLDelegate.java
View File

@ -66,8 +66,6 @@ class SSLDelegate {
Log.logSSL("No application protocols proposed");
}
engine.setSSLParameters(sslParameters);
engine.setEnabledCipherSuites(sslp.getCipherSuites());
engine.setEnabledProtocols(sslp.getProtocols());
wrapper = new EngineWrapper(chan, engine);
this.chan = chan;
this.client = client;

136
jdk/test/java/awt/Graphics2D/DrawString/AntialiasedTextArtifact.java Normal file
View File

@ -0,0 +1,136 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8015070
* @summary Tests for artifacts around the edges of anti-aliased text
* drawn over translucent background color.
*/
import java.awt.Color;
import java.awt.Font;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;
import java.io.IOException;
public class AntialiasedTextArtifact {
/* Image dimensions */
private static final int TEST_IMAGE_WIDTH = 2800;
private static final int TEST_IMAGE_HEIGHT = 100;
private static final String TEST_STRING =
"The quick brown fox jumps over the lazy dog. 0123456789.";
/*
* The artifacts appear when text is drawn ontop of translucent
* background. In other words, a background with alpha channel.
* Hence we test the algorithm for image types that contain either
* straight alpha channel or pre-multiplied alpha channel. In
* addition we test the images with other common pixel formats.
*/
private static final int[] TYPES = {BufferedImage.TYPE_INT_ARGB,
BufferedImage.TYPE_INT_ARGB_PRE,
BufferedImage.TYPE_4BYTE_ABGR,
BufferedImage.TYPE_4BYTE_ABGR_PRE,
BufferedImage.TYPE_INT_RGB,
BufferedImage.TYPE_INT_BGR,
BufferedImage.TYPE_3BYTE_BGR};
public static void main(String[] args) throws IOException {
/* Iterate over different image types */
for (int type : TYPES) {
BufferedImage testImg = getBufferedImage(type);
/* Draw anti-aliased string and check for artifacts */
drawAntialiasedString(testImg);
checkArtifact(testImg);
}
}
private static BufferedImage getBufferedImage(int imageType) {
/* Create a Graphics2D object from the given image type */
BufferedImage image = new BufferedImage(TEST_IMAGE_WIDTH,
TEST_IMAGE_HEIGHT,
imageType);
return image;
}
private static void drawAntialiasedString(BufferedImage image) {
/* Create Graphics2D object */
Graphics2D graphics = (Graphics2D) image.getGraphics();
/* Fill the image with translucent color */
graphics.setColor(new Color(127, 127, 127, 127));
graphics.fillRect(0, 0, TEST_IMAGE_WIDTH, TEST_IMAGE_HEIGHT);
/* Drawstring with Antialiasing hint */
graphics.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
Font font = new Font("Verdana" , Font.PLAIN, 60);
graphics.setFont(font);
graphics.setColor(new Color(255, 0, 0));
graphics.drawString(TEST_STRING, 10, 75);
graphics.dispose();
}
private static void checkArtifact(BufferedImage image) throws IOException {
int componentMask = 0xff;
int colorThreshold = 200;
int rowIndex = 0;
int colIndex = 0;
/* Loop through every pixel to check for possible artifact */
for (rowIndex = 0; rowIndex < image.getHeight(); rowIndex++) {
for (colIndex = 0; colIndex < image.getWidth(); colIndex++) {
/*
* API: getRGB(x,y) returns color in INT_ARGB color space.
* Extract individual color components with a simple mask.
*/
int colorValue = image.getRGB(colIndex, rowIndex);
int colorComponent1 = colorValue & componentMask;
int colorComponent2 = (colorValue>>8) & componentMask;
int colorComponent3 = (colorValue>>16) & componentMask;
/*
* Artifacts are predominantly a subjective decision based on
* the quality of the rendered image content. However, in the
* current use-case, the artifacts around the edges of the anti
* aliased text appear like spots of white pixels without any
* relation to the color of foreground text or the background
* translucent shape.
*
* To identify the artifact pixels, each color component from
* the testImage is compared with a constant threshold. The
* component threshold has been set based on observation from
* different experiments on mulitple Java versions.
*/
if (colorComponent1 >= colorThreshold
&& colorComponent2 >= colorThreshold
&& colorComponent3 >= colorThreshold) {
/* Artifact has been noticed. Report error. */
throw new RuntimeException("Test Failed.");
}
}
}
}
}

25
jdk/test/java/net/httpclient/http2/BasicTest.java
View File

@ -98,6 +98,7 @@ public class BasicTest {
simpleTest(true);
streamTest(false);
streamTest(true);
paramsTest();
Thread.sleep(1000 * 4);
} finally {
httpServer.stop();
@ -180,6 +181,30 @@ public class BasicTest {
System.err.println("DONE");
}
static void paramsTest() throws Exception {
Http2TestServer server = new Http2TestServer(true, 0, (t -> {
SSLSession s = t.getSSLSession();
String prot = s.getProtocol();
if (prot.equals("TLSv1.2")) {
t.sendResponseHeaders(200, -1);
} else {
System.err.printf("Protocols =%s\n", prot);
t.sendResponseHeaders(500, -1);
}
}), exec, sslContext);
server.start();
int port = server.getAddress().getPort();
URI u = new URI("https://127.0.0.1:"+port+"/foo");
HttpClient client = getClient();
HttpRequest req = client.request(u)
.GET();
HttpResponse resp = req.response();
int stat = resp.statusCode();
if (stat != 200) {
throw new RuntimeException("paramsTest failed "
+ Integer.toString(stat));
}
}
static void simpleTest(boolean secure) throws Exception {
URI uri = getURI(secure);

8
jdk/test/java/net/httpclient/http2/java.httpclient/java/net/http/Http2TestExchange.java
View File

@ -5,6 +5,7 @@ import java.io.OutputStream;
import java.io.IOException;
import java.net.URI;
import java.net.InetSocketAddress;
import javax.net.ssl.SSLSession;
public class Http2TestExchange {
@ -14,6 +15,7 @@ public class Http2TestExchange {
final String method;
final InputStream is;
final BodyOutputStream os;
final SSLSession sslSession;
final int streamid;
final boolean pushAllowed;
final Http2TestServerConnection conn;
@ -24,6 +26,7 @@ public class Http2TestExchange {
Http2TestExchange(int streamid, String method, HttpHeadersImpl reqheaders,
HttpHeadersImpl rspheaders, URI uri, InputStream is,
SSLSession sslSession,
BodyOutputStream os, Http2TestServerConnection conn, boolean pushAllowed) {
this.reqheaders = reqheaders;
this.rspheaders = rspheaders;
@ -32,6 +35,7 @@ public class Http2TestExchange {
this.is = is;
this.streamid = streamid;
this.os = os;
this.sslSession = sslSession;
this.pushAllowed = pushAllowed;
this.conn = conn;
this.server = conn.server;
@ -53,6 +57,10 @@ public class Http2TestExchange {
return method;
}
public SSLSession getSSLSession() {
return sslSession;
}
public void close() {
try {
is.close();

11
jdk/test/java/net/httpclient/http2/java.httpclient/java/net/http/Http2TestServerConnection.java
View File

@ -31,6 +31,8 @@ import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.URI;
import javax.net.ssl.SSLSession;
import javax.net.ssl.SSLSocket;
import java.net.URISyntaxException;
import static java.net.http.SettingsFrame.HEADER_TABLE_SIZE;
import java.nio.ByteBuffer;
@ -355,7 +357,8 @@ public class Http2TestServerConnection {
URI uri = new URI(us);
boolean pushAllowed = clientSettings.getParameter(SettingsFrame.ENABLE_PUSH) == 1;
Http2TestExchange exchange = new Http2TestExchange(streamid, method,
headers, rspheaders, uri, bis, bos, this, pushAllowed);
headers, rspheaders, uri, bis, getSSLSession(),
bos, this, pushAllowed);
// give to user
handler.handle(exchange);
@ -368,6 +371,12 @@ public class Http2TestServerConnection {
}
}
private SSLSession getSSLSession() {
if (! (socket instanceof SSLSocket))
return null;
SSLSocket ssl = (SSLSocket)socket;
return ssl.getSession();
}
// Runs in own thread
@SuppressWarnings({"rawtypes","unchecked"})

49
jdk/test/java/time/tck/java/time/format/TCKDateTimeFormatterBuilder.java
View File

@ -72,6 +72,7 @@ import static org.testng.Assert.assertEquals;
import java.text.ParsePosition;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.YearMonth;
import java.time.ZoneOffset;
import java.time.format.DateTimeFormatter;
@ -794,6 +795,54 @@ public class TCKDateTimeFormatterBuilder {
assertEquals(LocalDate.of(y, m, d).format(df), expected);
}
//-----------------------------------------------------------------------
@DataProvider(name="secondsPattern")
Object[][] data_secondsPattern() {
return new Object[][] {
{"A", "1", LocalTime.ofNanoOfDay(1_000_000)},
{"A", "100000", LocalTime.ofSecondOfDay(100)},
{"AA", "01", LocalTime.ofNanoOfDay(1_000_000)},
{"AA", "100000", LocalTime.ofSecondOfDay(100)},
{"AAAAAA", "100000", LocalTime.ofSecondOfDay(100)},
{"HHmmssn", "0000001", LocalTime.ofNanoOfDay(1)},
{"HHmmssn", "000000111", LocalTime.ofNanoOfDay(111)},
{"HHmmssnn", "00000001", LocalTime.ofNanoOfDay(1)},
{"HHmmssnn", "0000001111", LocalTime.ofNanoOfDay(1111)},
{"HHmmssnnnnnn", "000000111111", LocalTime.ofNanoOfDay(111_111)},
{"N", "1", LocalTime.ofNanoOfDay(1)},
{"N", "100000", LocalTime.ofNanoOfDay(100_000)},
{"NN", "01", LocalTime.ofNanoOfDay(1)},
{"NN", "100000", LocalTime.ofNanoOfDay(100_000)},
{"NNNNNN", "100000", LocalTime.ofNanoOfDay(100_000)},
};
}
@Test(dataProvider="secondsPattern")
public void test_secondsPattern(String pattern, String input, LocalTime expected) throws Exception {
DateTimeFormatter df = new DateTimeFormatterBuilder().appendPattern(pattern).toFormatter();
assertEquals(LocalTime.parse(input, df), expected);
}
@DataProvider(name="secondsValues")
Object[][] data_secondsValues() {
return new Object[][] {
{"A", 1, "1000"},
{"n", 1, "0"},
{"N", 1, "1000000000"},
};
}
@Test(dataProvider="secondsValues")
public void test_secondsValues(String pattern, int seconds , String expected) throws Exception {
DateTimeFormatter df = new DateTimeFormatterBuilder().appendPattern(pattern).toFormatter();
assertEquals(LocalTime.ofSecondOfDay(seconds).format(df), expected);
}
@Test(expectedExceptions = DateTimeParseException.class)
public void test_secondsPatternInvalidAdacentValueParsingPattern() {
// patterns A*, N*, n* will not take part in adjacent value parsing
DateTimeFormatter.ofPattern("yyyyAA").parse("201610");
}
//-----------------------------------------------------------------------
@Test

20
jdk/test/java/time/test/java/time/format/TestDateTimeFormatterBuilder.java
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2012, 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
@ -746,17 +746,17 @@ public class TestDateTimeFormatterBuilder {
{"SSS", "Fraction(NanoOfSecond,3,3)"},
{"SSSSSSSSS", "Fraction(NanoOfSecond,9,9)"},
{"A", "Value(MilliOfDay)"},
{"AA", "Value(MilliOfDay,2)"},
{"AAA", "Value(MilliOfDay,3)"},
{"A", "Value(MilliOfDay,1,19,NOT_NEGATIVE)"},
{"AA", "Value(MilliOfDay,2,19,NOT_NEGATIVE)"},
{"AAA", "Value(MilliOfDay,3,19,NOT_NEGATIVE)"},
{"n", "Value(NanoOfSecond)"},
{"nn", "Value(NanoOfSecond,2)"},
{"nnn", "Value(NanoOfSecond,3)"},
{"n", "Value(NanoOfSecond,1,19,NOT_NEGATIVE)"},
{"nn", "Value(NanoOfSecond,2,19,NOT_NEGATIVE)"},
{"nnn", "Value(NanoOfSecond,3,19,NOT_NEGATIVE)"},
{"N", "Value(NanoOfDay)"},
{"NN", "Value(NanoOfDay,2)"},
{"NNN", "Value(NanoOfDay,3)"},
{"N", "Value(NanoOfDay,1,19,NOT_NEGATIVE)"},
{"NN", "Value(NanoOfDay,2,19,NOT_NEGATIVE)"},
{"NNN", "Value(NanoOfDay,3,19,NOT_NEGATIVE)"},
{"z", "ZoneText(SHORT)"},
{"zz", "ZoneText(SHORT)"},

52
jdk/test/java/util/Map/EntrySetIterator.java Normal file
View File

@ -0,0 +1,52 @@
/*
* Copyright (c) 2016, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 8139233
* @summary ensure entry set's iterator doesn't have side effects on the entry set
* @run testng EntrySetIterator
*/
import java.util.*;
import org.testng.annotations.Test;
import static org.testng.Assert.assertTrue;
import static org.testng.Assert.assertEquals;
public class EntrySetIterator {
@Test
public void main() {
Map<String, String> map = Map.of("a", "1", "b", "2", "c", "3");
Set<Map.Entry<String, String>> entrySet = map.entrySet();
Iterator<Map.Entry<String, String>> iterator = entrySet.iterator();
assertTrue(iterator.hasNext());
// copying implicitly iterates an iterator
Set<Map.Entry<String, String>> copy1 = new HashSet<>(entrySet);
Set<Map.Entry<String, String>> copy2 = new HashSet<>(entrySet);
assertEquals(copy2, copy1);
assertTrue(iterator.hasNext());
}
}