folly::gen::detail Namespace Reference

Classes
class	Append
class	Batch
class	Chain
class	ChunkedRangeSource
class	ClosableMPMCQueue
class	Collect
class	CollectTemplate
class	Composed
class	Composer
class	Concat
class	Contains
class	CopiedSource
class	Count
class	Cycle
class	Dereference
class	Distinct
class	Empty
struct	FBounded
class	FileReader
class	FileWriter
class	Filter
class	First
class	FoldLeft
struct	GeneratorBuilder
class	GroupBy
class	GroupByAdjacent
class	GuardImpl
class	Indirect
class	InfiniteImpl
class	Interleave
class	IsEmpty
class	IStreamByLine
class	Map
class	MergeTuples
class	Min
class	Order
class	Parallel
class	PMap
class	RangeConcat
class	RangeImpl
class	RangeSource
class	RangeWithStepImpl
class	Reduce
class	ReferencedSource
class	Sample
class	SeqImpl
class	Sequence
class	SeqWithStepImpl
class	SingleCopy
class	SingleReference
class	Skip
class	SplitStringSource
class	SplitTo
class	Stride
class	StringResplitter
class	Sub
class	Sum
class	Take
class	TypeAssertion
class	Unsplit
class	UnsplitBuffer
class	Until
class	Unwrap
class	UnwrapOr
struct	ValueTypeOfRange
class	Visit
class	Window
class	Yield
class	Zip

Functions
template<class T >
T &&	operator| (Optional< T > &&opt, UnwrapOr< T > &&fallback)
template<class T >
T &	operator| (Optional< T > &opt, UnwrapOr< T > &fallback)
template<class T >
const T &	operator| (const Optional< T > &opt, const UnwrapOr< T > &fallback)
template<class T , class U , class R = typename std::enable_if< !std::is_same<T, U>::value, typename std::common_type<T, U>::type>::type>
R	operator| (Optional< T > &&opt, UnwrapOr< U > &&fallback)
template<class T , class U , class R = typename std::enable_if< !std::is_same<T, U>::value, typename std::common_type<T, U>::type>::type>
R	operator| (const Optional< T > &opt, UnwrapOr< U > &&fallback)
template<class T , class U , class R = typename std::enable_if< !std::is_same<T, U>::value, typename std::common_type<T, U>::type>::type>
R	operator| (Optional< T > &&opt, const UnwrapOr< U > &fallback)
template<class T , class U , class R = typename std::enable_if< !std::is_same<T, U>::value, typename std::common_type<T, U>::type>::type>
R	operator| (const Optional< T > &opt, const UnwrapOr< U > &fallback)
template<class T >
T &&	operator| (Optional< T > &&opt, const Unwrap &)
template<class T >
T &	operator| (Optional< T > &opt, const Unwrap &)
template<class T >
const T &	operator| (const Optional< T > &opt, const Unwrap &)
template<class... Types1, class... Types2>
auto	add_to_tuple (std::tuple< Types1... > t1, std::tuple< Types2... > t2) -> std::tuple< Types1..., Types2... >
template<class... Types1, class Type2 >
auto	add_to_tuple (std::tuple< Types1... > t1, Type2 &&t2) -> decltype(std::tuple_cat(std::move(t1), std::make_tuple(std::forward< Type2 >(t2))))
template<class Type1 , class... Types2>
auto	add_to_tuple (Type1 &&t1, std::tuple< Types2... > t2) -> decltype(std::tuple_cat(std::make_tuple(std::forward< Type1 >(t1)), std::move(t2)))
template<class Type1 , class Type2 >
auto	add_to_tuple (Type1 &&t1, Type2 &&t2) -> decltype(std::make_tuple(std::forward< Type1 >(t1), std::forward< Type2 >(t2)))
auto	byLineImpl (File file, char delim, bool keepDelimiter)
size_t	splitPrefix (StringPiece &in, StringPiece &prefix, char delimiter)
size_t	splitPrefix (StringPiece &in, StringPiece &prefix, StringPiece delimiter)
size_t	splitPrefix (StringPiece &in, StringPiece &prefix, MixedNewlines)
const char *	ch (const unsigned char *p)
template<class Callback >
bool	consumeFixedSizeChunks (Callback &cb, StringPiece &s, uint64_t maxLength)
template<class Callback >
bool	consumeBufferPlus (Callback &cb, IOBuf &buf, StringPiece &s, uint64_t n)
template<class Target , class = void>
Target	passthrough (Target target)

