Github   Telegram
Loading...
Searching...
No Matches
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
utils Namespace Reference

Utilities. More...

Namespaces

namespace  datetime
 Date and time utilities.
 
namespace  generators
 Generators.
 
namespace  log
 Algorithms to aid logging.
 
namespace  text
 Text utilities.
 

Classes

class  AnyMovable
 Replacement for std::any that is not copyable. It allows to store non-copyable and even non-movable types. More...
 
class  AtomicFlags
 Wrapper to extend enum with atomic flags interface. More...
 
class  BadAnyMovableCast
 The exception that is thrown when AnyCast fails. More...
 
struct  CachedHash
 Holds the key and its hash for faster comparisons and hashing. More...
 
class  CachedHashKeyEqual
 Compares utils::CachedHash only by keys. More...
 
class  CachedHashKeyEqual< Equal, std::false_type >
 
class  CheckedPtr
 Utility template for returning a pointer to an object that is owned by someone else; throws std::runtime_error if nullptr is stored. More...
 
class  CheckedPtr< T & >
 
class  CpuRelax
 
class  CurrentThreadNameGuard
 RAII helper to run some code with a temporary current thread name. More...
 
class  FastPimpl
 Implements pimpl idiom without dynamic memory allocation. More...
 
class  FastScopeGuard
 a helper class to perform actions on scope exit More...
 
class  FixedArray
 A fixed-size array with the size determined at runtime. More...
 
class  Flags
 Wrapper to extend enum with flags interface. More...
 
class  InvariantError
 Exception that is thrown on UINVARIANT violation. More...
 
class  LazyPrvalue
 Can be used with various emplace functions to allow in-place constructing a non-movable value using a callable. More...
 
class  LazySharedPtr
 A lazy wrapper around utils::SharedReadablePtr that fetches the data on first access. More...
 
class  NotNull
 Restricts a pointer or smart pointer to only hold non-null values. More...
 
class  OptionalRef
 Class that behaves as a nullable reference. Main difference from the pointer - value comparison of pointed values. More...
 
struct  Overloaded
 Utility to define std::variant visitors in a simple way. More...
 
class  PeriodicTask
 Task that periodically runs a user callback. More...
 
class  RandomBase
 Virtualized standard UniformRandomBitGenerator concept, for use with random number distributions. More...
 
class  regex
 Small alias for boost::regex / std::regex without huge includes. More...
 
class  ResultStore
 Simple value/exception store. More...
 
class  ResultStore< void >
 Simple void value/exception store. More...
 
class  ScopeGuard
 a helper class to perform actions on scope exit More...
 
class  ScopeTimePause
 Utility to easily pause ScopeTime, e.g. when yielding. More...
 
class  SharedReadablePtr
 std::shared_ptr<const T> wrapper that makes sure that the pointer is stored before dereferencing. Protects from dangling references: More...
 
class  StreamingCpuRelax
 
class  StrIcaseCompareThreeWay
 Case insensitive ASCII 3-way comparison functor. More...
 
class  StrIcaseEqual
 Case insensitive ASCII equality comparison functor. More...
 
class  StrIcaseHash
 Case insensitive ASCII hashing functor. More...
 
class  StrIcaseLess
 Case insensitive ASCII less comparison functor. More...
 
class  StrongTypedef
 Strong typedef for a type T. More...
 
class  SwappingSmart
 
class  TokenBucket
 
class  TracefulException
 Exception that remembers the backtrace at the point of its construction. More...
 
class  TracefulExceptionBase
 Base class implementing backtrace storage and message builder, published only for documentation purposes, please inherit from utils::TracefulException instead. More...
 

Typedefs

template<typename U >
using SharedRef = NotNull< std::shared_ptr< U > >
 A std::shared_ptr that is guaranteed to be not-null. More...
 
template<typename U >
using UniqueRef = NotNull< std::unique_ptr< U > >
 A std::unique_ptr that is guaranteed to be not-null. More...
 
template<class Tag , class T >
using NonLoggable = StrongTypedef< Tag, T, StrongTypedefOps::kCompareStrong|StrongTypedefOps::kNonLoggable >
 
template<typename... T>
using void_t = std::void_t< T... >
 std::void_t implementation with workarounds for compiler bugs More...
 

Enumerations

enum class  BytesPerSecond : long long
 Data type that represents bytes per second unit. More...
 
enum class  StrongTypedefOps {
  kNoCompare = 0 ,
  kCompareStrong = 1 ,
  kCompareTransparentOnly = 2 ,
  kCompareTransparent = 3 ,
  kNonLoggable = 4
}
 

Functions

template<typename... Strings>
std::string StrCat (const Strings &... strings)
 Concatenates multiple std::string_view-convertible items. More...
 
template<class Map , class Key >
auto * FindOrNullptr (Map &map, const Key &key)
 Returns nullptr if no key in associative container, otherwise returns pointer to value. More...
 
template<class Map , class Key , class Default >
Map::mapped_type FindOrDefault (Map &map, const Key &key, Default &&def)
 Returns default value if no key in associative container, otherwise returns a copy of the stored value. More...
 
template<class Map , class Key >
Map::mapped_type FindOrDefault (Map &map, const Key &key)
 Returns default value if no key in associative container, otherwise returns a copy of the stored value. More...
 
