FixedString.h File Reference

#include <cassert>
#include <cstddef>
#include <initializer_list>
#include <iosfwd>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>
#include <folly/ConstexprMath.h>
#include <folly/Portability.h>
#include <folly/Range.h>
#include <folly/Utility.h>
#include <folly/lang/Exception.h>
#include <folly/lang/Ordering.h>
#include <folly/portability/Constexpr.h>

Go to the source code of this file.

Classes
class	folly::BasicFixedString< Char, N >
	A class for holding up to N characters of type Char that is amenable to constexpr string manipulation. It is guaranteed to not perform any dynamic allocation. More...
struct	folly::detail::fixedstring::FixedStringBase_< class >
struct	folly::detail::fixedstring::Helper
struct	folly::detail::fixedstring::ReverseIterator< T >
struct	folly::detail::fixedstring::ReverseIterator< T >::dummy_
class	folly::BasicFixedString< Char, N >
	A class for holding up to N characters of type Char that is amenable to constexpr string manipulation. It is guaranteed to not perform any dynamic allocation. More...

Namespaces
	folly
	—— Concurrent Priority Queue Implementation ——
	folly::detail
	folly::detail::fixedstring
	folly::literals
	folly::literals::string_literals

Macros
#define	FOLLY_DEFINE_FIXED_STRING_UDL(N)

Typedefs
template<std::size_t N>
using	folly::FixedString = BasicFixedString< char, N >
using	folly::detail::fixedstring::FixedStringBase = FixedStringBase_<>

Functions
void	folly::detail::fixedstring::assertOutOfBounds ()
constexpr std::size_t	folly::detail::fixedstring::checkOverflow (std::size_t i, std::size_t max)
constexpr std::size_t	folly::detail::fixedstring::checkOverflowOrNpos (std::size_t i, std::size_t max)
void	folly::detail::fixedstring::assertNotNullTerminated () noexcept
template<class Char , std::size_t N>
constexpr const Char(&	folly::detail::fixedstring::checkNullTerminated (const Char(&a)[N]) noexcept)[N]
template<class Left , class Right >
constexpr ordering	folly::detail::fixedstring::compare_ (const Left &left, std::size_t left_pos, std::size_t left_size, const Right &right, std::size_t right_pos, std::size_t right_size) noexcept
template<class Left , class Right >
constexpr bool	folly::detail::fixedstring::equal_ (const Left &left, std::size_t left_size, const Right &right, std::size_t right_size) noexcept
template<class Char , class Left , class Right >
constexpr Char	folly::detail::fixedstring::char_at_ (const Left &left, std::size_t left_count, const Right &right, std::size_t right_count, std::size_t i) noexcept
template<class Char , class Left , class Right >
constexpr Char	folly::detail::fixedstring::char_at_ (const Left &left, std::size_t left_size, std::size_t left_pos, std::size_t left_count, const Right &right, std::size_t right_pos, std::size_t right_count, std::size_t i) noexcept
template<class Left , class Right >
constexpr bool	folly::detail::fixedstring::find_at_ (const Left &left, const Right &right, std::size_t pos, std::size_t count) noexcept
template<class Char , class Right >
constexpr bool	folly::detail::fixedstring::find_one_of_at_ (Char ch, const Right &right, std::size_t pos) noexcept
template<class Left , class Right >
constexpr std::size_t	folly::detail::fixedstring::find_ (const Left &left, std::size_t left_size, const Right &right, std::size_t pos, std::size_t count) noexcept
template<class Left , class Right >
constexpr std::size_t	folly::detail::fixedstring::rfind_ (const Left &left, const Right &right, std::size_t pos, std::size_t count) noexcept
template<class Left , class Right >
constexpr std::size_t	folly::detail::fixedstring::find_first_of_ (const Left &left, std::size_t left_size, const Right &right, std::size_t pos, std::size_t count) noexcept
template<class Left , class Right >
constexpr std::size_t	folly::detail::fixedstring::find_first_not_of_ (const Left &left, std::size_t left_size, const Right &right, std::size_t pos, std::size_t count) noexcept
template<class Left , class Right >
constexpr std::size_t	folly::detail::fixedstring::find_last_of_ (const Left &left, const Right &right, std::size_t pos, std::size_t count) noexcept
template<class Left , class Right >
constexpr std::size_t	folly::detail::fixedstring::find_last_not_of_ (const Left &left, const Right &right, std::size_t pos, std::size_t count) noexcept
template<class T >
FOLLY_CPP14_CONSTEXPR void	folly::detail::fixedstring::constexpr_swap (T &a, T &b) noexcept(noexcept(a=T(std::move(a))))
std::uint32_t	folly::hsieh_hash32_buf (const void *buf, std::size_t len)
template<class C , std::size_t N>
std::basic_ostream< C > &	folly::operator<< (std::basic_ostream< C > &os, const BasicFixedString< C, N > &string)
template<class Char , std::size_t A, std::size_t B>
constexpr bool	folly::operator== (const BasicFixedString< Char, A > &a, const BasicFixedString< Char, B > &b) noexcept
template<class Char , std::size_t A, std::size_t B>
constexpr bool	folly::operator!= (const BasicFixedString< Char, A > &a, const BasicFixedString< Char, B > &b)
template<class Char , std::size_t A, std::size_t B>
constexpr bool	folly::operator< (const BasicFixedString< Char, A > &a, const BasicFixedString< Char, B > &b) noexcept
template<class Char , std::size_t A, std::size_t B>
constexpr bool	folly::operator> (const BasicFixedString< Char, A > &a, const BasicFixedString< Char, B > &b) noexcept
template<class Char , std::size_t A, std::size_t B>
constexpr bool	folly::operator<= (const BasicFixedString< Char, A > &a, const BasicFixedString< Char, B > &b) noexcept
template<class Char , std::size_t A, std::size_t B>
constexpr bool	folly::operator>= (const BasicFixedString< Char, A > &a, const BasicFixedString< Char, B > &b) noexcept
template<class Char , std::size_t N, std::size_t M>
constexpr BasicFixedString< Char, N+M >	folly::operator+ (const BasicFixedString< Char, N > &a, const BasicFixedString< Char, M > &b) noexcept
template<class Char , std::size_t N>
constexpr BasicFixedString< Char, N-1u >	folly::makeFixedString (const Char(&a)[N]) noexcept
template<class Char , std::size_t N>
FOLLY_CPP14_CONSTEXPR void	folly::swap (BasicFixedString< Char, N > &a, BasicFixedString< Char, N > &b) noexcept
constexpr FixedString< 4 >	folly::literals::string_literals::operator""_fs4 (const char *that, std::size_t count) noexcept(false)
constexpr FixedString< 8 >	folly::literals::string_literals::operator""_fs8 (const char *that, std::size_t count) noexcept(false)
constexpr FixedString< 16 >	folly::literals::string_literals::operator""_fs16 (const char *that, std::size_t count) noexcept(false)
constexpr FixedString< 32 >	folly::literals::string_literals::operator""_fs32 (const char *that, std::size_t count) noexcept(false)
constexpr FixedString< 64 >	folly::literals::string_literals::operator""_fs64 (const char *that, std::size_t count) noexcept(false)
constexpr FixedString< 128 >	folly::literals::string_literals::operator""_fs128 (const char *that, std::size_t count) noexcept(false)

Macro Definition Documentation

#define FOLLY_DEFINE_FIXED_STRING_UDL

(

N

)

Value:

constexpr FixedString<N> operator"" _fs##N(                \
      const char* that, std::size_t count) noexcept(false) { \
    return {that, count};                                    \
  }                                                          \

Definition at line 3054 of file FixedString.h.