Skip to content

Commit d5f0893

Browse files
vectrixdevelopsvectrixdevelops
committed
chore(syncmap): clean up minor style errors
1 parent ef30bd6 commit d5f0893

File tree

1 file changed

+87
-87
lines changed
  • collections/src/main/java/space/vectrix/collections

1 file changed

+87
-87
lines changed

‎collections/src/main/java/space/vectrix/collections/SyncMap.java‎

Lines changed: 87 additions & 87 deletions
Original file line numberDiff line numberDiff line change
@@ -458,21 +458,21 @@ public boolean containsKey(final @NotNull Object key) {
458458
}
459459

460460
final ObjectReference reference = node.reference;
461-
Object current = reference.get();
461+
Object previous = reference.get();
462462
for(; ; ) {
463-
if(current != null && current != SyncMap.EXPUNGED) return (V) current;
463+
if(previous != null && previous != SyncMap.EXPUNGED) return (V) previous;
464464

465465
next = mappingFunction.apply(key);
466466
if(next == null) return null;
467467

468-
final Object previous = reference.compareAndExchange(current, next);
469-
if(previous != current) {
470-
current = previous;
468+
final Object witness = reference.compareAndExchange(previous, next);
469+
if(witness != previous) {
470+
previous = witness;
471471
Thread.onSpinWait();
472472
continue;
473473
}
474474

475-
if(previous == SyncMap.EXPUNGED) {
475+
if(witness == SyncMap.EXPUNGED) {
476476
this.amendNode(hash, key, reference);
477477
}
478478

@@ -501,16 +501,16 @@ public boolean containsKey(final @NotNull Object key) {
501501
final K nodeKey;
502502
if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
503503
final ObjectReference reference = node.reference;
504-
Object current = reference.get();
504+
Object previous = reference.get();
505505
for(; ; ) {
506-
if(current != null && current != SyncMap.EXPUNGED) return (V) current;
506+
if(previous != null && previous != SyncMap.EXPUNGED) return (V) previous;
507507

508508
next = mappingFunction.apply(key);
509509
if(next == null) return null;
510510

511-
final Object previous = reference.compareAndExchange(current, next);
512-
if (previous != current) {
513-
current = previous;
511+
final Object witness = reference.compareAndExchange(previous, next);
512+
if(witness != previous) {
513+
previous = witness;
514514
Thread.onSpinWait();
515515
continue;
516516
}
@@ -556,14 +556,14 @@ public boolean containsKey(final @NotNull Object key) {
556556
}
557557

558558
final ObjectReference reference = node.reference;
559-
Object current = reference.get();
559+
Object previous = reference.get();
560560
for(; ; ) {
561-
if(current == null || current == SyncMap.EXPUNGED) return null;
562-
next = remappingFunction.apply(key, (V) current);
561+
if(previous == null || previous == SyncMap.EXPUNGED) return null;
562+
next = remappingFunction.apply(key, (V) previous);
563563

564-
final Object previous = reference.compareAndExchange(current, next);
565-
if(previous != current) {
566-
current = previous;
564+
final Object witness = reference.compareAndExchange(previous, next);
565+
if(witness != previous) {
566+
previous = witness;
567567
Thread.onSpinWait();
568568
continue;
569569
}
@@ -586,14 +586,14 @@ public boolean containsKey(final @NotNull Object key) {
586586
final K nodeKey;
587587
if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
588588
final ObjectReference reference = node.reference;
589-
Object current = reference.get();
589+
Object previous = reference.get();
590590
for(; ; ) {
591-
if(current == null || current == SyncMap.EXPUNGED) return null;
592-
next = remappingFunction.apply(key, (V) current);
591+
if(previous == null || previous == SyncMap.EXPUNGED) return null;
592+
next = remappingFunction.apply(key, (V) previous);
593593

594-
final Object previous = reference.compareAndExchange(current, next);
595-
if(previous != current) {
596-
current = previous;
594+
final Object witness = reference.compareAndExchange(previous, next);
595+
if(witness != previous) {
596+
previous = witness;
597597
Thread.onSpinWait();
598598
continue;
599599
}
@@ -646,22 +646,22 @@ public boolean containsKey(final @NotNull Object key) {
646646
}
647647

648648
final ObjectReference reference = node.reference;
649-
Object current = reference.get();
649+
Object previous = reference.get();
650650
for(; ; ) {
651-
next = remappingFunction.apply(key, current == SyncMap.EXPUNGED ? null : (V) current);
652-
if(next == null && (current == null || current == SyncMap.EXPUNGED)) return null;
651+
next = remappingFunction.apply(key, previous == SyncMap.EXPUNGED ? null : (V) previous);
652+
if(next == null && (previous == null || previous == SyncMap.EXPUNGED)) return null;
653653

654-
final Object previous = reference.compareAndExchange(current, next);
655-
if(previous != current) {
656-
current = previous;
654+
final Object witness = reference.compareAndExchange(previous, next);
655+
if(witness != previous) {
656+
previous = witness;
657657
Thread.onSpinWait();
658658
continue;
659659
}
660660

661661
if(next != null) {
662-
if(previous == null) {
662+
if(witness == null) {
663663
count = 1L;
664-
} else if(previous == SyncMap.EXPUNGED) {
664+
} else if(witness == SyncMap.EXPUNGED) {
665665
this.amendNode(hash, key, reference);
666666

667667
count = 1L;
@@ -696,21 +696,21 @@ public boolean containsKey(final @NotNull Object key) {
696696
final K nodeKey;
697697
if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
698698
final ObjectReference reference = node.reference;
699-
Object current = reference.get();
699+
Object previous = reference.get();
700700
for(; ; ) {
701-
next = remappingFunction.apply(key, current == SyncMap.EXPUNGED ? null : (V) current);
702-
if(next == null && (current == null || current == SyncMap.EXPUNGED)) return null;
701+
next = remappingFunction.apply(key, previous == SyncMap.EXPUNGED ? null : (V) previous);
702+
if(next == null && (previous == null || previous == SyncMap.EXPUNGED)) return null;
703703

704-
final Object previous = reference.compareAndExchange(current, next);
705-
if(previous != current) {
706-
current = previous;
704+
final Object witness = reference.compareAndExchange(previous, next);
705+
if(witness != previous) {
706+
previous = witness;
707707
Thread.onSpinWait();
708708
continue;
709709
}
710710

711-
if(next != null && (previous == null || previous == SyncMap.EXPUNGED)) {
711+
if(next != null && (witness == null || witness == SyncMap.EXPUNGED)) {
712712
count = 1L;
713-
} else if(next == null && (previous != null && previous != SyncMap.EXPUNGED)) {
713+
} else if(next == null && (witness != null && witness != SyncMap.EXPUNGED)) {
714714
if(previousNode != null) {
715715
previousNode.next = node.next;
716716
} else {
@@ -763,18 +763,18 @@ public boolean containsKey(final @NotNull Object key) {
763763
}
764764

765765
final ObjectReference reference = node.reference;
766-
Object current = reference.get();
766+
Object previous = reference.get();
767767
for(; ; ) {
768-
if(current != null && current != SyncMap.EXPUNGED) return (V) current;
768+
if(previous != null && previous != SyncMap.EXPUNGED) return (V) previous;
769769

770-
final Object previous = reference.compareAndExchange(current, value);
771-
if(previous != current) {
772-
current = previous;
770+
final Object witness = reference.compareAndExchange(previous, value);
771+
if(witness != previous) {
772+
previous = witness;
773773
Thread.onSpinWait();
774774
continue;
775775
}
776776

777-
if(previous == SyncMap.EXPUNGED) {
777+
if(witness == SyncMap.EXPUNGED) {
778778
this.amendNode(hash, key, reference);
779779
}
780780

@@ -800,13 +800,13 @@ public boolean containsKey(final @NotNull Object key) {
800800
final K nodeKey;
801801
if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
802802
final ObjectReference reference = node.reference;
803-
Object current = reference.get();
803+
Object previous = reference.get();
804804
for(; ; ) {
805-
if(current != null && current != SyncMap.EXPUNGED) return (V) current;
805+
if(previous != null && previous != SyncMap.EXPUNGED) return (V) previous;
806806

807-
final Object previous = reference.compareAndExchange(current, value);
808-
if (previous != current) {
809-
current = previous;
807+
final Object witness = reference.compareAndExchange(previous, value);
808+
if(witness != previous) {
809+
previous = witness;
810810
Thread.onSpinWait();
811811
continue;
812812
}
@@ -848,19 +848,19 @@ public boolean containsKey(final @NotNull Object key) {
848848
}
849849

850850
final ObjectReference reference = node.reference;
851-
Object current = reference.get();
851+
Object previous = reference.get();
852852
for(; ; ) {
853-
final Object previous = reference.compareAndExchange(current, value);
854-
if(previous != current) {
855-
current = previous;
853+
final Object witness = reference.compareAndExchange(previous, value);
854+
if(witness != previous) {
855+
previous = witness;
856856
Thread.onSpinWait();
857857
continue;
858858
}
859859

860-
if(previous == SyncMap.EXPUNGED) {
860+
if(witness == SyncMap.EXPUNGED) {
861861
this.amendNode(hash, key, reference);
862-
} else if(previous != null) {
863-
return (V) previous;
862+
} else if(witness != null) {
863+
return (V) witness;
864864
}
865865

866866
break retry;
@@ -885,17 +885,17 @@ public boolean containsKey(final @NotNull Object key) {
885885
final K nodeKey;
886886
if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
887887
final ObjectReference reference = node.reference;
888-
Object current = reference.get();
888+
Object previous = reference.get();
889889
for(; ; ) {
890-
final Object previous = reference.compareAndExchange(current, value);
891-
if(previous != current) {
892-
current = previous;
890+
final Object witness = reference.compareAndExchange(previous, value);
891+
if(witness != previous) {
892+
previous = witness;
893893
Thread.onSpinWait();
894894
continue;
895895
}
896896

897-
if(previous != null && previous != SyncMap.EXPUNGED) {
898-
return (V) previous;
897+
if(witness != null && witness != SyncMap.EXPUNGED) {
898+
return (V) witness;
899899
}
900900

901901
break retry;
@@ -1050,14 +1050,14 @@ public boolean remove(final @NotNull Object key, final @NotNull Object value) {
10501050
}
10511051

10521052
final ObjectReference reference = node.reference;
1053-
Object current = reference.get();
1053+
Object previous = reference.get();
10541054
for(; ; ) {
1055-
if(current == null || current == SyncMap.EXPUNGED) return false;
1056-
if(!Objects.equals(value, current)) return false;
1055+
if(previous == null || previous == SyncMap.EXPUNGED) return false;
1056+
if(!Objects.equals(value, previous)) return false;
10571057

1058-
final Object previous = reference.compareAndExchange(current, null);
1059-
if(previous != current) {
1060-
current = previous;
1058+
final Object witness = reference.compareAndExchange(previous, null);
1059+
if(witness != previous) {
1060+
previous = witness;
10611061
Thread.onSpinWait();
10621062
continue;
10631063
}
@@ -1076,14 +1076,14 @@ public boolean remove(final @NotNull Object key, final @NotNull Object value) {
10761076
final K nodeKey;
10771077
if(node.hash == hash && ((nodeKey = node.key) == key || nodeKey.equals(key))) {
10781078
final ObjectReference reference = node.reference;
1079-
Object current = reference.get();
1079+
Object previous = reference.get();
10801080
for(; ; ) {
1081-
if(current == null || current == SyncMap.EXPUNGED) return false;
1082-
if(!Objects.equals(value, current)) return false;
1081+
if(previous == null || previous == SyncMap.EXPUNGED) return false;
1082+
if(!Objects.equals(value, previous)) return false;
10831083

1084-
final Object previous = reference.compareAndExchange(current, null);
1085-
if(previous != current) {
1086-
current = previous;
1084+
final Object witness = reference.compareAndExchange(previous, null);
1085+
if(witness != previous) {
1086+
previous = witness;
10871087
Thread.onSpinWait();
10881088
continue;
10891089
}
@@ -1290,9 +1290,9 @@ public void clear() {
12901290
for(; ; ) {
12911291
if(current == null || current == SyncMap.EXPUNGED) continue;
12921292

1293-
final Object previous = reference.compareAndExchange(current, null);
1294-
if(previous != current) {
1295-
current = previous;
1293+
final Object witness = reference.compareAndExchange(current, null);
1294+
if(witness != current) {
1295+
current = witness;
12961296
Thread.onSpinWait();
12971297
continue;
12981298
}
@@ -1317,7 +1317,7 @@ public void clear() {
13171317
* identical to the pair currently in the map.</p>
13181318
*/
13191319
@Override
1320-
public @NotNull Set<Entry<K, V>> entrySet() {
1320+
public @NotNull Set<Map.Entry<K, V>> entrySet() {
13211321
if(this.entrySet != null) return this.entrySet;
13221322
return this.entrySet = new EntrySet();
13231323
}
@@ -2017,7 +2017,7 @@ public void clear() {
20172017
/**
20182018
* Represents a view of a map entry.
20192019
*/
2020-
/* package */ final class MapEntry implements Entry<K, V> {
2020+
/* package */ final class MapEntry implements Map.Entry<K, V> {
20212021
private final K key;
20222022
private V value;
20232023

@@ -2065,7 +2065,7 @@ public String toString() {
20652065
/**
20662066
* Represents a view of the map entries.
20672067
*/
2068-
/* package */ final class EntrySet extends AbstractSet<Entry<K, V>> {
2068+
/* package */ final class EntrySet extends AbstractSet<Map.Entry<K, V>> {
20692069
@Override
20702070
public int size() {
20712071
return SyncMap.this.size();
@@ -2090,7 +2090,7 @@ public void clear() {
20902090
}
20912091

20922092
@Override
2093-
public @NotNull Iterator<Entry<K, V>> iterator() {
2093+
public @NotNull Iterator<Map.Entry<K, V>> iterator() {
20942094
SyncMap.this.promote();
20952095
return new EntryIterator(SyncMap.this.immutableTable);
20962096
}
@@ -2100,9 +2100,9 @@ public void clear() {
21002100
* Represents an entry {@link Iterator} that traverses the nodes in the
21012101
* given table.
21022102
*/
2103-
/* package */ final class EntryIterator extends Traverser<K, V> implements Iterator<Entry<K, V>> {
2104-
private Entry<K, V> next;
2105-
private Entry<K, V> current;
2103+
/* package */ final class EntryIterator extends Traverser<K, V> implements Iterator<Map.Entry<K, V>> {
2104+
private Map.Entry<K, V> next;
2105+
private Map.Entry<K, V> current;
21062106

21072107
/* package */ EntryIterator(final Node<K, V>@NotNull [] table) {
21082108
super(table);
@@ -2117,7 +2117,7 @@ public boolean hasNext() {
21172117

21182118
@Override
21192119
public @NotNull Entry<K, V> next() {
2120-
final Entry<K, V> current;
2120+
final Map.Entry<K, V> current;
21212121
if((current = this.next) == null) throw new NoSuchElementException();
21222122
this.current = current;
21232123
this.advanceEntry();
@@ -2126,7 +2126,7 @@ public boolean hasNext() {
21262126

21272127
@Override
21282128
public void remove() {
2129-
final Entry<K, V> current;
2129+
final Map.Entry<K, V> current;
21302130
if((current = this.current) == null) throw new IllegalStateException();
21312131
this.current = null;
21322132
SyncMap.this.remove(current.getKey(), current.getValue());

0 commit comments

Comments
 (0)