template<class Map , class Key >
std::optional< typename Map::mapped_type > FindOptional (Map &map, const Key &key)
 Returns std::nullopt if no key in associative container, otherwise returns std::optional with a copy of value. More...
 
template<typename Map , typename Key >
auto CheckedFind (Map &map, const Key &key) -> decltype(utils::MakeCheckedPtr(&map.find(key) ->second))
 Searches a map for an element and return a checked pointer to the found element. More...
 
template<class ToContainer , class FromContainer >
ToContainer AsContainer (FromContainer &&container)
 Converts one container type to another. More...
 
template<class Container , class Pred >
auto EraseIf (Container &container, Pred pred)
 Erased elements and returns number of deleted elements. More...
 
template<class Container , class T >
size_t Erase (Container &container, const T &elem)
 Erased elements and returns number of deleted elements. More...
 
template<typename Container , typename Pred >
bool ContainsIf (const Container &container, Pred pred)
 returns true if there is an element in container which satisfies the predicate More...
 
template<typename ValueType >
ValueType * AnyCast (AnyMovable *operand) noexcept
 
template<typename ValueType >
const ValueType * AnyCast (const AnyMovable *operand) noexcept
 
template<typename ValueType >
ValueType AnyCast (AnyMovable &operand)
 
template<typename ValueType >
ValueType AnyCast (const AnyMovable &operand)
 
template<typename ValueType >
ValueType AnyCast (AnyMovable &&operand)
 
template<typename T , typename Func >
AtomicUpdate (std::atomic< T > &atomic, Func updater)
 Atomically performs the operation of updater on atomic More...
 
template<typename T >
AtomicMin (std::atomic< T > &atomic, T value)
 Concurrently safe sets atomic to a value if value is less. More...
 
template<typename T >
AtomicMax (std::atomic< T > &atomic, T value)
 Concurrently safe sets atomic to a value if value is greater. More...
 
boost::uuids::uuid BoostUuidFromString (std::string const &str)
 Parse string into boost::uuids::uuid.
 
std::string ToString (const boost::uuids::uuid &)
 Serialize boost::uuids::uuid to string.
 
constexpr long long ToLongLong (BytesPerSecond x)
 
constexpr bool operator== (BytesPerSecond lhs, BytesPerSecond rhs)
 
constexpr bool operator!= (BytesPerSecond lhs, BytesPerSecond rhs)
 
BytesPerSecond StringToBytesPerSecond (const std::string &data)
 
template<class Value >
BytesPerSecond Parse (const Value &v, formats::parse::To< BytesPerSecond >)
 
template<class T >
constexpr bool operator== (const CachedHash< T > &x, const CachedHash< T > &y)
 Compares utils::CachedHash by hash first and then by keys. More...
 
template<class T >
constexpr bool operator!= (const CachedHash< T > &x, const CachedHash< T > &y)
 Compares utils::CachedHash by hash first and then by keys. More...
 
template<typename T >
constexpr CheckedPtr< T > MakeCheckedPtr (T *ptr) noexcept
 
template<typename Container >
constexpr auto enumerate (Container &&iterable)
 Implementation of python-style enumerate function for range-for loops. More...
 
template<typename T = std::runtime_error>
void LogErrorAndThrow (const std::string &error_message)
 Logs error_message and throws an exception ith that message. More...
 
template<class GeneratorFunc >
auto GenerateFixedArray (std::size_t size, GeneratorFunc &&generator)
 Applies generator to indices in the range [0, size), storing the results in a new utils::FixedArray. The generator is guaranteed to be invoked in the first-to-last order. More...
 
template<typename Enum >
constexpr Flags< Enum > operator| (Enum, Flags< Enum >)
 
template<typename Enum >
constexpr Flags< Enum > operator& (Enum, Flags< Enum >)
 
template<typename Enum >
constexpr bool operator== (Enum, Flags< Enum >)
 
template<typename Enum >
constexpr bool operator!= (Enum, Flags< Enum >)
 
template<typename Enum >
Flags< Enum > operator| (Enum, const AtomicFlags< Enum > &)
 
template<typename Enum >
Flags< Enum > operator& (Enum, const AtomicFlags< Enum > &)
 
template<typename Enum >
bool operator== (Enum, const AtomicFlags< Enum > &)
 
template<typename Enum >
bool operator!= (Enum, const AtomicFlags< Enum > &)
 
template<typename T >
FromString (const std::string &str)
 Extract the number contained in the string. No space characters or other extra characters allowed. Supported types: More...
 
template<typename Leaf >
constexpr auto * GetIf (Leaf &&leaf)
 
template<typename Root , typename Head , typename... Tail>
constexpr auto * GetIf (Root &&root, Head &&head, Tail &&... tail)
 Dereferences a chain of indirections and compositions, returns nullptr if one of the chain elements is not set. More...
 
template<class Target , class... Args>
boost::intrusive_ptr< Target > make_intrusive_ptr (Args &&... args)
 Factory function for boost::intrusive_ptr, like std::make_unique. More...
 
template<typename U , typename... Args>
SharedRef< U > MakeSharedRef (Args &&... args)
 An equivalent of std::make_shared for SharedRef. More...
 
