This is true even if the pointer-to-member is never actually used, but only has its type matched, which was what kj::size() was trying to do.

Oh well, define some damned constants instead.

It apparently cannot compile properly against libstdc++.

This is stupid, but the GCC maintainers refused to change it:

    https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66425

For some reason, KJ's uses of (void) did not warn with GCC 5 but do warn with GCC 7. Supposedly, GCC *never* supported silencing with (void), so there must have been some other bug that caused GCC to fail to trigger the warning previously -- maybe related to the fact that the values being returned are non-trivial types?

C++17 introduces `[[nodiscard]]` which is defined as being squelchable using `(void)`, but we're still on C++14, and KJ_UNUSED_RESULT is a post-declaration attribute so can't be defined in terms of the new C++17 attribute even if the compiler supports it. Sigh.

If we were using C++17, we could use [[fallthrough]] instead... but we are not.

So far this is only a small subset of all the STL uses.

I also modified the test runner to print how long each test takes to run, useful for comparing benchmarks.

Hash-based (unordered) and tree-based (ordered) indexing are provided.

kj::Table offers advantages over STL:
- A Table can have multiple indexes (allowing lookup by multiple keys). Different indexes can use different algorithms (e.g. hash vs. tree) and have different uniqueness constraints.
- The properties on which a Table is indexed need not be explicit fields -- they can be computed from the table's row type.
- Tables use less memory and make fewer allocations than STL, because rows are stored in a contiguous array.
- The hash indexing implementation uses linear probing rather than chaining, which again means far fewer allocations and more cache-friendliness.
- The tree indexing implementation uses B-trees optimized for cache line size, whereas STL uses cache-unfriendly and allocation-heavy red-black binary trees. (However, STL trees are overall more cache-friendly; see below.)
- Most of the b-tree implementation is not templated. This reduces code bloat, at the cost of some performance due to virtual calls.

On an ad hoc benchmark on large tables, the hash index implementation appears to outperform libc++'s `std::unordered_set` by ~60%. However, libc++'s `std::set` still outperforms the B-tree index by ~70%. It looks like the B-tree implementation suffers in part from the fact that keys are not stored inline in the tree nodes, forcing extra memory indirections. This is a price we pay for lower memory usage overall, and the ability to have multiple indexes on one table. The b-tree implementation also suffers somewhat from not being 100% templates, compared to STL, but I think this is a reasonable trade-off. The most performance-critical use cases will use hash indexes anyway.

You need to use a different constructor function, `refTuple()`, to opt into references. Otherwise, it's too easy to construct a tuple of references by mistake.

indexOfType<T, Tuple<...>>() searches the Tuple for a member of type T and returns its index. It fails to compile if there is not exactly one match.

TypeOfIndex<i, Tuple<...>> evaluates to the type of the Tuple member at the given index.

I'm tired of working around missing features that were added in C++14. It's four years old now, compilers should support it.

Ignore ECHILD in UnixEventPort::ChildSet::checkExits

If no child process has changed state, waitpid() returns zero. But if there
are no more child processes at all, it returns -1 and sets errno to ECHILD.
Since checkExits calls waitpid() in a loop, it must ignore ECHILD.

+Unit test modified to exhibit the unexpected behaviour.

cmake: drop NO_DEFAULT_PATHS when searching libraries

Add functions for async-signal-safe stringification

Alas, this means we can't use sprintf() anymore. Ugh.

Automatically reduce `Promise<RemotePromise<T>>` -> `RemotePromise<T>`.

VS 2015 is just too buggy. Working around the bugs is wasting developer time.

This change does not actually remove any of the hacks yet, so that we can undo this decision if there are significant complaints after the next release.

Just like `Promise<Promise<T>>` reduces to `Promise<T>`, we should be able to reduce `Promise<RemotePromise<T>>`. Moreover, this reduction should support pipelining, hence the reduced type should itself be `RemotePromise<T>`.

Fixes #341

This is safer for signal handlers.

This is useful especially in signal handlers where malloc() is potentially unsafe.

An inconsistency was introduced with the previous fix to allow Cap'n Proto
installations in system directories to be found by CapnProtoTargets.cmake:
if the user installed Cap'n Proto in two locations, one of which is a
system directory, e.g. /usr and /somewhere/else, and set
PKG_CONFIG_PATH=/somewhere/else/lib/pkgconfig, the dependent project
would use headers from /somewhere/else/include, but libraries from /usr/lib.

This change resolves the inconsistency, allowing PKG_CONFIG_PATH to solely
control the location of the desired installation of Cap'n Proto.

fix const-correctness on AnyPointer equality checks