Function Documentation

template<class... Types1, class... Types2>

auto folly::gen::detail::add_to_tuple	(	std::tuple< Types1... >	t1,
		std::tuple< Types2... >	t2
	)		-> std::tuple<Types1..., Types2...>

Definition at line 153 of file Combine-inl.h.

References folly::gen::move.

Referenced by folly::gen::detail::MergeTuples::operator()().

                                      {
  return std::tuple_cat(std::move(t1), std::move(t2));
}

template<class... Types1, class Type2 >

auto folly::gen::detail::add_to_tuple	(	std::tuple< Types1... >	t1,
		Type2 &&	t2
	)		-> decltype( std::tuple_cat(std::move(t1), std::make_tuple(std::forward<Type2>(t2))))

Definition at line 159 of file Combine-inl.h.

References std::tr1::make_tuple(), and folly::gen::move.

                                                                     {
  return std::tuple_cat(
      std::move(t1), std::make_tuple(std::forward<Type2>(t2)));
}

template<class Type1 , class... Types2>

auto folly::gen::detail::add_to_tuple	(	Type1 &&	t1,
		std::tuple< Types2... >	t2
	)		-> decltype( std::tuple_cat(std::make_tuple(std::forward<Type1>(t1)), std::move(t2)))

Definition at line 166 of file Combine-inl.h.

References std::tr1::make_tuple(), and folly::gen::move.

                                                                     {
  return std::tuple_cat(
      std::make_tuple(std::forward<Type1>(t1)), std::move(t2));
}

template<class Type1 , class Type2 >

auto folly::gen::detail::add_to_tuple	(	Type1 &&	t1,
		Type2 &&	t2
	)		-> decltype( std::make_tuple(std::forward<Type1>(t1), std::forward<Type2>(t2)))

Definition at line 173 of file Combine-inl.h.

References std::tr1::make_tuple().

                                                                 {
  return std::make_tuple(std::forward<Type1>(t1), std::forward<Type2>(t2));
}

auto folly::gen::detail::byLineImpl ( File  file, char  delim, bool  keepDelimiter  )

inline

Definition at line 121 of file File-inl.h.

References folly::gen::fromFile(), folly::gen::move, and folly::gen::resplit().

Referenced by folly::gen::byLine(), and folly::gen::byLineFull().

                                                                  {
  // clang-format off
  return fromFile(std::move(file))
      | eachAs<StringPiece>()
      | resplit(delim, keepDelimiter);
  // clang-format on
}

const char* folly::gen::detail::ch ( const unsigned char *  p )

inline

Definition at line 91 of file String-inl.h.

Referenced by consumeBufferPlus(), and folly::gen::StreamSplitter< Callback >::flush().

                                              {
  return reinterpret_cast<const char*>(p);
}

template<class Callback >

bool folly::gen::detail::consumeBufferPlus	(	Callback &	cb,
		IOBuf &	buf,
		StringPiece &	s,
		uint64_t	n
	)

Definition at line 113 of file String-inl.h.

References folly::Range< Iter >::advance(), folly::IOBuf::append(), ch(), folly::IOBuf::clear(), folly::Range< Iter >::data(), folly::IOBuf::data(), folly::IOBuf::length(), folly::IOBuf::reserve(), and folly::IOBuf::writableTail().

Referenced by folly::gen::StreamSplitter< Callback >::operator()().

                                                                             {
  buf.reserve(0, n);
  memcpy(buf.writableTail(), s.data(), n);
  buf.append(n);
  s.advance(n);
  if (!cb(StringPiece(detail::ch(buf.data()), buf.length()))) {
    return false;
  }
  buf.clear();
  return true;
}

