PGPainless/pgpainless
PGPainless/pgpainless
1
0
Fork 0
mirror of https://github.com/pgpainless/pgpainless.git synced 2024-12-22 19:08:00 +01:00
Code Issues Releases Wiki Activity

Kotlin conversion: RevocationState

Browse source
This commit is contained in:
Paul Schaub 2023-08-04 17:05:13 +02:00
parent 608edc2378
commit c8bfcc807b
Signed by: vanitasvitae
GPG key ID: 62BEE9264BF17311
2 changed files with 87 additions and 131 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

131
pgpainless-core/src/main/java/org/pgpainless/algorithm/RevocationState.java
View file

@ -1,131 +0,0 @@
// SPDX-FileCopyrightText: 2022 Paul Schaub <vanitasvitae@fsfe.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.pgpainless.algorithm;
import org.pgpainless.util.DateUtil;
import javax.annotation.Nonnull;
import java.util.Date;
import java.util.NoSuchElementException;
public final class RevocationState implements Comparable<RevocationState> {
private final RevocationStateType type;
private final Date date;
private RevocationState(RevocationStateType type) {
this(type, null);
}
private RevocationState(RevocationStateType type, Date date) {
this.type = type;
if (type == RevocationStateType.softRevoked && date == null) {
throw new NullPointerException("If type is 'softRevoked' then date cannot be null.");
}
this.date = date;
}
public static RevocationState notRevoked() {
return new RevocationState(RevocationStateType.notRevoked);
}
public static RevocationState softRevoked(@Nonnull Date date) {
return new RevocationState(RevocationStateType.softRevoked, date);
}
public static RevocationState hardRevoked() {
return new RevocationState(RevocationStateType.hardRevoked);
}
public RevocationStateType getType() {
return type;
}
public @Nonnull Date getDate() {
if (!isSoftRevocation()) {
throw new NoSuchElementException("RevocationStateType is not equal to 'softRevoked'. Cannot extract date.");
}
return date;
}
public boolean isHardRevocation() {
return getType() == RevocationStateType.hardRevoked;
}
public boolean isSoftRevocation() {
return getType() == RevocationStateType.softRevoked;
}
public boolean isNotRevoked() {
return getType() == RevocationStateType.notRevoked;
}
@Override
public String toString() {
String out = getType().toString();
if (isSoftRevocation()) {
out = out + " (" + DateUtil.formatUTCDate(date) + ")";
}
return out;
}
@Override
public int compareTo(@Nonnull RevocationState o) {
switch (getType()) {
case notRevoked:
if (o.isNotRevoked()) {
return 0;
} else {
return -1;
}
case softRevoked:
if (o.isNotRevoked()) {
return 1;
} else if (o.isSoftRevocation()) {
// Compare soft dates in reverse
return o.getDate().compareTo(getDate());
} else {
return -1;
}
case hardRevoked:
if (o.isHardRevocation()) {
return 0;
} else {
return 1;
}
default:
throw new AssertionError("Unknown type: " + type);
}
}
@Override
public int hashCode() {
return type.hashCode() * 31 + (isSoftRevocation() ? getDate().hashCode() : 0);
}
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (this == obj) {
return true;
}
if (!(obj instanceof RevocationState)) {
return false;
}
RevocationState other = (RevocationState) obj;
if (getType() != other.getType()) {
return false;
}
if (isSoftRevocation()) {
return DateUtil.toSecondsPrecision(getDate()).getTime() == DateUtil.toSecondsPrecision(other.getDate()).getTime();
}
return true;
}
}

87
pgpainless-core/src/main/java/org/pgpainless/algorithm/RevocationState.kt Normal file
View file

@ -0,0 +1,87 @@
// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.pgpainless.algorithm
import org.pgpainless.util.DateUtil
import java.lang.AssertionError
import java.util.*
import kotlin.NoSuchElementException
class RevocationState private constructor(
val type: RevocationStateType,
private val _date: Date?): Comparable<RevocationState> {
val date: Date
get() {
if (!isSoftRevocation()) {
throw NoSuchElementException("RevocationStateType is not equal to 'softRevoked'. Cannot extract date.")
}
return _date!!
}
private constructor(type: RevocationStateType): this(type, null)
fun isSoftRevocation() = type == RevocationStateType.softRevoked
fun isHardRevocation() = type == RevocationStateType.hardRevoked
fun isNotRevoked() = type == RevocationStateType.notRevoked
companion object {
@JvmStatic
fun notRevoked() = RevocationState(RevocationStateType.notRevoked)
@JvmStatic
fun softRevoked(date: Date) = RevocationState(RevocationStateType.softRevoked, date)
@JvmStatic
fun hardRevoked() = RevocationState(RevocationStateType.hardRevoked)
}
override fun compareTo(other: RevocationState): Int {
return when(type) {
RevocationStateType.notRevoked ->
if (other.isNotRevoked()) 0
else -1
RevocationStateType.softRevoked ->
if (other.isNotRevoked()) 1
// Compare soft dates in reverse
else if (other.isSoftRevocation()) other.date.compareTo(date)
else -1
RevocationStateType.hardRevoked ->
if (other.isHardRevocation()) 0
else 1
else -> throw AssertionError("Unknown type: $type")
}
}
override fun toString(): String {
return buildString {
append(type)
if (isSoftRevocation()) append(" (${DateUtil.formatUTCDate(date)})")
}
}
override fun hashCode(): Int {
return type.hashCode() * 31 + if (isSoftRevocation()) date.hashCode() else 0
}
override fun equals(other: Any?): Boolean {
if (other == null) {
return false
}
if (this === other) {
return true
}
if (other !is RevocationState) {
return false
}
if (type != other.type) {
return false
}
if (isSoftRevocation()) {
return DateUtil.toSecondsPrecision(date).time == DateUtil.toSecondsPrecision(other.date).time
}
return true
}
}