folly::detail::fixedstring Namespace Reference

Classes
struct	FixedStringBase_
struct	Helper
struct	ReverseIterator

Typedefs
using	FixedStringBase = FixedStringBase_<>

Functions
void	assertOutOfBounds ()
constexpr std::size_t	checkOverflow (std::size_t i, std::size_t max)
constexpr std::size_t	checkOverflowOrNpos (std::size_t i, std::size_t max)
void	assertNotNullTerminated () noexcept
template<class Char , std::size_t N>
constexpr const Char(&	checkNullTerminated (const Char(&a)[N]) noexcept)[N]
template<class Left , class Right >
constexpr ordering	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	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	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	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	find_at_ (const Left &left, const Right &right, std::size_t pos, std::size_t count) noexcept
template<class Char , class Right >
constexpr bool	find_one_of_at_ (Char ch, const Right &right, std::size_t pos) noexcept
template<class Left , class Right >
constexpr std::size_t	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	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	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	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	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	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	constexpr_swap (T &a, T &b) noexcept(noexcept(a=T(std::move(a))))

Typedef Documentation

using folly::detail::fixedstring::FixedStringBase = typedef FixedStringBase_<>

Definition at line 60 of file FixedString.h.

Function Documentation

void folly::detail::fixedstring::assertNotNullTerminated ( )

inlinenoexcept

Definition at line 83 of file FixedString.h.

Referenced by checkNullTerminated().

                                                            {
  assert(!"Non-null terminated string used to initialize a BasicFixedString");
  std::terminate(); // Fail hard, fail fast.
}

void folly::detail::fixedstring::assertOutOfBounds ( )

inline

Definition at line 66 of file FixedString.h.

Referenced by checkOverflow(), and checkOverflowOrNpos().

                                             {
  assert(!"Array index out of bounds in BasicFixedString");
  throw_exception<std::out_of_range>(
      "Array index out of bounds in BasicFixedString");
}

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

Definition at line 145 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), and i.

                          {
  return i < left_count
      ? left[i]
      : i < (left_count + right_count) ? right[i - left_count] : Char(0);
}

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

Definition at line 157 of file FixedString.h.

References testing::gmock_generated_actions_test::Char(), and i.

                          {
  return i < left_pos
      ? left[i]
      : (i < right_count + left_pos ? right[i - left_pos + right_pos]
                                    : (i < left_size - left_count + right_count
                                           ? left[i - right_count + left_count]
                                           : Char(0)));
}

template<class Char , std::size_t N>

constexpr const Char(& folly::detail::fixedstring::checkNullTerminated

(

const Char(&)

a[N]

)

)[N]

Definition at line 92 of file FixedString.h.

References a, assertNotNullTerminated(), testing::gmock_generated_actions_test::Char(), and folly::detail::constexpr_strlen_internal().

Referenced by folly::BasicFixedString< Char, N >::assign(), folly::BasicFixedString< Char, N >::BasicFixedString(), folly::BasicFixedString< Char, N >::creplace(), and folly::BasicFixedString< Char, N >::operator=().

                                                                            {
  // Strange decltype(a)(a) used to make MSVC happy.
  return a[N - 1u] == Char(0)
#ifndef NDEBUG
          // In Debug mode, guard against embedded nulls:
          && N - 1u == folly::detail::constexpr_strlen_internal(a, 0u)
#endif
      ? decltype(a)(a)
      : (assertNotNullTerminated(), decltype(a)(a));
}

constexpr std::size_t folly::detail::fixedstring::checkOverflow	(	std::size_t	i,
		std::size_t	max
	)

Definition at line 72 of file FixedString.h.

References assertOutOfBounds(), and max.

Referenced by folly::BasicFixedString< Char, N >::append(), folly::BasicFixedString< Char, N >::assign(), folly::BasicFixedString< Char, N >::back(), folly::BasicFixedString< Char, N >::BasicFixedString(), folly::BasicFixedString< Char, N >::cerase(), folly::BasicFixedString< Char, N >::compare(), folly::BasicFixedString< Char, N >::copy(), folly::BasicFixedString< Char, N >::cpop_back(), folly::BasicFixedString< Char, N >::creplace(), folly::BasicFixedString< Char, N >::erase(), folly::BasicFixedString< Char, N >::find(), folly::BasicFixedString< Char, N >::find_first_not_of(), folly::BasicFixedString< Char, N >::find_first_of(), folly::BasicFixedString< Char, N >::find_last_not_of(), folly::BasicFixedString< Char, N >::find_last_of(), folly::BasicFixedString< Char, N >::operator=(), folly::BasicFixedString< Char, N >::operator[](), folly::BasicFixedString< Char, N >::pop_back(), folly::BasicFixedString< Char, N >::push_back(), folly::BasicFixedString< Char, N >::replace(), folly::BasicFixedString< Char, N >::resize(), and folly::BasicFixedString< Char, N >::rfind().

                                                              {
  return i <= max ? i : (void(assertOutOfBounds()), max);
}

constexpr std::size_t folly::detail::fixedstring::checkOverflowOrNpos	(	std::size_t	i,
		std::size_t	max
	)

