MMapper/src/global/utils.cpp at 1a05a1de8f3f3caf4d89ae6130ead6fc7b08aa03 · nschimme/MMapper · GitHub

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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
// SPDX-License-Identifier: GPL-2.0-or-later
// Copyright (C) 2019 The MMapper Authors
// Author: Ulf Hermann <ulfonk_mennhar@gmx.de> (Alve)
// Author: Marek Krejza <krejza@gmail.com> (Caligor)
// Author: Nils Schimmelmann <nschimme@gmail.com> (Jahara)

#include "utils.h"

#include <cassert>
#include <cmath>
#include <limits>
#include <optional>

#include <QByteArray>
#include <qglobal.h>

namespace utils::details {

static_assert(!cpp17::IsValidCircularSize_v<0, bool>);
static_assert(!cpp17::IsValidCircularSize_v<1, bool>);
static_assert(cpp17::IsValidCircularSize_v<2, bool>);
static_assert(!cpp17::IsValidCircularSize_v<3, bool>);

static_assert(!cpp17::IsValidCircularSize_v<0, uint8_t>);
static_assert(!cpp17::IsValidCircularSize_v<1, uint8_t>);
static_assert(cpp17::IsValidCircularSize_v<2, uint8_t>);
static_assert(cpp17::IsValidCircularSize_v<3, uint8_t>);
static_assert(cpp17::IsValidCircularSize_v<255, uint8_t>);
static_assert(cpp17::IsValidCircularSize_v<256, uint8_t>);
static_assert(!cpp17::IsValidCircularSize_v<257, uint8_t>);

static_assert(cpp17::IsValidCircularSize_v<65536, uint16_t>);
static_assert(!cpp17::IsValidCircularSize_v<65537, uint16_t>);

static_assert(circular_increment<2, bool>(false) == true);
static_assert(circular_increment<2, bool>(true) == false);
static_assert(circular_decrement<2, bool>(false) == true);
static_assert(circular_decrement<2, bool>(true) == false);

static_assert(circular_increment<255, uint8_t>(254) == 0);
static_assert(circular_increment<256, uint8_t>(255) == 0);

static_assert(circular_increment<3, uint32_t>(0) == 1);
static_assert(circular_increment<3, uint32_t>(1) == 2);
static_assert(circular_increment<3, uint32_t>(2) == 0);
static_assert(circular_increment<3, uint32_t>(3) == 1); // doesn't throw; just wraps.

static_assert(circular_decrement<3, uint32_t>(0) == 2);
static_assert(circular_decrement<3, uint32_t>(1) == 0);
static_assert(circular_decrement<3, uint32_t>(2) == 1);
static_assert(circular_decrement<3, uint32_t>(3) == 2); // doesn't throw; just wraps.
static_assert(circular_decrement<3, uint32_t>(4) == 0); // doesn't throw; just wraps.

} // namespace utils::details

namespace utils::details::tests {

static_assert(!isBitMask<int32_t>());
static_assert(isBitMask<uint32_t>());

enum class NODISCARD NotBitmaskEnum { A = -1, B, C };
static_assert(!isBitMask<NotBitmaskEnum>());

enum class NODISCARD NotBitmask_intEnum : int { A = -1, B, C };
static_assert(!isBitMask<NotBitmask_intEnum>());

enum class NODISCARD NotBitmask_int8Enum : int8_t { A, B, C };
static_assert(!isBitMask<NotBitmask_int8Enum>());

enum class NODISCARD Bitmask_uint8Enum : uint8_t { A, B, C };
static_assert(isBitMask<Bitmask_uint8Enum>());

static_assert(!isBitMask<float>());
static_assert(!isBitMask<double>());

} // namespace utils::details::tests

namespace utils::tests {

static_assert(!isPowerOfTwo(0u) && !isAtLeastTwoBits(0u));
static_assert(isPowerOfTwo(1u) && !isAtLeastTwoBits(1u));
static_assert(isPowerOfTwo(2u) && !isAtLeastTwoBits(2u));
static_assert(!isPowerOfTwo(3u) && isAtLeastTwoBits(3u));
static_assert(isPowerOfTwo(4u) && !isAtLeastTwoBits(4u));
static_assert(!isPowerOfTwo(~0u) && isAtLeastTwoBits(~0u));
static constexpr const auto max = std::numeric_limits<uint32_t>::max();
static_assert(!isPowerOfTwo(max) && isAtLeastTwoBits(max));
static constexpr const auto topbit = max ^ (max >> 1);
static_assert(isPowerOfTwo(topbit) && !isAtLeastTwoBits(topbit));
} // namespace utils::tests

int utils::round_ftoi(const float f)
{
    using lim = std::numeric_limits<int>;
    assert(std::isfinite(f));
    const long l = std::lround(f);
    assert(isClamped<long>(l, lim::min(), lim::max()));
    return static_cast<int>(l);
}

std::optional<bool> utils::getEnvBool(const char *const key)
{
    if (!qEnvironmentVariableIsSet(key)) {
        return std::nullopt;
    }

    bool valid = false;
    const int value = qEnvironmentVariableIntValue(key, &valid);
    if (valid) {
        return value == 1;
    }

    QByteArray arr = qgetenv(key).toLower();
    if (arr == "true" || arr == "yes") {
        return true;
    } else if (arr == "false" || arr == "no") {
        return false;
    }

    return std::nullopt;
}

std::optional<int> utils::getEnvInt(const char *const key)
{
    if (!qEnvironmentVariableIsSet(key)) {
        return std::nullopt;
    }

    bool valid = false;
    const int value = qEnvironmentVariableIntValue(key, &valid);
    if (!valid) {
        return std::nullopt;
    }

    return value;
}

static_assert(!utils::equals(0.0, 1.0));
static_assert(utils::equals(1.0, 1.0));
static_assert(utils::equals(0.0, 0.0));
static_assert(utils::equals(0.0, -0.0));

QDateTime utils::getFileTime(const QFileInfo &fileInfo)
{
    const QDateTime birth = fileInfo.birthTime();
    if (birth.isValid() && birth.toMSecsSinceEpoch() > EPOCH_CUTOFF_MS) {
        return birth;
    }
    return fileInfo.lastModified();
}