Summary: Not supported by some environments.

Reviewed By: yfeldblum

Differential Revision: D5526180

fbshipit-source-id: 2c2b6f7627860c5f896532b90601c817530e6b69

Summary: [Folly] Consistency in namespace-closing comments.

Reviewed By: Orvid

Differential Revision: D5524744

fbshipit-source-id: ced4dd2398ed6baa3ad5b68b74eee6a5d6b2b103

Summary: [Folly] Formatting for template parameters.

Reviewed By: Orvid

Differential Revision: D5525123

fbshipit-source-id: 4feb772300cfdd6ae3168fe9f59f5a951fb85d0e

Summary:
[Folly] Simplify the `StateSize` helper in `Random`.

* Using member type aliases rather than class constants means we can remove definitions.
* Partially specializing over all RNG types with `state_size` class constants means we can remove the `mersenne_twister` specializations, which have many template parameters and are a pain.

Reviewed By: Orvid

Differential Revision: D5525144

fbshipit-source-id: bc27f112ed0d9b55befe9dabe08c4d345a402435

Summary: [Folly] Outline `throw` statements in `format`.

Reviewed By: Orvid

Differential Revision: D5523933

fbshipit-source-id: 371c9ecc707e48dcc05fa4aab4fd326111466161

Summary:
[Folly] Let `MacAddress` use a helper hex-table.

The table is in the `folly::detail` namespace so it is non-public to users of folly, but the rules may not be quite as strict in at least some cases within folly.

Also the helper `unhex` function that this replaces is not `clang-format`-clean, so this lets us sidestep that.

Reviewed By: Orvid

Differential Revision: D5524229

fbshipit-source-id: 21d6938e20cd675e65499a5b64d2af934f980222

Summary: [Folly] Consistent indentation for class visibility labels (`public:`, `protected:`, `private:`). Style is +1 column relative to the `class` keyword.

Reviewed By: andrewjcg

Differential Revision: D5524869

fbshipit-source-id: 53e4b6cbda10d5b63bafbd535794a8b7ae01a8e0

Summary:
[Folly] `template<` -> `template <`.

And then apply `clang-format` style to affected `template <...>` lines.

Reviewed By: andrewjcg

Differential Revision: D5524792

fbshipit-source-id: 6614eecf384bf3e3ccc2f0cc7c5334a0cb9c76af

Summary:
[Folly] Mark two implicit ctors as `explicit`.

They did not need to be implicit.

Reviewed By: andrewjcg

Differential Revision: D5524798

fbshipit-source-id: a50bc6bfc9da2642891faf0aa38a19f46e75b9da

Summary: [Folly] Define `IPAddressV6` comparison ops in terms of its fields using `std::tie`.

Reviewed By: andrewjcg

Differential Revision: D5524248

fbshipit-source-id: 5f5f2acd6e9cfd6dfd148cc7d95bda720bf81ee9

Summary:
[Folly] Merge `IPAddressTest.h` into the `IPAddressTest.cpp`.

There is no real need to split anything out into a header file.

Reviewed By: andrewjcg

Differential Revision: D5524267

fbshipit-source-id: e128c69c7da38663f19d0ccd73edaae36c3f469a

Summary: [Folly] Outline `throw` statements in `folly/futures/`.

Reviewed By: ericniebler

Differential Revision: D5522791

fbshipit-source-id: 545185bc580ea8628075b9ecae46c2f19308e937

Summary: [Folly] Compute masks in `IPAddressV4`. Just like in `IPAddressV6`.

Reviewed By: WillerZ

Differential Revision: D5524197

fbshipit-source-id: ebeeab28304bff4f6150cf76216d170908e62aa4

Summary:
Fix the copy constructor, and add the missing testcase which would have found
this problem.

Reviewed By: yfeldblum

Differential Revision: D5516628

fbshipit-source-id: 3e688c34f061511df5b68243111fecb83483d79d

Summary:
[Folly] Optimal `make_integer_sequence`.

When the builtin `__make_integer_seq` is available, use that. It is the most optimal implementation.

Otherwise, use a tweaked divide-and-conquer implementation. Designed to reuse more template instantiations than the straightforward divide-and-conquer approach in libstdc++ >= 6. And definitely not linearly recursive as in libstdc++ < 6.

Illustrating with an example. Let `M` be whatever template type implements `make_integer_sequence`. For `M<17>`, libstdc++ < 6 does linear recursion (least optimal), instantiating `M<16>`, `M<15>`, ..., `M<1>`. libstdc++ >= 6 does straightforward divide-and-conquer recursion, instantiating `M<8>` and `M<9>`, recursing into `M<4>` and `M<5>`, recursing into `M<2>` and `M<3>`, recursing into `M<1>`. Our implementation does a variant of divide-and-conquer recursion to maximize reuse, instantiating `M<8>` and `M<1>`, recursing into `M<4>`, recursing into `M<2>`.

Implementation derived from `fatal/type/sequence.h`.

Reviewed By: ericniebler

Differential Revision: D5496975