template<typename U , typename... Args>
UniqueRef< U > MakeUniqueRef (Args &&... args)
 An equivalent of std::make_unique for UniqueRef. More...
 
template<class T , class U >
constexpr bool operator== (OptionalRef< T > lhs, OptionalRef< U > rhs) noexcept
 
template<class T , class U >
constexpr bool operator!= (OptionalRef< T > lhs, OptionalRef< U > rhs) noexcept
 
template<class T >
std::string ToString (const std::optional< T > &from)
 Converts std::optional to a string, empty value represented as "--". More...
 
template<class... Ts>
 Overloaded (Ts...) -> Overloaded< Ts... >
 
RandomBaseDefaultRandom ()
 Returns a thread-local UniformRandomBitGenerator. More...
 
template<typename T >
RandRange (T from_inclusive, T to_exclusive)
 Generates a random number in range [from, to) More...
 
template<typename T >
RandRange (T to_exclusive)
 Generates a random number in range [0, to) More...
 
uint32_t Rand ()
 Generate a random number in the whole uint32_t range. More...
 
bool regex_match (std::string_view str, const regex &pattern)
 Determines whether the regular expression matches the entire target character sequence.
 
bool regex_search (std::string_view str, const regex &pattern)
 Determines whether the regular expression matches anywhere in the target character sequence.
 
template<typename T >
bool operator== (const SharedReadablePtr< T > &ptr, std::nullptr_t)
 
template<typename T >
bool operator== (std::nullptr_t, const SharedReadablePtr< T > &ptr)
 
template<typename T >
bool operator!= (const SharedReadablePtr< T > &ptr, std::nullptr_t)
 
template<typename T >
bool operator!= (std::nullptr_t, const SharedReadablePtr< T > &ptr)
 
template<typename T , typename... Args>
SharedReadablePtr< T > MakeSharedReadable (Args &&... args)
 
std::chrono::milliseconds StringToDuration (const std::string &data)
 Converts strings like "10s", "5d", "1h" to durations. More...
 
constexpr bool operator& (StrongTypedefOps op, StrongTypedefOps mask) noexcept
 
constexpr auto operator| (StrongTypedefOps op1, StrongTypedefOps op2) noexcept
 
template<class Tag , class T , StrongTypedefOps Ops>
std::ostream & operator<< (std::ostream &os, const StrongTypedef< Tag, T, Ops > &v)
 Ostreams and Logging. More...
 
template<class Tag , class T , StrongTypedefOps Ops>
logging::LogHelperoperator<< (logging::LogHelper &os, const StrongTypedef< Tag, T, Ops > &v)
 
template<class Tag , class T , StrongTypedefOps Ops>
constexpr decltype(auto) UnderlyingValue (const StrongTypedef< Tag, T, Ops > &v) noexcept
 
template<class Tag , class T , StrongTypedefOps Ops>
constexpr T UnderlyingValue (StrongTypedef< Tag, T, Ops > &&v) noexcept
 
constexpr bool IsStrongTypedefLoggable (StrongTypedefOps Ops)
 
template<typename Tag , typename T , StrongTypedefOps Ops, typename Enable , typename ValueType >
std::enable_if_t< formats::common::kIsFormatValue< ValueType >, StrongTypedef< Tag, T, Ops, Enable > > Parse (const ValueType &source, formats::parse::To< StrongTypedef< Tag, T, Ops, Enable > >)
 
template<typename Tag , typename T , StrongTypedefOps Ops, typename Enable , typename TargetType >
TargetType Serialize (const StrongTypedef< Tag, T, Ops, Enable > &object, formats::serialize::To< TargetType >)
 
template<typename Tag , typename T , StrongTypedefOps Ops, typename Enable , typename StringBuilder >
void WriteToStream (const StrongTypedef< Tag, T, Ops, Enable > &object, StringBuilder &sw)
 
template<typename Tag , StrongTypedefOps Ops>
std::string ToString (const StrongTypedef< Tag, std::string, Ops > &object)
 
template<typename Tag , typename T , StrongTypedefOps Ops, typename = std::enable_if_t<meta::kIsInteger<T>>>
std::string ToString (const StrongTypedef< Tag, T, Ops > &object)
 
template<typename Target , typename Tag , typename T , StrongTypedefOps Ops, typename Enable >
constexpr Target StrongCast (const StrongTypedef< Tag, T, Ops, Enable > &src)
 
template<typename Target , typename Tag , typename T , StrongTypedefOps Ops, typename Enable >
constexpr Target StrongCast (StrongTypedef< Tag, T, Ops, Enable > &&src)
 
template<class Tag , class T , StrongTypedefOps Ops>
std::size_t hash_value (const StrongTypedef< Tag, T, Ops > &v)
 
std::string GetCurrentThreadName ()
 Get the name of the current thread. More...
 
void SetCurrentThreadName (std::string_view name)
 Set the name of the current thread. More...
 
template<class T >
constexpr auto UnderlyingValue (T v) noexcept
 Function that extracts integral value from enum or StrongTypedef. More...
 
