}
}
-} // namespace folly
+} // namespace folly
template <>
struct IsArenaAllocator<SysArena> : std::true_type { };
-} // namespace folly
+} // namespace folly
#include <folly/Arena-inl.h>
#endif
}
-} // namespace folly
+} // namespace folly
return test(idx);
}
-} // namespaces
+} // namespace folly
DCHECK_NE(key_in, lockedKey);
DCHECK_NE(key_in, erasedKey);
}
-} // namespace detail
+} // namespace detail
template <
class KeyT,
constexpr static bool value = !folly::IsTriviallyCopyable<Decayed>::value ||
sizeof(Decayed) > sizeof(long) || std::is_pointer<Decayed>::value;
};
-} // detail namespace
+} // namespace detail
template <typename T>
auto doNotOptimizeAway(const T& datum) -> typename std::enable_if<
}
};
-} // namespace detail
+} // namespace detail
// big* convert between native and big-endian representations
// little* convert between native and little-endian representations
}
}
-} // namespace folly
+} // namespace folly
return crc_sw<CRC32_POLYNOMIAL>(data, nbytes, startingChecksum);
}
-} // folly::detail
+} // namespace detail
uint32_t crc32c(const uint8_t *data, size_t nbytes,
uint32_t startingChecksum) {
return ~crc32(data, nbytes, startingChecksum);
}
-} // folly
+} // namespace folly
uint32_t
crc32_type(const uint8_t* data, size_t nbytes, uint32_t startingChecksum = ~0U);
-} // folly
+} // namespace folly
return true;
}
-} // anonymous namespace
+} // namespace
Expected<bool, ConversionCode> str_to_bool(StringPiece* src) noexcept {
auto b = src->begin(), e = src->end();
namespace detail {
constexpr int kConvMaxDecimalInShortestLow = -6;
constexpr int kConvMaxDecimalInShortestHigh = 21;
-} // folly::detail
+} // namespace detail
/** Wrapper around DoubleToStringConverter **/
template <class Tgt, class Src>
toAppend(delim, detail::getLastElement(vs...));
toAppendDelimStrImpl(delim, vs...);
}
-} // folly::detail
-
+} // namespace detail
/**
* Variadic conversion to string. Appends each element in turn.
uint32_t f7c_ = 0;
};
-} // namespace folly
+} // namespace folly
buf->total += size;
}
-} // namespace
+} // namespace
size_t demangle(const char* name, char* out, size_t outSize) {
#ifdef FOLLY_DEMANGLE_MAX_SYMBOL_SIZE
return len;
}
-} // folly
+} // namespace folly
return variant.apply(std::forward<Visitor>(visitor));
}
-} // namespace folly
+} // namespace folly
std::size_t clearSize_;
};
-} // folly
+} // namespace folly
} \
} while (0)
-} // namespace folly
+} // namespace folly
return ew.what();
}
-} // folly
+} // namespace folly
return exception_wrapper(std::current_exception(), ex);
}
}
-} // detail
+} // namespace detail
//! `try_and_catch` is a simple replacement for `try {} catch(){}`` that allows
//! you to specify which derived exceptions you would like to catch and store in
exception_wrapper try_and_catch(F&& fn) {
return detail::try_and_catch_<F, Exceptions...>(std::forward<F>(fn));
}
-} // folly
+} // namespace folly
#include <folly/ExceptionWrapper-inl.h>
}
};
-} // folly
+} // namespace folly
FOLLY_FBSTRING_HASH
-} // namespace std
+} // namespace std
#undef FOLLY_FBSTRING_HASH
#undef FOLLY_FBSTRING_HASH1
: public IndexableTraitsSeq<fbvector<T, A>> {
};
-} // namespace detail
+} // namespace detail
template <class T, class A>
void compactResize(fbvector<T, A>* v, size_t sz) {
}
void File::unlock_shared() { unlock(); }
-} // namespace folly
+} // namespace folly
void swap(File& a, File& b);
-
-} // namespace folly
+} // namespace folly
writeFileAtomic(filename, ByteRange(data), permissions);
}
-} // namespaces
+} // namespace folly
int count,
mode_t permissions = 0644);
-} // namespaces
+} // namespace folly
return out;
}
-} // namespace folly
+} // namespace folly
extern const FormatArg::Align formatAlignTable[];
extern const FormatArg::Sign formatSignTable[];
-} // namespace detail
+} // namespace detail
using namespace folly::detail;
remaining_digits -= current_group_size;
}
}
-} // detail
+} // namespace detail
-} // namespace folly
+} // namespace folly
typename std::enable_if<
std::is_same<typename T::IsFormatter, detail::FormatterTag>::value>::
type> : public std::true_type {};
-} // folly::detail
+} // namespace detail
// Deprecated API. formatChecked() et. al. now behave identically to their
// non-Checked counterparts.
}
}
-} // namespace folly
+} // namespace folly
0xffffffffffffffffULL
};
-} // namespace folly
+} // namespace folly
#endif
namespace folly {
namespace detail {
alignas(16) extern const uint64_t groupVarintSSEMasks[];
-} // namespace detail
-} // namespace folly
+} // namespace detail
+} // namespace folly
#endif
namespace folly {
namespace detail {
extern const uint8_t groupVarintLengths[];
-} // namespace detail
-} // namespace folly
+} // namespace detail
+} // namespace folly
namespace folly {
typedef GroupVarintDecoder<uint32_t> GroupVarint32Decoder;
typedef GroupVarintDecoder<uint64_t> GroupVarint64Decoder;
-} // namespace folly
+} // namespace folly
#endif /* FOLLY_X64 || defined(__i386__) || FOLLY_PPC64 */
"Can't convert address with family ", fam, " to AF_INET6 address"));
}
-
-} // folly
+} // namespace folly
return !(a < b);
}
-} // folly
+} // namespace folly
namespace std {
template <>
return addr.hash();
}
};
-} // std
+} // namespace std
default;
};
-} // folly
+} // namespace folly
return {IPAddressV4(prefix.first), prefix.second};
}
-} // folly
+} // namespace folly
return !(a < b);
}
-} // folly
+} // namespace folly
namespace std {
template <>
return addr.hash();
}
};
-} // std
+} // namespace std
auto masked = mask(numBits);
return (std::memcmp(addr.data(), masked.bytes(), 2) == 0);
}
-} // folly
+} // namespace folly
void toAppend(IPAddressV6 addr, std::string* result);
void toAppend(IPAddressV6 addr, fbstring* result);
-} // folly
+} // namespace folly
namespace std {
template <>
return addr.hash();
}
};
-} // std
+} // namespace std
boost::intrusive::member_hook<T, SafeIntrusiveListHook, PtrToMember>,
boost::intrusive::constant_time_size<true>>;
-} // folly
+} // namespace folly
emplace_iterator_impl& operator=(const emplace_iterator_impl&) = default;
emplace_iterator_impl& operator=(emplace_iterator_impl&&) noexcept = default;
};
-} // folly::detail
+} // namespace detail
/**
* Behaves just like std::insert_iterator except that it calls emplace()
}
};
-} // detail
+} // namespace detail
/**
* LockTraits describes details about a particular mutex type.
}
};
-} // folly
+} // namespace folly
return mutex.try_lock_for(detail::toBoostDuration(timeout));
}
};
-} // folly
+} // namespace folly
#endif // FOLLY_LOCK_TRAITS_HAVE_TIMED_MUTEXES
StageTuple stages_;
};
-
-} // namespaces
+} // namespace folly
return os;
}
-} // folly
+} // namespace folly
std::ostream& operator<<(std::ostream& os, MacAddress address);
-} // folly
+} // namespace folly
sformat("mallctl {}: {} ({})", cmd, errnoStr(err), err));
}
-} // detail
+} // namespace detail
-} // folly
+} // namespace folly
}
}
-} // detail
+} // namespace detail
template <typename T>
void mallctlRead(const char* cmd, T* out) {
mallctlRead<unsigned>(cmd, nullptr);
}
-} // folly
+} // namespace folly
_GLIBCXX_END_NAMESPACE_VERSION
#endif
-} // folly
+} // namespace folly
#endif // !defined(_GLIBCXX_USE_FB) || defined(_LIBSTDCXX_FBSTRING)
}
return detail::extract_default(keysDefault...);
}
-} // namespace folly
+} // namespace folly
#endif
-} // namespace folly
+} // namespace folly
inline void getDeviceOptions(dev_t, off_t&, bool&) {}
#endif
-} // namespace
+} // namespace
void MemoryMapping::init(off_t offset, off_t length) {
const bool grow = options_.grow;
return true;
}
-} // anonymous namespace
+} // namespace
bool MemoryMapping::mlock(LockMode lock) {
size_t amountSucceeded = 0;
srcMap.range().size());
}
-} // namespace folly
+} // namespace folly
*/
void mmapFileCopy(const char* src, const char* dest, mode_t mode = 0666);
-} // namespace folly
+} // namespace folly
namespace folly {
-namespace details {
+namespace detail {
template <typename...>
struct Overload;
using Case::operator();
};
-} // details
+} // namespace detail
/*
* Combine multiple `Cases` in one function object
*/
template <typename... Cases>
decltype(auto) overload(Cases&&... cases) {
- return details::Overload<typename std::decay<Cases>::type...>{
+ return detail::Overload<typename std::decay<Cases>::type...>{
std::forward<Cases>(cases)...};
}
overload(std::forward<Cases>(cases)...), std::forward<Variant>(variant));
}
-} // folly
+} // namespace folly
NS % alignof(T) == 0)>::type> {
typedef void type;
};
-} // namespace detail
+} // namespace detail
template <class T, size_t NS>
class Node<T, NS, typename detail::NodeValid<T,NS>::type> {
> type;
};
-} // namespace detail
+} // namespace detail
/**
* Wrapper around iterators to Node to return iterators to the underlying
size_t lastCount_; // number of elements in last Node
};
-} // namespace padded
-} // namespace folly
+} // namespace padded
+} // namespace folly
namespace FOLLY_GFLAGS_NAMESPACE { }
namespace gflags {
using namespace FOLLY_GFLAGS_NAMESPACE;
-} // namespace gflags
+} // namespace gflags
#endif
// for TARGET_OS_IPHONE
}
#endif
};
-} // detail
+} // namespace detail
template <size_t kBitWidth, bool kFavorWriter = false>
class RWTicketSpinLockT {
#endif // RW_SPINLOCK_USE_X86_INTRINSIC_
-} // namespace folly
+} // namespace folly
#ifdef RW_SPINLOCK_USE_X86_INTRINSIC_
#undef RW_SPINLOCK_USE_X86_INTRINSIC_
std::array<uint32_t, stateSize> seedData;
};
-} // namespace detail
+} // namespace detail
template <class RNG, class /* EnableIf */>
void Random::seed(RNG& rng) {
return RNG(s);
}
-} // namespaces
+} // namespace folly
void writeStderr(const char* s) {
writeStderr(s, strlen(s));
}
-} // namespace
+} // namespace
void assertionFailure(const char* expr, const char* msg, const char* file,
unsigned int line, const char* function) {
}
} // namespace detail
-} // folly
+} // namespace folly
#define SCOPE_EXIT \
auto FB_ANONYMOUS_VARIABLE(SCOPE_EXIT_STATE) \
return quoted + "'";
}
-} // folly
+} // namespace folly
return detail::shellify(format, std::forward<Arguments>(arguments)...);
}
-} // folly
+} // namespace folly
char* allocated;
};
-} // unnamed namespace
+} // namespace
namespace folly {
return os;
}
-} // folly
+} // namespace folly
// an octal escape sequence, or 'P' if the character is printable and
// should be printed as is.
extern const char cEscapeTable[];
-} // namespace detail
+} // namespace detail
template <class String>
void cEscape(StringPiece str, String& out) {
// Map from the character code to the hex value, or 16 if invalid hex char.
extern const unsigned char hexTable[];
-} // namespace detail
+} // namespace detail
template <class String>
void cUnescape(StringPiece str, String& out, bool strict) {
// 3 = space, replace with '+' in QUERY mode
// 4 = percent-encode
extern const unsigned char uriEscapeTable[];
-} // namespace detail
+} // namespace detail
template <class String>
void uriEscape(StringPiece str, String& out, UriEscapeMode mode) {
internalJoinAppend(delimiter, begin, end, output);
}
-} // namespace detail
+} // namespace detail
template <class Delim, class Iterator, class String>
void join(const Delim& delimiter,
*/
size_t hexDumpLine(const void* ptr, size_t offset, size_t size,
std::string& line);
-} // namespace detail
+} // namespace detail
template <class OutIt>
void hexDump(const void* ptr, size_t size, OutIt out) {
}
}
-} // namespace folly
+} // namespace folly
output.append(heap_buffer.get(), size_t(final_bytes_used));
}
-} // anon namespace
+} // namespace
std::string stringPrintf(const char* format, ...) {
va_list ap;
kPrettySISuffixes,
};
-} // namespace
+} // namespace
std::string prettyPrint(double val, PrettyType type, bool addSpace) {
char buf[100];
c += rotated;
}
-} // anon namespace
+} // namespace
void toLowerAscii(char* str, size_t length) {
static const size_t kAlignMask64 = 7;
return join("\n", piecer);
}
-} // namespace folly
+} // namespace folly
#ifdef FOLLY_DEFINED_DMGL
# undef FOLLY_DEFINED_DMGL
}
}
-} // namespace
+} // namespace
Subprocess::Options& Subprocess::Options::fd(int fd, int action) {
if (action == Subprocess::PIPE) {
_exit(errCode);
}
-} // namespace
+} // namespace
void Subprocess::setAllNonBlocking() {
for (auto& p : pipes_) {
}
}
-} // namespace
+} // namespace
std::pair<std::string, std::string> Subprocess::communicate(
StringPiece input) {
Initializer initializer;
-} // namespace
+} // namespace
-} // namespace folly
+} // namespace folly
std::vector<Pipe> pipes_;
};
-} // namespace folly
+} // namespace folly
std::is_const<SynchronizedType>::value,
typename SynchronizedType::ConstLockedPtr,
typename SynchronizedType::LockedPtr>::type;
-} // detail
+} // namespace detail
/**
* A helper base class for implementing LockedPtr.
return result;
}
-} // namespace folly
+} // namespace folly
template <>
struct IsArenaAllocator<ThreadCachedArena> : std::true_type { };
-} // namespace folly
+} // namespace folly
mutable typename StaticMeta::EntryID id_;
};
-} // namespace folly
+} // namespace folly
return nextExp;
}
-} // namespace folly
+} // namespace folly
Id nextId_;
};
-} // namespace folly
+} // namespace folly
FOLLY_POP_WARNING
-} // namespace detail {
+} // namespace detail
// same as `x < 0`
template <typename T>
std::forward<std::tuple<folly::Try<Ts>...>>(ts));
}
-} // folly
+} // namespace folly
template <typename... Ts>
std::tuple<Ts...> unwrapTryTuple(std::tuple<folly::Try<Ts>...>&& ts);
-} // folly
+} // namespace folly
#include <folly/Try-inl.h>
#endif
}
-} // namespaces
+} // namespace folly
}
}
-} // namespace
+} // namespace
Uri::Uri(StringPiece str) : hasAuthority_(false), port_(0) {
static const boost::regex uriRegex(
return queryParams_;
}
-} // namespace folly
+} // namespace folly
std::vector<std::pair<std::string, std::string>> queryParams_;
};
-} // namespace folly
+} // namespace folly
#include <folly/Uri-inl.h>
return val;
}
-} // folly
+} // namespace folly
CHECK_ERR(fprintf(file, "\n};\n\n"));
}
-} // namespace
+} // namespace
int main(int argc, char *argv[]) {
gflags::ParseCommandLineFlags(&argc, &argv, true);
f.write("""
};
-} // namespace detail
-} // namespace folly
+} // namespace detail
+} // namespace folly
""")
def main():
Atom<Buckets*> buckets_{nullptr};
Mutex m_;
};
-}
-} // folly::detail namespace
+} // namespace detail
+} // namespace folly
ssize_t> type;
};
-
-} // namespace bititerator_detail
-} // namespace folly
+} // namespace bititerator_detail
+} // namespace folly
typename ConstVisitorResult<V, Types...>::type,
Types...>;
-} // namespace dptr_detail
-} // namespace folly
+} // namespace dptr_detail
+} // namespace folly
uint64_t val_[1 + DEG/64];
};
-} // namespace detail
-} // namespace folly
+} // namespace detail
+} // namespace folly
using namespace std::chrono;
-namespace folly { namespace detail {
+namespace folly {
+namespace detail {
namespace {
return FutexResult::AWOKEN;
}
-} // anon namespace
-
+} // namespace
/////////////////////////////////
// Futex<> specializations
this, expected, absSystemTime, absSteadyTime, waitMask);
}
-}} // namespace folly::detail
+} // namespace detail
+} // namespace folly
enum { kFullGroupSize = kHeaderSize + kGroupSize * sizeof(type) };
};
-} // namespace detail
-} // namespace folly
+} // namespace detail
+} // namespace folly
FingerprintPolynomial<BITS-1> fp_;
};
-} // namespace detail
-} // namespace folly
+} // namespace detail
+} // namespace folly
}
};
-} // namespace threadlocal_detail
-} // namespace folly
+} // namespace threadlocal_detail
+} // namespace folly
const detail::DefaultValueWrapper<dynamic, V>& val_;
};
-} // namespaces
+} // namespace folly
#undef FB_DYNAMIC_APPLY
}
};
-} // namespace detail
+} // namespace detail
/**
* Wrapper class with static methods for various bit-level operations,
return n;
}
-} // namespace folly
+} // namespace folly
invokeForKeyValue(Fn fn, const folly::dynamic& k, const folly::dynamic& v) {
fn(k.asInt(), v.asString());
}
-} // namespace detail
+} // namespace detail
template <typename Fn>
void DynamicParser::optional(const folly::dynamic& key, Fn fn) {
return *value_;
}
-} // namespace folly
+} // namespace folly
"Unsupported key type ", key.typeName(), " of ", detail::toPseudoJson(key)
);
}
-} // anonymous namespace
+} // namespace
void DynamicParser::reportError(
const folly::dynamic* lookup_k,
ss << d;
return ss.str();
}
-} // namespace detail
+} // namespace detail
-} // namespace folly
+} // namespace folly
// Firstly, the input dynamic need not correspond to valid JSON. Secondly,
// wrapError() uses integer-keyed objects to report arrary-indexing errors.
std::string toPseudoJson(const folly::dynamic& d);
-} // namespace detail
+} // namespace detail
/**
* With DynamicParser::OnError::THROW, reports the first error.
bool allowNonStringKeyErrors_{false}; // See the setter's docblock.
};
-} // namespace folly
+} // namespace folly
#include <folly/experimental/DynamicParser-inl.h>
ValueType value_;
};
-} // namespace detail
+} // namespace detail
// If kUnchecked = true the caller must guarantee that all the
// operations return valid elements, i.e., they would never return
}
}
-} // namespace folly
+} // namespace folly
} // outer while loop
}
-} // namespace folly {
+} // namespace folly
milliseconds operator()() { return milliseconds(dist(generator)); }
};
-} // anonymous namespace
+} // namespace
FunctionScheduler::FunctionScheduler() {}
virtual ~FutureDAGFunctor(){}
};
-} // folly
+} // namespace folly
#endif
}
};
-}
-}
-} // namespaces
+} // namespace instructions
+} // namespace compression
+} // namespace folly
return *instance;
}
-} // folly
+} // namespace folly
*/
JemallocNodumpAllocator& globalJemallocNodumpAllocator();
-} // folly
+} // namespace folly
}
}
-} // namespace
+} // namespace
ProgramExit::ProgramExit(int status, const std::string& msg)
: std::runtime_error(msg),
info.command(vm, cmdArgs);
}
-} // namespaces
+} // namespace folly
std::map<std::string, std::string> aliases_;
};
-} // namespaces
+} // namespace folly
#undef X
};
-} // namespace
+} // namespace
po::options_description getGFlags(ProgramOptionsStyle style) {
static const std::unordered_set<std::string> gSkipFlags{
return result;
}
-} // namespace
+} // namespace
NestedCommandLineParseResult parseNestedCommandLine(
int argc, const char* const argv[],
return doParseNestedCommandLine(po::command_line_parser(cmdline), desc);
}
-} // namespaces
+} // namespace folly
const std::vector<std::string>& cmdline,
const boost::program_options::options_description& desc);
-} // namespaces
+} // namespace folly
.deallocate(const_cast<char*>(piece.data()), piece.size());
}
-} // folly
+} // namespace folly
}
};
-} // folly
+} // namespace folly
using StringKeyedSet = StringKeyedSetBase<>;
-} // folly
+} // namespace folly
}
};
-} // folly
+} // namespace folly
typedef BasicStringKeyedUnorderedSet<> StringKeyedUnorderedSet;
-} // folly
+} // namespace folly
return path;
}
-} // namespace
+} // namespace
TemporaryFile::TemporaryFile(StringPiece namePrefix,
fs::path dir,
return !hasPCREPatternMatch(pattern, target);
}
-} // namespace detail
+} // namespace detail
CaptureFD::CaptureFD(int fd, ChunkCob chunk_cob)
: chunkCob_(std::move(chunk_cob)), fd_(fd), readOffset_(0) {
return std::string(buf.get(), size);
}
-} // namespace test
-} // namespace folly
+} // namespace test
+} // namespace folly
)
namespace detail {
- bool hasPCREPatternMatch(StringPiece pattern, StringPiece target);
- bool hasNoPCREPatternMatch(StringPiece pattern, StringPiece target);
-} // namespace detail
+bool hasPCREPatternMatch(StringPiece pattern, StringPiece target);
+bool hasNoPCREPatternMatch(StringPiece pattern, StringPiece target);
+} // namespace detail
/**
* Use these patterns together with CaptureFD and EXPECT_PCRE_MATCH() to
off_t readOffset_; // for incremental reading
};
-} // namespace test
-} // namespace folly
+} // namespace test
+} // namespace folly
}
};
-} // namespace detail
+} // namespace detail
// Return a tuple consisting of the elements at a range of indices.
//
std::forward<U>(cdr));
}
-} // namespaces
+} // namespace folly
__cxa_eh_globals* __cxa_get_globals_fast(void) noexcept;
}
-} // namespace __cxxabiv1
+} // namespace __cxxabiv1
GetExceptionStackTraceStackType getExceptionStackTraceStackFn;
}
-} // namespace
+} // namespace
namespace folly {
namespace exception_tracer {
return (exc->unwindHeader.exception_class & 0xffffffff) == cppClass;
}
-} // namespace
+} // namespace
std::vector<ExceptionInfo> getCurrentExceptions() {
struct Once {
origUnexpected();
}
-} // namespace
+} // namespace
void installHandlers() {
struct Once {
static Once once;
}
-} // namespace exception_tracer
-} // namespace folly
+} // namespace exception_tracer
+} // namespace folly
*/
void installHandlers();
-} // namespace exception_tracer
-} // namespace folly
+} // namespace exception_tracer
+} // namespace folly
DECLARE_CALLBACK(CxaEndCatch);
DECLARE_CALLBACK(RethrowException);
-} // exception_tracer
-} // folly
+} // namespace exception_tracer
+} // namespace folly
// Clang is smart enough to understand that the symbols we're loading
// are [[noreturn]], but GCC is not. In order to be able to build with
}
};
-} // namespace folly {
+} // namespace folly
Data data_;
};
-} // namespace folly {
+} // namespace folly
}
}
-} // namespace test {
-} // namespace folly {
+} // namespace test
+} // namespace folly
std::cout << "----------------------------------------------------------\n";
}
-} // namespace hazptr {
-} // namespace folly {
+} // namespace hazptr
+} // namespace folly
/*
------------------------------------------- no amb - no tc
std::atomic<Node*> head_ = {nullptr};
};
-} // namespace folly {
-} // namespace hazptr {
+} // namespace folly
+} // namespace hazptr
}
};
-} // namespace folly {
-} // namespace hazptr {
+} // namespace folly
+} // namespace hazptr
}
};
-} // namespace folly {
-} // namespace hazptr {
+} // namespace folly
+} // namespace hazptr
}
};
-} // namespace folly {
-} // namespace hazptr {
+} // namespace folly
+} // namespace hazptr
return &mr;
}
-} // namespace folly {
-} // namespace hazptr {
+} // namespace folly
+} // namespace hazptr
char a[100];
};
-} // namespace folly {
-} // namespace hazptr {
+} // namespace folly
+} // namespace hazptr
delete p;
}
-} // namespace folly {
-} // namespace hazptr {
+} // namespace folly
+} // namespace hazptr
return os;
}
-} // anonymous namespace
+} // namespace
std::ostream& operator<<(std::ostream& os, const AsyncIOOp& op) {
os << "{" << op.state_ << ", ";
testReadsQueued(specs, pollMode);
}
-} // anonymous namespace
+} // namespace
TEST(AsyncIO, ZeroAsyncDataNotPollable) {
testReads({{0, 0}}, AsyncIO::NOT_POLLABLE);
return formatter.formatMessage(logMessage, category);
}
-} // unnamed namespace
+} // namespace
TEST(GlogFormatter, log) {
auto tid = getOSThreadID();
idx = end + 1;
}
}
-} // unnamed namespace
+} // namespace
std::string getXlogCategoryNameForFile(StringPiece filename) {
// Buck mangles the directory layout for header files. Rather than including
return !(term == nullptr || term[0] == '\0' || strcmp(term, "dumb") == 0);
}
-} // anonymous namespace
+} // namespace
OStreamSymbolizePrinter::OStreamSymbolizePrinter(std::ostream& out, int options)
: SymbolizePrinter(options, isColorfulTty(options, getFD(out))),
CHECK_LE(value, std::numeric_limits<T>::max());
return static_cast<T>(value);
}
-} // anonymous namespace
+} // namespace
TEST(Bits, Boundaries) {
uint8_t buf[20];
return uint8_t(folly::findLastSet(upperBound / size) - 1);
}
-} // namespace
+} // namespace
TEST(EliasFanoCoding, defaultNumLowerBits) {
// Verify that slowDefaultNumLowerBits and optimized
list.free();
}
-} // namespace bm
+} // namespace bm
BENCHMARK(Next, iters) {
bmNext<bm::Reader>(bm::list, bm::data, iters);
}
}
-} // namespace
+} // namespace
TEST(EventCount, Simple) {
// We're basically testing for no deadlock.
usleep(usec.count());
}
-} // unnamed namespace
+} // namespace
TEST(FunctionScheduler, StartAndShutdown) {
FunctionScheduler fs;
};
std::atomic<int> PThreadCreateFailure::forceFailure_{0};
-} // unnamed namespce
+} // namespace
// Replace the system pthread_create() function with our own stub, so we can
// trigger failures in the StartThrows() test.
}
}
-} // namespace
+} // namespace
int main(int argc, char *argv[]) {
// Initialize a NestedCommandLineApp object.
return p.first;
}
-} // namespace
+} // namespace
TEST(ProgramOptionsTest, Errors) {
callHelper({}, 1);
}
}
-} // namespace
+} // namespace
int main(int argc, char *argv[]) {
folly::NestedCommandLineApp app("", "0.1", "", "", init);
return p.first;
}
-} // namespace
+} // namespace
// name value
name.c_str(),
folly::to<std::string>(v.as<T>()).c_str());
}
-} // namespace
+} // namespace
int main(int argc, char *argv[]) {
po::options_description desc;
}
} // namespace fibers
-} // manespace folly
+} // namespace folly
FiberContext fiberContext_;
MainContext mainContext_;
};
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
delay_ms = std::max<decltype(delay_ms)>(delay_ms, 0);
eventBase_->tryRunAfterDelay(func, uint32_t(delay_ms));
}
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
friend class FiberManager;
};
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
#include "EventBaseLoopController-inl.h"
reinterpret_cast<T*>(ptr)->~T();
freeHeapBuffer(ptr);
}
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
return (end - firstNonMagic) * sizeof(uint64_t);
}
-} // anonymous namespace
+} // namespace
void Fiber::resume() {
DCHECK_EQ(state_, AWAITING);
return opts;
}
-} // anonymous
+} // namespace
inline void FiberManager::ensureLoopScheduled() {
if (isLoopScheduled_) {
g(id);
}
-} // anonymous namespace
+} // namespace
template <class InputIterator, class F>
inline void forEach(InputIterator first, InputIterator last, F&& f) {
std::rethrow_exception(e);
}
}
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
*/
template <class InputIterator, class F>
inline void forEach(InputIterator first, InputIterator last, F&& f);
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
#include <folly/fibers/ForEach-inl.h>
fallbackAllocator_.deallocate(limit, size);
}
}
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
std::allocator<unsigned char> fallbackAllocator_;
bool useGuardPages_{true};
};
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
*/
virtual void timedSchedule(std::function<void()> func, TimePoint time) = 0;
};
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
friend class FiberManager;
};
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
EXPECT_EQ(numResultsFilled, expectedNumResults);
}
-} // AtomicBatchDispatcherTesting
+} // namespace AtomicBatchDispatcherTesting
#define SET_UP_TEST_FUNC \
using namespace AtomicBatchDispatcherTesting; \
typedef First type;
};
-} // detail
+} // namespace detail
/** Default - use boost */
template <typename F, typename Enable = void>
typedef
typename detail::ExtractFirstMemfn<decltype(&F::operator())>::type type;
};
-}
-} // folly::fibers
+} // namespace fibers
+} // namespace folly
virtual void drive() = 0;
};
-} // folly
+} // namespace folly
}
};
-} // folly
+} // namespace folly
#include <folly/futures/Future-inl.h>
run();
}
-} // folly
+} // namespace folly
}
};
-} // folly
+} // namespace folly
return timekeeperSingleton_.try_get();
}
-} // detail
+} // namespace detail
-} // folly
+} // namespace folly
HHWheelTimer::UniquePtr wheelTimer_;
};
-} // folly
+} // namespace folly
}
}
-} // anonymous namespace
+} // namespace
BENCHMARK(constantFuture) {
makeFuture(42);
cv_.notify_one();
}
-} // folly
+} // namespace folly
std::vector<std::thread> workers_;
};
-} // folly
+} // namespace folly
inline detail::Batch batch(size_t batchSize) {
return detail::Batch(batchSize);
}
-} // gen
-} // folly
+} // namespace gen
+} // namespace folly
FOLLY_POP_WARNING
return UnwrapOr(std::forward<Fallback>(fallback));
}
-} // gen
-} // folly
+} // namespace gen
+} // namespace folly
#include <folly/gen/Base-inl.h>
static constexpr bool infinite = First::infinite || Second::infinite;
};
-} // detail
-} // gen
-} // folly
+} // namespace detail
+} // namespace gen
+} // namespace folly
FOLLY_POP_WARNING
template <class Value, class First, class Second>
class Chain;
-} // detail
-} // gen
-} // folly
+} // namespace detail
+} // namespace gen
+} // namespace folly
#include <folly/gen/Core-inl.h>
*hash2 = h1;
}
-} // namespace hash
-} // namespace folly
+} // namespace hash
+} // namespace folly
uint8_t m_remainder; // length of unhashed data stashed in m_data
};
-} // namespace hash
-} // namespace folly
+} // namespace hash
+} // namespace folly
*hash2 = h1;
}
-} // namespace hash
-} // namespace folly
+} // namespace hash
+} // namespace folly
uint8_t m_remainder; // length of unhashed data stashed in m_data
};
-} // namespace hash
-} // namespace folly
+} // namespace hash
+} // namespace folly
void init(int* argc, char*** argv, bool removeFlags = true);
-} // folly
+} // namespace folly
}
}
-} // unnamed namespace
+} // namespace
namespace folly {
}
}
-} // folly
+} // namespace folly
std::unique_ptr<T, D>,
typename std::enable_if<std::is_standard_layout<T>::value>::type>
: public std::true_type { };
-} // namespace detail
+} // namespace detail
class IOBuf {
public:
inline IOBuf::Iterator IOBuf::begin() const { return cbegin(); }
inline IOBuf::Iterator IOBuf::end() const { return cend(); }
-} // folly
+} // namespace folly
FOLLY_POP_WARNING
}
}
-} // anonymous namespace
+} // namespace
namespace folly {
}
}
-} // folly
+} // namespace folly
std::unique_ptr<folly::IOBuf> head_;
};
-} // folly
+} // namespace folly
}
}
-} // folly
+} // namespace folly
}
};
-} // folly
+} // namespace folly
return nullptr;
}
-} // anonymous namespace
+} // namespace
namespace folly {
}
}
-
-
-} // folly
+} // namespace folly
ConnectionEventCallback* connectionEventCallback_{nullptr};
};
-} // folly
+} // namespace folly
handler->signalReceived(int(signum));
}
-} // folly
+} // namespace folly
SignalEventMap signalEvents_;
};
-} // folly
+} // namespace folly
bufferCallback_ = cb;
}
-} // folly
+} // namespace folly
#pragma vtordisp(pop)
#endif
-} // folly
+} // namespace folly
}
};
-} // folly
+} // namespace folly
timeout->timeoutExpired();
}
-} // folly
+} // namespace folly
TCallback callback_;
};
-} // namespace detail {
+} // namespace detail
template <typename TCallback>
std::unique_ptr<AsyncTimeout> AsyncTimeout::make(
return wrapper;
}
-} // folly
+} // namespace folly
virtual std::string getSecurityProtocol() const { return ""; }
};
-} // folly
+} // namespace folly
bool reusePort_{false};
};
-} // Namespace
+} // namespace folly
return registerHandler(uint16_t(flags | PERSIST));
}
-} // Namespace
+} // namespace folly
bool reusePort_{false};
};
-} // Namespace
+} // namespace folly
delete this;
}
};
-} // folly
+} // namespace folly
const DelayedDestructionBase::IntrusivePtr<RightAliasType>& right) {
return left != right.get();
}
-} // folly
+} // namespace folly
return *virtualEventBase_;
}
-} // folly
+} // namespace folly
return runImmediatelyOrRunInEventBaseThreadAndWait([=] { fn(arg); });
}
-} // folly
+} // namespace folly
return info->eventBase;
}
-} // folly
+} // namespace folly
std::shared_ptr<folly::EventBaseObserver> observer_;
};
-} // folly
+} // namespace folly
return false;
}
-} // folly
+} // namespace folly
EventBase* eventBase_;
};
-} // folly
+} // namespace folly
}
};
-} // folly
+} // namespace folly
}
}
-} // folly
+} // namespace folly
}
};
-} // folly
+} // namespace folly
std::forward<TCallback>(callback)));
}
-} // folly
+} // namespace folly
return os;
}
-} // folly
+} // namespace folly
std::ostream& os,
const folly::PasswordCollector& collector);
-} // folly
+} // namespace folly
setSignatureAlgorithms<SSLCommonOptions>(ctx);
}
-} // ssl
-} // folly
+} // namespace ssl
+} // namespace folly
}
}
-} // ssl
-} // folly
+} // namespace ssl
+} // namespace folly
std::unique_ptr<CobTimeouts> cobTimeouts_;
};
-} // folly
+} // namespace folly
BIO_set_fd(b, sock, flags);
}
-} // ssl
-} // folly
+} // namespace ssl
+} // namespace folly
namespace {
#ifdef OPENSSL_IS_BORINGSSL
static void setBioFd(BIO* b, int fd, int flags);
};
-} // ssl
-} // folly
+} // namespace ssl
+} // namespace folly
std::vector<uint16_t> clientHelloSupportedVersions_;
};
-} // ssl
-} // folly
+} // namespace ssl
+} // namespace folly
return buf;
}
-} // anonymous namespace
-
+} // namespace
TEST_F(AsyncPipeTest, simple) {
for (int pass = 0; pass < 2; ++pass) {
}
};
Initializer initializer;
-} // anonymous
+} // namespace
#endif
EXPECT_TRUE(f.within(std::chrono::seconds(3)).get());
}
-
-} // folly
+} // namespace folly
int main(int argc, char *argv[]) {
#ifdef SIGPIPE
EXPECT_NE(expected, value);
}
-} // namespace folly {
+} // namespace folly
::testing::ExitedWithCode(0),
"SSLContextLocksSetAfterInitIgnored passed");
}
-} // folly
+} // namespace folly
int main(int argc, char* argv[]) {
#ifdef SIGPIPE
// allowing the resulting methods to be inline-able. If you think that
// seems hacky keep reading...
struct FollyMemoryDetailTranslationUnitTag {};
-} // anon namespace
+} // namespace
namespace folly {
namespace detail {
void unsafeStringSetLargerSize(std::string& s, std::size_t n);
folly::NotificationQueue<Func>::SimpleConsumer consumer_{queue_};
}; // NotificationQueueExecutor
-} // python
-} // folly
+} // namespace python
+} // namespace folly
getExecutor(), std::move(futureFrom), std::move(callback), userData);
}
-} // python
-} // folly
+} // namespace python
+} // namespace folly
//////////////////////////////////////////////////////////////////////
-} // small_vector_policy
+} // namespace small_vector_policy
//////////////////////////////////////////////////////////////////////
: public IndexableTraitsSeq<small_vector<T, M, A, B, C>> {
};
-} // namespace detail
+} // namespace detail
-} // namespace folly
+} // namespace folly
FOLLY_POP_WARNING
return detail::isSSLLockDisabled(lockId);
}
-} // ssl
-} // folly
+} // namespace ssl
+} // namespace folly
void randomize();
-} // ssl
-} // folly
+} // namespace ssl
+} // namespace folly
buf->append(len);
return buf;
}
-} // ssl
-} // folly
+} // namespace ssl
+} // namespace folly
*/
using LockTypeMapping = std::map<int, LockType>;
-} // ssl
-} // folly
+} // namespace ssl
+} // namespace folly
std::mutex mutex;
SharedMutex sharedMutex;
};
-} // end anonymous namespace
+} // namespace
// Statics are unsafe in environments that call exit().
// If one thread calls exit() while another thread is
locks().reset();
}
-} // detail
-} // ssl
-} // folly
+} // namespace detail
+} // namespace ssl
+} // namespace folly
});
}
-} // folly
+} // namespace folly
std::vector<Bucket> buckets_; // actual buckets of values
};
-} // folly
+} // namespace folly
}
}
-} // detail
+} // namespace detail
template <typename T>
std::string Histogram<T>::debugString() const {
}
}
-} // folly
+} // namespace folly
computeTotalCount<Histogram<int64_t>::CountFromBucket>(
Histogram<int64_t>::CountFromBucket countFromBucket) const;
-} // folly
+} // namespace folly
std::vector<BucketType> buckets_;
};
-} // detail
+} // namespace detail
/*
* A basic histogram class.
detail::HistogramBuckets<ValueType, Bucket> buckets_;
};
-} // folly
+} // namespace folly
uint64_t cachedCount_;
};
-} // folly
+} // namespace folly
DSched::join(cons);
}
-} // namespace test {
-} // namespace folly {
+} // namespace test
+} // namespace folly
}
}
-} // namespace
+} // namespace
TEST(BitIterator, Simple) {
std::vector<int> v;
}
}
-} // namespace
+} // namespace
TEST(Bits, FindFirstSet) {
testFFS<char>();
TestNonTrivialDeallocation(list);
}
-} // namespace
+} // namespace
int main(int argc, char* argv[]) {
testing::InitGoogleTest(&argc, argv);
namespace folly_test {
struct ThisIsAVeryLongStructureName {
};
-} // namespace folly_test
+} // namespace folly_test
#if FOLLY_HAVE_CPLUS_DEMANGLE_V3_CALLBACK
TEST(Demangle, demangle) {
m.unlock();
}
};
-}
-} // namespace folly::test
+} // namespace test
+} // namespace folly
/* Specialization declarations */
std::chrono::time_point<std::chrono::system_clock>* absSystemTime,
std::chrono::time_point<std::chrono::steady_clock>* absSteadyTime,
uint32_t waitMask);
-}
+} // namespace detail
template <>
Getcpu::Func AccessSpreader<test::DeterministicAtomic>::pickGetcpuFunc();
-} // namespace folly::detail
+} // namespace folly
}
}
} // for bug
-} // TEST
+}
/// Test DSched support for auxiliary data and global invariants
///
void testEW(const exception_wrapper& ew) {
EXPECT_THROW(ew.throw_exception(), TestException);
}
-} // namespace
+} // namespace
TEST(ExceptionWrapper, implicitConstruction) {
// Try with both lvalue and rvalue references
}
};
-} // anon namespace
+} // namespace
TEST(FBStringCtorTest, DefaultInitStructDefaultAlloc) {
TestStructDefaultAllocator t1 { };
int savedErrno = errno;
EXPECT_LE(0, r) << ": errno=" << errnoStr(savedErrno);
}
-} // namespace
+} // namespace
TEST(File, Simple) {
// Open a file, ensure it's indeed open for reading
return operator()(fd, iov, count);
}
-} // namespace
+} // namespace
class FileUtilTest : public ::testing::Test {
protected:
fingerprintTerms<Fingerprint<128> >(num_iterations, num_ids);
}
-
-} // namespace
+} // namespace
// Only benchmark one size of slowFingerprint; it's significantly slower
// than fastFingeprint (as you can see for 64 bits) and it just slows down
EXPECT_EQ("10 20 0030", svformat("{} {} {:04}", v));
}
-} // namespace
+} // namespace
TEST(FormatOther, fbvector) {
testFormatSeq<fbvector<int>>();
int value;
};
-} // namespace
+} // namespace
namespace folly {
EXPECT_EQ(e, fe);
}
-} // namespace
+} // namespace
TEST(GroupVarint, GroupVarint32) {
EXPECT_EQ(0, GroupVarint32::maxSize(0));
uint64_t result = twang_mix64(r);
EXPECT_EQ(r, twang_unmix64(result));
}
-} // namespace
+} // namespace
TEST(Hash, TWang_Unmix64) {
// We'll try (1 << i), (1 << i) + 1, (1 << i) - 1
uint32_t result = jenkins_rev_mix32(r);
EXPECT_EQ(r, jenkins_rev_unmix32(result));
}
-} // namespace
+} // namespace
TEST(Hash, Jenkins_Rev_Unmix32) {
// We'll try (1 << i), (1 << i) + 1, (1 << i) - 1
} while (r != 0 && count);
}
-} // anonymous namespace
+} // namespace
TEST(MemoryMapping, Simple) {
File f = File::temporary();
EXPECT_FALSE(variant_match(two, is_one_copy));
EXPECT_FALSE(variant_match(two, is_one_const_copy));
}
-}
-} // folly::test
+} // namespace test
+} // namespace folly
}
}
-} // anonymous namespace
+} // namespace
BENCHMARK(FindSingleCharMemchr, n) {
StringPiece haystack(str);
struct Indestructible {
~Indestructible() = delete;
};
-} // anonymous namespace
+} // namespace
template <typename T>
struct ReplaceableStaticAttributeTest : Test {};
std::vector<std::shared_ptr<std::thread>> threads_;
std::atomic<size_t> counter_ {0};
};
-} // namespace
+} // namespace
namespace {
struct EagerInitParallelTag {};
EXPECT_GE(state.failed + 1, state.obtained);
}
-} // unnamed namespace
+} // namespace
TEST(SpinLock, Correctness) {
correctnessTest<folly::SpinLock>();
EXPECT_GE(127, c);
}
}
-} // namespace
+} // namespace
TEST(Escape, uriEscapeAllCombinations) {
char c[3];
(v >= 'A' && v <= 'F') ||
(v >= 'a' && v <= 'f'));
}
-} // namespace
+} // namespace
TEST(Escape, uriUnescapePercentDecoding) {
char c[4] = {'%', '\0', '\0', '\0'};
return double(int64_t(1) << exponent);
}
-} // namespace
+} // namespace
struct PrettyTestCase{
std::string prettyString;
double realValue;
}
}
-} // anon namespace
+} // namespace
TEST(String, toLowerAsciiAligned) {
static const size_t kSize = 256;
return (n == 0);
}
-} // namespace
+} // namespace
TEST(CommunicateSubprocessTest, Chatty) {
checkFdLeak([] {
namespace {
constexpr int kSignal = SIGUSR1;
-} // namespace
+} // namespace
void runChild(const char* file) {
// Block SIGUSR1 so it's queued
other.areas_.clear();
}
-} // namespace
+} // namespace
TEST(ThreadCachedArena, BlockSize) {
static const size_t alignment = folly::max_align_v;
BENCHMARK_DRAW_LINE()
-} // namespace
-
+} // namespace
// Benchmark Iters Total t t/iter iter/sec
// ----------------------------------------------------------------------------
struct Foo {
folly::ThreadLocal<int, Tag> tl;
};
-} // namespace
+} // namespace
TEST(ThreadLocal, Movable1) {
Foo a;
uint64_t data_[kFillObjectSize];
};
-} // namespace
+} // namespace
TEST(ThreadLocal, Stress) {
static constexpr size_t numFillObjects = 250;
return value;
}
-} // namespace
+} // namespace
#ifdef FOLLY_HAVE_PTHREAD_ATFORK
TEST(ThreadLocal, Fork) {
struct TokenBucketTest :
public ::testing::TestWithParam<std::pair<double,double> > {};
-} // folly
+} // namespace folly
}
}
-} // namespace
-
+} // namespace
}} // namespaces
int main(int argc, char *argv[]) {
projects / folly.git / commitdiff