template<class Callback >

bool folly::gen::detail::consumeFixedSizeChunks	(	Callback &	cb,
		StringPiece &	s,
		uint64_t	maxLength
	)

Definition at line 97 of file String-inl.h.

References folly::Range< Iter >::advance(), folly::Range< Iter >::begin(), folly::Range< Iter >::empty(), and folly::Range< Iter >::size().

Referenced by folly::gen::StreamSplitter< Callback >::operator()().

                                                                              {
  while (!s.empty()) {
    auto num_to_add = s.size();
    if (maxLength) {
      num_to_add = std::min<uint64_t>(num_to_add, maxLength);
    }
    if (!cb(StringPiece(s.begin(), num_to_add))) {
      return false;
    }
    s.advance(num_to_add);
  }
  return true;
}

template<class T >

T&& folly::gen::detail::operator|	(	Optional< T > &&	opt,
		UnwrapOr< T > &&	fallback
	)

Definition at line 2380 of file Base-inl.h.

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

                                                         {
  if (T* p = opt.get_pointer()) {
    return std::move(*p);
  }
  return std::move(fallback.value());
}

template<class T >

T& folly::gen::detail::operator|	(	Optional< T > &	opt,
		UnwrapOr< T > &	fallback
	)

Definition at line 2388 of file Base-inl.h.

References folly::Optional< Value >::get_pointer(), T, and folly::gen::detail::UnwrapOr< T >::value().

                                                      {
  if (T* p = opt.get_pointer()) {
    return *p;
  }
  return fallback.value();
}

template<class T >

const T& folly::gen::detail::operator|	(	const Optional< T > &	opt,
		const UnwrapOr< T > &	fallback
	)

Definition at line 2396 of file Base-inl.h.

References folly::Optional< Value >::get_pointer(), T, type, value, and folly::gen::detail::UnwrapOr< T >::value().

                                                                        {
  if (const T* p = opt.get_pointer()) {
    return *p;
  }
  return fallback.value();
}

template<class T , class U , class R = typename std::enable_if< !std::is_same<T, U>::value, typename std::common_type<T, U>::type>::type>

R folly::gen::detail::operator|	(	Optional< T > &&	opt,
		UnwrapOr< U > &&	fallback
	)

Definition at line 2410 of file Base-inl.h.

References folly::gen::move, T, type, and value.

                                                       {
  if (T* p = opt.get_pointer()) {
    return std::move(*p);
  }
  return std::move(fallback.value());
}

template<class T , class U , class R = typename std::enable_if< !std::is_same<T, U>::value, typename std::common_type<T, U>::type>::type>

R folly::gen::detail::operator|	(	const Optional< T > &	opt,
		UnwrapOr< U > &&	fallback
	)

Definition at line 2423 of file Base-inl.h.

References folly::Optional< Value >::get_pointer(), folly::gen::move, T, type, and value.

                                                            {
  if (const T* p = opt.get_pointer()) {
    return *p;
  }
  return std::move(fallback.value());
}

template<class T , class U , class R = typename std::enable_if< !std::is_same<T, U>::value, typename std::common_type<T, U>::type>::type>

R folly::gen::detail::operator|	(	Optional< T > &&	opt,
		const UnwrapOr< U > &	fallback
	)

Definition at line 2436 of file Base-inl.h.

References folly::gen::move, T, type, value, and folly::gen::detail::UnwrapOr< T >::value().

                                                            {
  if (T* p = opt.get_pointer()) {
    return std::move(*p);
  }
  return fallback.value();
}

template<class T , class U , class R = typename std::enable_if< !std::is_same<T, U>::value, typename std::common_type<T, U>::type>::type>

R folly::gen::detail::operator|	(	const Optional< T > &	opt,
		const UnwrapOr< U > &	fallback
	)

Definition at line 2449 of file Base-inl.h.

References folly::Optional< Value >::get_pointer(), and folly::gen::detail::UnwrapOr< T >::value().

                                                                 {
  if (const T* p = opt.get_pointer()) {
    return *p;
  }
  return fallback.value();
}