template<typename Function , typename... Args>
auto CriticalAsync (engine::TaskProcessor &task_processor, std::string name, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto SharedCriticalAsync (engine::TaskProcessor &task_processor, std::string name, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto Async (engine::TaskProcessor &task_processor, std::string name, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto SharedAsync (engine::TaskProcessor &task_processor, std::string name, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto Async (engine::TaskProcessor &task_processor, std::string name, engine::Deadline deadline, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto SharedAsync (engine::TaskProcessor &task_processor, std::string name, engine::Deadline deadline, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto CriticalAsync (std::string name, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto SharedCriticalAsync (std::string name, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto Async (std::string name, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto SharedAsync (std::string name, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto Async (std::string name, engine::Deadline deadline, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto SharedAsync (std::string name, engine::Deadline deadline, Function &&f, Args &&... args)
 
template<typename Function , typename... Args>
auto AsyncBackground (std::string name, engine::TaskProcessor &task_processor, Function &&f, Args &&... args)
 
int DaemonMain (int argc, const char *const argv[], const components::ComponentList &components_list)
 
template<typename Cache >
LazySharedPtr< typename Cache::DataType > MakeLazyCachePtr (Cache &cache)
 Make a lazy pointer to the data of a cache. More...
 
const char * GetUserverVersion () noexcept
 
const char * GetUserverVcsRevision () noexcept
 
const char * GetUserverIdentifier () noexcept
 
template<class Tag , class T , StrongTypedefOps Ops>
void PrintTo (const StrongTypedef< Tag, T, Ops > &v, std::ostream *os)
 

Variables

constexpr bool kStrictMatch = true
 Helper constant to use with FastPimpl. More...
 

Detailed Description

Utilities.

Typedef Documentation

◆ NonLoggable

template<class Tag , class T >
using utils::NonLoggable = typedef StrongTypedef< Tag, T, StrongTypedefOps::kCompareStrong | StrongTypedefOps::kNonLoggable>

A StrongTypedef for data that MUST NOT be logged or outputted in some other way. Also prevents the data from appearing in backtrace prints of debugger.

class UserPasswords {
public:
UserPasswords(const formats::json::Value& doc)
: user_password_(doc["user-passwords"].As<Storage>()) {}
bool IsMatching(const std::string& user, const Password& password) const {
const auto* ptr = utils::FindOrNullptr(user_password_, user);
ptr->GetUnderlying(), password.GetUnderlying());
}
private:
using Storage = std::unordered_map<std::string, Password>;
Storage user_password_;
};

Definition at line 413 of file strong_typedef.hpp.

◆ void_t

template<typename... T>
using utils::void_t = typedef std::void_t<T...>

std::void_t implementation with workarounds for compiler bugs

Definition at line 15 of file void_t.hpp.

Enumeration Type Documentation

◆ StrongTypedefOps

enum class utils::StrongTypedefOps
strong
Enumerator
kCompareStrong 

Forbid all comparisons for StrongTypedef.

kCompareTransparentOnly 

Allow comparing two StrongTypedef<Tag, T>

kCompareTransparent 

Allow comparing StrongTypedef<Tag, T> and T.

kNonLoggable 

Allow both of the above.

Definition at line 29 of file strong_typedef.hpp.

Function Documentation

◆ AnyCast() [1/5]

template<typename ValueType >
ValueType utils::AnyCast ( AnyMovable &&  operand)
Note
Cast to a reference type to avoid extra moves
Exceptions
BadAnyMovableCastif type of the data stored in operand does not match ValueType

Definition at line 219 of file any_movable.hpp.

◆ AnyCast() [2/5]

template<typename ValueType >
ValueType utils::AnyCast ( AnyMovable operand)
Note
Cast to a reference type to avoid extra copies
Exceptions
BadAnyMovableCastif type of the data stored in operand does not match ValueType

Definition at line 201 of file any_movable.hpp.

◆ AnyCast() [3/5]

template<typename ValueType >
ValueType * utils::AnyCast ( AnyMovable operand)
noexcept
Returns
nullptr if operand is nullptr or type of the data stored in operand does not match ValueType

Definition at line 189 of file any_movable.hpp.

◆ AnyCast() [4/5]

template<typename ValueType >
ValueType utils::AnyCast ( const AnyMovable operand)
Note
Cast to a reference type to avoid extra copies
Exceptions
BadAnyMovableCastif type of the data stored in operand does not match ValueType

Definition at line 211 of file any_movable.hpp.

◆ AnyCast() [5/5]

template<typename ValueType >
const ValueType * utils::AnyCast ( const AnyMovable operand)
noexcept
Returns
nullptr if operand is nullptr or type of the data stored in operand does not match ValueType

Definition at line 194 of file any_movable.hpp.

◆ AsContainer()

template<class ToContainer , class FromContainer >
ToContainer utils::AsContainer ( FromContainer &&  container)

Converts one container type to another.

Definition at line 91 of file algo.hpp.

◆ CheckedFind()

template<typename Map , typename Key >
auto utils::CheckedFind ( Map &  map,
const Key &  key 
) -> decltype(utils::MakeCheckedPtr(&map.find(key)->second))

Searches a map for an element and return a checked pointer to the found element.

Definition at line 81 of file algo.hpp.

◆ ContainsIf()

template<typename Container , typename Pred >
bool utils::ContainsIf ( const Container &  container,
Pred  pred 
)

returns true if there is an element in container which satisfies the predicate

Definition at line 151 of file algo.hpp.

◆ DaemonMain()

int utils::DaemonMain ( int  argc,
const char *const  argv[],
const components::ComponentList components_list 
)

Parses command line arguments and calls components::Run with config file from –config parameter.

Other command line argumants:

  • –init-log FILENAME - path to the initial log file, stdout if not set
  • –help - show all command line argumants
  • –config CONFIG - path to config.yaml
  • –config_vars CONFIG_VARS - path to config_vars.yaml
  • –config_vars_override CONFIG_VARS - path to config_vars.override.yaml
Examples
samples/config_service/config_service.cpp, samples/flatbuf_service/flatbuf_service.cpp, samples/grpc_service/grpc_service.cpp, samples/hello_service/hello_service.cpp, samples/http_caching/http_caching.cpp, samples/mongo_service/mongo_service.cpp, samples/postgres_service/postgres_service.cpp, samples/production_service/production_service.cpp, samples/redis_service/redis_service.cpp, samples/tcp_full_duplex_service/tcp_full_duplex_service.cpp, and samples/tcp_service/tcp_service.cpp.

◆ DefaultRandom()

RandomBase & utils::DefaultRandom ( )

Returns a thread-local UniformRandomBitGenerator.

Note
The provided Random instance is not cryptographically secure
Warning
Don't pass the returned Random across thread boundaries
Examples
core/src/engine/mutex_benchmark.cpp.

◆ enumerate()

template<typename Container >
constexpr auto utils::enumerate ( Container &&  iterable)
constexpr

Implementation of python-style enumerate function for range-for loops.

Parameters
iterableContainer to iterate
Returns
ContainerWrapper, which iterator after dereference returns tuple of index and (!!!)non-const reference to element(it seems imposible to make this reference const). It can be used in "range based for loop" with "structured binding" like this
for (auto [pos, elem] : enumerate(someContainer)) {...}

Definition at line 64 of file enumerate.hpp.

◆ Erase()

template<class Container , class T >
size_t utils::Erase ( Container &  container,
const T &  elem 
)

Erased elements and returns number of deleted elements.

Definition at line 136 of file algo.hpp.

◆ EraseIf()

template<class Container , class Pred >
auto utils::EraseIf ( Container &  container,
Pred  pred 
)

Erased elements and returns number of deleted elements.

Definition at line 114 of file algo.hpp.

◆ FindOptional()

template<class Map , class Key >
std::optional< typename Map::mapped_type > utils::FindOptional ( Map &  map,
const Key &  key 
)

Returns std::nullopt if no key in associative container, otherwise returns std::optional with a copy of value.

Definition at line 69 of file algo.hpp.

◆ FindOrDefault() [1/2]

template<class Map , class Key >
Map::mapped_type utils::FindOrDefault ( Map &  map,
const Key &  key 
)

Returns default value if no key in associative container, otherwise returns a copy of the stored value.

Definition at line 58 of file algo.hpp.

◆ FindOrDefault() [2/2]

template<class Map , class Key , class Default >
Map::mapped_type utils::FindOrDefault ( Map &  map,
const Key &  key,
Default &&  def 
)

Returns default value if no key in associative container, otherwise returns a copy of the stored value.

Definition at line 46 of file algo.hpp.

◆ FindOrNullptr()

template<class Map , class Key >
auto * utils::FindOrNullptr ( Map &  map,
const Key &  key 
)

Returns nullptr if no key in associative container, otherwise returns pointer to value.

Definition at line 38 of file algo.hpp.

◆ FromString()

template<typename T >
T utils::FromString ( const std::string &  str)

Extract the number contained in the string. No space characters or other extra characters allowed. Supported types:

Parse YAML from string.

  • Integer types. Leading plus or minus is allowed. The number is always base-10.
  • Floating-point types. The accepted number format is identical to std::strtod.
Template Parameters
TThe type of the number to be parsed
Parameters
strThe string that contains the number
Returns
The extracted number
Exceptions
std::runtime_errorif the string does not contain an integer or floating-point number in the specified format, or the string contains extra junk, or the number does not fit into the provided type

Definition at line 45 of file from_string.hpp.

◆ GenerateFixedArray()

template<class GeneratorFunc >
auto utils::GenerateFixedArray ( std::size_t  size,
GeneratorFunc &&  generator 
)

Applies generator to indices in the range [0, size), storing the results in a new utils::FixedArray. The generator is guaranteed to be invoked in the first-to-last order.

Parameters
sizeHow many objects to generate
generatorA functor that takes an index and returns an object for the FixedArray
Returns
FixedArray with the return objects of generator

Definition at line 175 of file fixed_array.hpp.

◆ GetCurrentThreadName()

std::string utils::GetCurrentThreadName ( )

Get the name of the current thread.

Thread names should only be used for debugging purposes. Thread names aren't required to be preserved exactly due to the system limit on thread name length.

Returns
the current thread name
Exceptions
std::system_erroron error

◆ GetIf() [1/2]

template<typename Leaf >
constexpr auto * utils::GetIf ( Leaf &&  leaf)
constexpr

Definition at line 28 of file get_if.hpp.

◆ GetIf() [2/2]

template<typename Root , typename Head , typename... Tail>
constexpr auto * utils::GetIf ( Root &&  root,
Head &&  head,
Tail &&...  tail 
)
constexpr

Dereferences a chain of indirections and compositions, returns nullptr if one of the chain elements is not set.

struct C {};
struct B {
std::unique_ptr<C> c = std::make_unique<C>();
};
struct A {
std::shared_ptr<B> b = std::make_shared<B>();
};
auto a = std::make_optional<A>();
EXPECT_EQ(utils::GetIf(a, &A::b, &B::c), a->b->c.get());
EXPECT_EQ(utils::GetIf(a, &A::b), a->b.get());
EXPECT_EQ(utils::GetIf(a), &*a);
a->b->c.reset();
EXPECT_EQ(utils::GetIf(a, &A::b, &B::c), static_cast<C*>(nullptr));
EXPECT_EQ(utils::GetIf(a, &A::b), a->b.get());
EXPECT_EQ(utils::GetIf(a), &*a);
a->b.reset();
EXPECT_EQ(utils::GetIf(a, &A::b, &B::c), static_cast<C*>(nullptr));
EXPECT_EQ(utils::GetIf(a, &A::b), static_cast<B*>(nullptr));
EXPECT_EQ(utils::GetIf(a), &*a);
a.reset();
EXPECT_EQ(utils::GetIf(a, &A::b, &B::c), static_cast<C*>(nullptr));
EXPECT_EQ(utils::GetIf(a, &A::b), static_cast<B*>(nullptr));
EXPECT_EQ(utils::GetIf(a), static_cast<A*>(nullptr));

Definition at line 41 of file get_if.hpp.

◆ GetUserverIdentifier()

const char * utils::GetUserverIdentifier ( )
noexcept
Returns
zero-terminated string with description of the server as "userver/{GetUserverVersion()} ({__DATE__}; rv: {GetUserverHash()})"

◆ GetUserverVcsRevision()

const char * utils::GetUserverVcsRevision ( )
noexcept
Returns
zero-terminated string with GIT short hash of userver repo

◆ GetUserverVersion()

const char * utils::GetUserverVersion ( )
noexcept
Returns
zero-terminated string with version as "major.minor.patch"

◆ hash_value()

template<class Tag , class T , StrongTypedefOps Ops>
std::size_t utils::hash_value ( const StrongTypedef< Tag, T, Ops > &  v)

Definition at line 404 of file strong_typedef.hpp.

◆ IsStrongTypedefLoggable()

constexpr bool utils::IsStrongTypedefLoggable ( StrongTypedefOps  Ops)
constexpr

Definition at line 329 of file strong_typedef.hpp.

◆ LogErrorAndThrow()

template<typename T = std::runtime_error>
void utils::LogErrorAndThrow ( const std::string &  error_message)

Logs error_message and throws an exception ith that message.

Definition at line 17 of file exception.hpp.

◆ make_intrusive_ptr()

template<class Target , class... Args>
boost::intrusive_ptr< Target > utils::make_intrusive_ptr ( Args &&...  args)

Factory function for boost::intrusive_ptr, like std::make_unique.

Definition at line 16 of file make_intrusive_ptr.hpp.

◆ MakeCheckedPtr()

template<typename T >
constexpr CheckedPtr< T > utils::MakeCheckedPtr ( T *  ptr)
constexprnoexcept

Definition at line 73 of file checked_pointer.hpp.

◆ MakeLazyCachePtr()

template<typename Cache >
LazySharedPtr< typename Cache::DataType > utils::MakeLazyCachePtr ( Cache &  cache)

Make a lazy pointer to the data of a cache.

The cache type must have:

For example, components::CachingComponentBase satisfies these requirements.

Definition at line 152 of file lazy_shared_ptr.hpp.

◆ MakeSharedReadable()

template<typename T , typename... Args>
SharedReadablePtr< T > utils::MakeSharedReadable ( Args &&...  args)

Definition at line 137 of file shared_readable_ptr.hpp.

◆ MakeSharedRef()

template<typename U , typename... Args>
SharedRef< U > utils::MakeSharedRef ( Args &&...  args)

An equivalent of std::make_shared for SharedRef.

Definition at line 112 of file not_null.hpp.

◆ MakeUniqueRef()

template<typename U , typename... Args>
UniqueRef< U > utils::MakeUniqueRef ( Args &&...  args)

An equivalent of std::make_unique for UniqueRef.

Definition at line 118 of file not_null.hpp.

◆ operator!=() [1/7]

constexpr bool utils::operator!= ( BytesPerSecond  lhs,
BytesPerSecond  rhs 
)
constexpr

Definition at line 27 of file bytes_per_second.hpp.

◆ operator!=() [2/7]

template<class T >
constexpr bool utils::operator!= ( const CachedHash< T > &  x,
const CachedHash< T > &  y 
)
constexpr

Compares utils::CachedHash by hash first and then by keys.

Definition at line 28 of file cached_hash.hpp.

◆ operator!=() [3/7]

template<typename T >
bool utils::operator!= ( const SharedReadablePtr< T > &  ptr,
std::nullptr_t   
)

Definition at line 127 of file shared_readable_ptr.hpp.

◆ operator!=() [4/7]

template<typename Enum >
bool utils::operator!= ( Enum  lhs,
const AtomicFlags< Enum > &  rhs 
)

Definition at line 371 of file flags.hpp.

◆ operator!=() [5/7]

template<typename Enum >
constexpr bool utils::operator!= ( Enum  lhs,
Flags< Enum >  rhs 
)
constexpr

Definition at line 203 of file flags.hpp.

◆ operator!=() [6/7]

template<class T , class U >
constexpr bool utils::operator!= ( OptionalRef< T >  lhs,
OptionalRef< U >  rhs 
)
constexprnoexcept

Definition at line 106 of file optional_ref.hpp.

◆ operator!=() [7/7]

template<typename T >
bool utils::operator!= ( std::nullptr_t  ,
const SharedReadablePtr< T > &  ptr 
)

Definition at line 132 of file shared_readable_ptr.hpp.

◆ operator&() [1/3]

template<typename Enum >
Flags< Enum > utils::operator& ( Enum  lhs,
const AtomicFlags< Enum > &  rhs 
)

Definition at line 361 of file flags.hpp.

◆ operator&() [2/3]

template<typename Enum >
constexpr Flags< Enum > utils::operator& ( Enum  lhs,
Flags< Enum >  rhs 
)
constexpr

Definition at line 193 of file flags.hpp.

◆ operator&() [3/3]

constexpr bool utils::operator& ( StrongTypedefOps  op,
StrongTypedefOps  mask 
)
constexprnoexcept

Definition at line 39 of file strong_typedef.hpp.

◆ operator<<() [1/2]

template<class Tag , class T , StrongTypedefOps Ops>
logging::LogHelper & utils::operator<< ( logging::LogHelper os,
const StrongTypedef< Tag, T, Ops > &  v 
)

Definition at line 311 of file strong_typedef.hpp.

◆ operator<<() [2/2]

template<class Tag , class T , StrongTypedefOps Ops>
std::ostream & utils::operator<< ( std::ostream &  os,
const StrongTypedef< Tag, T, Ops > &  v 
)

Ostreams and Logging.

Definition at line 304 of file strong_typedef.hpp.

◆ operator==() [1/7]

constexpr bool utils::operator== ( BytesPerSecond  lhs,
BytesPerSecond  rhs 
)
constexpr

Definition at line 23 of file bytes_per_second.hpp.

◆ operator==() [2/7]

template<class T >
constexpr bool utils::operator== ( const CachedHash< T > &  x,
const CachedHash< T > &  y 
)
constexpr

Compares utils::CachedHash by hash first and then by keys.

Definition at line 22 of file cached_hash.hpp.

◆ operator==() [3/7]

template<typename T >
bool utils::operator== ( const SharedReadablePtr< T > &  ptr,
std::nullptr_t   
)

Definition at line 117 of file shared_readable_ptr.hpp.

◆ operator==() [4/7]

template<typename Enum >
bool utils::operator== ( Enum  lhs,
const AtomicFlags< Enum > &  rhs 
)

Definition at line 366 of file flags.hpp.

◆ operator==() [5/7]

template<typename Enum >
constexpr bool utils::operator== ( Enum  lhs,
Flags< Enum >  rhs 
)
constexpr

Definition at line 198 of file flags.hpp.

◆ operator==() [6/7]

template<class T , class U >
constexpr bool utils::operator== ( OptionalRef< T >  lhs,
OptionalRef< U >  rhs 
)
constexprnoexcept

Definition at line 100 of file optional_ref.hpp.

◆ operator==() [7/7]

template<typename T >
bool utils::operator== ( std::nullptr_t  ,
const SharedReadablePtr< T > &  ptr 
)

Definition at line 122 of file shared_readable_ptr.hpp.

◆ operator|() [1/3]

template<typename Enum >
Flags< Enum > utils::operator| ( Enum  lhs,
const AtomicFlags< Enum > &  rhs 
)

Definition at line 356 of file flags.hpp.

◆ operator|() [2/3]

template<typename Enum >
constexpr Flags< Enum > utils::operator| ( Enum  lhs,
Flags< Enum >  rhs 
)
constexpr

Definition at line 188 of file flags.hpp.

◆ operator|() [3/3]

constexpr auto utils::operator| ( StrongTypedefOps  op1,
StrongTypedefOps  op2 
)
constexprnoexcept

Definition at line 43 of file strong_typedef.hpp.

◆ Parse() [1/2]

template<class Value >
BytesPerSecond utils::Parse ( const Value &  v,
formats::parse::To< BytesPerSecond  
)

Definition at line 36 of file bytes_per_second.hpp.

◆ Parse() [2/2]

template<typename Tag , typename T , StrongTypedefOps Ops, typename Enable , typename ValueType >
std::enable_if_t< formats::common::kIsFormatValue< ValueType >, StrongTypedef< Tag, T, Ops, Enable > > utils::Parse ( const ValueType &  source,
formats::parse::To< StrongTypedef< Tag, T, Ops, Enable > >   
)

Definition at line 339 of file strong_typedef.hpp.

◆ PrintTo()

template<class Tag , class T , StrongTypedefOps Ops>
void utils::PrintTo ( const StrongTypedef< Tag, T, Ops > &  v,
std::ostream *  os 
)

Definition at line 50 of file utest.hpp.

◆ Rand()

uint32_t utils::Rand ( )

Generate a random number in the whole uint32_t range.

Note
The used random generator is not cryptographically secure
Warning
Don't use Rand() % N, use RandRange instead

◆ RandRange() [1/2]

template<typename T >
T utils::RandRange ( from_inclusive,
to_exclusive 
)

Generates a random number in range [from, to)

Note
The used random generator is not cryptographically secure
from_inclusive must be less than to_exclusive

Definition at line 38 of file rand.hpp.

◆ RandRange() [2/2]

template<typename T >
T utils::RandRange ( to_exclusive)

Generates a random number in range [0, to)

Note
The used random generator is not cryptographically secure

Definition at line 53 of file rand.hpp.

◆ Serialize()

template<typename Tag , typename T , StrongTypedefOps Ops, typename Enable , typename TargetType >
TargetType utils::Serialize ( const StrongTypedef< Tag, T, Ops, Enable > &  object,
formats::serialize::To< TargetType >   
)

Definition at line 347 of file strong_typedef.hpp.

◆ SetCurrentThreadName()

void utils::SetCurrentThreadName ( std::string_view  name)

Set the name of the current thread.

This function should only be used from drivers that create their own threads! Users should normally rely on the coroutine engine instead of creating additional threads.

There is a system limit on thread name length, e.g. 15 chars on Linux. The name is automatically cut to fit the limit.

Parameters
namethe new thread name
Exceptions
std::system_erroron error

◆ StrCat()

template<typename... Strings>
std::string utils::StrCat ( const Strings &...  strings)

Concatenates multiple std::string_view-convertible items.

Definition at line 23 of file algo.hpp.

◆ StringToBytesPerSecond()

BytesPerSecond utils::StringToBytesPerSecond ( const std::string &  data)

Understands all the date-rate unit suffixes from https://en.wikipedia.org/wiki/Data-rate_units#Conversion_table

◆ StringToDuration()

std::chrono::milliseconds utils::StringToDuration ( const std::string &  data)

Converts strings like "10s", "5d", "1h" to durations.

Understands the following suffixes: s - seconds ms - milliseconds m - minutes h - hours d - days

◆ StrongCast() [1/2]

template<typename Target , typename Tag , typename T , StrongTypedefOps Ops, typename Enable >
constexpr Target utils::StrongCast ( const StrongTypedef< Tag, T, Ops, Enable > &  src)
constexpr

Explicitly cast from one strong typedef to another, to replace constructions SomeStrongTydef{utils::UnderlyingValue(another_strong_val)} with utils::StrongCast<SomeStrongTydef>(another_strong_val)

Definition at line 383 of file strong_typedef.hpp.

◆ StrongCast() [2/2]

template<typename Target , typename Tag , typename T , StrongTypedefOps Ops, typename Enable >
constexpr Target utils::StrongCast ( StrongTypedef< Tag, T, Ops, Enable > &&  src)
constexpr

Definition at line 394 of file strong_typedef.hpp.

◆ ToLongLong()

constexpr long long utils::ToLongLong ( BytesPerSecond  x)
constexpr

Definition at line 19 of file bytes_per_second.hpp.

◆ ToString() [1/3]

template<class T >
std::string utils::ToString ( const std::optional< T > &  from)

Converts std::optional to a string, empty value represented as "--".

Definition at line 18 of file optionals.hpp.

◆ ToString() [2/3]

template<typename Tag , StrongTypedefOps Ops>
std::string utils::ToString ( const StrongTypedef< Tag, std::string, Ops > &  object)

Definition at line 362 of file strong_typedef.hpp.

◆ ToString() [3/3]

template<typename Tag , typename T , StrongTypedefOps Ops, typename = std::enable_if_t<meta::kIsInteger<T>>>
std::string utils::ToString ( const StrongTypedef< Tag, T, Ops > &  object)

Definition at line 370 of file strong_typedef.hpp.

◆ UnderlyingValue() [1/3]

template<class Tag , class T , StrongTypedefOps Ops>
constexpr decltype(auto) utils::UnderlyingValue ( const StrongTypedef< Tag, T, Ops > &  v)
constexprnoexcept

Definition at line 319 of file strong_typedef.hpp.

◆ UnderlyingValue() [2/3]

template<class Tag , class T , StrongTypedefOps Ops>
constexpr T utils::UnderlyingValue ( StrongTypedef< Tag, T, Ops > &&  v)
constexprnoexcept

Definition at line 325 of file strong_typedef.hpp.

◆ UnderlyingValue() [3/3]

template<class T >
constexpr auto utils::UnderlyingValue ( v)
constexprnoexcept

Function that extracts integral value from enum or StrongTypedef.

Definition at line 14 of file underlying_value.hpp.

◆ WriteToStream()

template<typename Tag , typename T , StrongTypedefOps Ops, typename Enable , typename StringBuilder >
void utils::WriteToStream ( const StrongTypedef< Tag, T, Ops, Enable > &  object,
StringBuilder &  sw 
)

Definition at line 355 of file strong_typedef.hpp.

Variable Documentation

◆ kStrictMatch

constexpr bool utils::kStrictMatch = true
inlineconstexpr

Helper constant to use with FastPimpl.

Definition at line 16 of file fast_pimpl.hpp.