fbshipit-source-id: 449b4e0a1c7b4a5b602752c1d3dd8914bf9a8e71

Summary:
Current `IsOneOf` implementation does unnecessary work because it instantiates all of the possible template specializations, even if type is same as the first of the tested ones. E.g.
`IsOneOf<char, char, int, float>` will instantiate:
```
IsOneOf<char, char, int, float>
IsOneOf<char, char, int>
IsOneOf<char, char>
IsOneOf<char>
```

With the proposed inheritance, compiler will stop initializing at the first match.
Closes https://github.com/facebook/folly/pull/643

Reviewed By: ericniebler

Differential Revision: D5482783

Pulled By: yfeldblum

fbshipit-source-id: 3d04c750ce72fa9b19b4d0588cccfb396a9e0715

Reviewed By: yfeldblum

Differential Revision: D5509756

fbshipit-source-id: 0b9581dafb073c5e3e5a229c032c6cf272ceb2e0

Summary:
std::ostream may be incomplete because Range.h doesn't use <ostream>,
only <iosfwd>. Changing the operator<< overloads to be templated on the char
type defers typechecking until callsites, which will avoid the potential problem.

Reviewed By: yfeldblum, ericniebler

Differential Revision: D5494648

fbshipit-source-id: e59b6fdfba6c08ec70ebb1e10c14a43307a1119f

Summary:
When attempting to output a FixedString into eg. glog or
some other ostream, it is first being implicitly converted to StringPiece
and then that is printed using the overloaded operator<<. If another
suitable implicit conversion is provided, eg. to `dynamic`, compilers
cannot choose between either one. Instead, overload operator<< directly
on FixedString to resolve the ambiguity.

Reviewed By: yfeldblum, ericniebler

Differential Revision: D5492779

fbshipit-source-id: 92d661e5471a91057d7a0d010420709c5d59232f

Summary: Older versions of libc++ do not support `std::aligned_storage_t`, switch to something more widely supported.

Differential Revision: D5506449

fbshipit-source-id: 3f5cf5dddf00bda76d4f16cfd4d8944ee5f1ba55

Summary:
[Folly] Add `FOLLY_HAS_FEATURE` and use it.

Use it in the definitions of `FOLLY_SANITIZE_ADDRESS` and `FOLLY_SANITIZE_THREAD`.

Reviewed By: meyering

Differential Revision: D5496915

fbshipit-source-id: e272137ad8ba891e64fc98444edf573115764ee2

Summary: [Folly] Cut `moveFromTry`. Not necessary, and is even longer than `std::move`.

Reviewed By: WillerZ, ericniebler

Differential Revision: D5478450

fbshipit-source-id: ecd01cb1bcd435e49268a76dd558e57ba8dd9b9e

Summary:
[Folly] Outline `throw` statements in `dynamic`.

There is no need for them to be inline - definitionally, they are always cold.

Reviewed By: WillerZ

Differential Revision: D5497457

fbshipit-source-id: 7b649c59b5b2609f838eb10e9329468d1bd1d558

Summary: It has been years since BEAST attack surfaced. The vulnerabilities have been patched and the mitigation using RC4 cipher is no longer needed. This diff removes the code relevant to mitigating BEAST years ago.

Reviewed By: anirudhvr

Differential Revision: D5409859

fbshipit-source-id: 58178e68a447f372b19491832a7be590af9402e9

Summary: Add an event base getter for AsyncUDPSocket similar to the other socket classes.

Reviewed By: knekritz

Differential Revision: D5498587

fbshipit-source-id: ac3179e03485328417ed9863f6bb790de7c691cb

Summary:
A ConcurrentHashMap with wait-free readers, as in Java's ConcurrentHashMap.

It's a pretty generic closed-addressing chaining hashtable, except find() uses two hazard pointers
to do hand-over-hand traversal of the list, so it never takes a lock.

On rehash, only the part of the chain that remains the same (i.e. is still hashed to the same bucket)
is reused, otherwise we have to allocate new nodes.

Reallocating nodes means we either have to copy the value_type, or add in an extra indirection
to access it.  Both are supported.

There's still a couple opportunities to squeeze some more perf out with optimistic loading
of nodes / cachelines, but I didn't go that far yet, it sill looks pretty good.

Reviewed By: davidtgoldblatt

Differential Revision: D5349966

fbshipit-source-id: 022e8adacd0ddd32b2a4563caa99c0c4878851d8

Summary:
Currently hazard pointers doesn't support stealing any of the pointer bits.
You can *almost* roll it yourself using try_protect, but this prevents
implementations from choosing their type of barrier.

This adds a new get_protected interface that you can use to steal bits, or
otherwise manipulate pointers as you would like.

This also adds a MWMR list based set example that uses it, that is wait-free
for readers (unlike the SWMR example, that is only lock-free).

Reviewed By: magedm

Differential Revision: D5455615

fbshipit-source-id: 53d282eda433e00b6b53cd804d4e1c32c74c2fb8

Summary: Now const-optimizer safe, and safe when the contained value overloads unary operator&

Reviewed By: yfeldblum

