RedAuburn/organicmaps
1
Fork 0
forked from organicmaps/organicmaps
Code Pull requests Activity

[base] Code cleanup

Browse source 
Signed-off-by: Andrew Shkrob <andrew.shkrob.social@yandex.by>
This commit is contained in:
Andrew Shkrob 2024-03-26 19:51:27 +01:00 • committed by Alexander Borsuk
parent 60c8b641f3
commit 2bbe4f9c93
52 changed files with 190 additions and 194 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
base/array_adapters.hpp
View file

@ -1,6 +1,6 @@
#pragma once #pragma once
#include "base/assert.hpp"
#include "base/assert.hpp"
namespace detail namespace detail
{ {

2
base/base.cpp
View file

@ -5,8 +5,6 @@
#include "base/logging.hpp" #include "base/logging.hpp"
#include "base/src_point.hpp" #include "base/src_point.hpp"
#include "std/target_os.hpp"
#include <iostream> #include <iostream>
namespace base namespace base

11
base/bits.hpp
View file

@ -1,4 +1,5 @@
#pragma once #pragma once
#include "base/assert.hpp" #include "base/assert.hpp"
#include <cstdint> #include <cstdint>
@ -111,14 +112,14 @@ namespace bits
} }
template <typename T> template <typename T>
inline std::make_unsigned_t<T> ZigZagEncode(T x) std::make_unsigned_t<T> ZigZagEncode(T x)
{ {
static_assert(std::is_signed<T>::value, "Type should be signed"); static_assert(std::is_signed<T>::value, "Type should be signed");
return (x << 1) ^ (x >> (sizeof(x) * 8 - 1)); return (x << 1) ^ (x >> (sizeof(x) * 8 - 1));
} }
template <typename T> template <typename T>
inline std::make_signed_t<T> ZigZagDecode(T x) std::make_signed_t<T> ZigZagDecode(T x)
{ {
static_assert(std::is_unsigned<T>::value, "Type should be unsigned."); static_assert(std::is_unsigned<T>::value, "Type should be unsigned.");
return (x >> 1) ^ -static_cast<std::make_signed_t<T>>(x & 1); return (x >> 1) ^ -static_cast<std::make_signed_t<T>>(x & 1);
@ -157,10 +158,10 @@ namespace bits
inline void BitwiseSplit(uint64_t v, uint32_t & x, uint32_t & y) inline void BitwiseSplit(uint64_t v, uint32_t & x, uint32_t & y)
{ {
uint32_t const hi = bits::PerfectUnshuffle(static_cast<uint32_t>(v >> 32)); uint32_t const hi = PerfectUnshuffle(static_cast<uint32_t>(v >> 32));
uint32_t const lo = bits::PerfectUnshuffle(static_cast<uint32_t>(v & 0xFFFFFFFFULL)); uint32_t const lo = PerfectUnshuffle(static_cast<uint32_t>(v & 0xFFFFFFFFULL));
x = ((hi & 0xFFFF) << 16) | (lo & 0xFFFF); x = ((hi & 0xFFFF) << 16) | (lo & 0xFFFF);
y = (hi & 0xFFFF0000) | (lo >> 16); y = (hi & 0xFFFF0000) | (lo >> 16);
} }
// Returns 1 if bit is set and 0 otherwise. // Returns 1 if bit is set and 0 otherwise.

33
base/buffer_vector.hpp
View file

@ -1,4 +1,5 @@
#pragma once #pragma once
#include "base/assert.hpp" #include "base/assert.hpp"
#include "base/checked_cast.hpp" #include "base/checked_cast.hpp"
@ -8,14 +9,16 @@
// Calls swap() function using argument dependant lookup. // Calls swap() function using argument dependant lookup.
// // Do NOT override this function, but override swap() function instead! // // Do NOT override this function, but override swap() function instead!
template <typename T> inline void Swap(T & a, T & b) template <typename T>
void Swap(T & a, T & b)
{ {
using std::swap; using std::swap;
swap(a, b); swap(a, b);
} }
template <class T, size_t N> class buffer_vector template <class T, size_t N>
class buffer_vector
{ {
private: private:
enum { USE_DYNAMIC = N + 1 }; enum { USE_DYNAMIC = N + 1 };
@ -24,10 +27,12 @@ private:
size_t m_size; size_t m_size;
std::vector<T> m_dynamic; std::vector<T> m_dynamic;
inline bool IsDynamic() const { return m_size == USE_DYNAMIC; } bool IsDynamic() const { return m_size == USE_DYNAMIC; }
void MoveStatic(buffer_vector<T, N> & rhs) void MoveStatic(buffer_vector & rhs) noexcept
{ {
static_assert(std::is_nothrow_move_assignable<T>::value);
std::move(rhs.m_static, rhs.m_static + rhs.m_size, m_static); std::move(rhs.m_static, rhs.m_static + rhs.m_size, m_static);
} }
@ -71,7 +76,7 @@ public:
buffer_vector(buffer_vector const &) = default; buffer_vector(buffer_vector const &) = default;
buffer_vector(buffer_vector && rhs) : m_size(rhs.m_size), m_dynamic(std::move(rhs.m_dynamic)) buffer_vector(buffer_vector && rhs) noexcept : m_size(rhs.m_size), m_dynamic(std::move(rhs.m_dynamic))
{ {
if (!IsDynamic()) if (!IsDynamic())
MoveStatic(rhs); MoveStatic(rhs);
@ -81,7 +86,7 @@ public:
buffer_vector & operator=(buffer_vector const & rhs) = default; buffer_vector & operator=(buffer_vector const & rhs) = default;
buffer_vector & operator=(buffer_vector && rhs) buffer_vector & operator=(buffer_vector && rhs) noexcept
{ {
if (this != &rhs) if (this != &rhs)
{ {
@ -252,16 +257,19 @@ public:
ASSERT(!empty(), ()); ASSERT(!empty(), ());
return *begin(); return *begin();
} }
T & front() T & front()
{ {
ASSERT(!empty(), ()); ASSERT(!empty(), ());
return *begin(); return *begin();
} }
T const & back() const T const & back() const
{ {
ASSERT(!empty(), ()); ASSERT(!empty(), ());
return *(end() - 1); return *(end() - 1);
} }
T & back() T & back()
{ {
ASSERT(!empty(), ()); ASSERT(!empty(), ());
@ -273,6 +281,7 @@ public:
ASSERT_LESS(i, size(), ()); ASSERT_LESS(i, size(), ());
return *(begin() + i); return *(begin() + i);
} }
T & operator[](size_t i) T & operator[](size_t i)
{ {
ASSERT_LESS(i, size(), ()); ASSERT_LESS(i, size(), ());
@ -374,7 +383,7 @@ public:
} }
} }
inline void insert(const_iterator where, value_type const & value) void insert(const_iterator where, value_type const & value)
{ {
insert(where, &value, &value + 1); insert(where, &value, &value + 1);
} }
@ -424,31 +433,31 @@ void swap(buffer_vector<T, N> & r1, buffer_vector<T, N> & r2)
} }
template <typename T, size_t N> template <typename T, size_t N>
inline std::string DebugPrint(buffer_vector<T, N> const & v) std::string DebugPrint(buffer_vector<T, N> const & v)
{ {
return DebugPrintSequence(v.data(), v.data() + v.size()); return DebugPrintSequence(v.data(), v.data() + v.size());
} }
template <typename T, size_t N1, size_t N2> template <typename T, size_t N1, size_t N2>
inline bool operator==(buffer_vector<T, N1> const & v1, buffer_vector<T, N2> const & v2) bool operator==(buffer_vector<T, N1> const & v1, buffer_vector<T, N2> const & v2)
{ {
return (v1.size() == v2.size() && std::equal(v1.begin(), v1.end(), v2.begin())); return (v1.size() == v2.size() && std::equal(v1.begin(), v1.end(), v2.begin()));
} }
template <typename T, size_t N1, size_t N2> template <typename T, size_t N1, size_t N2>
inline bool operator!=(buffer_vector<T, N1> const & v1, buffer_vector<T, N2> const & v2) bool operator!=(buffer_vector<T, N1> const & v1, buffer_vector<T, N2> const & v2)
{ {
return !(v1 == v2); return !(v1 == v2);
} }
template <typename T, size_t N1, size_t N2> template <typename T, size_t N1, size_t N2>
inline bool operator<(buffer_vector<T, N1> const & v1, buffer_vector<T, N2> const & v2) bool operator<(buffer_vector<T, N1> const & v1, buffer_vector<T, N2> const & v2)
{ {
return std::lexicographical_compare(v1.begin(), v1.end(), v2.begin(), v2.end()); return std::lexicographical_compare(v1.begin(), v1.end(), v2.begin(), v2.end());
} }
template <typename T, size_t N1, size_t N2> template <typename T, size_t N1, size_t N2>
inline bool operator>(buffer_vector<T, N1> const & v1, buffer_vector<T, N2> const & v2) bool operator>(buffer_vector<T, N1> const & v1, buffer_vector<T, N2> const & v2)
{ {
return v2 < v1; return v2 < v1;
} }

7
base/cache.hpp
View file

@ -79,12 +79,12 @@ namespace base
} }
private: private:
inline size_t Index(KeyT const & key) const size_t Index(KeyT const & key) const
{ {
return static_cast<size_t>(Hash(key) & m_hashMask); return static_cast<size_t>(Hash(key) & m_hashMask);
} }
inline static uint32_t Hash(uint32_t x) static uint32_t Hash(uint32_t x)
{ {
x = (x ^ 61) ^ (x >> 16); x = (x ^ 61) ^ (x >> 16);
x = x + (x << 3); x = x + (x << 3);
@ -93,7 +93,8 @@ namespace base
x = x ^ (x >> 15); x = x ^ (x >> 15);
return x; return x;
} }
inline static uint32_t Hash(uint64_t x)
static uint32_t Hash(uint64_t x)
{ {
return Hash(uint32_t(x) ^ uint32_t(x >> 32)); return Hash(uint32_t(x) ^ uint32_t(x >> 32));
} }

8
base/cancellable.cpp
View file

@ -6,7 +6,7 @@ namespace base
{ {
void Cancellable::Reset() void Cancellable::Reset()
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard lock(m_mutex);
m_status = Status::Active; m_status = Status::Active;
m_deadline = {}; m_deadline = {};
@ -14,14 +14,14 @@ void Cancellable::Reset()
void Cancellable::Cancel() void Cancellable::Cancel()
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard lock(m_mutex);
m_status = Status::CancelCalled; m_status = Status::CancelCalled;
} }
void Cancellable::SetDeadline(std::chrono::steady_clock::time_point const & deadline) void Cancellable::SetDeadline(std::chrono::steady_clock::time_point const & deadline)
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard lock(m_mutex);
m_deadline = deadline; m_deadline = deadline;
CheckDeadline(); CheckDeadline();
@ -34,7 +34,7 @@ bool Cancellable::IsCancelled() const
Cancellable::Status Cancellable::CancellationStatus() const Cancellable::Status Cancellable::CancellationStatus() const
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard lock(m_mutex);
CheckDeadline(); CheckDeadline();
return m_status; return m_status;

16
base/checked_cast.hpp
View file

@ -10,10 +10,10 @@ namespace base
template <typename ReturnType, typename ParameterType> template <typename ReturnType, typename ParameterType>
ReturnType checked_cast(ParameterType v) ReturnType checked_cast(ParameterType v)
{ {
static_assert(std::is_integral<ParameterType>::value, "ParameterType should be integral"); static_assert(std::is_integral_v<ParameterType>, "ParameterType should be integral");
static_assert(std::is_integral<ReturnType>::value, "ReturnType should be integral"); static_assert(std::is_integral_v<ReturnType>, "ReturnType should be integral");
ReturnType const result = static_cast<ReturnType>(v); auto const result = static_cast<ReturnType>(v);
CHECK_EQUAL(static_cast<ParameterType>(result), v, ()); CHECK_EQUAL(static_cast<ParameterType>(result), v, ());
CHECK((result > 0) == (v > 0), ("checked_cast failed, value =", v, ", result =", result)); CHECK((result > 0) == (v > 0), ("checked_cast failed, value =", v, ", result =", result));
return result; return result;
@ -22,10 +22,10 @@ ReturnType checked_cast(ParameterType v)
template <typename ReturnType, typename ParameterType> template <typename ReturnType, typename ParameterType>
ReturnType asserted_cast(ParameterType v) ReturnType asserted_cast(ParameterType v)
{ {
static_assert(std::is_integral<ParameterType>::value, "ParameterType should be integral"); static_assert(std::is_integral_v<ParameterType>, "ParameterType should be integral");
static_assert(std::is_integral<ReturnType>::value, "ReturnType should be integral"); static_assert(std::is_integral_v<ReturnType>, "ReturnType should be integral");
ReturnType const result = static_cast<ReturnType>(v); auto const result = static_cast<ReturnType>(v);
ASSERT_EQUAL(static_cast<ParameterType>(result), v, ()); ASSERT_EQUAL(static_cast<ParameterType>(result), v, ());
ASSERT((result > 0) == (v > 0), ("asserted_cast failed, value =", v, ", result =", result)); ASSERT((result > 0) == (v > 0), ("asserted_cast failed, value =", v, ", result =", result));
return result; return result;
@ -34,8 +34,8 @@ ReturnType asserted_cast(ParameterType v)
template <typename ResultType, typename ParameterType> template <typename ResultType, typename ParameterType>
bool IsCastValid(ParameterType v) bool IsCastValid(ParameterType v)
{ {
static_assert(std::is_integral<ParameterType>::value, "ParameterType should be integral"); static_assert(std::is_integral_v<ParameterType>, "ParameterType should be integral");
static_assert(std::is_integral<ResultType>::value, "ReturnType should be integral"); static_assert(std::is_integral_v<ResultType>, "ReturnType should be integral");
auto const result = static_cast<ResultType>(v); auto const result = static_cast<ResultType>(v);
return static_cast<ParameterType>(result) == v && ((result > 0) == (v > 0)); return static_cast<ParameterType>(result) == v && ((result > 0) == (v > 0));

6
base/control_flow.hpp
View file

@ -1,7 +1,6 @@
#pragma once #pragma once
#include <type_traits> #include <type_traits>
#include <utility>
namespace base namespace base
{ {
@ -25,15 +24,14 @@ public:
} }
template <typename... Args> template <typename... Args>
std::enable_if_t<std::is_same<std::invoke_result_t<Fn, Args...>, base::ControlFlow>::value, std::enable_if_t<std::is_same_v<std::invoke_result_t<Fn, Args...>, ControlFlow>, ControlFlow>
base::ControlFlow>
operator()(Args &&... args) operator()(Args &&... args)
{ {
return m_fn(std::forward<Args>(args)...); return m_fn(std::forward<Args>(args)...);
} }
template <typename... Args> template <typename... Args>
std::enable_if_t<std::is_same<std::invoke_result_t<Fn, Args...>, void>::value, base::ControlFlow> std::enable_if_t<std::is_same_v<std::invoke_result_t<Fn, Args...>, void>, ControlFlow>
operator()(Args &&... args) operator()(Args &&... args)
{ {
m_fn(std::forward<Args>(args)...); m_fn(std::forward<Args>(args)...);

6
base/deferred_task.cpp
View file

@ -6,7 +6,7 @@ DeferredTask::DeferredTask(Duration const & duration) : m_duration(duration)
{ {
m_thread = threads::SimpleThread([this] m_thread = threads::SimpleThread([this]
{ {
std::unique_lock<std::mutex> l(m_mutex); std::unique_lock l(m_mutex);
while (!m_terminate) while (!m_terminate)
{ {
if (!m_fn) if (!m_fn)
@ -31,7 +31,7 @@ DeferredTask::DeferredTask(Duration const & duration) : m_duration(duration)
DeferredTask::~DeferredTask() DeferredTask::~DeferredTask()
{ {
{ {
std::unique_lock<std::mutex> l(m_mutex); std::unique_lock l(m_mutex);
m_terminate = true; m_terminate = true;
} }
m_cv.notify_one(); m_cv.notify_one();
@ -41,7 +41,7 @@ DeferredTask::~DeferredTask()
void DeferredTask::Drop() void DeferredTask::Drop()
{ {
{ {
std::unique_lock<std::mutex> l(m_mutex); std::unique_lock l(m_mutex);
m_fn = nullptr; m_fn = nullptr;
} }
m_cv.notify_one(); m_cv.notify_one();

6
base/deferred_task.hpp
View file

@ -14,7 +14,7 @@ class DeferredTask
public: public:
using Duration = std::chrono::duration<double>; using Duration = std::chrono::duration<double>;
DeferredTask(Duration const & duration); explicit DeferredTask(Duration const & duration);
~DeferredTask(); ~DeferredTask();
void Drop(); void Drop();
@ -23,14 +23,14 @@ public:
void RestartWith(Fn const && fn) void RestartWith(Fn const && fn)
{ {
{ {
std::unique_lock<std::mutex> l(m_mutex); std::unique_lock l(m_mutex);
m_fn = fn; m_fn = fn;
} }
m_cv.notify_one(); m_cv.notify_one();
} }
private: private:
::threads::SimpleThread m_thread; threads::SimpleThread m_thread;
std::mutex m_mutex; std::mutex m_mutex;
std::condition_variable m_cv; std::condition_variable m_cv;
std::function<void()> m_fn; std::function<void()> m_fn;

2
base/dfa_helpers.hpp
View file

@ -14,7 +14,7 @@ public:
class Iterator class Iterator
{ {
public: public:
Iterator & Move(strings::UniChar c) Iterator & Move(UniChar c)
{ {
if (Rejects()) if (Rejects())
return *this; return *this;

3
base/file_name_utils.cpp
View file

@ -1,6 +1,5 @@
#include "base/file_name_utils.hpp" #include "base/file_name_utils.hpp"
namespace base namespace base
{ {
using namespace std; using namespace std;
@ -70,7 +69,7 @@ string AddSlashIfNeeded(string const & path)
{ {
auto const sep = GetNativeSeparator(); auto const sep = GetNativeSeparator();
string::size_type const pos = path.rfind(sep); string::size_type const pos = path.rfind(sep);
if ((pos != string::npos) && (pos + sizeof(sep) == path.size())) if (pos != string::npos && pos + sizeof(sep) == path.size())
return path; return path;
return path + sep; return path + sep;
} }

1
base/file_name_utils.hpp
View file

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <initializer_list>
#include <string> #include <string>
#include <utility> #include <utility>

22
base/geo_object_id.cpp
View file

@ -19,7 +19,7 @@ namespace base
{ {
GeoObjectId::GeoObjectId(uint64_t encodedId) : m_encodedId(encodedId) {} GeoObjectId::GeoObjectId(uint64_t encodedId) : m_encodedId(encodedId) {}
GeoObjectId::GeoObjectId(GeoObjectId::Type type, uint64_t id) GeoObjectId::GeoObjectId(Type type, uint64_t id)
: m_encodedId((static_cast<uint64_t>(type) << 56) | id) {} : m_encodedId((static_cast<uint64_t>(type) << 56) | id) {}
uint64_t GeoObjectId::GetSerialId() const uint64_t GeoObjectId::GetSerialId() const
@ -37,16 +37,16 @@ GeoObjectId::Type GeoObjectId::GetType() const
uint64_t const typeBits = (m_encodedId & kTypeMask) >> 56; uint64_t const typeBits = (m_encodedId & kTypeMask) >> 56;
switch (typeBits) switch (typeBits)
{ {
case 0x00: return GeoObjectId::Type::Invalid; case 0x00: return Type::Invalid;
case 0x01: return GeoObjectId::Type::OsmNode; case 0x01: return Type::OsmNode;
case 0x02: return GeoObjectId::Type::OsmWay; case 0x02: return Type::OsmWay;
case 0x03: return GeoObjectId::Type::OsmRelation; case 0x03: return Type::OsmRelation;
case 0x04: return GeoObjectId::Type::BookingComNode; case 0x04: return Type::BookingComNode;
case 0x05: return GeoObjectId::Type::OsmSurrogate; case 0x05: return Type::OsmSurrogate;
case 0x06: return GeoObjectId::Type::Fias; case 0x06: return Type::Fias;
case 0x40: return GeoObjectId::Type::ObsoleteOsmNode; case 0x40: return Type::ObsoleteOsmNode;
case 0x80: return GeoObjectId::Type::ObsoleteOsmWay; case 0x80: return Type::ObsoleteOsmWay;
case 0xC0: return GeoObjectId::Type::ObsoleteOsmRelation; case 0xC0: return Type::ObsoleteOsmRelation;
} }
UNREACHABLE(); UNREACHABLE();
} }

2
base/geo_object_id.hpp
View file

@ -61,7 +61,7 @@ public:
static constexpr uint64_t kInvalid = 0ULL; static constexpr uint64_t kInvalid = 0ULL;
explicit GeoObjectId(uint64_t encodedId = kInvalid); explicit GeoObjectId(uint64_t encodedId = kInvalid);
explicit GeoObjectId(GeoObjectId::Type type, uint64_t id); explicit GeoObjectId(Type type, uint64_t id);
// Returns the id that the object has within its source. // Returns the id that the object has within its source.
uint64_t GetSerialId() const; uint64_t GetSerialId() const;

2
base/gmtime.cpp
View file

@ -4,7 +4,7 @@
namespace base namespace base
{ {
std::tm GmTime(time_t const time) std::tm GmTime(time_t time)
{ {
std::tm result{}; std::tm result{};
#ifndef OMIM_OS_WINDOWS #ifndef OMIM_OS_WINDOWS

2
base/gmtime.hpp
View file

@ -5,5 +5,5 @@
namespace base namespace base
{ {
/// A cross-platform replacenemt of gmtime_r /// A cross-platform replacenemt of gmtime_r
std::tm GmTime(time_t const time); std::tm GmTime(time_t time);
} // namespace base } // namespace base

6
base/levenshtein_dfa.cpp
View file

@ -13,7 +13,7 @@ namespace strings
{ {
namespace namespace
{ {
inline size_t AbsDiff(size_t a, size_t b) { return a > b ? a - b : b - a; } size_t AbsDiff(size_t a, size_t b) { return a > b ? a - b : b - a; }
class TransitionTable class TransitionTable
{ {
@ -129,7 +129,7 @@ bool LevenshteinDFA::Position::SubsumedBy(Position const & rhs) const
if (m_errorsLeft >= rhs.m_errorsLeft) if (m_errorsLeft >= rhs.m_errorsLeft)
return false; return false;
auto const errorsAvail = static_cast<size_t>(rhs.m_errorsLeft - m_errorsLeft); auto const errorsAvail = rhs.m_errorsLeft - m_errorsLeft;
if (IsStandard() && rhs.IsStandard()) if (IsStandard() && rhs.IsStandard())
return AbsDiff(m_offset, rhs.m_offset) <= errorsAvail; return AbsDiff(m_offset, rhs.m_offset) <= errorsAvail;
@ -197,7 +197,7 @@ LevenshteinDFA::LevenshteinDFA(UniString const & s, size_t prefixSize,
m_alphabet.assign(s.begin(), s.end()); m_alphabet.assign(s.begin(), s.end());
CHECK_LESS_OR_EQUAL(prefixSize, s.size(), ()); CHECK_LESS_OR_EQUAL(prefixSize, s.size(), ());
auto const pSize = static_cast<typename std::iterator_traits< auto const pSize = static_cast<std::iterator_traits<
UniString::iterator>::difference_type>(prefixSize); UniString::iterator>::difference_type>(prefixSize);
for (auto it = s.begin(); std::distance(s.begin(), it) < pSize; ++it) for (auto it = s.begin(); std::distance(s.begin(), it) < pSize; ++it)
{ {

16
base/levenshtein_dfa.hpp
View file

@ -47,8 +47,8 @@ public:
bool operator<(Position const & rhs) const; bool operator<(Position const & rhs) const;
bool operator==(Position const & rhs) const; bool operator==(Position const & rhs) const;
inline bool IsStandard() const { return !m_transposed; } bool IsStandard() const { return !m_transposed; }
inline bool IsTransposed() const { return m_transposed; } bool IsTransposed() const { return m_transposed; }
size_t m_offset = 0; size_t m_offset = 0;
size_t m_errorsLeft = 0; size_t m_errorsLeft = 0;
@ -58,9 +58,9 @@ public:
struct State struct State
{ {
void Normalize(); void Normalize();
inline void Clear() { m_positions.clear(); } void Clear() { m_positions.clear(); }
inline bool operator<(State const & rhs) const { return m_positions < rhs.m_positions; } bool operator<(State const & rhs) const { return m_positions < rhs.m_positions; }
std::vector<Position> m_positions; std::vector<Position> m_positions;
}; };
@ -106,7 +106,7 @@ public:
bool IsEmpty() const { return m_alphabet.empty(); } bool IsEmpty() const { return m_alphabet.empty(); }
inline Iterator Begin() const { return Iterator(*this); } Iterator Begin() const { return Iterator(*this); }
size_t GetNumStates() const { return m_transitions.size(); } size_t GetNumStates() const { return m_transitions.size(); }
size_t GetAlphabetSize() const { return m_alphabet.size(); } size_t GetAlphabetSize() const { return m_alphabet.size(); }
@ -122,10 +122,10 @@ private:
bool IsAccepting(Position const & p) const; bool IsAccepting(Position const & p) const;
bool IsAccepting(State const & s) const; bool IsAccepting(State const & s) const;
inline bool IsAccepting(size_t s) const { return m_accepting[s]; } bool IsAccepting(size_t s) const { return m_accepting[s]; }
inline bool IsRejecting(State const & s) const { return s.m_positions.empty(); } bool IsRejecting(State const & s) const { return s.m_positions.empty(); }
inline bool IsRejecting(size_t s) const { return s == kRejectingState; } bool IsRejecting(size_t s) const { return s == kRejectingState; }
// Returns minimum number of made errors among accepting positions in |s|. // Returns minimum number of made errors among accepting positions in |s|.
size_t ErrorsMade(State const & s) const; size_t ErrorsMade(State const & s) const;

5
base/limited_priority_queue.hpp
View file

@ -1,6 +1,5 @@
#pragma once #pragma once
#include "base/base.hpp"
#include "base/assert.hpp" #include "base/assert.hpp"
#include <algorithm> #include <algorithm>
@ -67,7 +66,7 @@ public:
void clear() { m_queue.clear(); } void clear() { m_queue.clear(); }
void swap(limited_priority_queue<T, CompareT> & queue) void swap(limited_priority_queue & queue) noexcept
{ {
m_queue.swap(queue.m_queue); m_queue.swap(queue.m_queue);
using std::swap; using std::swap;
@ -86,7 +85,7 @@ private:
}; };
template <typename T, typename CompareT> template <typename T, typename CompareT>
void swap(limited_priority_queue<T, CompareT> & q1, limited_priority_queue<T, CompareT> & q2) void swap(limited_priority_queue<T, CompareT> & q1, limited_priority_queue<T, CompareT> & q2) noexcept
{ {
q1.swap(q2); q1.swap(q2);
} }

15
base/logging.hpp
View file

@ -1,6 +1,5 @@
#pragma once #pragma once
#include "base/base.hpp"
#include "base/internal/message.hpp" #include "base/internal/message.hpp"
#include "base/src_point.hpp" #include "base/src_point.hpp"
#include "base/thread.hpp" #include "base/thread.hpp"
@ -38,7 +37,7 @@ private:
int m_threadsCount; int m_threadsCount;
std::map<threads::ThreadID, int> m_threadID; std::map<threads::ThreadID, int> m_threadID;
base::Timer m_timer; Timer m_timer;
std::array<char const *, NUM_LOG_LEVELS> m_names; std::array<char const *, NUM_LOG_LEVELS> m_names;
std::array<size_t, NUM_LOG_LEVELS> m_lens; std::array<size_t, NUM_LOG_LEVELS> m_lens;
@ -95,12 +94,12 @@ struct ScopedLogAbortLevelChanger
}; };
} // namespace base } // namespace base
using ::base::LDEBUG; using base::LDEBUG;
using ::base::LINFO; using base::LINFO;
using ::base::LWARNING; using base::LWARNING;
using ::base::LERROR; using base::LERROR;
using ::base::LCRITICAL; using base::LCRITICAL;
using ::base::NUM_LOG_LEVELS; using base::NUM_LOG_LEVELS;
// Logging macro. // Logging macro.
// Example usage: LOG(LINFO, (Calc(), m_Var, "Some string constant")); // Example usage: LOG(LINFO, (Calc(), m_Var, "Some string constant"));

2
base/lower_case.cpp
View file

@ -46,7 +46,7 @@ UniChar LowerUniChar(UniChar c)
{ {
if (c >= 0xfb00 && c <= 0xfb06) if (c >= 0xfb00 && c <= 0xfb06)
return 0; return 0;
else if (c >= 0xfb13 && c <= 0xfb17) if (c >= 0xfb13 && c <= 0xfb17)
return 0; return 0;
return c; return c;
} }

3
base/macros.hpp
View file

@ -1,7 +1,6 @@
#pragma once #pragma once
#include "base/assert.hpp" #include "base/assert.hpp"
#include "base/base.hpp"
namespace base namespace base
{ {
@ -40,7 +39,7 @@ namespace base
namespace impl namespace impl
{ {
template <typename T> template <typename T>
inline void ForceUseValue(T const & t) void ForceUseValue(T const & t)
{ {
volatile T dummy = t; volatile T dummy = t;
UNUSED_VALUE(dummy); UNUSED_VALUE(dummy);

6
base/math.hpp
View file

@ -25,7 +25,7 @@ T Abs(T x)
template <typename Number, template <typename Number,
typename EnableIf = typename std::enable_if_t< typename EnableIf = typename std::enable_if_t<
std::is_integral<Number>::value || std::is_floating_point<Number>::value, void>> std::is_integral_v<Number> || std::is_floating_point_v<Number>, void>>
int constexpr Sign(Number const number) noexcept int constexpr Sign(Number const number) noexcept
{ {
return number == 0 ? 0 : number > 0 ? 1 : -1; return number == 0 ? 0 : number > 0 ? 1 : -1;
@ -150,7 +150,7 @@ inline uint32_t NextPowOf2(uint32_t v)
// Greatest Common Divisor. // Greatest Common Divisor.
template <typename Number, template <typename Number,
typename EnableIf = typename std::enable_if_t<std::is_integral<Number>::value, void>> typename EnableIf = typename std::enable_if_t<std::is_integral_v<Number>, void>>
Number constexpr GCD(Number const a, Number const b) Number constexpr GCD(Number const a, Number const b)
{ {
return b == 0 ? a : GCD(b, a % b); return b == 0 ? a : GCD(b, a % b);
@ -158,7 +158,7 @@ Number constexpr GCD(Number const a, Number const b)
// Least Common Multiple. // Least Common Multiple.
template <typename Number, template <typename Number,
typename EnableIf = typename std::enable_if_t<std::is_integral<Number>::value, void>> typename EnableIf = typename std::enable_if_t<std::is_integral_v<Number>, void>>
Number constexpr LCM(Number const a, Number const b) Number constexpr LCM(Number const a, Number const b)
{ {
return a / GCD(a, b) * b; return a / GCD(a, b) * b;

4
base/matrix.hpp
View file

@ -33,7 +33,7 @@ namespace math
} }
template <typename U> template <typename U>
Matrix<T, Rows, Cols> const & operator=(Matrix<U, Rows, Cols> const & src) Matrix & operator=(Matrix<U, Rows, Cols> const & src)
{ {
if ((void*)this != (void*)&src) if ((void*)this != (void*)&src)
{ {
@ -181,7 +181,7 @@ namespace math
} }
template <typename T, unsigned M, unsigned N, unsigned K> template <typename T, unsigned M, unsigned N, unsigned K>
Matrix<T, M, K> const operator*(Matrix<T, M, N> const & l, Matrix<T, N, K> const & r) Matrix<T, M, K> operator*(Matrix<T, M, N> const & l, Matrix<T, N, K> const & r)
{ {
Matrix<T, M, K> res; Matrix<T, M, K> res;
for (size_t m = 0; m < M; ++m) for (size_t m = 0; m < M; ++m)

5
base/mem_trie.hpp
View file

@ -5,7 +5,6 @@
#include <algorithm> #include <algorithm>
#include <map> #include <map>
#include <memory>
#include <string> #include <string>
#include <vector> #include <vector>
@ -204,7 +203,7 @@ public:
public: public:
using Char = MemTrie::Char; using Char = MemTrie::Char;
Iterator(MemTrie::Node const & node) : m_node(node) {} Iterator(Node const & node) : m_node(node) {}
// Iterates over all possible moves from this Iterator's node // Iterates over all possible moves from this Iterator's node
// and calls |toDo| with two arguments: // and calls |toDo| with two arguments:
@ -226,7 +225,7 @@ public:
ValuesHolder const & GetValues() const { return m_node.m_values; } ValuesHolder const & GetValues() const { return m_node.m_values; }
private: private:
MemTrie::Node const & m_node; Node const & m_node;
}; };
// Adds a key-value pair to the trie. // Adds a key-value pair to the trie.

1
base/newtype.hpp
View file

@ -1,7 +1,6 @@
#pragma once #pragma once
#include <functional> #include <functional>
#include <iostream>
#include <string> #include <string>
#include <type_traits> #include <type_traits>

1
base/non_intersecting_intervals.hpp
View file

@ -3,7 +3,6 @@
#include "base/assert.hpp" #include "base/assert.hpp"
#include <algorithm> #include <algorithm>
#include <iterator>
#include <set> #include <set>
namespace base namespace base

10
base/normalize_unicode.cpp
View file

File diff suppressed because one or more lines are too long

1
base/random.cpp
View file

@ -1,6 +1,5 @@
#include "base/random.hpp" #include "base/random.hpp"
#include <algorithm>
#include <numeric> #include <numeric>
namespace base namespace base

8
base/ref_counted.hpp
View file

@ -12,9 +12,9 @@ class RefCounted
public: public:
virtual ~RefCounted() = default; virtual ~RefCounted() = default;
inline void IncRef() noexcept { ++m_refs; } void IncRef() noexcept { ++m_refs; }
inline uint64_t DecRef() noexcept { return --m_refs; } uint64_t DecRef() noexcept { return --m_refs; }
inline uint64_t NumRefs() const noexcept { return m_refs; } uint64_t NumRefs() const noexcept { return m_refs; }
protected: protected:
RefCounted() noexcept = default; RefCounted() noexcept = default;
@ -99,7 +99,7 @@ public:
T * operator->() noexcept { return m_p; } T * operator->() noexcept { return m_p; }
T const * operator->() const noexcept { return m_p; } T const * operator->() const noexcept { return m_p; }
inline operator bool() const noexcept { return m_p != nullptr; } operator bool() const noexcept { return m_p != nullptr; }
private: private:
T * m_p = nullptr; T * m_p = nullptr;

8
base/rolling_hash.hpp
View file

@ -1,7 +1,6 @@
#pragma once #pragma once
#include "base/assert.hpp" #include "base/assert.hpp"
#include "base/base.hpp"
#include "base/math.hpp" #include "base/math.hpp"
#ifdef DEBUG #ifdef DEBUG
@ -19,7 +18,8 @@ public:
{ {
} }
template <typename Iter> hash_type Init(Iter it, uint64_t windowSize) template <typename Iter>
hash_type Init(Iter it, uint64_t windowSize)
{ {
ASSERT_GREATER(m_windowSize, 0, ()); ASSERT_GREATER(m_windowSize, 0, ());
m_windowSize = windowSize; m_windowSize = windowSize;
@ -67,14 +67,14 @@ class RabinKarpRollingHasher32 : public RabinKarpRollingHasher<uint32_t, uint32_
{ {
public: public:
RabinKarpRollingHasher32() RabinKarpRollingHasher32()
: RabinKarpRollingHasher<uint32_t, uint32_t>(1103515245U) {} : RabinKarpRollingHasher(1103515245U) {}
}; };
class RabinKarpRollingHasher64 : public RabinKarpRollingHasher<uint64_t, uint64_t> class RabinKarpRollingHasher64 : public RabinKarpRollingHasher<uint64_t, uint64_t>
{ {
public: public:
RabinKarpRollingHasher64() RabinKarpRollingHasher64()
: RabinKarpRollingHasher<uint64_t, uint64_t>(6364136223846793005ULL) {} : RabinKarpRollingHasher(6364136223846793005ULL) {}
}; };
using RollingHasher32 = RabinKarpRollingHasher32; using RollingHasher32 = RabinKarpRollingHasher32;

2
base/scope_guard.hpp
View file

@ -4,8 +4,6 @@
#pragma once #pragma once
#include "base/base.hpp"
namespace base namespace base
{ {
namespace impl namespace impl

2
base/set_operations.hpp
View file

@ -1,7 +1,5 @@
#pragma once #pragma once
#include <algorithm>
// Similar to set_difference(), but if element is present n times in the first sequence and once in // Similar to set_difference(), but if element is present n times in the first sequence and once in
// the second sequence, all n copies are filtered, insted of one. // the second sequence, all n copies are filtered, insted of one.
template<typename Iter1T, typename Iter2T, typename OutIterT, typename LessT> template<typename Iter1T, typename Iter2T, typename OutIterT, typename LessT>

9
base/shared_buffer_manager.cpp
View file

@ -1,6 +1,5 @@
#include "base/shared_buffer_manager.hpp" #include "base/shared_buffer_manager.hpp"
SharedBufferManager & SharedBufferManager::instance() SharedBufferManager & SharedBufferManager::instance()
{ {
static SharedBufferManager i; static SharedBufferManager i;
@ -9,13 +8,13 @@ SharedBufferManager & SharedBufferManager::instance()
void SharedBufferManager::clearReserved() void SharedBufferManager::clearReserved()
{ {
std::lock_guard<std::mutex> g(m_mutex); std::lock_guard g(m_mutex);
m_sharedBuffers.clear(); m_sharedBuffers.clear();
} }
SharedBufferManager::shared_buffer_ptr_t SharedBufferManager::reserveSharedBuffer(size_t s) SharedBufferManager::shared_buffer_ptr_t SharedBufferManager::reserveSharedBuffer(size_t s)
{ {
std::lock_guard<std::mutex> g(m_mutex); std::lock_guard g(m_mutex);
shared_buffer_ptr_list_t & l = m_sharedBuffers[s]; shared_buffer_ptr_list_t & l = m_sharedBuffers[s];
@ -30,14 +29,14 @@ SharedBufferManager::shared_buffer_ptr_t SharedBufferManager::reserveSharedBuffe
void SharedBufferManager::freeSharedBuffer(size_t s, shared_buffer_ptr_t buf) void SharedBufferManager::freeSharedBuffer(size_t s, shared_buffer_ptr_t buf)
{ {
std::lock_guard<std::mutex> g(m_mutex); std::lock_guard g(m_mutex);
shared_buffer_ptr_list_t & l = m_sharedBuffers[s]; shared_buffer_ptr_list_t & l = m_sharedBuffers[s];
l.push_back(buf); l.push_back(buf);
} }
uint8_t * SharedBufferManager::GetRawPointer(SharedBufferManager::shared_buffer_ptr_t ptr) uint8_t * SharedBufferManager::GetRawPointer(shared_buffer_ptr_t ptr)
{ {
return &((*ptr)[0]); return &((*ptr)[0]);
} }

1
base/small_set.hpp
View file

@ -2,7 +2,6 @@
#include "base/assert.hpp" #include "base/assert.hpp"
#include "base/bits.hpp" #include "base/bits.hpp"
#include "base/macros.hpp"
#include <cstdint> #include <cstdint>
#include <iterator> #include <iterator>

4
base/stats.hpp
View file

@ -57,7 +57,7 @@ private:
template <class T> class StatsCollector template <class T> class StatsCollector
{ {
std::vector<std::pair<std::string, base::AverageStats<T>>> m_vec; std::vector<std::pair<std::string, AverageStats<T>>> m_vec;
public: public:
explicit StatsCollector(std::initializer_list<std::string> init) explicit StatsCollector(std::initializer_list<std::string> init)
@ -71,7 +71,7 @@ public:
LOG_SHORT(LINFO, (e.first, ":", e.second.ToString())); LOG_SHORT(LINFO, (e.first, ":", e.second.ToString()));
} }
base::AverageStats<T> & Get(size_t i) { return m_vec[i].second; } AverageStats<T> & Get(size_t i) { return m_vec[i].second; }
}; };
template <class Key> class TopStatsCounter template <class Key> class TopStatsCounter

58
base/std_serialization.hpp
View file

@ -1,12 +1,8 @@
#pragma once #pragma once
#include "base/base.hpp"
#include <array> #include <array>
#include <map> #include <map>
#include <set>
#include <unordered_map> #include <unordered_map>
#include <utility>
#include <vector> #include <vector>
@ -27,7 +23,8 @@ TArchive & operator >> (TArchive & ar, std::pair<T1, T2> & t)
return ar; return ar;
} }
template <class TArchive, class TCont> void save_like_map(TArchive & ar, TCont const & rMap) template <class TArchive, class TCont>
void save_like_map(TArchive & ar, TCont const & rMap)
{ {
uint32_t const count = static_cast<uint32_t>(rMap.size()); uint32_t const count = static_cast<uint32_t>(rMap.size());
ar << count; ar << count;
@ -36,7 +33,8 @@ template <class TArchive, class TCont> void save_like_map(TArchive & ar, TCont c
ar << i->first << i->second; ar << i->first << i->second;
} }
template <class TArchive, class TCont> void load_like_map(TArchive & ar, TCont & rMap) template <class TArchive, class TCont>
void load_like_map(TArchive & ar, TCont & rMap)
{ {
rMap.clear(); rMap.clear();
@ -55,7 +53,8 @@ template <class TArchive, class TCont> void load_like_map(TArchive & ar, TCont &
} }
} }
template <class TArchive, class TCont> void save_like_vector(TArchive & ar, TCont const & rCont) template <class TArchive, class TCont>
void save_like_vector(TArchive & ar, TCont const & rCont)
{ {
uint32_t const count = static_cast<uint32_t>(rCont.size()); uint32_t const count = static_cast<uint32_t>(rCont.size());
ar << count; ar << count;
@ -64,7 +63,8 @@ template <class TArchive, class TCont> void save_like_vector(TArchive & ar, TCon
ar << rCont[i]; ar << rCont[i];
} }
template <class TArchive, class TCont> void load_like_vector(TArchive & ar, TCont & rCont) template <class TArchive, class TCont>
void load_like_vector(TArchive & ar, TCont & rCont)
{ {
rCont.clear(); rCont.clear();
@ -76,7 +76,8 @@ template <class TArchive, class TCont> void load_like_vector(TArchive & ar, TCon
ar >> rCont[i]; ar >> rCont[i];
} }
template <class TArchive, class TCont> void save_like_set(TArchive & ar, TCont const & rSet) template <class TArchive, class TCont>
void save_like_set(TArchive & ar, TCont const & rSet)
{ {
uint32_t const count = static_cast<uint32_t>(rSet.size()); uint32_t const count = static_cast<uint32_t>(rSet.size());
ar << count; ar << count;
@ -85,7 +86,8 @@ template <class TArchive, class TCont> void save_like_set(TArchive & ar, TCont c
ar << *it; ar << *it;
} }
template <class TArchive, class TCont> void load_like_set(TArchive & ar, TCont & rSet) template <class TArchive, class TCont>
void load_like_set(TArchive & ar, TCont & rSet)
{ {
rSet.clear(); rSet.clear();
@ -100,74 +102,86 @@ template <class TArchive, class TCont> void load_like_set(TArchive & ar, TCont &
} }
} }
template <class TArchive, class T1, class T2> TArchive & operator << (TArchive & ar, std::map<T1, T2> const & rMap) template <class TArchive, class T1, class T2>
TArchive & operator << (TArchive & ar, std::map<T1, T2> const & rMap)
{ {
save_like_map(ar, rMap); save_like_map(ar, rMap);
return ar; return ar;
} }
template <class TArchive, class T1, class T2> TArchive & operator >> (TArchive & ar, std::map<T1, T2> & rMap) template <class TArchive, class T1, class T2>
TArchive & operator >> (TArchive & ar, std::map<T1, T2> & rMap)
{ {
load_like_map(ar, rMap); load_like_map(ar, rMap);
return ar; return ar;
} }
template <class TArchive, class T1, class T2> TArchive & operator << (TArchive & ar, std::multimap<T1, T2> const & rMap) template <class TArchive, class T1, class T2>
TArchive & operator << (TArchive & ar, std::multimap<T1, T2> const & rMap)
{ {
save_like_map(ar, rMap); save_like_map(ar, rMap);
return ar; return ar;
} }
template <class TArchive, class T1, class T2> TArchive & operator >> (TArchive & ar, std::multimap<T1, T2> & rMap) template <class TArchive, class T1, class T2>
TArchive & operator >> (TArchive & ar, std::multimap<T1, T2> & rMap)
{ {
load_like_map(ar, rMap); load_like_map(ar, rMap);
return ar; return ar;
} }
template <class TArchive, class T1, class T2> TArchive & operator << (TArchive & ar, std::unordered_map<T1, T2> const & rMap) template <class TArchive, class T1, class T2>
TArchive & operator << (TArchive & ar, std::unordered_map<T1, T2> const & rMap)
{ {
save_like_map(ar, rMap); save_like_map(ar, rMap);
return ar; return ar;
} }
template <class TArchive, class T1, class T2> TArchive & operator >> (TArchive & ar, std::unordered_map<T1, T2> & rMap) template <class TArchive, class T1, class T2>
TArchive & operator >> (TArchive & ar, std::unordered_map<T1, T2> & rMap)
{ {
load_like_map(ar, rMap); load_like_map(ar, rMap);
return ar; return ar;
} }
template <class TArchive, class T> TArchive & operator << (TArchive & ar, std::vector<T> const & rVector) template <class TArchive, class T>
TArchive & operator << (TArchive & ar, std::vector<T> const & rVector)
{ {
save_like_vector(ar, rVector); save_like_vector(ar, rVector);
return ar; return ar;
} }
template <class TArchive, class T> TArchive & operator >> (TArchive & ar, std::vector<T> & rVector) template <class TArchive, class T>
TArchive & operator >> (TArchive & ar, std::vector<T> & rVector)
{ {
load_like_vector(ar, rVector); load_like_vector(ar, rVector);
return ar; return ar;
} }
template <class TArchive, class T> TArchive & operator << (TArchive & ar, std::set<T> const & rSet) template <class TArchive, class T>
TArchive & operator << (TArchive & ar, std::set<T> const & rSet)
{ {
save_like_set(ar, rSet); save_like_set(ar, rSet);
return ar; return ar;
} }
template <class TArchive, class T> TArchive & operator >> (TArchive & ar, std::set<T> & rSet) template <class TArchive, class T>
TArchive & operator >> (TArchive & ar, std::set<T> & rSet)
{ {
load_like_set(ar, rSet); load_like_set(ar, rSet);
return ar; return ar;
} }
template <class TArchive, class T, size_t N> TArchive & operator << (TArchive & ar, std::array<T, N> const & rArray) template <class TArchive, class T, size_t N>
TArchive & operator << (TArchive & ar, std::array<T, N> const & rArray)
{ {
for (size_t i = 0; i < N; ++i) for (size_t i = 0; i < N; ++i)
ar << rArray[i]; ar << rArray[i];
return ar; return ar;
} }
template <class TArchive, class T, size_t N> TArchive & operator >> (TArchive & ar, std::array<T, N> & rArray) template <class TArchive, class T, size_t N>
TArchive & operator >> (TArchive & ar, std::array<T, N> & rArray)
{ {
for (size_t i = 0; i < N; ++i) for (size_t i = 0; i < N; ++i)
ar >> rArray[i]; ar >> rArray[i];

2
base/stl_helpers.hpp
View file

@ -1,14 +1,12 @@
#pragma once #pragma once
#include <algorithm> #include <algorithm>
#include <cstdint>
#include <functional> #include <functional>
#include <initializer_list> #include <initializer_list>
#include <iterator> #include <iterator>
#include <memory> #include <memory>
#include <tuple> #include <tuple>
#include <type_traits> #include <type_traits>
#include <utility>
#include <vector> #include <vector>
namespace base namespace base

4
base/string_utils.cpp
View file

@ -87,7 +87,7 @@ UniChar LastUniChar(std::string const & s)
{ {
if (s.empty()) if (s.empty())
return 0; return 0;
utf8::unchecked::iterator<std::string::const_iterator> iter(s.end()); utf8::unchecked::iterator iter(s.end());
--iter; --iter;
return *iter; return *iter;
} }
@ -439,7 +439,7 @@ void ParseCSVRow(std::string const & s, char const delimiter, std::vector<std::s
for (; it; ++it) for (; it; ++it)
{ {
std::string column(*it); std::string column(*it);
strings::Trim(column); Trim(column);
target.push_back(std::move(column)); target.push_back(std::move(column));
} }

1
base/strings_bundle.cpp
View file

@ -1,6 +1,5 @@
#include "base/strings_bundle.hpp" #include "base/strings_bundle.hpp"
void StringsBundle::SetDefaultString(std::string const & name, std::string const & value) void StringsBundle::SetDefaultString(std::string const & name, std::string const & value)
{ {
m_defValues[name] = value; m_defValues[name] = value;

8
base/sunrise_sunset.cpp
View file

@ -17,7 +17,7 @@ double constexpr kZenith = 90 + 50. / 60.; // 90 degrees 50'
time_t constexpr kOneDaySeconds = 24 * 60 * 60; time_t constexpr kOneDaySeconds = 24 * 60 * 60;
inline double NormalizeAngle(double a) double NormalizeAngle(double a)
{ {
double res = fmod(a, 360.); double res = fmod(a, 360.);
if (res < 0) if (res < 0)
@ -213,7 +213,7 @@ DayTimeType GetDayTime(time_t timeUtc, double latitude, double longitude)
// Edge cases: polar day and polar night // Edge cases: polar day and polar night
if (sunrise.first == DayEventType::PolarDay || sunset.first == DayEventType::PolarDay) if (sunrise.first == DayEventType::PolarDay || sunset.first == DayEventType::PolarDay)
return DayTimeType::PolarDay; return DayTimeType::PolarDay;
else if (sunrise.first == DayEventType::PolarNight || sunset.first == DayEventType::PolarNight) if (sunrise.first == DayEventType::PolarNight || sunset.first == DayEventType::PolarNight)
return DayTimeType::PolarNight; return DayTimeType::PolarNight;
if (timeUtc < sunrise.second) if (timeUtc < sunrise.second)
@ -227,7 +227,7 @@ DayTimeType GetDayTime(time_t timeUtc, double latitude, double longitude)
return DayTimeType::Night; return DayTimeType::Night;
return DayTimeType::Day; return DayTimeType::Day;
} }
else if (timeUtc > sunset.second) if (timeUtc > sunset.second)
{ {
auto const nextSunrise = CalculateDayEventTime(timeUtc + kOneDaySeconds, latitude, longitude, true /* sunrise */); auto const nextSunrise = CalculateDayEventTime(timeUtc + kOneDaySeconds, latitude, longitude, true /* sunrise */);
auto const nextSunset = CalculateDayEventTime(timeUtc + kOneDaySeconds, latitude, longitude, false /* sunrise */); auto const nextSunset = CalculateDayEventTime(timeUtc + kOneDaySeconds, latitude, longitude, false /* sunrise */);
@ -251,5 +251,5 @@ std::string DebugPrint(DayTimeType type)
case DayTimeType::PolarDay: return "PolarDay"; case DayTimeType::PolarDay: return "PolarDay";
case DayTimeType::PolarNight: return "PolarNight"; case DayTimeType::PolarNight: return "PolarNight";
} }
return std::string(); return {};
} }

5
base/thread_pool.cpp
View file

@ -5,7 +5,6 @@
#include <functional> #include <functional>
#include <memory> #include <memory>
#include <utility>
#include <vector> #include <vector>
namespace base::thread_pool namespace base::thread_pool
@ -29,7 +28,7 @@ public:
{ {
while (!IsCancelled()) while (!IsCancelled())
{ {
threads::IRoutine * task = m_popFn(); IRoutine * task = m_popFn();
if (task == NULL) if (task == NULL)
{ {
Cancel(); Cancel();
@ -57,7 +56,7 @@ public:
for (auto & thread : m_threads) for (auto & thread : m_threads)
{ {
thread = std::make_unique<threads::Thread>(); thread = std::make_unique<threads::Thread>();
thread->Create(std::make_unique<PoolRoutine>(std::bind(&ThreadPool::Impl::PopFront, this), m_finishFn)); thread->Create(std::make_unique<PoolRoutine>(std::bind(&Impl::PopFront, this), m_finishFn));
} }
} }

12
base/thread_pool_computational.hpp
View file

@ -53,7 +53,7 @@ public:
~ThreadPool() ~ThreadPool()
{ {
{ {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock lock(m_mutex);
m_done = true; m_done = true;
} }
m_condition.notify_all(); m_condition.notify_all();
@ -72,7 +72,7 @@ public:
std::forward<Args>(args)...)); std::forward<Args>(args)...));
std::future<ResultType> result(task.get_future()); std::future<ResultType> result(task.get_future());
{ {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock lock(m_mutex);
if (m_done) if (m_done)
return {}; return {};
@ -91,7 +91,7 @@ public:
{ {
auto f = std::bind(std::forward<F>(func), std::forward<Args>(args)...); auto f = std::bind(std::forward<F>(func), std::forward<Args>(args)...);
{ {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock lock(m_mutex);
if (m_done) if (m_done)
return; return;
@ -107,7 +107,7 @@ public:
void Stop() void Stop()
{ {
{ {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock lock(m_mutex);
auto empty = std::queue<FunctionType>(); auto empty = std::queue<FunctionType>();
m_queue.swap(empty); m_queue.swap(empty);
m_done = true; m_done = true;
@ -118,7 +118,7 @@ public:
void WaitingStop() void WaitingStop()
{ {
{ {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock lock(m_mutex);
m_done = true; m_done = true;
} }
m_condition.notify_all(); m_condition.notify_all();
@ -132,7 +132,7 @@ private:
{ {
FunctionType task; FunctionType task;
{ {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock lock(m_mutex);
m_condition.wait(lock, [&] { m_condition.wait(lock, [&] {
return m_done || !m_queue.empty(); return m_done || !m_queue.empty();
}); });

4
base/thread_pool_delayed.hpp
View file

@ -11,9 +11,7 @@
#include <cstdint> #include <cstdint>
#include <map> #include <map>
#include <memory> #include <memory>
#include <mutex>
#include <unordered_map> #include <unordered_map>
#include <utility>
#include <vector> #include <vector>
namespace base namespace base
@ -124,7 +122,7 @@ private:
bool operator()(T const & lhs, T const & rhs) const { return *lhs < *rhs; } bool operator()(T const & lhs, T const & rhs) const { return *lhs < *rhs; }
}; };
using ImmediateQueue = base::LinkedMap<TaskId, Task>; using ImmediateQueue = LinkedMap<TaskId, Task>;
using DelayedValue = std::shared_ptr<DelayedTask>; using DelayedValue = std::shared_ptr<DelayedTask>;
class DelayedQueue : public BidirectionalMap<TaskId, DelayedValue, class DelayedQueue : public BidirectionalMap<TaskId, DelayedValue,

13
base/thread_safe_queue.hpp
View file

@ -3,7 +3,6 @@
#include <condition_variable> #include <condition_variable>
#include <mutex> #include <mutex>
#include <queue> #include <queue>
#include <utility>
namespace threads namespace threads
{ {
@ -21,7 +20,7 @@ public:
void Push(T const & value) void Push(T const & value)
{ {
{ {
std::lock_guard<std::mutex> lk(m_mutex); std::lock_guard lk(m_mutex);
m_queue.push(value); m_queue.push(value);
} }
m_cond.notify_one(); m_cond.notify_one();
@ -30,7 +29,7 @@ public:
void Push(T && value) void Push(T && value)
{ {
{ {
std::lock_guard<std::mutex> lk(m_mutex); std::lock_guard lk(m_mutex);
m_queue.push(std::move(value)); m_queue.push(std::move(value));
} }
m_cond.notify_one(); m_cond.notify_one();
@ -38,7 +37,7 @@ public:
void WaitAndPop(T & value) void WaitAndPop(T & value)
{ {
std::unique_lock<std::mutex> lk(m_mutex); std::unique_lock lk(m_mutex);
m_cond.wait(lk, [this]{ return !m_queue.empty(); }); m_cond.wait(lk, [this]{ return !m_queue.empty(); });
value = std::move(m_queue.front()); value = std::move(m_queue.front());
m_queue.pop(); m_queue.pop();
@ -46,7 +45,7 @@ public:
bool TryPop(T & value) bool TryPop(T & value)
{ {
std::lock_guard<std::mutex> lk(m_mutex); std::lock_guard lk(m_mutex);
if (m_queue.empty()) if (m_queue.empty())
return false; return false;
@ -58,13 +57,13 @@ public:
bool Empty() const bool Empty() const
{ {
std::lock_guard<std::mutex> lk(m_mutex); std::lock_guard lk(m_mutex);
return m_queue.empty(); return m_queue.empty();
} }
size_t Size() const size_t Size() const
{ {
std::lock_guard<std::mutex> lk(m_mutex); std::lock_guard lk(m_mutex);
return m_queue.size(); return m_queue.size();
} }

2
base/threaded_container.cpp
View file

@ -3,6 +3,6 @@
void ThreadedContainer::Cancel() void ThreadedContainer::Cancel()
{ {
std::unique_lock lock(m_condLock); std::unique_lock lock(m_condLock);
base::Cancellable::Cancel(); Cancellable::Cancel();
m_Cond.notify_all(); m_Cond.notify_all();
} }

14
base/threaded_list.hpp
View file

@ -35,7 +35,7 @@ public:
template <typename Fn> template <typename Fn>
void ProcessList(Fn const & fn) void ProcessList(Fn const & fn)
{ {
std::unique_lock<std::mutex> lock(m_condLock); std::unique_lock lock(m_condLock);
bool hadElements = !m_list.empty(); bool hadElements = !m_list.empty();
@ -51,7 +51,7 @@ public:
void PushBack(T const & t) void PushBack(T const & t)
{ {
std::unique_lock<std::mutex> lock(m_condLock); std::unique_lock lock(m_condLock);
bool doSignal = m_list.empty(); bool doSignal = m_list.empty();
@ -64,7 +64,7 @@ public:
void PushFront(T const & t) void PushFront(T const & t)
{ {
std::unique_lock<std::mutex> lock(m_condLock); std::unique_lock lock(m_condLock);
bool doSignal = m_list.empty(); bool doSignal = m_list.empty();
@ -77,7 +77,7 @@ public:
T const Front(bool doPop) T const Front(bool doPop)
{ {
std::unique_lock<std::mutex> lock(m_condLock); std::unique_lock lock(m_condLock);
if (WaitNonEmpty(lock)) if (WaitNonEmpty(lock))
return T(); return T();
@ -94,7 +94,7 @@ public:
T const Back(bool doPop) T const Back(bool doPop)
{ {
std::unique_lock<std::mutex> lock(m_condLock); std::unique_lock lock(m_condLock);
if (WaitNonEmpty(lock)) if (WaitNonEmpty(lock))
return T(); return T();
@ -111,7 +111,7 @@ public:
size_t Size() const size_t Size() const
{ {
std::unique_lock<std::mutex> lock(m_condLock); std::unique_lock lock(m_condLock);
return m_list.size(); return m_list.size();
} }
@ -122,7 +122,7 @@ public:
void Clear() void Clear()
{ {
std::unique_lock<std::mutex> lock(m_condLock); std::unique_lock lock(m_condLock);
m_list.clear(); m_list.clear();
m_isEmpty = true; m_isEmpty = true;
} }

2
base/timegm.cpp
View file

@ -3,8 +3,6 @@
#include "base/assert.hpp" #include "base/assert.hpp"
#include "base/timer.hpp" #include "base/timer.hpp"
#include <chrono>
// There are issues with this implementation due to absence // There are issues with this implementation due to absence
// of time_t fromat specification. There are no guarantees // of time_t fromat specification. There are no guarantees
// of its internal structure so we cannot rely on + or -. // of its internal structure so we cannot rely on + or -.

1
base/timegm.hpp
View file

@ -1,6 +1,5 @@
#pragma once #pragma once
#include <cstdint>
#include <ctime> #include <ctime>
namespace base namespace base

12
base/timer.hpp
View file

@ -22,19 +22,19 @@ public:
using DurationT = typename ClockT::duration; using DurationT = typename ClockT::duration;
/// @return Elapsed time from start (@see Reset). /// @return Elapsed time from start (@see Reset).
inline DurationT TimeElapsed() const { return ClockT::now() - m_startTime; } DurationT TimeElapsed() const { return ClockT::now() - m_startTime; }
template <typename Duration> template <typename Duration>
inline Duration TimeElapsedAs() const Duration TimeElapsedAs() const
{ {
return std::chrono::duration_cast<Duration>(TimeElapsed()); return std::chrono::duration_cast<Duration>(TimeElapsed());
} }
inline double ElapsedSeconds() const { return TimeElapsedAs<std::chrono::duration<double>>().count(); } double ElapsedSeconds() const { return TimeElapsedAs<std::chrono::duration<double>>().count(); }
inline uint64_t ElapsedMilliseconds() const { return TimeElapsedAs<std::chrono::milliseconds>().count(); } uint64_t ElapsedMilliseconds() const { return TimeElapsedAs<std::chrono::milliseconds>().count(); }
inline uint64_t ElapsedNanoseconds() const { return TimeElapsedAs<std::chrono::nanoseconds>().count(); } uint64_t ElapsedNanoseconds() const { return TimeElapsedAs<std::chrono::nanoseconds>().count(); }
inline void Reset() { m_startTime = ClockT::now(); } void Reset() { m_startTime = ClockT::now(); }
}; };
} // namespace impl } // namespace impl

6
base/waiter.hpp
View file

@ -19,7 +19,7 @@ public:
void Wait() void Wait()
{ {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock lock(m_mutex);
if (m_notified) if (m_notified)
return; return;
@ -30,7 +30,7 @@ public:
template <typename Rep, typename Period> template <typename Rep, typename Period>
Result Wait(std::chrono::duration<Rep, Period> const & waitDuration) Result Wait(std::chrono::duration<Rep, Period> const & waitDuration)
{ {
std::unique_lock<std::mutex> lock(m_mutex); std::unique_lock lock(m_mutex);
if (m_notified) if (m_notified)
return Result::PreviouslyNotified; return Result::PreviouslyNotified;
@ -55,7 +55,7 @@ public:
private: private:
void SetNotified(bool notified) void SetNotified(bool notified)
{ {
std::lock_guard<std::mutex> lock(m_mutex); std::lock_guard lock(m_mutex);
m_notified = notified; m_notified = notified;
} }