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
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
/*
This file is part of Telegram Desktop,
the official desktop application for the Telegram messaging service.
For license and copyright information please follow this link:
https://github.com/telegramdesktop/tdesktop/blob/master/LEGAL
*/
#pragma once
#include "base/basic_types.h"
#include "base/flags.h"
#include "base/algorithm.h"
#include "base/bytes.h"
#include <crl/crl_time.h>
#include <QtCore/QReadWriteLock>
#include <QtCore/QRegularExpression>
#include <QtCore/QMimeData>
#include <QtNetwork/QNetworkProxy>
#include <cmath>
#include <set>
#include <filesystem>
#if __has_include(<kurlmimedata.h>)
#include <kurlmimedata.h>
#endif
#if __has_include(<ksandbox.h>)
#include <ksandbox.h>
#endif
#define qsl(s) QStringLiteral(s)
namespace base {
template <typename Value, typename From, typename Till>
inline bool in_range(Value &&value, From &&from, Till &&till) {
return (value >= from) && (value < till);
}
#if __has_include(<ksandbox.h>)
inline QString IconName() {
static const auto Result = KSandbox::isFlatpak()
? qEnvironmentVariable("FLATPAK_ID")
: u"telegram"_q;
return Result;
}
#endif
inline bool CanReadDirectory(const QString &path) {
#ifndef Q_OS_MAC // directory_iterator since 10.15
try {
std::filesystem::directory_iterator(path.toStdString());
return true;
} catch (...) {
return false;
}
#else
Unexpected("Not implemented.");
#endif
}
} // namespace base
static const int32 ScrollMax = INT_MAX;
extern uint64 _SharedMemoryLocation[];
template <typename T, unsigned int N>
T *SharedMemoryLocation() {
static_assert(N < 4, "Only 4 shared memory locations!");
return reinterpret_cast<T*>(_SharedMemoryLocation + N);
}
inline void mylocaltime(struct tm * _Tm, const time_t * _Time) {
#ifdef Q_OS_WIN
localtime_s(_Tm, _Time);
#else
localtime_r(_Time, _Tm);
#endif
}
namespace ThirdParty {
void start();
void finish();
} // namespace ThirdParty
const static uint32 _md5_block_size = 64;
class HashMd5 {
public:
HashMd5(const void *input = 0, uint32 length = 0);
void feed(const void *input, uint32 length);
int32 *result();
private:
void init();
void finalize();
void transform(const uchar *block);
bool _finalized;
uchar _buffer[_md5_block_size];
uint32 _count[2];
uint32 _state[4];
uchar _digest[16];
};
int32 *hashSha1(const void *data, uint32 len, void *dest); // dest - ptr to 20 bytes, returns (int32*)dest
inline std::array<char, 20> hashSha1(const void *data, int size) {
auto result = std::array<char, 20>();
hashSha1(data, size, result.data());
return result;
}
int32 *hashSha256(const void *data, uint32 len, void *dest); // dest - ptr to 32 bytes, returns (int32*)dest
inline std::array<char, 32> hashSha256(const void *data, int size) {
auto result = std::array<char, 32>();
hashSha256(data, size, result.data());
return result;
}
int32 *hashMd5(const void *data, uint32 len, void *dest); // dest = ptr to 16 bytes, returns (int32*)dest
inline std::array<char, 16> hashMd5(const void *data, int size) {
auto result = std::array<char, 16>();
hashMd5(data, size, result.data());
return result;
}
char *hashMd5Hex(const int32 *hashmd5, void *dest); // dest = ptr to 32 bytes, returns (char*)dest
inline char *hashMd5Hex(const void *data, uint32 len, void *dest) { // dest = ptr to 32 bytes, returns (char*)dest
return hashMd5Hex(HashMd5(data, len).result(), dest);
}
inline std::array<char, 32> hashMd5Hex(const void *data, int size) {
auto result = std::array<char, 32>();
hashMd5Hex(data, size, result.data());
return result;
}
QString translitRusEng(const QString &rus);
QString rusKeyboardLayoutSwitch(const QString &from);
inline int rowscount(int fullCount, int countPerRow) {
return (fullCount + countPerRow - 1) / countPerRow;
}
inline int floorclamp(int value, int step, int lowest, int highest) {
return std::clamp(value / step, lowest, highest);
}
inline int floorclamp(float64 value, int step, int lowest, int highest) {
return std::clamp(
static_cast<int>(std::floor(value / step)),
lowest,
highest);
}
inline int ceilclamp(int value, int step, int lowest, int highest) {
return std::clamp((value + step - 1) / step, lowest, highest);
}
inline int ceilclamp(float64 value, int32 step, int32 lowest, int32 highest) {
return std::clamp(
static_cast<int>(std::ceil(value / step)),
lowest,
highest);
}
|