Differential Revision: D5480170

fbshipit-source-id: 3b53b0b6ce608857aa29d3f61eccd0b793b4cddc

Reviewed By: yfeldblum

Differential Revision: D5497522

fbshipit-source-id: bb208aeb37b5b9ce99619193d4cd2d0f3fb39178

Summary:
[Folly] Add `FOLLY_HAS_BUILTIN` and use it.

Use it in the definition of `folly::launder`. Of course, since GCC does not have `__has_builtin`, we still have to check its version.

Reviewed By: WillerZ

Differential Revision: D5496748

fbshipit-source-id: 3bd6e89424dfd2c9cb9795ee4d88f66c4294cc4c

Summary:
[Folly] Cut `throwOnFail`.

It is not necessary, and `CHECK_THROW`, its reason for existing, can be implemented without it.

It can also easily be a pessimization because there is no way to delay computation of the arguments to the exception ctor until after the check. So if there is, say, a computation using `sformat` to compute a string argument to the exception ctor, that will always be performed rather than being performed only should the check fail.

Reviewed By: Orvid

Differential Revision: D5478804

fbshipit-source-id: 71a125c126eae76c6e95ef1bd23ee883b1db39a5

Summary:
(1) small_vector.h line 1099: wrap the default return in an else statement to
avoid compiler warning of "unreachable statement".
(2) Constexpr.h: need to treat cudacc similarly to msvc.

(Note: this ignores all push blocking failures!)

Reviewed By: dzhulgakov

Differential Revision: D5387061

fbshipit-source-id: f002ab5ec00d4dcd85d86386f87a0327023afa1b

Summary: [Folly] Move `__CLANG_PREREQ` to `folly/CPortabiilty.h`.

Reviewed By: Orvid

Differential Revision: D5496372

fbshipit-source-id: 710af3d30aa8bd0e5f645beede354e3463f1bb25

Summary:
[Folly] There is no `HAVE_SHADOW_LOCAL_WARNINGS`

It is `FOLLY_HAVE_SHADOW_LOCAL_WARNINGS`.

Reviewed By: Orvid

Differential Revision: D5496247

fbshipit-source-id: 689f40180180465bdc44593059e44fb64cf3e415

Reviewed By: anirudhvr

Differential Revision: D5492790

fbshipit-source-id: 10e868976a7ea42673d5b5c906a53c6c9495a288

Summary: Closes https://github.com/facebook/folly/pull/642

Reviewed By: Orvid

Differential Revision: D5471368

Pulled By: yfeldblum

fbshipit-source-id: 3bbafd04b93828121ba829027959b6b3e0e55888

Summary:
OpenSSL 1.1.0 deprecates the callback based locking setup in favor
for platform native mutexes.

Added `OPENSSL_init_ssl` in the OpenSSL portability module for OpenSSL API < 1.1.0. This implements
the standard OpenSSL library initialization routines (taken from SSLContext::initializeOpenSSL).

Added `OPENSSL_cleanup` in the OpenSSL portability module for OpenSSL API < 1.1.0. This implements
the cleanup routine from SSLContext::cleanupOpenSSL.

Removed `SSLContext::SSLLockType`. Replaced with `folly::ssl::LockType`.

Reviewed By: mzlee, ngoyal

Differential Revision: D5404777

fbshipit-source-id: 7e5d9bf4a6683afb5560ada0a5b73cac3ff2662b

Summary:
If an exception is thrown during the construction of value in a container, then the Transformer iterator will not successfully reconstruct a cache_ object after explicitly calling its destructor (due to the exception being thrown), which results in a double-free when cache_ is destroyed as part of Transformer's destructor.

Conveniently, there exists a piece of code designed to solve just this problem: folly::Optional. Replace cache_ and valid_ with folly::Optional.

This also fixes the unnecessary requirement that container value types have default constructors, since cache_ is no longer default constructed inside of Transformer.

Reviewed By: markisaa

Differential Revision: D5472342

fbshipit-source-id: eade1f7ce260b9b3406d92af8255b5ffa4e4a51c

Summary:
An instance of `Replaceable<T>` wraps an instance of `T`.

You access the inner `T` instance with `operator*` and `operator->` (as if
it were a smart pointer).

`Replaceable<T>` adds no indirection cost and performs no allocations.

`Replaceable<T>` has the same size and alignment as `T`.

You can replace the `T` within a `Replaceable<T>` using the `emplace` method
(presuming that it is constructible and destructible without throwing
exceptions). If the destructor or constructor you're using could throw an
exception you should use `Optional<T>` instead, as it's not a logic error for
that to be empty.

Reviewed By: yfeldblum

Differential Revision: D5346528

fbshipit-source-id: c7d72e73ea04e371325327a7ff0b345315d6e5ac

Summary:
[Folly] Move the SpookyHash libraries into `folly/hash`.

And propagate the changes to `#include` lines, etc.

Reviewed By: Orvid

Differential Revision: D5477735

fbshipit-source-id: 94fe95ece05b52bde1466ab5f9fb8b53a4c59bed