template<class T >

T&& folly::gen::detail::operator|	(	Optional< T > &&	opt,
		const Unwrap &
	)

Definition at line 2465 of file Base-inl.h.

References folly::gen::move.

                                                {
  return std::move(opt.value());
}

template<class T >

T& folly::gen::detail::operator|	(	Optional< T > &	opt,
		const Unwrap &
	)

Definition at line 2470 of file Base-inl.h.

References folly::Optional< Value >::value().

                                              {
  return opt.value();
}

template<class T >

const T& folly::gen::detail::operator|	(	const Optional< T > &	opt,
		const Unwrap &
	)

Definition at line 2475 of file Base-inl.h.

References folly::Optional< Value >::value().

                                                          {
  return opt.value();
}

template<class Target , class = void>

Target folly::gen::detail::passthrough ( Target  target )

inline

Hack for static for-like constructs

Definition at line 356 of file String-inl.h.

References folly::Delimiter, and FOLLY_PUSH_WARNING.

Referenced by BENCHMARK().

                                         {
  return target;
}

size_t folly::gen::detail::splitPrefix ( StringPiece &  in, StringPiece &  prefix, char  delimiter  )

inline

Finds the first occurrence of delimiter in "in", advances "in" past the delimiter. Populates "prefix" with the consumed bytes, including the delimiter.

Returns the number of trailing bytes of "prefix" that make up the delimiter, or 0 if the delimiter was not found.

Definition at line 38 of file String-inl.h.

References folly::Range< Iter >::advance(), folly::Range< Iter >::assign(), folly::Range< Iter >::clear(), folly::Range< Iter >::data(), folly::Range< Iter >::find(), and folly::Range< const char * >::npos.

Referenced by folly::gen::detail::SplitStringSource< DelimiterType >::apply(), and folly::gen::StreamSplitter< Callback >::operator()().

                                                                  {
  size_t found = in.find(delimiter);
  if (found != StringPiece::npos) {
    ++found;
    prefix.assign(in.data(), in.data() + found);
    in.advance(found);
    return 1;
  }
  prefix.clear();
  return 0;
}

size_t folly::gen::detail::splitPrefix ( StringPiece &  in, StringPiece &  prefix, StringPiece  delimiter  )

inline

As above, but supports multibyte delimiters.

Definition at line 54 of file String-inl.h.

References folly::Range< Iter >::advance(), folly::Range< Iter >::assign(), folly::Range< Iter >::clear(), folly::Range< Iter >::data(), folly::Range< Iter >::find(), folly::Range< const char * >::npos, and folly::Range< Iter >::size().

                                                                         {
  auto found = in.find(delimiter);
  if (found != StringPiece::npos) {
    found += delimiter.size();
    prefix.assign(in.data(), in.data() + found);
    in.advance(found);
    return delimiter.size();
  }
  prefix.clear();
  return 0;
}

size_t folly::gen::detail::splitPrefix ( StringPiece &  in, StringPiece &  prefix, MixedNewlines    )

inline

As above, but splits by any of the EOL terms: ,
, or
.

Definition at line 69 of file String-inl.h.

References folly::Range< Iter >::advance(), folly::Range< Iter >::assign(), folly::Range< Iter >::clear(), folly::Range< Iter >::data(), folly::Range< Iter >::find_first_of(), and folly::Range< Iter >::removePrefix().

                                                                               {
  const auto kCRLF = "\r\n";
  const size_t kLenCRLF = 2;

  auto p = in.find_first_of(kCRLF);
  if (p != std::string::npos) {
    const auto in_start = in.data();
    size_t delim_len = 1;
    in.advance(p);
    // Either remove an MS-DOS CR-LF 2-byte newline, or eat 1 byte at a time.
    if (in.removePrefix(kCRLF)) {
      delim_len = kLenCRLF;
    } else {
      in.advance(delim_len);
    }
    prefix.assign(in_start, in.data());
    return delim_len;
  }
  prefix.clear();
  return 0;
}