common_containers.hpp File Reference

Table of Contents

• Namespaces
• Functions
• Detailed Description

Dump support for C++ Standard Library and Boost containers, std::optional, utils::StrongTypedef, std::{unique,shared}_ptr More...

#include <cstddef>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <type_traits>
#include <typeinfo>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <variant>
#include <vector>
#include <userver/utils/lazy_prvalue.hpp>
#include <userver/utils/meta.hpp>
#include <userver/utils/strong_typedef.hpp>
#include <userver/dump/common.hpp>
#include <userver/dump/meta.hpp>
#include <userver/dump/meta_containers.hpp>
#include <userver/dump/operations.hpp>

Include dependency graph for common_containers.hpp:

Go to the source code of this file.

Namespaces
namespace	dump
	Dumping of cache-like components.

Functions
template<typename T >
std::enable_if_t< kIsContainer< T > &&kIsWritable< meta::RangeValueType< T > > >	dump::Write (Writer &writer, const T &value)
	Container serialization support.
template<typename T >
std::enable_if_t< kIsContainer< T > &&kIsReadable< meta::RangeValueType< T > >, T >	dump::Read (Reader &reader, To< T >)
	Container deserialization support.
template<typename T , typename U >
std::enable_if_t< kIsWritable< T > &&kIsWritable< U >, void >	dump::Write (Writer &writer, const std::pair< T, U > &value)
	Pair serialization support (for maps)
template<typename T , typename U >
std::enable_if_t< kIsReadable< T > &&kIsReadable< U >, std::pair< T, U > >	dump::Read (Reader &reader, To< std::pair< T, U > >)
	Pair deserialization support (for maps)
template<typename T >
std::enable_if_t< kIsWritable< T > >	dump::Write (Writer &writer, const std::optional< T > &value)
	std::optional serialization support
template<typename T >
std::enable_if_t< kIsReadable< T >, std::optional< T > >	dump::Read (Reader &reader, To< std::optional< T > >)
	std::optional deserialization support
template<typename... Args>
std::enable_if_t<(true &&... &&kIsWritable< Args >)>	dump::Write (Writer &writer, const std::variant< Args... > &value)
	std::variant serialization support
template<typename... Args>
std::enable_if_t<(true &&... &&(std::is_move_constructible_v< Args > &&kIsReadable< Args >)), std::variant< Args... > >	dump::Read (Reader &reader, To< std::variant< Args... > >)
	std::variant deserialization support
template<typename T >
std::enable_if_t< kIsReadable< T >, T >	dump::Read (Reader &reader, To< const T >)
template<typename Tag , typename T , utils::StrongTypedefOps Ops>
std::enable_if_t< kIsWritable< T > >	dump::Write (Writer &writer, const utils::StrongTypedef< Tag, T, Ops > &object)
	utils::StrongTypedef serialization support
template<typename Tag , typename T , utils::StrongTypedefOps Ops>
std::enable_if_t< kIsReadable< T >, utils::StrongTypedef< Tag, T, Ops > >	dump::Read (Reader &reader, To< utils::StrongTypedef< Tag, T, Ops > >)
	utils::StrongTypedef deserialization support
template<typename T >
std::enable_if_t< kIsWritable< T > >	dump::Write (Writer &writer, const std::unique_ptr< T > &ptr)
	std::unique_ptr serialization support
template<typename T >
std::enable_if_t< kIsReadable< T >, std::unique_ptr< T > >	dump::Read (Reader &reader, To< std::unique_ptr< T > >)
	std::unique_ptr deserialization support
template<typename T >
std::enable_if_t< kIsWritable< T > >	dump::Write (Writer &writer, const std::shared_ptr< T > &ptr)
	std::shared_ptr serialization support
template<typename T >
std::enable_if_t< kIsReadable< T >, std::shared_ptr< T > >	dump::Read (Reader &reader, To< std::shared_ptr< T > >)
	std::shared_ptr deserialization support
template<typename L , typename R , typename AP1 , typename AP2 , typename AP3 >
std::enable_if_t< kIsReadable< L > &&kIsReadable< R > >	dump::Write (Writer &writer, const boost::bimap< L, R, AP1, AP2, AP3 > &map)
	boost::bimap serialization support
template<typename L , typename R , typename AP1 , typename AP2 , typename AP3 >
std::enable_if_t< kIsWritable< L > &&kIsWritable< R >, boost::bimap< L, R, AP1, AP2, AP3 > >	dump::Read (Reader &reader, To< boost::bimap< L, R, AP1, AP2, AP3 > >)
	boost::bimap deserialization support
template<typename T , typename Index , typename Alloc >
std::enable_if_t< kIsWritable< T > >	dump::Write (Writer &writer, const boost::multi_index_container< T, Index, Alloc > &container)
	boost::multi_index_container serialization support
template<typename T , typename Index , typename Alloc >
std::enable_if_t< kIsReadable< T >, boost::multi_index_container< T, Index, Alloc > >	dump::Read (Reader &reader, To< boost::multi_index_container< T, Index, Alloc > >)
	boost::multi_index_container deserialization support

Detailed Description

Dump support for C++ Standard Library and Boost containers, std::optional, utils::StrongTypedef, std::{unique,shared}_ptr

Note

There are no traits in CachingComponentBase. If T is writable/readable, we have to generate the code for dumps regardless of dump: enabled. So it's important that all Read-Write operations for containers are SFINAE-correct.

Definition in file common_containers.hpp.