blob: 37b6606f4473d4341cdbb91b2efe2cc6925bcf70 (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
|
/*
* This file is part of GNU Taler
* (C) 2020 Taler Systems S.A.
*
* GNU Taler is free software; you can redistribute it and/or modify it under the
* terms of the GNU General Public License as published by the Free Software
* Foundation; either version 3, or (at your option) any later version.
*
* GNU Taler 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 for more details.
*
* You should have received a copy of the GNU General Public License along with
* GNU Taler; see the file COPYING. If not, see <http://www.gnu.org/licenses/>
*/
package net.taler.common
import kotlinx.serialization.SerialName
import kotlinx.serialization.Serializable
import kotlinx.serialization.builtins.serializer
import kotlinx.serialization.json.JsonElement
import kotlinx.serialization.json.JsonPrimitive
import kotlinx.serialization.json.JsonTransformingSerializer
import kotlinx.serialization.json.contentOrNull
import kotlinx.serialization.json.longOrNull
import net.taler.common.Duration.Companion.FOREVER
import kotlin.math.max
expect fun nowMillis(): Long
@Serializable
data class Timestamp(
@SerialName("t_ms")
@Serializable(NeverSerializer::class)
val ms: Long
) : Comparable<Timestamp> {
companion object {
const val NEVER: Long = -1
fun now(): Timestamp = Timestamp(nowMillis())
}
/**
* Returns a copy of this [Timestamp] rounded to seconds.
*/
fun truncateSeconds(): Timestamp {
if (ms == NEVER) return Timestamp(ms)
return Timestamp((ms / 1000L) * 1000L)
}
operator fun minus(other: Timestamp): Duration = when {
ms == NEVER -> Duration(FOREVER)
other.ms == NEVER -> throw Error("Invalid argument for timestamp comparision")
ms < other.ms -> Duration(0)
else -> Duration(ms - other.ms)
}
operator fun minus(other: Duration): Timestamp = when {
ms == NEVER -> this
other.ms == FOREVER -> Timestamp(0)
else -> Timestamp(max(0, ms - other.ms))
}
override fun compareTo(other: Timestamp): Int {
return if (ms == NEVER) {
if (other.ms == NEVER) 0
else 1
} else {
if (other.ms == NEVER) -1
else ms.compareTo(other.ms)
}
}
}
@Serializable
data class Duration(
/**
* Duration in milliseconds.
*/
@SerialName("d_ms")
@Serializable(ForeverSerializer::class)
val ms: Long
) {
companion object {
const val FOREVER: Long = -1
}
}
abstract class MinusOneSerializer(private val keyword: String) :
JsonTransformingSerializer<Long>(Long.serializer(), keyword) {
override fun readTransform(element: JsonElement): JsonElement {
return if (element.contentOrNull == keyword) return JsonPrimitive(-1)
else super.readTransform(element)
}
override fun writeTransform(element: JsonElement): JsonElement {
return if (element.longOrNull == -1L) return JsonPrimitive(keyword)
else element
}
}
object NeverSerializer : MinusOneSerializer("never")
object ForeverSerializer : MinusOneSerializer("forever")
|