Definition at line 76 of file FixedString.h.

References assertOutOfBounds(), max, and folly::detail::fixedstring::FixedStringBase_< class >::npos.

Referenced by folly::BasicFixedString< Char, N >::append(), folly::BasicFixedString< Char, N >::assign(), folly::BasicFixedString< Char, N >::BasicFixedString(), folly::BasicFixedString< Char, N >::cerase(), folly::BasicFixedString< Char, N >::compare(), folly::BasicFixedString< Char, N >::creplace(), folly::BasicFixedString< Char, N >::erase(), and folly::BasicFixedString< Char, N >::replace().

                                                                    {
  return i == FixedStringBase::npos
      ? max
      : (i <= max ? i : (void(assertOutOfBounds()), max));
}

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

Definition at line 111 of file FixedString.h.

References folly::eq, folly::gt, and folly::lt.

Referenced by folly::BasicFixedString< Char, N >::compare(), equal_(), and folly::operator<().

                                   {
  return left_pos == left_size
      ? (right_pos == right_size ? ordering::eq : ordering::lt)
      : (right_pos == right_size ? ordering::gt
                                 : (left[left_pos] < right[right_pos]
                                        ? ordering::lt
                                        : (left[left_pos] > right[right_pos]
                                               ? ordering::gt
                                               : fixedstring::compare_(
                                                     left,
                                                     left_pos + 1u,
                                                     left_size,
                                                     right,
                                                     right_pos + 1u,
                                                     right_size))));
}

template<class T >

FOLLY_CPP14_CONSTEXPR void folly::detail::fixedstring::constexpr_swap ( T &  a, T &  b  )

noexcept

Definition at line 310 of file FixedString.h.

References a, b, folly::gen::move, and folly::T.

Referenced by folly::BasicFixedString< Char, N >::swap().

                                 {
  T tmp((std::move(a)));
  a = std::move(b);
  b = std::move(tmp);
}

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

Definition at line 135 of file FixedString.h.

References compare_(), and folly::eq.

Referenced by folly::f14::GenericEqual< T >::operator()(), and folly::operator==().

                                   {
  return left_size == right_size &&
      ordering::eq == compare_(left, 0u, left_size, right, 0u, right_size);
}

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

Definition at line 193 of file FixedString.h.

References count, find_at_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

Referenced by folly::BasicFixedString< Char, N >::find().

                              {
  return find_at_(left, right, pos, count) ? pos
                                           : left_size <= pos + count
          ? FixedStringBase::npos
          : find_(left, left_size, right, pos + 1u, count);
}

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

Definition at line 175 of file FixedString.h.

References count.

Referenced by find_(), and rfind_().

                              {
  return 0u == count ||
      (left[pos + count - 1u] == right[count - 1u] &&
       find_at_(left, right, pos, count - 1u));
}

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

Definition at line 231 of file FixedString.h.

References count, find_one_of_at_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

Referenced by folly::BasicFixedString< Char, N >::find_first_not_of().

                              {
  return !find_one_of_at_(left[pos], right, count) ? pos
                                                   : left_size <= pos + 1u
          ? FixedStringBase::npos
          : find_first_not_of_(left, left_size, right, pos + 1u, count);
}

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

Definition at line 218 of file FixedString.h.

References count, find_one_of_at_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

Referenced by folly::BasicFixedString< Char, N >::find_first_of().

                              {
  return find_one_of_at_(left[pos], right, count) ? pos
                                                  : left_size <= pos + 1u
          ? FixedStringBase::npos
          : find_first_of_(left, left_size, right, pos + 1u, count);
}

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

Definition at line 256 of file FixedString.h.

References count, find_one_of_at_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

Referenced by folly::BasicFixedString< Char, N >::find_last_not_of().

                              {
  return !find_one_of_at_(left[pos], right, count)
      ? pos
      : 0u == pos ? FixedStringBase::npos
                  : find_last_not_of_(left, right, pos - 1u, count);
}

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

Definition at line 244 of file FixedString.h.

References count, find_one_of_at_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

Referenced by folly::BasicFixedString< Char, N >::find_last_of().

                              {
  return find_one_of_at_(left[pos], right, count)
      ? pos
      : 0u == pos ? FixedStringBase::npos
                  : find_last_of_(left, right, pos - 1u, count);
}

template<class Char , class Right >

constexpr bool folly::detail::fixedstring::find_one_of_at_ ( Char  ch, const Right &  right, std::size_t  pos  )

noexcept

Definition at line 187 of file FixedString.h.

References ch.

Referenced by find_first_not_of_(), find_first_of_(), find_last_not_of_(), and find_last_of_().

                                                                     {
  return 0u != pos &&
      (ch == right[pos - 1u] || find_one_of_at_(ch, right, pos - 1u));
}

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

Definition at line 206 of file FixedString.h.

References count, find_at_(), and folly::detail::fixedstring::FixedStringBase_< class >::npos.

Referenced by folly::BasicFixedString< Char, N >::rfind().

                              {
  return find_at_(left, right, pos, count)
      ? pos
      : 0u == pos ? FixedStringBase::npos
                  : rfind_(left, right, pos - 1u, count);
}