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

Kotlin conversion: SignatureCreationDateComparator, SignatureValidityComparator

Browse source
This commit is contained in:
Paul Schaub 2023-10-17 18:58:37 +02:00
parent 70e1b40cd2
commit 4fc513fa25
Signed by: vanitasvitae
GPG key ID: 62BEE9264BF17311
4 changed files with 65 additions and 106 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

53
pgpainless-core/src/main/java/org/pgpainless/signature/consumer/SignatureCreationDateComparator.java
View file

@ -1,53 +0,0 @@
// SPDX-FileCopyrightText: 2021 Paul Schaub <vanitasvitae@fsfe.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.pgpainless.signature.consumer;
import java.util.Comparator;
import org.bouncycastle.openpgp.PGPSignature;
/**
* Comparator which can be used to sort signatures with regard to their creation time.
*/
public class SignatureCreationDateComparator implements Comparator<PGPSignature> {
public static final Order DEFAULT_ORDER = Order.OLD_TO_NEW;
public enum Order {
/**
* Oldest signatures first.
*/
OLD_TO_NEW,
/**
* Newest signatures first.
*/
NEW_TO_OLD
}
private final Order order;
/**
* Create a new comparator which sorts signatures old to new.
*/
public SignatureCreationDateComparator() {
this(DEFAULT_ORDER);
}
/**
* Create a new comparator which sorts signatures according to the passed ordering.
* @param order ordering
*/
public SignatureCreationDateComparator(Order order) {
this.order = order;
}
@Override
public int compare(PGPSignature one, PGPSignature two) {
return order == Order.OLD_TO_NEW
? one.getCreationTime().compareTo(two.getCreationTime())
: two.getCreationTime().compareTo(one.getCreationTime());
}
}

53
pgpainless-core/src/main/java/org/pgpainless/signature/consumer/SignatureValidityComparator.java
View file

@ -1,53 +0,0 @@
// SPDX-FileCopyrightText: 2021 Paul Schaub <vanitasvitae@fsfe.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.pgpainless.signature.consumer;
import java.util.Comparator;
import org.bouncycastle.openpgp.PGPSignature;
import org.pgpainless.signature.SignatureUtils;
/**
* Comparator which sorts signatures based on an ordering and on revocation hardness.
*
* If a list of signatures gets ordered using this comparator, hard revocations will always
* come first.
* Further, signatures are ordered by date according to the {@link SignatureCreationDateComparator.Order}.
*/
public class SignatureValidityComparator implements Comparator<PGPSignature> {
private final SignatureCreationDateComparator creationDateComparator;
/**
* Create a new {@link SignatureValidityComparator} which orders signatures the oldest first.
* Still, hard revocations will come first.
*/
public SignatureValidityComparator() {
this(SignatureCreationDateComparator.DEFAULT_ORDER);
}
/**
* Create a new {@link SignatureValidityComparator} which orders signatures following the passed ordering.
* Still, hard revocations will come first.
*
* @param order order of creation dates
*/
public SignatureValidityComparator(SignatureCreationDateComparator.Order order) {
this.creationDateComparator = new SignatureCreationDateComparator(order);
}
@Override
public int compare(PGPSignature one, PGPSignature two) {
boolean oneIsHard = SignatureUtils.isHardRevocation(one);
boolean twoIsHard = SignatureUtils.isHardRevocation(two);
// both have same "hardness", so compare creation time
if (oneIsHard == twoIsHard) {
return creationDateComparator.compare(one, two);
}
// favor the "harder" signature
return oneIsHard ? -1 : 1;
}
}

34
pgpainless-core/src/main/kotlin/org/pgpainless/signature/consumer/SignatureCreationDateComparator.kt Normal file
View file

@ -0,0 +1,34 @@
// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.pgpainless.signature.consumer
import org.bouncycastle.openpgp.PGPSignature
/**
* Create a new comparator which sorts signatures according to the passed ordering.
* @param order ordering
*/
class SignatureCreationDateComparator(
private val order: Order = Order.OLD_TO_NEW
) : Comparator<PGPSignature> {
enum class Order {
/**
* Oldest signatures first.
*/
OLD_TO_NEW,
/**
* Newest signatures first.
*/
NEW_TO_OLD
}
override fun compare(one: PGPSignature, two: PGPSignature): Int {
return when(order) {
Order.OLD_TO_NEW -> one.creationTime.compareTo(two.creationTime)
Order.NEW_TO_OLD -> two.creationTime.compareTo(one.creationTime)
}
}
}

31
pgpainless-core/src/main/kotlin/org/pgpainless/signature/consumer/SignatureValidityComparator.kt Normal file
View file

@ -0,0 +1,31 @@
// SPDX-FileCopyrightText: 2023 Paul Schaub <vanitasvitae@fsfe.org>
//
// SPDX-License-Identifier: Apache-2.0
package org.pgpainless.signature.consumer
import org.bouncycastle.extensions.isHardRevocation
import org.bouncycastle.openpgp.PGPSignature
/**
* Comparator which sorts signatures based on an ordering and on revocation hardness.
*
* If a list of signatures gets ordered using this comparator, hard revocations will always
* come first.
* Further, signatures are ordered by date according to the [SignatureCreationDateComparator.Order].
*/
class SignatureValidityComparator(
order: SignatureCreationDateComparator.Order = SignatureCreationDateComparator.Order.OLD_TO_NEW
) : Comparator<PGPSignature> {
private val creationDateComparator: SignatureCreationDateComparator = SignatureCreationDateComparator(order)
override fun compare(one: PGPSignature, two: PGPSignature): Int {
return if (one.isHardRevocation == two.isHardRevocation) {
// Both have the same hardness, so compare creation time
creationDateComparator.compare(one, two)
}
// else favor the "harder" signature
else if (one.isHardRevocation) -1 else 1
}
}