You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@marmotta.apache.org by ja...@apache.org on 2018/06/18 18:35:20 UTC
[01/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Repository: marmotta
Updated Branches:
refs/heads/develop b7e0dd4d3 -> 4ab4f15ce
refs/heads/master 6a10c48c1 -> 28c9b8b07
Updated Tags: refs/tags/3.4.0 [created] d66207b1b
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/utility/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/utility/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/utility/BUILD.bazel
new file mode 100644
index 0000000..c01b49b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/utility/BUILD.bazel
@@ -0,0 +1,33 @@
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "utility",
+ hdrs = ["utility.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/base:base_internal",
+ "//absl/base:config",
+ "//absl/meta:type_traits",
+ ],
+)
+
+cc_test(
+ name = "utility_test",
+ srcs = ["utility_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":utility",
+ "//absl/base:core_headers",
+ "//absl/memory",
+ "//absl/strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
[23/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex.cc
new file mode 100644
index 0000000..33f92d8
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex.cc
@@ -0,0 +1,2688 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/mutex.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#ifdef ERROR
+#undef ERROR
+#endif
+#else
+#include <fcntl.h>
+#include <pthread.h>
+#include <sched.h>
+#include <sys/time.h>
+#endif
+
+#include <assert.h>
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cinttypes>
+#include <thread> // NOLINT(build/c++11)
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/dynamic_annotations.h"
+#include "absl/base/internal/atomic_hook.h"
+#include "absl/base/internal/cycleclock.h"
+#include "absl/base/internal/low_level_alloc.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/spinlock.h"
+#include "absl/base/internal/sysinfo.h"
+#include "absl/base/internal/thread_identity.h"
+#include "absl/base/port.h"
+#include "absl/debugging/stacktrace.h"
+#include "absl/synchronization/internal/graphcycles.h"
+#include "absl/synchronization/internal/per_thread_sem.h"
+#include "absl/time/time.h"
+
+using absl::base_internal::CurrentThreadIdentityIfPresent;
+using absl::base_internal::PerThreadSynch;
+using absl::base_internal::ThreadIdentity;
+using absl::synchronization_internal::GetOrCreateCurrentThreadIdentity;
+using absl::synchronization_internal::GraphCycles;
+using absl::synchronization_internal::GraphId;
+using absl::synchronization_internal::InvalidGraphId;
+using absl::synchronization_internal::KernelTimeout;
+using absl::synchronization_internal::PerThreadSem;
+
+extern "C" {
+ABSL_ATTRIBUTE_WEAK void AbslInternalMutexYield() { std::this_thread::yield(); }
+} // extern "C"
+
+namespace absl {
+
+namespace {
+
+#if defined(THREAD_SANITIZER)
+constexpr OnDeadlockCycle kDeadlockDetectionDefault = OnDeadlockCycle::kIgnore;
+#else
+constexpr OnDeadlockCycle kDeadlockDetectionDefault = OnDeadlockCycle::kAbort;
+#endif
+
+ABSL_CONST_INIT std::atomic<OnDeadlockCycle> synch_deadlock_detection(
+ kDeadlockDetectionDefault);
+ABSL_CONST_INIT std::atomic<bool> synch_check_invariants(false);
+
+// ------------------------------------------ spinlock support
+
+// Make sure read-only globals used in the Mutex code are contained on the
+// same cacheline and cacheline aligned to eliminate any false sharing with
+// other globals from this and other modules.
+static struct MutexGlobals {
+ MutexGlobals() {
+ // Find machine-specific data needed for Delay() and
+ // TryAcquireWithSpinning(). This runs in the global constructor
+ // sequence, and before that zeros are safe values.
+ num_cpus = absl::base_internal::NumCPUs();
+ spinloop_iterations = num_cpus > 1 ? 1500 : 0;
+ }
+ int num_cpus;
+ int spinloop_iterations;
+ // Pad this struct to a full cacheline to prevent false sharing.
+ char padding[ABSL_CACHELINE_SIZE - 2 * sizeof(int)];
+} ABSL_CACHELINE_ALIGNED mutex_globals;
+static_assert(
+ sizeof(MutexGlobals) == ABSL_CACHELINE_SIZE,
+ "MutexGlobals must occupy an entire cacheline to prevent false sharing");
+
+ABSL_CONST_INIT absl::base_internal::AtomicHook<void (*)(int64_t wait_cycles)>
+ submit_profile_data;
+ABSL_CONST_INIT absl::base_internal::AtomicHook<
+ void (*)(const char *msg, const void *obj, int64_t wait_cycles)> mutex_tracer;
+ABSL_CONST_INIT absl::base_internal::AtomicHook<
+ void (*)(const char *msg, const void *cv)> cond_var_tracer;
+ABSL_CONST_INIT absl::base_internal::AtomicHook<
+ bool (*)(const void *pc, char *out, int out_size)> symbolizer;
+
+} // namespace
+
+void RegisterMutexProfiler(void (*fn)(int64_t wait_timestamp)) {
+ submit_profile_data.Store(fn);
+}
+
+void RegisterMutexTracer(void (*fn)(const char *msg, const void *obj,
+ int64_t wait_cycles)) {
+ mutex_tracer.Store(fn);
+}
+
+void RegisterCondVarTracer(void (*fn)(const char *msg, const void *cv)) {
+ cond_var_tracer.Store(fn);
+}
+
+void RegisterSymbolizer(bool (*fn)(const void *pc, char *out, int out_size)) {
+ symbolizer.Store(fn);
+}
+
+// spinlock delay on iteration c. Returns new c.
+namespace {
+ enum DelayMode { AGGRESSIVE, GENTLE };
+};
+static int Delay(int32_t c, DelayMode mode) {
+ // If this a uniprocessor, only yield/sleep. Otherwise, if the mode is
+ // aggressive then spin many times before yielding. If the mode is
+ // gentle then spin only a few times before yielding. Aggressive spinning is
+ // used to ensure that an Unlock() call, which must get the spin lock for
+ // any thread to make progress gets it without undue delay.
+ int32_t limit = (mutex_globals.num_cpus > 1) ?
+ ((mode == AGGRESSIVE) ? 5000 : 250) : 0;
+ if (c < limit) {
+ c++; // spin
+ } else {
+ ABSL_TSAN_MUTEX_PRE_DIVERT(0, 0);
+ if (c == limit) { // yield once
+ AbslInternalMutexYield();
+ c++;
+ } else { // then wait
+ absl::SleepFor(absl::Microseconds(10));
+ c = 0;
+ }
+ ABSL_TSAN_MUTEX_POST_DIVERT(0, 0);
+ }
+ return (c);
+}
+
+// --------------------------Generic atomic ops
+// Ensure that "(*pv & bits) == bits" by doing an atomic update of "*pv" to
+// "*pv | bits" if necessary. Wait until (*pv & wait_until_clear)==0
+// before making any change.
+// This is used to set flags in mutex and condition variable words.
+static void AtomicSetBits(std::atomic<intptr_t>* pv, intptr_t bits,
+ intptr_t wait_until_clear) {
+ intptr_t v;
+ do {
+ v = pv->load(std::memory_order_relaxed);
+ } while ((v & bits) != bits &&
+ ((v & wait_until_clear) != 0 ||
+ !pv->compare_exchange_weak(v, v | bits,
+ std::memory_order_release,
+ std::memory_order_relaxed)));
+}
+
+// Ensure that "(*pv & bits) == 0" by doing an atomic update of "*pv" to
+// "*pv & ~bits" if necessary. Wait until (*pv & wait_until_clear)==0
+// before making any change.
+// This is used to unset flags in mutex and condition variable words.
+static void AtomicClearBits(std::atomic<intptr_t>* pv, intptr_t bits,
+ intptr_t wait_until_clear) {
+ intptr_t v;
+ do {
+ v = pv->load(std::memory_order_relaxed);
+ } while ((v & bits) != 0 &&
+ ((v & wait_until_clear) != 0 ||
+ !pv->compare_exchange_weak(v, v & ~bits,
+ std::memory_order_release,
+ std::memory_order_relaxed)));
+}
+
+//------------------------------------------------------------------
+
+// Data for doing deadlock detection.
+static absl::base_internal::SpinLock deadlock_graph_mu(
+ absl::base_internal::kLinkerInitialized);
+
+// graph used to detect deadlocks.
+static GraphCycles *deadlock_graph GUARDED_BY(deadlock_graph_mu)
+ PT_GUARDED_BY(deadlock_graph_mu);
+
+//------------------------------------------------------------------
+// An event mechanism for debugging mutex use.
+// It also allows mutexes to be given names for those who can't handle
+// addresses, and instead like to give their data structures names like
+// "Henry", "Fido", or "Rupert IV, King of Yondavia".
+
+namespace { // to prevent name pollution
+enum { // Mutex and CondVar events passed as "ev" to PostSynchEvent
+ // Mutex events
+ SYNCH_EV_TRYLOCK_SUCCESS,
+ SYNCH_EV_TRYLOCK_FAILED,
+ SYNCH_EV_READERTRYLOCK_SUCCESS,
+ SYNCH_EV_READERTRYLOCK_FAILED,
+ SYNCH_EV_LOCK,
+ SYNCH_EV_LOCK_RETURNING,
+ SYNCH_EV_READERLOCK,
+ SYNCH_EV_READERLOCK_RETURNING,
+ SYNCH_EV_UNLOCK,
+ SYNCH_EV_READERUNLOCK,
+
+ // CondVar events
+ SYNCH_EV_WAIT,
+ SYNCH_EV_WAIT_RETURNING,
+ SYNCH_EV_SIGNAL,
+ SYNCH_EV_SIGNALALL,
+};
+
+enum { // Event flags
+ SYNCH_F_R = 0x01, // reader event
+ SYNCH_F_LCK = 0x02, // PostSynchEvent called with mutex held
+ SYNCH_F_ACQ = 0x04, // event is an acquire
+
+ SYNCH_F_LCK_W = SYNCH_F_LCK,
+ SYNCH_F_LCK_R = SYNCH_F_LCK | SYNCH_F_R,
+ SYNCH_F_ACQ_W = SYNCH_F_ACQ,
+ SYNCH_F_ACQ_R = SYNCH_F_ACQ | SYNCH_F_R,
+};
+} // anonymous namespace
+
+// Properties of the events.
+static const struct {
+ int flags;
+ const char *msg;
+} event_properties[] = {
+ { SYNCH_F_LCK_W|SYNCH_F_ACQ_W, "TryLock succeeded " },
+ { 0, "TryLock failed " },
+ { SYNCH_F_LCK_R|SYNCH_F_ACQ_R, "ReaderTryLock succeeded " },
+ { 0, "ReaderTryLock failed " },
+ { SYNCH_F_ACQ_W, "Lock blocking " },
+ { SYNCH_F_LCK_W, "Lock returning " },
+ { SYNCH_F_ACQ_R, "ReaderLock blocking " },
+ { SYNCH_F_LCK_R, "ReaderLock returning " },
+ { SYNCH_F_LCK_W, "Unlock " },
+ { SYNCH_F_LCK_R, "ReaderUnlock " },
+ { 0, "Wait on " },
+ { 0, "Wait unblocked " },
+ { 0, "Signal on " },
+ { 0, "SignalAll on " },
+};
+static absl::base_internal::SpinLock synch_event_mu(
+ absl::base_internal::kLinkerInitialized);
+// protects synch_event
+
+// Hash table size; should be prime > 2.
+// Can't be too small, as it's used for deadlock detection information.
+static const uint32_t kNSynchEvent = 1031;
+
+// We need to hide Mutexes (or other deadlock detection's pointers)
+// from the leak detector.
+static const uintptr_t kHideMask = static_cast<uintptr_t>(0xF03A5F7BF03A5F7BLL);
+static uintptr_t MaskMu(const void *mu) {
+ return reinterpret_cast<uintptr_t>(mu) ^ kHideMask;
+}
+
+static struct SynchEvent { // this is a trivial hash table for the events
+ // struct is freed when refcount reaches 0
+ int refcount GUARDED_BY(synch_event_mu);
+
+ // buckets have linear, 0-terminated chains
+ SynchEvent *next GUARDED_BY(synch_event_mu);
+
+ // Constant after initialization
+ uintptr_t masked_addr; // object at this address is called "name"
+
+ // No explicit synchronization used. Instead we assume that the
+ // client who enables/disables invariants/logging on a Mutex does so
+ // while the Mutex is not being concurrently accessed by others.
+ void (*invariant)(void *arg); // called on each event
+ void *arg; // first arg to (*invariant)()
+ bool log; // logging turned on
+
+ // Constant after initialization
+ char name[1]; // actually longer---null-terminated std::string
+} *synch_event[kNSynchEvent] GUARDED_BY(synch_event_mu);
+
+// Ensure that the object at "addr" has a SynchEvent struct associated with it,
+// set "bits" in the word there (waiting until lockbit is clear before doing
+// so), and return a refcounted reference that will remain valid until
+// UnrefSynchEvent() is called. If a new SynchEvent is allocated,
+// the std::string name is copied into it.
+// When used with a mutex, the caller should also ensure that kMuEvent
+// is set in the mutex word, and similarly for condition variables and kCVEvent.
+static SynchEvent *EnsureSynchEvent(std::atomic<intptr_t> *addr,
+ const char *name, intptr_t bits,
+ intptr_t lockbit) {
+ uint32_t h = reinterpret_cast<intptr_t>(addr) % kNSynchEvent;
+ SynchEvent *e;
+ // first look for existing SynchEvent struct..
+ synch_event_mu.Lock();
+ for (e = synch_event[h]; e != nullptr && e->masked_addr != MaskMu(addr);
+ e = e->next) {
+ }
+ if (e == nullptr) { // no SynchEvent struct found; make one.
+ if (name == nullptr) {
+ name = "";
+ }
+ size_t l = strlen(name);
+ e = reinterpret_cast<SynchEvent *>(
+ base_internal::LowLevelAlloc::Alloc(sizeof(*e) + l));
+ e->refcount = 2; // one for return value, one for linked list
+ e->masked_addr = MaskMu(addr);
+ e->invariant = nullptr;
+ e->arg = nullptr;
+ e->log = false;
+ strcpy(e->name, name); // NOLINT(runtime/printf)
+ e->next = synch_event[h];
+ AtomicSetBits(addr, bits, lockbit);
+ synch_event[h] = e;
+ } else {
+ e->refcount++; // for return value
+ }
+ synch_event_mu.Unlock();
+ return e;
+}
+
+// Deallocate the SynchEvent *e, whose refcount has fallen to zero.
+static void DeleteSynchEvent(SynchEvent *e) {
+ base_internal::LowLevelAlloc::Free(e);
+}
+
+// Decrement the reference count of *e, or do nothing if e==null.
+static void UnrefSynchEvent(SynchEvent *e) {
+ if (e != nullptr) {
+ synch_event_mu.Lock();
+ bool del = (--(e->refcount) == 0);
+ synch_event_mu.Unlock();
+ if (del) {
+ DeleteSynchEvent(e);
+ }
+ }
+}
+
+// Forget the mapping from the object (Mutex or CondVar) at address addr
+// to SynchEvent object, and clear "bits" in its word (waiting until lockbit
+// is clear before doing so).
+static void ForgetSynchEvent(std::atomic<intptr_t> *addr, intptr_t bits,
+ intptr_t lockbit) {
+ uint32_t h = reinterpret_cast<intptr_t>(addr) % kNSynchEvent;
+ SynchEvent **pe;
+ SynchEvent *e;
+ synch_event_mu.Lock();
+ for (pe = &synch_event[h];
+ (e = *pe) != nullptr && e->masked_addr != MaskMu(addr); pe = &e->next) {
+ }
+ bool del = false;
+ if (e != nullptr) {
+ *pe = e->next;
+ del = (--(e->refcount) == 0);
+ }
+ AtomicClearBits(addr, bits, lockbit);
+ synch_event_mu.Unlock();
+ if (del) {
+ DeleteSynchEvent(e);
+ }
+}
+
+// Return a refcounted reference to the SynchEvent of the object at address
+// "addr", if any. The pointer returned is valid until the UnrefSynchEvent() is
+// called.
+static SynchEvent *GetSynchEvent(const void *addr) {
+ uint32_t h = reinterpret_cast<intptr_t>(addr) % kNSynchEvent;
+ SynchEvent *e;
+ synch_event_mu.Lock();
+ for (e = synch_event[h]; e != nullptr && e->masked_addr != MaskMu(addr);
+ e = e->next) {
+ }
+ if (e != nullptr) {
+ e->refcount++;
+ }
+ synch_event_mu.Unlock();
+ return e;
+}
+
+// Called when an event "ev" occurs on a Mutex of CondVar "obj"
+// if event recording is on
+static void PostSynchEvent(void *obj, int ev) {
+ SynchEvent *e = GetSynchEvent(obj);
+ // logging is on if event recording is on and either there's no event struct,
+ // or it explicitly says to log
+ if (e == nullptr || e->log) {
+ void *pcs[40];
+ int n = absl::GetStackTrace(pcs, ABSL_ARRAYSIZE(pcs), 1);
+ // A buffer with enough space for the ASCII for all the PCs, even on a
+ // 64-bit machine.
+ char buffer[ABSL_ARRAYSIZE(pcs) * 24];
+ int pos = snprintf(buffer, sizeof (buffer), " @");
+ for (int i = 0; i != n; i++) {
+ pos += snprintf(&buffer[pos], sizeof (buffer) - pos, " %p", pcs[i]);
+ }
+ ABSL_RAW_LOG(INFO, "%s%p %s %s", event_properties[ev].msg, obj,
+ (e == nullptr ? "" : e->name), buffer);
+ }
+ if ((event_properties[ev].flags & SYNCH_F_LCK) != 0 && e != nullptr &&
+ e->invariant != nullptr) {
+ (*e->invariant)(e->arg);
+ }
+ UnrefSynchEvent(e);
+}
+
+//------------------------------------------------------------------
+
+// The SynchWaitParams struct encapsulates the way in which a thread is waiting:
+// whether it has a timeout, the condition, exclusive/shared, and whether a
+// condition variable wait has an associated Mutex (as opposed to another
+// type of lock). It also points to the PerThreadSynch struct of its thread.
+// cv_word tells Enqueue() to enqueue on a CondVar using CondVarEnqueue().
+//
+// This structure is held on the stack rather than directly in
+// PerThreadSynch because a thread can be waiting on multiple Mutexes if,
+// while waiting on one Mutex, the implementation calls a client callback
+// (such as a Condition function) that acquires another Mutex. We don't
+// strictly need to allow this, but programmers become confused if we do not
+// allow them to use functions such a LOG() within Condition functions. The
+// PerThreadSynch struct points at the most recent SynchWaitParams struct when
+// the thread is on a Mutex's waiter queue.
+struct SynchWaitParams {
+ SynchWaitParams(Mutex::MuHow how_arg, const Condition *cond_arg,
+ KernelTimeout timeout_arg, Mutex *cvmu_arg,
+ PerThreadSynch *thread_arg,
+ std::atomic<intptr_t> *cv_word_arg)
+ : how(how_arg),
+ cond(cond_arg),
+ timeout(timeout_arg),
+ cvmu(cvmu_arg),
+ thread(thread_arg),
+ cv_word(cv_word_arg),
+ contention_start_cycles(base_internal::CycleClock::Now()) {}
+
+ const Mutex::MuHow how; // How this thread needs to wait.
+ const Condition *cond; // The condition that this thread is waiting for.
+ // In Mutex, this field is set to zero if a timeout
+ // expires.
+ KernelTimeout timeout; // timeout expiry---absolute time
+ // In Mutex, this field is set to zero if a timeout
+ // expires.
+ Mutex *const cvmu; // used for transfer from cond var to mutex
+ PerThreadSynch *const thread; // thread that is waiting
+
+ // If not null, thread should be enqueued on the CondVar whose state
+ // word is cv_word instead of queueing normally on the Mutex.
+ std::atomic<intptr_t> *cv_word;
+
+ int64_t contention_start_cycles; // Time (in cycles) when this thread started
+ // to contend for the mutex.
+};
+
+struct SynchLocksHeld {
+ int n; // number of valid entries in locks[]
+ bool overflow; // true iff we overflowed the array at some point
+ struct {
+ Mutex *mu; // lock acquired
+ int32_t count; // times acquired
+ GraphId id; // deadlock_graph id of acquired lock
+ } locks[40];
+ // If a thread overfills the array during deadlock detection, we
+ // continue, discarding information as needed. If no overflow has
+ // taken place, we can provide more error checking, such as
+ // detecting when a thread releases a lock it does not hold.
+};
+
+// A sentinel value in lists that is not 0.
+// A 0 value is used to mean "not on a list".
+static PerThreadSynch *const kPerThreadSynchNull =
+ reinterpret_cast<PerThreadSynch *>(1);
+
+static SynchLocksHeld *LocksHeldAlloc() {
+ SynchLocksHeld *ret = reinterpret_cast<SynchLocksHeld *>(
+ base_internal::LowLevelAlloc::Alloc(sizeof(SynchLocksHeld)));
+ ret->n = 0;
+ ret->overflow = false;
+ return ret;
+}
+
+// Return the PerThreadSynch-struct for this thread.
+static PerThreadSynch *Synch_GetPerThread() {
+ ThreadIdentity *identity = GetOrCreateCurrentThreadIdentity();
+ return &identity->per_thread_synch;
+}
+
+static PerThreadSynch *Synch_GetPerThreadAnnotated(Mutex *mu) {
+ if (mu) {
+ ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
+ }
+ PerThreadSynch *w = Synch_GetPerThread();
+ if (mu) {
+ ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
+ }
+ return w;
+}
+
+static SynchLocksHeld *Synch_GetAllLocks() {
+ PerThreadSynch *s = Synch_GetPerThread();
+ if (s->all_locks == nullptr) {
+ s->all_locks = LocksHeldAlloc(); // Freed by ReclaimThreadIdentity.
+ }
+ return s->all_locks;
+}
+
+// Post on "w"'s associated PerThreadSem.
+inline void Mutex::IncrementSynchSem(Mutex *mu, PerThreadSynch *w) {
+ if (mu) {
+ ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
+ }
+ PerThreadSem::Post(w->thread_identity());
+ if (mu) {
+ ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
+ }
+}
+
+// Wait on "w"'s associated PerThreadSem; returns false if timeout expired.
+bool Mutex::DecrementSynchSem(Mutex *mu, PerThreadSynch *w, KernelTimeout t) {
+ if (mu) {
+ ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
+ }
+ assert(w == Synch_GetPerThread());
+ static_cast<void>(w);
+ bool res = PerThreadSem::Wait(t);
+ if (mu) {
+ ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
+ }
+ return res;
+}
+
+// We're in a fatal signal handler that hopes to use Mutex and to get
+// lucky by not deadlocking. We try to improve its chances of success
+// by effectively disabling some of the consistency checks. This will
+// prevent certain ABSL_RAW_CHECK() statements from being triggered when
+// re-rentry is detected. The ABSL_RAW_CHECK() statements are those in the
+// Mutex code checking that the "waitp" field has not been reused.
+void Mutex::InternalAttemptToUseMutexInFatalSignalHandler() {
+ // Fix the per-thread state only if it exists.
+ ThreadIdentity *identity = CurrentThreadIdentityIfPresent();
+ if (identity != nullptr) {
+ identity->per_thread_synch.suppress_fatal_errors = true;
+ }
+ // Don't do deadlock detection when we are already failing.
+ synch_deadlock_detection.store(OnDeadlockCycle::kIgnore,
+ std::memory_order_release);
+}
+
+// --------------------------time support
+
+// Return the current time plus the timeout. Use the same clock as
+// PerThreadSem::Wait() for consistency. Unfortunately, we don't have
+// such a choice when a deadline is given directly.
+static absl::Time DeadlineFromTimeout(absl::Duration timeout) {
+#ifndef _WIN32
+ struct timeval tv;
+ gettimeofday(&tv, nullptr);
+ return absl::TimeFromTimeval(tv) + timeout;
+#else
+ return absl::Now() + timeout;
+#endif
+}
+
+// --------------------------Mutexes
+
+// In the layout below, the msb of the bottom byte is currently unused. Also,
+// the following constraints were considered in choosing the layout:
+// o Both the debug allocator's "uninitialized" and "freed" patterns (0xab and
+// 0xcd) are illegal: reader and writer lock both held.
+// o kMuWriter and kMuEvent should exceed kMuDesig and kMuWait, to enable the
+// bit-twiddling trick in Mutex::Unlock().
+// o kMuWriter / kMuReader == kMuWrWait / kMuWait,
+// to enable the bit-twiddling trick in CheckForMutexCorruption().
+static const intptr_t kMuReader = 0x0001L; // a reader holds the lock
+static const intptr_t kMuDesig = 0x0002L; // there's a designated waker
+static const intptr_t kMuWait = 0x0004L; // threads are waiting
+static const intptr_t kMuWriter = 0x0008L; // a writer holds the lock
+static const intptr_t kMuEvent = 0x0010L; // record this mutex's events
+// INVARIANT1: there's a thread that was blocked on the mutex, is
+// no longer, yet has not yet acquired the mutex. If there's a
+// designated waker, all threads can avoid taking the slow path in
+// unlock because the designated waker will subsequently acquire
+// the lock and wake someone. To maintain INVARIANT1 the bit is
+// set when a thread is unblocked(INV1a), and threads that were
+// unblocked reset the bit when they either acquire or re-block
+// (INV1b).
+static const intptr_t kMuWrWait = 0x0020L; // runnable writer is waiting
+ // for a reader
+static const intptr_t kMuSpin = 0x0040L; // spinlock protects wait list
+static const intptr_t kMuLow = 0x00ffL; // mask all mutex bits
+static const intptr_t kMuHigh = ~kMuLow; // mask pointer/reader count
+
+// Hack to make constant values available to gdb pretty printer
+enum {
+ kGdbMuSpin = kMuSpin,
+ kGdbMuEvent = kMuEvent,
+ kGdbMuWait = kMuWait,
+ kGdbMuWriter = kMuWriter,
+ kGdbMuDesig = kMuDesig,
+ kGdbMuWrWait = kMuWrWait,
+ kGdbMuReader = kMuReader,
+ kGdbMuLow = kMuLow,
+};
+
+// kMuWrWait implies kMuWait.
+// kMuReader and kMuWriter are mutually exclusive.
+// If kMuReader is zero, there are no readers.
+// Otherwise, if kMuWait is zero, the high order bits contain a count of the
+// number of readers. Otherwise, the reader count is held in
+// PerThreadSynch::readers of the most recently queued waiter, again in the
+// bits above kMuLow.
+static const intptr_t kMuOne = 0x0100; // a count of one reader
+
+// flags passed to Enqueue and LockSlow{,WithTimeout,Loop}
+static const int kMuHasBlocked = 0x01; // already blocked (MUST == 1)
+static const int kMuIsCond = 0x02; // conditional waiter (CV or Condition)
+
+static_assert(PerThreadSynch::kAlignment > kMuLow,
+ "PerThreadSynch::kAlignment must be greater than kMuLow");
+
+// This struct contains various bitmasks to be used in
+// acquiring and releasing a mutex in a particular mode.
+struct MuHowS {
+ // if all the bits in fast_need_zero are zero, the lock can be acquired by
+ // adding fast_add and oring fast_or. The bit kMuDesig should be reset iff
+ // this is the designated waker.
+ intptr_t fast_need_zero;
+ intptr_t fast_or;
+ intptr_t fast_add;
+
+ intptr_t slow_need_zero; // fast_need_zero with events (e.g. logging)
+
+ intptr_t slow_inc_need_zero; // if all the bits in slow_inc_need_zero are
+ // zero a reader can acquire a read share by
+ // setting the reader bit and incrementing
+ // the reader count (in last waiter since
+ // we're now slow-path). kMuWrWait be may
+ // be ignored if we already waited once.
+};
+
+static const MuHowS kSharedS = {
+ // shared or read lock
+ kMuWriter | kMuWait | kMuEvent, // fast_need_zero
+ kMuReader, // fast_or
+ kMuOne, // fast_add
+ kMuWriter | kMuWait, // slow_need_zero
+ kMuSpin | kMuWriter | kMuWrWait, // slow_inc_need_zero
+};
+static const MuHowS kExclusiveS = {
+ // exclusive or write lock
+ kMuWriter | kMuReader | kMuEvent, // fast_need_zero
+ kMuWriter, // fast_or
+ 0, // fast_add
+ kMuWriter | kMuReader, // slow_need_zero
+ ~static_cast<intptr_t>(0), // slow_inc_need_zero
+};
+static const Mutex::MuHow kShared = &kSharedS; // shared lock
+static const Mutex::MuHow kExclusive = &kExclusiveS; // exclusive lock
+
+#ifdef NDEBUG
+static constexpr bool kDebugMode = false;
+#else
+static constexpr bool kDebugMode = true;
+#endif
+
+#ifdef THREAD_SANITIZER
+static unsigned TsanFlags(Mutex::MuHow how) {
+ return how == kShared ? __tsan_mutex_read_lock : 0;
+}
+#endif
+
+static bool DebugOnlyIsExiting() {
+ return false;
+}
+
+Mutex::~Mutex() {
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+ if ((v & kMuEvent) != 0 && !DebugOnlyIsExiting()) {
+ ForgetSynchEvent(&this->mu_, kMuEvent, kMuSpin);
+ }
+ if (kDebugMode) {
+ this->ForgetDeadlockInfo();
+ }
+ ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static);
+}
+
+void Mutex::EnableDebugLog(const char *name) {
+ SynchEvent *e = EnsureSynchEvent(&this->mu_, name, kMuEvent, kMuSpin);
+ e->log = true;
+ UnrefSynchEvent(e);
+}
+
+void EnableMutexInvariantDebugging(bool enabled) {
+ synch_check_invariants.store(enabled, std::memory_order_release);
+}
+
+void Mutex::EnableInvariantDebugging(void (*invariant)(void *),
+ void *arg) {
+ if (synch_check_invariants.load(std::memory_order_acquire) &&
+ invariant != nullptr) {
+ SynchEvent *e = EnsureSynchEvent(&this->mu_, nullptr, kMuEvent, kMuSpin);
+ e->invariant = invariant;
+ e->arg = arg;
+ UnrefSynchEvent(e);
+ }
+}
+
+void SetMutexDeadlockDetectionMode(OnDeadlockCycle mode) {
+ synch_deadlock_detection.store(mode, std::memory_order_release);
+}
+
+// Return true iff threads x and y are waiting on the same condition for the
+// same type of lock. Requires that x and y be waiting on the same Mutex
+// queue.
+static bool MuSameCondition(PerThreadSynch *x, PerThreadSynch *y) {
+ return x->waitp->how == y->waitp->how &&
+ Condition::GuaranteedEqual(x->waitp->cond, y->waitp->cond);
+}
+
+// Given the contents of a mutex word containing a PerThreadSynch pointer,
+// return the pointer.
+static inline PerThreadSynch *GetPerThreadSynch(intptr_t v) {
+ return reinterpret_cast<PerThreadSynch *>(v & kMuHigh);
+}
+
+// The next several routines maintain the per-thread next and skip fields
+// used in the Mutex waiter queue.
+// The queue is a circular singly-linked list, of which the "head" is the
+// last element, and head->next if the first element.
+// The skip field has the invariant:
+// For thread x, x->skip is one of:
+// - invalid (iff x is not in a Mutex wait queue),
+// - null, or
+// - a pointer to a distinct thread waiting later in the same Mutex queue
+// such that all threads in [x, x->skip] have the same condition and
+// lock type (MuSameCondition() is true for all pairs in [x, x->skip]).
+// In addition, if x->skip is valid, (x->may_skip || x->skip == null)
+//
+// By the spec of MuSameCondition(), it is not necessary when removing the
+// first runnable thread y from the front a Mutex queue to adjust the skip
+// field of another thread x because if x->skip==y, x->skip must (have) become
+// invalid before y is removed. The function TryRemove can remove a specified
+// thread from an arbitrary position in the queue whether runnable or not, so
+// it fixes up skip fields that would otherwise be left dangling.
+// The statement
+// if (x->may_skip && MuSameCondition(x, x->next)) { x->skip = x->next; }
+// maintains the invariant provided x is not the last waiter in a Mutex queue
+// The statement
+// if (x->skip != null) { x->skip = x->skip->skip; }
+// maintains the invariant.
+
+// Returns the last thread y in a mutex waiter queue such that all threads in
+// [x, y] inclusive share the same condition. Sets skip fields of some threads
+// in that range to optimize future evaluation of Skip() on x values in
+// the range. Requires thread x is in a mutex waiter queue.
+// The locking is unusual. Skip() is called under these conditions:
+// - spinlock is held in call from Enqueue(), with maybe_unlocking == false
+// - Mutex is held in call from UnlockSlow() by last unlocker, with
+// maybe_unlocking == true
+// - both Mutex and spinlock are held in call from DequeueAllWakeable() (from
+// UnlockSlow()) and TryRemove()
+// These cases are mutually exclusive, so Skip() never runs concurrently
+// with itself on the same Mutex. The skip chain is used in these other places
+// that cannot occur concurrently:
+// - FixSkip() (from TryRemove()) - spinlock and Mutex are held)
+// - Dequeue() (with spinlock and Mutex held)
+// - UnlockSlow() (with spinlock and Mutex held)
+// A more complex case is Enqueue()
+// - Enqueue() (with spinlock held and maybe_unlocking == false)
+// This is the first case in which Skip is called, above.
+// - Enqueue() (without spinlock held; but queue is empty and being freshly
+// formed)
+// - Enqueue() (with spinlock held and maybe_unlocking == true)
+// The first case has mutual exclusion, and the second isolation through
+// working on an otherwise unreachable data structure.
+// In the last case, Enqueue() is required to change no skip/next pointers
+// except those in the added node and the former "head" node. This implies
+// that the new node is added after head, and so must be the new head or the
+// new front of the queue.
+static PerThreadSynch *Skip(PerThreadSynch *x) {
+ PerThreadSynch *x0 = nullptr;
+ PerThreadSynch *x1 = x;
+ PerThreadSynch *x2 = x->skip;
+ if (x2 != nullptr) {
+ // Each iteration attempts to advance sequence (x0,x1,x2) to next sequence
+ // such that x1 == x0->skip && x2 == x1->skip
+ while ((x0 = x1, x1 = x2, x2 = x2->skip) != nullptr) {
+ x0->skip = x2; // short-circuit skip from x0 to x2
+ }
+ x->skip = x1; // short-circuit skip from x to result
+ }
+ return x1;
+}
+
+// "ancestor" appears before "to_be_removed" in the same Mutex waiter queue.
+// The latter is going to be removed out of order, because of a timeout.
+// Check whether "ancestor" has a skip field pointing to "to_be_removed",
+// and fix it if it does.
+static void FixSkip(PerThreadSynch *ancestor, PerThreadSynch *to_be_removed) {
+ if (ancestor->skip == to_be_removed) { // ancestor->skip left dangling
+ if (to_be_removed->skip != nullptr) {
+ ancestor->skip = to_be_removed->skip; // can skip past to_be_removed
+ } else if (ancestor->next != to_be_removed) { // they are not adjacent
+ ancestor->skip = ancestor->next; // can skip one past ancestor
+ } else {
+ ancestor->skip = nullptr; // can't skip at all
+ }
+ }
+}
+
+static void CondVarEnqueue(SynchWaitParams *waitp);
+
+// Enqueue thread "waitp->thread" on a waiter queue.
+// Called with mutex spinlock held if head != nullptr
+// If head==nullptr and waitp->cv_word==nullptr, then Enqueue() is
+// idempotent; it alters no state associated with the existing (empty)
+// queue.
+//
+// If waitp->cv_word == nullptr, queue the thread at either the front or
+// the end (according to its priority) of the circular mutex waiter queue whose
+// head is "head", and return the new head. mu is the previous mutex state,
+// which contains the reader count (perhaps adjusted for the operation in
+// progress) if the list was empty and a read lock held, and the holder hint if
+// the list was empty and a write lock held. (flags & kMuIsCond) indicates
+// whether this thread was transferred from a CondVar or is waiting for a
+// non-trivial condition. In this case, Enqueue() never returns nullptr
+//
+// If waitp->cv_word != nullptr, CondVarEnqueue() is called, and "head" is
+// returned. This mechanism is used by CondVar to queue a thread on the
+// condition variable queue instead of the mutex queue in implementing Wait().
+// In this case, Enqueue() can return nullptr (if head==nullptr).
+static PerThreadSynch *Enqueue(PerThreadSynch *head,
+ SynchWaitParams *waitp, intptr_t mu, int flags) {
+ // If we have been given a cv_word, call CondVarEnqueue() and return
+ // the previous head of the Mutex waiter queue.
+ if (waitp->cv_word != nullptr) {
+ CondVarEnqueue(waitp);
+ return head;
+ }
+
+ PerThreadSynch *s = waitp->thread;
+ ABSL_RAW_CHECK(
+ s->waitp == nullptr || // normal case
+ s->waitp == waitp || // Fer()---transfer from condition variable
+ s->suppress_fatal_errors,
+ "detected illegal recursion into Mutex code");
+ s->waitp = waitp;
+ s->skip = nullptr; // maintain skip invariant (see above)
+ s->may_skip = true; // always true on entering queue
+ s->wake = false; // not being woken
+ s->cond_waiter = ((flags & kMuIsCond) != 0);
+ if (head == nullptr) { // s is the only waiter
+ s->next = s; // it's the only entry in the cycle
+ s->readers = mu; // reader count is from mu word
+ s->maybe_unlocking = false; // no one is searching an empty list
+ head = s; // s is new head
+ } else {
+ PerThreadSynch *enqueue_after = nullptr; // we'll put s after this element
+#ifdef ABSL_HAVE_PTHREAD_GETSCHEDPARAM
+ int64_t now_cycles = base_internal::CycleClock::Now();
+ if (s->next_priority_read_cycles < now_cycles) {
+ // Every so often, update our idea of the thread's priority.
+ // pthread_getschedparam() is 5% of the block/wakeup time;
+ // base_internal::CycleClock::Now() is 0.5%.
+ int policy;
+ struct sched_param param;
+ pthread_getschedparam(pthread_self(), &policy, ¶m);
+ s->priority = param.sched_priority;
+ s->next_priority_read_cycles =
+ now_cycles +
+ static_cast<int64_t>(base_internal::CycleClock::Frequency());
+ }
+ if (s->priority > head->priority) { // s's priority is above head's
+ // try to put s in priority-fifo order, or failing that at the front.
+ if (!head->maybe_unlocking) {
+ // No unlocker can be scanning the queue, so we can insert between
+ // skip-chains, and within a skip-chain if it has the same condition as
+ // s. We insert in priority-fifo order, examining the end of every
+ // skip-chain, plus every element with the same condition as s.
+ PerThreadSynch *advance_to = head; // next value of enqueue_after
+ PerThreadSynch *cur; // successor of enqueue_after
+ do {
+ enqueue_after = advance_to;
+ cur = enqueue_after->next; // this advance ensures progress
+ advance_to = Skip(cur); // normally, advance to end of skip chain
+ // (side-effect: optimizes skip chain)
+ if (advance_to != cur && s->priority > advance_to->priority &&
+ MuSameCondition(s, cur)) {
+ // but this skip chain is not a singleton, s has higher priority
+ // than its tail and has the same condition as the chain,
+ // so we can insert within the skip-chain
+ advance_to = cur; // advance by just one
+ }
+ } while (s->priority <= advance_to->priority);
+ // termination guaranteed because s->priority > head->priority
+ // and head is the end of a skip chain
+ } else if (waitp->how == kExclusive &&
+ Condition::GuaranteedEqual(waitp->cond, nullptr)) {
+ // An unlocker could be scanning the queue, but we know it will recheck
+ // the queue front for writers that have no condition, which is what s
+ // is, so an insert at front is safe.
+ enqueue_after = head; // add after head, at front
+ }
+ }
+#endif
+ if (enqueue_after != nullptr) {
+ s->next = enqueue_after->next;
+ enqueue_after->next = s;
+
+ // enqueue_after can be: head, Skip(...), or cur.
+ // The first two imply enqueue_after->skip == nullptr, and
+ // the last is used only if MuSameCondition(s, cur).
+ // We require this because clearing enqueue_after->skip
+ // is impossible; enqueue_after's predecessors might also
+ // incorrectly skip over s if we were to allow other
+ // insertion points.
+ ABSL_RAW_CHECK(
+ enqueue_after->skip == nullptr || MuSameCondition(enqueue_after, s),
+ "Mutex Enqueue failure");
+
+ if (enqueue_after != head && enqueue_after->may_skip &&
+ MuSameCondition(enqueue_after, enqueue_after->next)) {
+ // enqueue_after can skip to its new successor, s
+ enqueue_after->skip = enqueue_after->next;
+ }
+ if (MuSameCondition(s, s->next)) { // s->may_skip is known to be true
+ s->skip = s->next; // s may skip to its successor
+ }
+ } else { // enqueue not done any other way, so
+ // we're inserting s at the back
+ // s will become new head; copy data from head into it
+ s->next = head->next; // add s after head
+ head->next = s;
+ s->readers = head->readers; // reader count is from previous head
+ s->maybe_unlocking = head->maybe_unlocking; // same for unlock hint
+ if (head->may_skip && MuSameCondition(head, s)) {
+ // head now has successor; may skip
+ head->skip = s;
+ }
+ head = s; // s is new head
+ }
+ }
+ s->state.store(PerThreadSynch::kQueued, std::memory_order_relaxed);
+ return head;
+}
+
+// Dequeue the successor pw->next of thread pw from the Mutex waiter queue
+// whose last element is head. The new head element is returned, or null
+// if the list is made empty.
+// Dequeue is called with both spinlock and Mutex held.
+static PerThreadSynch *Dequeue(PerThreadSynch *head, PerThreadSynch *pw) {
+ PerThreadSynch *w = pw->next;
+ pw->next = w->next; // snip w out of list
+ if (head == w) { // we removed the head
+ head = (pw == w) ? nullptr : pw; // either emptied list, or pw is new head
+ } else if (pw != head && MuSameCondition(pw, pw->next)) {
+ // pw can skip to its new successor
+ if (pw->next->skip !=
+ nullptr) { // either skip to its successors skip target
+ pw->skip = pw->next->skip;
+ } else { // or to pw's successor
+ pw->skip = pw->next;
+ }
+ }
+ return head;
+}
+
+// Traverse the elements [ pw->next, h] of the circular list whose last element
+// is head.
+// Remove all elements with wake==true and place them in the
+// singly-linked list wake_list in the order found. Assumes that
+// there is only one such element if the element has how == kExclusive.
+// Return the new head.
+static PerThreadSynch *DequeueAllWakeable(PerThreadSynch *head,
+ PerThreadSynch *pw,
+ PerThreadSynch **wake_tail) {
+ PerThreadSynch *orig_h = head;
+ PerThreadSynch *w = pw->next;
+ bool skipped = false;
+ do {
+ if (w->wake) { // remove this element
+ ABSL_RAW_CHECK(pw->skip == nullptr, "bad skip in DequeueAllWakeable");
+ // we're removing pw's successor so either pw->skip is zero or we should
+ // already have removed pw since if pw->skip!=null, pw has the same
+ // condition as w.
+ head = Dequeue(head, pw);
+ w->next = *wake_tail; // keep list terminated
+ *wake_tail = w; // add w to wake_list;
+ wake_tail = &w->next; // next addition to end
+ if (w->waitp->how == kExclusive) { // wake at most 1 writer
+ break;
+ }
+ } else { // not waking this one; skip
+ pw = Skip(w); // skip as much as possible
+ skipped = true;
+ }
+ w = pw->next;
+ // We want to stop processing after we've considered the original head,
+ // orig_h. We can't test for w==orig_h in the loop because w may skip over
+ // it; we are guaranteed only that w's predecessor will not skip over
+ // orig_h. When we've considered orig_h, either we've processed it and
+ // removed it (so orig_h != head), or we considered it and skipped it (so
+ // skipped==true && pw == head because skipping from head always skips by
+ // just one, leaving pw pointing at head). So we want to
+ // continue the loop with the negation of that expression.
+ } while (orig_h == head && (pw != head || !skipped));
+ return head;
+}
+
+// Try to remove thread s from the list of waiters on this mutex.
+// Does nothing if s is not on the waiter list.
+void Mutex::TryRemove(PerThreadSynch *s) {
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+ // acquire spinlock & lock
+ if ((v & (kMuWait | kMuSpin | kMuWriter | kMuReader)) == kMuWait &&
+ mu_.compare_exchange_strong(v, v | kMuSpin | kMuWriter,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ PerThreadSynch *h = GetPerThreadSynch(v);
+ if (h != nullptr) {
+ PerThreadSynch *pw = h; // pw is w's predecessor
+ PerThreadSynch *w;
+ if ((w = pw->next) != s) { // search for thread,
+ do { // processing at least one element
+ if (!MuSameCondition(s, w)) { // seeking different condition
+ pw = Skip(w); // so skip all that won't match
+ // we don't have to worry about dangling skip fields
+ // in the threads we skipped; none can point to s
+ // because their condition differs from s
+ } else { // seeking same condition
+ FixSkip(w, s); // fix up any skip pointer from w to s
+ pw = w;
+ }
+ // don't search further if we found the thread, or we're about to
+ // process the first thread again.
+ } while ((w = pw->next) != s && pw != h);
+ }
+ if (w == s) { // found thread; remove it
+ // pw->skip may be non-zero here; the loop above ensured that
+ // no ancestor of s can skip to s, so removal is safe anyway.
+ h = Dequeue(h, pw);
+ s->next = nullptr;
+ s->state.store(PerThreadSynch::kAvailable, std::memory_order_release);
+ }
+ }
+ intptr_t nv;
+ do { // release spinlock and lock
+ v = mu_.load(std::memory_order_relaxed);
+ nv = v & (kMuDesig | kMuEvent);
+ if (h != nullptr) {
+ nv |= kMuWait | reinterpret_cast<intptr_t>(h);
+ h->readers = 0; // we hold writer lock
+ h->maybe_unlocking = false; // finished unlocking
+ }
+ } while (!mu_.compare_exchange_weak(v, nv,
+ std::memory_order_release,
+ std::memory_order_relaxed));
+ }
+}
+
+// Wait until thread "s", which must be the current thread, is removed from the
+// this mutex's waiter queue. If "s->waitp->timeout" has a timeout, wake up
+// if the wait extends past the absolute time specified, even if "s" is still
+// on the mutex queue. In this case, remove "s" from the queue and return
+// true, otherwise return false.
+void Mutex::Block(PerThreadSynch *s) {
+ while (s->state.load(std::memory_order_acquire) == PerThreadSynch::kQueued) {
+ if (!DecrementSynchSem(this, s, s->waitp->timeout)) {
+ // After a timeout, we go into a spin loop until we remove ourselves
+ // from the queue, or someone else removes us. We can't be sure to be
+ // able to remove ourselves in a single lock acquisition because this
+ // mutex may be held, and the holder has the right to read the centre
+ // of the waiter queue without holding the spinlock.
+ this->TryRemove(s);
+ int c = 0;
+ while (s->next != nullptr) {
+ c = Delay(c, GENTLE);
+ this->TryRemove(s);
+ }
+ if (kDebugMode) {
+ // This ensures that we test the case that TryRemove() is called when s
+ // is not on the queue.
+ this->TryRemove(s);
+ }
+ s->waitp->timeout = KernelTimeout::Never(); // timeout is satisfied
+ s->waitp->cond = nullptr; // condition no longer relevant for wakeups
+ }
+ }
+ ABSL_RAW_CHECK(s->waitp != nullptr || s->suppress_fatal_errors,
+ "detected illegal recursion in Mutex code");
+ s->waitp = nullptr;
+}
+
+// Wake thread w, and return the next thread in the list.
+PerThreadSynch *Mutex::Wakeup(PerThreadSynch *w) {
+ PerThreadSynch *next = w->next;
+ w->next = nullptr;
+ w->state.store(PerThreadSynch::kAvailable, std::memory_order_release);
+ IncrementSynchSem(this, w);
+
+ return next;
+}
+
+static GraphId GetGraphIdLocked(Mutex *mu)
+ EXCLUSIVE_LOCKS_REQUIRED(deadlock_graph_mu) {
+ if (!deadlock_graph) { // (re)create the deadlock graph.
+ deadlock_graph =
+ new (base_internal::LowLevelAlloc::Alloc(sizeof(*deadlock_graph)))
+ GraphCycles;
+ }
+ return deadlock_graph->GetId(mu);
+}
+
+static GraphId GetGraphId(Mutex *mu) LOCKS_EXCLUDED(deadlock_graph_mu) {
+ deadlock_graph_mu.Lock();
+ GraphId id = GetGraphIdLocked(mu);
+ deadlock_graph_mu.Unlock();
+ return id;
+}
+
+// Record a lock acquisition. This is used in debug mode for deadlock
+// detection. The held_locks pointer points to the relevant data
+// structure for each case.
+static void LockEnter(Mutex* mu, GraphId id, SynchLocksHeld *held_locks) {
+ int n = held_locks->n;
+ int i = 0;
+ while (i != n && held_locks->locks[i].id != id) {
+ i++;
+ }
+ if (i == n) {
+ if (n == ABSL_ARRAYSIZE(held_locks->locks)) {
+ held_locks->overflow = true; // lost some data
+ } else { // we have room for lock
+ held_locks->locks[i].mu = mu;
+ held_locks->locks[i].count = 1;
+ held_locks->locks[i].id = id;
+ held_locks->n = n + 1;
+ }
+ } else {
+ held_locks->locks[i].count++;
+ }
+}
+
+// Record a lock release. Each call to LockEnter(mu, id, x) should be
+// eventually followed by a call to LockLeave(mu, id, x) by the same thread.
+// It does not process the event if is not needed when deadlock detection is
+// disabled.
+static void LockLeave(Mutex* mu, GraphId id, SynchLocksHeld *held_locks) {
+ int n = held_locks->n;
+ int i = 0;
+ while (i != n && held_locks->locks[i].id != id) {
+ i++;
+ }
+ if (i == n) {
+ if (!held_locks->overflow) {
+ // The deadlock id may have been reassigned after ForgetDeadlockInfo,
+ // but in that case mu should still be present.
+ i = 0;
+ while (i != n && held_locks->locks[i].mu != mu) {
+ i++;
+ }
+ if (i == n) { // mu missing means releasing unheld lock
+ SynchEvent *mu_events = GetSynchEvent(mu);
+ ABSL_RAW_LOG(FATAL,
+ "thread releasing lock it does not hold: %p %s; "
+ ,
+ static_cast<void *>(mu),
+ mu_events == nullptr ? "" : mu_events->name);
+ }
+ }
+ } else if (held_locks->locks[i].count == 1) {
+ held_locks->n = n - 1;
+ held_locks->locks[i] = held_locks->locks[n - 1];
+ held_locks->locks[n - 1].id = InvalidGraphId();
+ held_locks->locks[n - 1].mu =
+ nullptr; // clear mu to please the leak detector.
+ } else {
+ assert(held_locks->locks[i].count > 0);
+ held_locks->locks[i].count--;
+ }
+}
+
+// Call LockEnter() if in debug mode and deadlock detection is enabled.
+static inline void DebugOnlyLockEnter(Mutex *mu) {
+ if (kDebugMode) {
+ if (synch_deadlock_detection.load(std::memory_order_acquire) !=
+ OnDeadlockCycle::kIgnore) {
+ LockEnter(mu, GetGraphId(mu), Synch_GetAllLocks());
+ }
+ }
+}
+
+// Call LockEnter() if in debug mode and deadlock detection is enabled.
+static inline void DebugOnlyLockEnter(Mutex *mu, GraphId id) {
+ if (kDebugMode) {
+ if (synch_deadlock_detection.load(std::memory_order_acquire) !=
+ OnDeadlockCycle::kIgnore) {
+ LockEnter(mu, id, Synch_GetAllLocks());
+ }
+ }
+}
+
+// Call LockLeave() if in debug mode and deadlock detection is enabled.
+static inline void DebugOnlyLockLeave(Mutex *mu) {
+ if (kDebugMode) {
+ if (synch_deadlock_detection.load(std::memory_order_acquire) !=
+ OnDeadlockCycle::kIgnore) {
+ LockLeave(mu, GetGraphId(mu), Synch_GetAllLocks());
+ }
+ }
+}
+
+static char *StackString(void **pcs, int n, char *buf, int maxlen,
+ bool symbolize) {
+ static const int kSymLen = 200;
+ char sym[kSymLen];
+ int len = 0;
+ for (int i = 0; i != n; i++) {
+ if (symbolize) {
+ if (!symbolizer(pcs[i], sym, kSymLen)) {
+ sym[0] = '\0';
+ }
+ snprintf(buf + len, maxlen - len, "%s\t@ %p %s\n",
+ (i == 0 ? "\n" : ""),
+ pcs[i], sym);
+ } else {
+ snprintf(buf + len, maxlen - len, " %p", pcs[i]);
+ }
+ len += strlen(&buf[len]);
+ }
+ return buf;
+}
+
+static char *CurrentStackString(char *buf, int maxlen, bool symbolize) {
+ void *pcs[40];
+ return StackString(pcs, absl::GetStackTrace(pcs, ABSL_ARRAYSIZE(pcs), 2), buf,
+ maxlen, symbolize);
+}
+
+namespace {
+enum { kMaxDeadlockPathLen = 10 }; // maximum length of a deadlock cycle;
+ // a path this long would be remarkable
+// Buffers required to report a deadlock.
+// We do not allocate them on stack to avoid large stack frame.
+struct DeadlockReportBuffers {
+ char buf[6100];
+ GraphId path[kMaxDeadlockPathLen];
+};
+
+struct ScopedDeadlockReportBuffers {
+ ScopedDeadlockReportBuffers() {
+ b = reinterpret_cast<DeadlockReportBuffers *>(
+ base_internal::LowLevelAlloc::Alloc(sizeof(*b)));
+ }
+ ~ScopedDeadlockReportBuffers() { base_internal::LowLevelAlloc::Free(b); }
+ DeadlockReportBuffers *b;
+};
+
+// Helper to pass to GraphCycles::UpdateStackTrace.
+int GetStack(void** stack, int max_depth) {
+ return absl::GetStackTrace(stack, max_depth, 3);
+}
+} // anonymous namespace
+
+// Called in debug mode when a thread is about to acquire a lock in a way that
+// may block.
+static GraphId DeadlockCheck(Mutex *mu) {
+ if (synch_deadlock_detection.load(std::memory_order_acquire) ==
+ OnDeadlockCycle::kIgnore) {
+ return InvalidGraphId();
+ }
+
+ SynchLocksHeld *all_locks = Synch_GetAllLocks();
+
+ absl::base_internal::SpinLockHolder lock(&deadlock_graph_mu);
+ const GraphId mu_id = GetGraphIdLocked(mu);
+
+ if (all_locks->n == 0) {
+ // There are no other locks held. Return now so that we don't need to
+ // call GetSynchEvent(). This way we do not record the stack trace
+ // for this Mutex. It's ok, since if this Mutex is involved in a deadlock,
+ // it can't always be the first lock acquired by a thread.
+ return mu_id;
+ }
+
+ // We prefer to keep stack traces that show a thread holding and acquiring
+ // as many locks as possible. This increases the chances that a given edge
+ // in the acquires-before graph will be represented in the stack traces
+ // recorded for the locks.
+ deadlock_graph->UpdateStackTrace(mu_id, all_locks->n + 1, GetStack);
+
+ // For each other mutex already held by this thread:
+ for (int i = 0; i != all_locks->n; i++) {
+ const GraphId other_node_id = all_locks->locks[i].id;
+ const Mutex *other =
+ static_cast<const Mutex *>(deadlock_graph->Ptr(other_node_id));
+ if (other == nullptr) {
+ // Ignore stale lock
+ continue;
+ }
+
+ // Add the acquired-before edge to the graph.
+ if (!deadlock_graph->InsertEdge(other_node_id, mu_id)) {
+ ScopedDeadlockReportBuffers scoped_buffers;
+ DeadlockReportBuffers *b = scoped_buffers.b;
+ static int number_of_reported_deadlocks = 0;
+ number_of_reported_deadlocks++;
+ // Symbolize only 2 first deadlock report to avoid huge slowdowns.
+ bool symbolize = number_of_reported_deadlocks <= 2;
+ ABSL_RAW_LOG(ERROR, "Potential Mutex deadlock: %s",
+ CurrentStackString(b->buf, sizeof (b->buf), symbolize));
+ int len = 0;
+ for (int j = 0; j != all_locks->n; j++) {
+ void* pr = deadlock_graph->Ptr(all_locks->locks[j].id);
+ if (pr != nullptr) {
+ snprintf(b->buf + len, sizeof (b->buf) - len, " %p", pr);
+ len += static_cast<int>(strlen(&b->buf[len]));
+ }
+ }
+ ABSL_RAW_LOG(ERROR, "Acquiring %p Mutexes held: %s",
+ static_cast<void *>(mu), b->buf);
+ ABSL_RAW_LOG(ERROR, "Cycle: ");
+ int path_len = deadlock_graph->FindPath(
+ mu_id, other_node_id, ABSL_ARRAYSIZE(b->path), b->path);
+ for (int j = 0; j != path_len; j++) {
+ GraphId id = b->path[j];
+ Mutex *path_mu = static_cast<Mutex *>(deadlock_graph->Ptr(id));
+ if (path_mu == nullptr) continue;
+ void** stack;
+ int depth = deadlock_graph->GetStackTrace(id, &stack);
+ snprintf(b->buf, sizeof(b->buf),
+ "mutex@%p stack: ", static_cast<void *>(path_mu));
+ StackString(stack, depth, b->buf + strlen(b->buf),
+ static_cast<int>(sizeof(b->buf) - strlen(b->buf)),
+ symbolize);
+ ABSL_RAW_LOG(ERROR, "%s", b->buf);
+ }
+ if (synch_deadlock_detection.load(std::memory_order_acquire) ==
+ OnDeadlockCycle::kAbort) {
+ deadlock_graph_mu.Unlock(); // avoid deadlock in fatal sighandler
+ ABSL_RAW_LOG(FATAL, "dying due to potential deadlock");
+ return mu_id;
+ }
+ break; // report at most one potential deadlock per acquisition
+ }
+ }
+
+ return mu_id;
+}
+
+// Invoke DeadlockCheck() iff we're in debug mode and
+// deadlock checking has been enabled.
+static inline GraphId DebugOnlyDeadlockCheck(Mutex *mu) {
+ if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
+ OnDeadlockCycle::kIgnore) {
+ return DeadlockCheck(mu);
+ } else {
+ return InvalidGraphId();
+ }
+}
+
+void Mutex::ForgetDeadlockInfo() {
+ if (kDebugMode && synch_deadlock_detection.load(std::memory_order_acquire) !=
+ OnDeadlockCycle::kIgnore) {
+ deadlock_graph_mu.Lock();
+ if (deadlock_graph != nullptr) {
+ deadlock_graph->RemoveNode(this);
+ }
+ deadlock_graph_mu.Unlock();
+ }
+}
+
+void Mutex::AssertNotHeld() const {
+ // We have the data to allow this check only if in debug mode and deadlock
+ // detection is enabled.
+ if (kDebugMode &&
+ (mu_.load(std::memory_order_relaxed) & (kMuWriter | kMuReader)) != 0 &&
+ synch_deadlock_detection.load(std::memory_order_acquire) !=
+ OnDeadlockCycle::kIgnore) {
+ GraphId id = GetGraphId(const_cast<Mutex *>(this));
+ SynchLocksHeld *locks = Synch_GetAllLocks();
+ for (int i = 0; i != locks->n; i++) {
+ if (locks->locks[i].id == id) {
+ SynchEvent *mu_events = GetSynchEvent(this);
+ ABSL_RAW_LOG(FATAL, "thread should not hold mutex %p %s",
+ static_cast<const void *>(this),
+ (mu_events == nullptr ? "" : mu_events->name));
+ }
+ }
+ }
+}
+
+// Attempt to acquire *mu, and return whether successful. The implementation
+// may spin for a short while if the lock cannot be acquired immediately.
+static bool TryAcquireWithSpinning(std::atomic<intptr_t>* mu) {
+ int c = mutex_globals.spinloop_iterations;
+ int result = -1; // result of operation: 0=false, 1=true, -1=unknown
+
+ do { // do/while somewhat faster on AMD
+ intptr_t v = mu->load(std::memory_order_relaxed);
+ if ((v & (kMuReader|kMuEvent)) != 0) { // a reader or tracing -> give up
+ result = 0;
+ } else if (((v & kMuWriter) == 0) && // no holder -> try to acquire
+ mu->compare_exchange_strong(v, kMuWriter | v,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ result = 1;
+ }
+ } while (result == -1 && --c > 0);
+ return result == 1;
+}
+
+ABSL_XRAY_LOG_ARGS(1) void Mutex::Lock() {
+ ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
+ GraphId id = DebugOnlyDeadlockCheck(this);
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+ // try fast acquire, then spin loop
+ if ((v & (kMuWriter | kMuReader | kMuEvent)) != 0 ||
+ !mu_.compare_exchange_strong(v, kMuWriter | v,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ // try spin acquire, then slow loop
+ if (!TryAcquireWithSpinning(&this->mu_)) {
+ this->LockSlow(kExclusive, nullptr, 0);
+ }
+ }
+ DebugOnlyLockEnter(this, id);
+ ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+}
+
+ABSL_XRAY_LOG_ARGS(1) void Mutex::ReaderLock() {
+ ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
+ GraphId id = DebugOnlyDeadlockCheck(this);
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+ // try fast acquire, then slow loop
+ if ((v & (kMuWriter | kMuWait | kMuEvent)) != 0 ||
+ !mu_.compare_exchange_strong(v, (kMuReader | v) + kMuOne,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ this->LockSlow(kShared, nullptr, 0);
+ }
+ DebugOnlyLockEnter(this, id);
+ ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
+}
+
+void Mutex::LockWhen(const Condition &cond) {
+ ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
+ GraphId id = DebugOnlyDeadlockCheck(this);
+ this->LockSlow(kExclusive, &cond, 0);
+ DebugOnlyLockEnter(this, id);
+ ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+}
+
+bool Mutex::LockWhenWithTimeout(const Condition &cond, absl::Duration timeout) {
+ return LockWhenWithDeadline(cond, DeadlineFromTimeout(timeout));
+}
+
+bool Mutex::LockWhenWithDeadline(const Condition &cond, absl::Time deadline) {
+ ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
+ GraphId id = DebugOnlyDeadlockCheck(this);
+ bool res = LockSlowWithDeadline(kExclusive, &cond,
+ KernelTimeout(deadline), 0);
+ DebugOnlyLockEnter(this, id);
+ ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+ return res;
+}
+
+void Mutex::ReaderLockWhen(const Condition &cond) {
+ ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
+ GraphId id = DebugOnlyDeadlockCheck(this);
+ this->LockSlow(kShared, &cond, 0);
+ DebugOnlyLockEnter(this, id);
+ ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
+}
+
+bool Mutex::ReaderLockWhenWithTimeout(const Condition &cond,
+ absl::Duration timeout) {
+ return ReaderLockWhenWithDeadline(cond, DeadlineFromTimeout(timeout));
+}
+
+bool Mutex::ReaderLockWhenWithDeadline(const Condition &cond,
+ absl::Time deadline) {
+ ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_read_lock);
+ GraphId id = DebugOnlyDeadlockCheck(this);
+ bool res = LockSlowWithDeadline(kShared, &cond, KernelTimeout(deadline), 0);
+ DebugOnlyLockEnter(this, id);
+ ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_read_lock, 0);
+ return res;
+}
+
+void Mutex::Await(const Condition &cond) {
+ if (cond.Eval()) { // condition already true; nothing to do
+ if (kDebugMode) {
+ this->AssertReaderHeld();
+ }
+ } else { // normal case
+ ABSL_RAW_CHECK(this->AwaitCommon(cond, KernelTimeout::Never()),
+ "condition untrue on return from Await");
+ }
+}
+
+bool Mutex::AwaitWithTimeout(const Condition &cond, absl::Duration timeout) {
+ return AwaitWithDeadline(cond, DeadlineFromTimeout(timeout));
+}
+
+bool Mutex::AwaitWithDeadline(const Condition &cond, absl::Time deadline) {
+ if (cond.Eval()) { // condition already true; nothing to do
+ if (kDebugMode) {
+ this->AssertReaderHeld();
+ }
+ return true;
+ }
+
+ KernelTimeout t{deadline};
+ bool res = this->AwaitCommon(cond, t);
+ ABSL_RAW_CHECK(res || t.has_timeout(),
+ "condition untrue on return from Await");
+ return res;
+}
+
+bool Mutex::AwaitCommon(const Condition &cond, KernelTimeout t) {
+ this->AssertReaderHeld();
+ MuHow how =
+ (mu_.load(std::memory_order_relaxed) & kMuWriter) ? kExclusive : kShared;
+ ABSL_TSAN_MUTEX_PRE_UNLOCK(this, TsanFlags(how));
+ SynchWaitParams waitp(
+ how, &cond, t, nullptr /*no cvmu*/, Synch_GetPerThreadAnnotated(this),
+ nullptr /*no cv_word*/);
+ int flags = kMuHasBlocked;
+ if (!Condition::GuaranteedEqual(&cond, nullptr)) {
+ flags |= kMuIsCond;
+ }
+ this->UnlockSlow(&waitp);
+ this->Block(waitp.thread);
+ ABSL_TSAN_MUTEX_POST_UNLOCK(this, TsanFlags(how));
+ ABSL_TSAN_MUTEX_PRE_LOCK(this, TsanFlags(how));
+ this->LockSlowLoop(&waitp, flags);
+ bool res = waitp.cond != nullptr || // => cond known true from LockSlowLoop
+ cond.Eval();
+ ABSL_TSAN_MUTEX_POST_LOCK(this, TsanFlags(how), 0);
+ return res;
+}
+
+ABSL_XRAY_LOG_ARGS(1) bool Mutex::TryLock() {
+ ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+ if ((v & (kMuWriter | kMuReader | kMuEvent)) == 0 && // try fast acquire
+ mu_.compare_exchange_strong(v, kMuWriter | v,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ DebugOnlyLockEnter(this);
+ ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_try_lock, 0);
+ return true;
+ }
+ if ((v & kMuEvent) != 0) { // we're recording events
+ if ((v & kExclusive->slow_need_zero) == 0 && // try fast acquire
+ mu_.compare_exchange_strong(
+ v, (kExclusive->fast_or | v) + kExclusive->fast_add,
+ std::memory_order_acquire, std::memory_order_relaxed)) {
+ DebugOnlyLockEnter(this);
+ PostSynchEvent(this, SYNCH_EV_TRYLOCK_SUCCESS);
+ ABSL_TSAN_MUTEX_POST_LOCK(this, __tsan_mutex_try_lock, 0);
+ return true;
+ } else {
+ PostSynchEvent(this, SYNCH_EV_TRYLOCK_FAILED);
+ }
+ }
+ ABSL_TSAN_MUTEX_POST_LOCK(
+ this, __tsan_mutex_try_lock | __tsan_mutex_try_lock_failed, 0);
+ return false;
+}
+
+ABSL_XRAY_LOG_ARGS(1) bool Mutex::ReaderTryLock() {
+ ABSL_TSAN_MUTEX_PRE_LOCK(this,
+ __tsan_mutex_read_lock | __tsan_mutex_try_lock);
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+ // The while-loops (here and below) iterate only if the mutex word keeps
+ // changing (typically because the reader count changes) under the CAS. We
+ // limit the number of attempts to avoid having to think about livelock.
+ int loop_limit = 5;
+ while ((v & (kMuWriter|kMuWait|kMuEvent)) == 0 && loop_limit != 0) {
+ if (mu_.compare_exchange_strong(v, (kMuReader | v) + kMuOne,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ DebugOnlyLockEnter(this);
+ ABSL_TSAN_MUTEX_POST_LOCK(
+ this, __tsan_mutex_read_lock | __tsan_mutex_try_lock, 0);
+ return true;
+ }
+ loop_limit--;
+ v = mu_.load(std::memory_order_relaxed);
+ }
+ if ((v & kMuEvent) != 0) { // we're recording events
+ loop_limit = 5;
+ while ((v & kShared->slow_need_zero) == 0 && loop_limit != 0) {
+ if (mu_.compare_exchange_strong(v, (kMuReader | v) + kMuOne,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ DebugOnlyLockEnter(this);
+ PostSynchEvent(this, SYNCH_EV_READERTRYLOCK_SUCCESS);
+ ABSL_TSAN_MUTEX_POST_LOCK(
+ this, __tsan_mutex_read_lock | __tsan_mutex_try_lock, 0);
+ return true;
+ }
+ loop_limit--;
+ v = mu_.load(std::memory_order_relaxed);
+ }
+ if ((v & kMuEvent) != 0) {
+ PostSynchEvent(this, SYNCH_EV_READERTRYLOCK_FAILED);
+ }
+ }
+ ABSL_TSAN_MUTEX_POST_LOCK(this,
+ __tsan_mutex_read_lock | __tsan_mutex_try_lock |
+ __tsan_mutex_try_lock_failed,
+ 0);
+ return false;
+}
+
+ABSL_XRAY_LOG_ARGS(1) void Mutex::Unlock() {
+ ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
+ DebugOnlyLockLeave(this);
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+
+ if (kDebugMode && ((v & (kMuWriter | kMuReader)) != kMuWriter)) {
+ ABSL_RAW_LOG(FATAL, "Mutex unlocked when destroyed or not locked: v=0x%x",
+ static_cast<unsigned>(v));
+ }
+
+ // should_try_cas is whether we'll try a compare-and-swap immediately.
+ // NOTE: optimized out when kDebugMode is false.
+ bool should_try_cas = ((v & (kMuEvent | kMuWriter)) == kMuWriter &&
+ (v & (kMuWait | kMuDesig)) != kMuWait);
+ // But, we can use an alternate computation of it, that compilers
+ // currently don't find on their own. When that changes, this function
+ // can be simplified.
+ intptr_t x = (v ^ (kMuWriter | kMuWait)) & (kMuWriter | kMuEvent);
+ intptr_t y = (v ^ (kMuWriter | kMuWait)) & (kMuWait | kMuDesig);
+ // Claim: "x == 0 && y > 0" is equal to should_try_cas.
+ // Also, because kMuWriter and kMuEvent exceed kMuDesig and kMuWait,
+ // all possible non-zero values for x exceed all possible values for y.
+ // Therefore, (x == 0 && y > 0) == (x < y).
+ if (kDebugMode && should_try_cas != (x < y)) {
+ // We would usually use PRIdPTR here, but is not correctly implemented
+ // within the android toolchain.
+ ABSL_RAW_LOG(FATAL, "internal logic error %llx %llx %llx\n",
+ static_cast<long long>(v), static_cast<long long>(x),
+ static_cast<long long>(y));
+ }
+ if (x < y &&
+ mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
+ std::memory_order_release,
+ std::memory_order_relaxed)) {
+ // fast writer release (writer with no waiters or with designated waker)
+ } else {
+ this->UnlockSlow(nullptr /*no waitp*/); // take slow path
+ }
+ ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
+}
+
+// Requires v to represent a reader-locked state.
+static bool ExactlyOneReader(intptr_t v) {
+ assert((v & (kMuWriter|kMuReader)) == kMuReader);
+ assert((v & kMuHigh) != 0);
+ // The more straightforward "(v & kMuHigh) == kMuOne" also works, but
+ // on some architectures the following generates slightly smaller code.
+ // It may be faster too.
+ constexpr intptr_t kMuMultipleWaitersMask = kMuHigh ^ kMuOne;
+ return (v & kMuMultipleWaitersMask) == 0;
+}
+
+ABSL_XRAY_LOG_ARGS(1) void Mutex::ReaderUnlock() {
+ ABSL_TSAN_MUTEX_PRE_UNLOCK(this, __tsan_mutex_read_lock);
+ DebugOnlyLockLeave(this);
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+ assert((v & (kMuWriter|kMuReader)) == kMuReader);
+ if ((v & (kMuReader|kMuWait|kMuEvent)) == kMuReader) {
+ // fast reader release (reader with no waiters)
+ intptr_t clear = ExactlyOneReader(v) ? kMuReader|kMuOne : kMuOne;
+ if (mu_.compare_exchange_strong(v, v - clear,
+ std::memory_order_release,
+ std::memory_order_relaxed)) {
+ ABSL_TSAN_MUTEX_POST_UNLOCK(this, __tsan_mutex_read_lock);
+ return;
+ }
+ }
+ this->UnlockSlow(nullptr /*no waitp*/); // take slow path
+ ABSL_TSAN_MUTEX_POST_UNLOCK(this, __tsan_mutex_read_lock);
+}
+
+// The zap_desig_waker bitmask is used to clear the designated waker flag in
+// the mutex if this thread has blocked, and therefore may be the designated
+// waker.
+static const intptr_t zap_desig_waker[] = {
+ ~static_cast<intptr_t>(0), // not blocked
+ ~static_cast<intptr_t>(
+ kMuDesig) // blocked; turn off the designated waker bit
+};
+
+// The ignore_waiting_writers bitmask is used to ignore the existence
+// of waiting writers if a reader that has already blocked once
+// wakes up.
+static const intptr_t ignore_waiting_writers[] = {
+ ~static_cast<intptr_t>(0), // not blocked
+ ~static_cast<intptr_t>(
+ kMuWrWait) // blocked; pretend there are no waiting writers
+};
+
+// Internal version of LockWhen(). See LockSlowWithDeadline()
+void Mutex::LockSlow(MuHow how, const Condition *cond, int flags) {
+ ABSL_RAW_CHECK(
+ this->LockSlowWithDeadline(how, cond, KernelTimeout::Never(), flags),
+ "condition untrue on return from LockSlow");
+}
+
+// Compute cond->Eval() and tell race detectors that we do it under mutex mu.
+static inline bool EvalConditionAnnotated(const Condition *cond, Mutex *mu,
+ bool locking, Mutex::MuHow how) {
+ // Delicate annotation dance.
+ // We are currently inside of read/write lock/unlock operation.
+ // All memory accesses are ignored inside of mutex operations + for unlock
+ // operation tsan considers that we've already released the mutex.
+ bool res = false;
+ if (locking) {
+ // For lock we pretend that we have finished the operation,
+ // evaluate the predicate, then unlock the mutex and start locking it again
+ // to match the annotation at the end of outer lock operation.
+ // Note: we can't simply do POST_LOCK, Eval, PRE_LOCK, because then tsan
+ // will think the lock acquisition is recursive which will trigger
+ // deadlock detector.
+ ABSL_TSAN_MUTEX_POST_LOCK(mu, TsanFlags(how), 0);
+ res = cond->Eval();
+ ABSL_TSAN_MUTEX_PRE_UNLOCK(mu, TsanFlags(how));
+ ABSL_TSAN_MUTEX_POST_UNLOCK(mu, TsanFlags(how));
+ ABSL_TSAN_MUTEX_PRE_LOCK(mu, TsanFlags(how));
+ } else {
+ // Similarly, for unlock we pretend that we have unlocked the mutex,
+ // lock the mutex, evaluate the predicate, and start unlocking it again
+ // to match the annotation at the end of outer unlock operation.
+ ABSL_TSAN_MUTEX_POST_UNLOCK(mu, TsanFlags(how));
+ ABSL_TSAN_MUTEX_PRE_LOCK(mu, TsanFlags(how));
+ ABSL_TSAN_MUTEX_POST_LOCK(mu, TsanFlags(how), 0);
+ res = cond->Eval();
+ ABSL_TSAN_MUTEX_PRE_UNLOCK(mu, TsanFlags(how));
+ }
+ // Prevent unused param warnings in non-TSAN builds.
+ static_cast<void>(mu);
+ static_cast<void>(how);
+ return res;
+}
+
+// Compute cond->Eval() hiding it from race detectors.
+// We are hiding it because inside of UnlockSlow we can evaluate a predicate
+// that was just added by a concurrent Lock operation; Lock adds the predicate
+// to the internal Mutex list without actually acquiring the Mutex
+// (it only acquires the internal spinlock, which is rightfully invisible for
+// tsan). As the result there is no tsan-visible synchronization between the
+// addition and this thread. So if we would enable race detection here,
+// it would race with the predicate initialization.
+static inline bool EvalConditionIgnored(Mutex *mu, const Condition *cond) {
+ // Memory accesses are already ignored inside of lock/unlock operations,
+ // but synchronization operations are also ignored. When we evaluate the
+ // predicate we must ignore only memory accesses but not synchronization,
+ // because missed synchronization can lead to false reports later.
+ // So we "divert" (which un-ignores both memory accesses and synchronization)
+ // and then separately turn on ignores of memory accesses.
+ ABSL_TSAN_MUTEX_PRE_DIVERT(mu, 0);
+ ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
+ bool res = cond->Eval();
+ ANNOTATE_IGNORE_READS_AND_WRITES_END();
+ ABSL_TSAN_MUTEX_POST_DIVERT(mu, 0);
+ static_cast<void>(mu); // Prevent unused param warning in non-TSAN builds.
+ return res;
+}
+
+// Internal equivalent of *LockWhenWithDeadline(), where
+// "t" represents the absolute timeout; !t.has_timeout() means "forever".
+// "how" is "kShared" (for ReaderLockWhen) or "kExclusive" (for LockWhen)
+// In flags, bits are ored together:
+// - kMuHasBlocked indicates that the client has already blocked on the call so
+// the designated waker bit must be cleared and waiting writers should not
+// obstruct this call
+// - kMuIsCond indicates that this is a conditional acquire (condition variable,
+// Await, LockWhen) so contention profiling should be suppressed.
+bool Mutex::LockSlowWithDeadline(MuHow how, const Condition *cond,
+ KernelTimeout t, int flags) {
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+ bool unlock = false;
+ if ((v & how->fast_need_zero) == 0 && // try fast acquire
+ mu_.compare_exchange_strong(
+ v, (how->fast_or | (v & zap_desig_waker[flags & kMuHasBlocked])) +
+ how->fast_add,
+ std::memory_order_acquire, std::memory_order_relaxed)) {
+ if (cond == nullptr || EvalConditionAnnotated(cond, this, true, how)) {
+ return true;
+ }
+ unlock = true;
+ }
+ SynchWaitParams waitp(
+ how, cond, t, nullptr /*no cvmu*/, Synch_GetPerThreadAnnotated(this),
+ nullptr /*no cv_word*/);
+ if (!Condition::GuaranteedEqual(cond, nullptr)) {
+ flags |= kMuIsCond;
+ }
+ if (unlock) {
+ this->UnlockSlow(&waitp);
+ this->Block(waitp.thread);
+ flags |= kMuHasBlocked;
+ }
+ this->LockSlowLoop(&waitp, flags);
+ return waitp.cond != nullptr || // => cond known true from LockSlowLoop
+ cond == nullptr || EvalConditionAnnotated(cond, this, true, how);
+}
+
+// RAW_CHECK_FMT() takes a condition, a printf-style format std::string, and
+// the printf-style argument list. The format std::string must be a literal.
+// Arguments after the first are not evaluated unless the condition is true.
+#define RAW_CHECK_FMT(cond, ...) \
+ do { \
+ if (ABSL_PREDICT_FALSE(!(cond))) { \
+ ABSL_RAW_LOG(FATAL, "Check " #cond " failed: " __VA_ARGS__); \
+ } \
+ } while (0)
+
+static void CheckForMutexCorruption(intptr_t v, const char* label) {
+ // Test for either of two situations that should not occur in v:
+ // kMuWriter and kMuReader
+ // kMuWrWait and !kMuWait
+ const intptr_t w = v ^ kMuWait;
+ // By flipping that bit, we can now test for:
+ // kMuWriter and kMuReader in w
+ // kMuWrWait and kMuWait in w
+ // We've chosen these two pairs of values to be so that they will overlap,
+ // respectively, when the word is left shifted by three. This allows us to
+ // save a branch in the common (correct) case of them not being coincident.
+ static_assert(kMuReader << 3 == kMuWriter, "must match");
+ static_assert(kMuWait << 3 == kMuWrWait, "must match");
+ if (ABSL_PREDICT_TRUE((w & (w << 3) & (kMuWriter | kMuWrWait)) == 0)) return;
+ RAW_CHECK_FMT((v & (kMuWriter | kMuReader)) != (kMuWriter | kMuReader),
+ "%s: Mutex corrupt: both reader and writer lock held: %p",
+ label, reinterpret_cast<void *>(v));
+ RAW_CHECK_FMT((v & (kMuWait | kMuWrWait)) != kMuWrWait,
+ "%s: Mutex corrupt: waiting writer with no waiters: %p",
+ label, reinterpret_cast<void *>(v));
+ assert(false);
+}
+
+void Mutex::LockSlowLoop(SynchWaitParams *waitp, int flags) {
+ int c = 0;
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+ if ((v & kMuEvent) != 0) {
+ PostSynchEvent(this,
+ waitp->how == kExclusive? SYNCH_EV_LOCK: SYNCH_EV_READERLOCK);
+ }
+ ABSL_RAW_CHECK(
+ waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
+ "detected illegal recursion into Mutex code");
+ for (;;) {
+ v = mu_.load(std::memory_order_relaxed);
+ CheckForMutexCorruption(v, "Lock");
+ if ((v & waitp->how->slow_need_zero) == 0) {
+ if (mu_.compare_exchange_strong(
+ v, (waitp->how->fast_or |
+ (v & zap_desig_waker[flags & kMuHasBlocked])) +
+ waitp->how->fast_add,
+ std::memory_order_acquire, std::memory_order_relaxed)) {
+ if (waitp->cond == nullptr ||
+ EvalConditionAnnotated(waitp->cond, this, true, waitp->how)) {
+ break; // we timed out, or condition true, so return
+ }
+ this->UnlockSlow(waitp); // got lock but condition false
+ this->Block(waitp->thread);
+ flags |= kMuHasBlocked;
+ c = 0;
+ }
+ } else { // need to access waiter list
+ bool dowait = false;
+ if ((v & (kMuSpin|kMuWait)) == 0) { // no waiters
+ // This thread tries to become the one and only waiter.
+ PerThreadSynch *new_h = Enqueue(nullptr, waitp, v, flags);
+ intptr_t nv = (v & zap_desig_waker[flags & kMuHasBlocked] & kMuLow) |
+ kMuWait;
+ ABSL_RAW_CHECK(new_h != nullptr, "Enqueue to empty list failed");
+ if (waitp->how == kExclusive && (v & kMuReader) != 0) {
+ nv |= kMuWrWait;
+ }
+ if (mu_.compare_exchange_strong(
+ v, reinterpret_cast<intptr_t>(new_h) | nv,
+ std::memory_order_release, std::memory_order_relaxed)) {
+ dowait = true;
+ } else { // attempted Enqueue() failed
+ // zero out the waitp field set by Enqueue()
+ waitp->thread->waitp = nullptr;
+ }
+ } else if ((v & waitp->how->slow_inc_need_zero &
+ ignore_waiting_writers[flags & kMuHasBlocked]) == 0) {
+ // This is a reader that needs to increment the reader count,
+ // but the count is currently held in the last waiter.
+ if (mu_.compare_exchange_strong(
+ v, (v & zap_desig_waker[flags & kMuHasBlocked]) | kMuSpin |
+ kMuReader,
+ std::memory_order_acquire, std::memory_order_relaxed)) {
+ PerThreadSynch *h = GetPerThreadSynch(v);
+ h->readers += kMuOne; // inc reader count in waiter
+ do { // release spinlock
+ v = mu_.load(std::memory_order_relaxed);
+ } while (!mu_.compare_exchange_weak(v, (v & ~kMuSpin) | kMuReader,
+ std::memory_order_release,
+ std::memory_order_relaxed));
+ if (waitp->cond == nullptr ||
+ EvalConditionAnnotated(waitp->cond, this, true, waitp->how)) {
+ break; // we timed out, or condition true, so return
+ }
+ this->UnlockSlow(waitp); // got lock but condition false
+ this->Block(waitp->thread);
+ flags |= kMuHasBlocked;
+ c = 0;
+ }
+ } else if ((v & kMuSpin) == 0 && // attempt to queue ourselves
+ mu_.compare_exchange_strong(
+ v, (v & zap_desig_waker[flags & kMuHasBlocked]) | kMuSpin |
+ kMuWait,
+ std::memory_order_acquire, std::memory_order_relaxed)) {
+ PerThreadSynch *h = GetPerThreadSynch(v);
+ PerThreadSynch *new_h = Enqueue(h, waitp, v, flags);
+ intptr_t wr_wait = 0;
+ ABSL_RAW_CHECK(new_h != nullptr, "Enqueue to list failed");
+ if (waitp->how == kExclusive && (v & kMuReader) != 0) {
+ wr_wait = kMuWrWait; // give priority to a waiting writer
+ }
+ do { // release spinlock
+ v = mu_.load(std::memory_order_relaxed);
+ } while (!mu_.compare_exchange_weak(
+ v, (v & (kMuLow & ~kMuSpin)) | kMuWait | wr_wait |
+ reinterpret_cast<intptr_t>(new_h),
+ std::memory_order_release, std::memory_order_relaxed));
+ dowait = true;
+ }
+ if (dowait) {
+ this->Block(waitp->thread); // wait until removed from list or timeout
+ flags |= kMuHasBlocked;
+ c = 0;
+ }
+ }
+ ABSL_RAW_CHECK(
+ waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
+ "detected illegal recursion into Mutex code");
+ c = Delay(c, GENTLE); // delay, then try again
+ }
+ ABSL_RAW_CHECK(
+ waitp->thread->waitp == nullptr || waitp->thread->suppress_fatal_errors,
+ "detected illegal recursion into Mutex code");
+ if ((v & kMuEvent) != 0) {
+ PostSynchEvent(this,
+ waitp->how == kExclusive? SYNCH_EV_LOCK_RETURNING :
+ SYNCH_EV_READERLOCK_RETURNING);
+ }
+}
+
+// Unlock this mutex, which is held by the current thread.
+// If waitp is non-zero, it must be the wait parameters for the current thread
+// which holds the lock but is not runnable because its condition is false
+// or it n the process of blocking on a condition variable; it must requeue
+// itself on the mutex/condvar to wait for its condition to become true.
+void Mutex::UnlockSlow(SynchWaitParams *waitp) {
+ intptr_t v = mu_.load(std::memory_order_relaxed);
+ this->AssertReaderHeld();
+ CheckForMutexCorruption(v, "Unlock");
+ if ((v & kMuEvent) != 0) {
+ PostSynchEvent(this,
+ (v & kMuWriter) != 0? SYNCH_EV_UNLOCK: SYNCH_EV_READERUNLOCK);
+ }
+ int c = 0;
+ // the waiter under consideration to wake, or zero
+ PerThreadSynch *w = nullptr;
+ // the predecessor to w or zero
+ PerThreadSynch *pw = nullptr;
+ // head of the list searched previously, or zero
+ PerThreadSynch *old_h = nullptr;
+ // a condition that's known to be false.
+ const Condition *known_false = nullptr;
+ PerThreadSynch *wake_list = kPerThreadSynchNull; // list of threads to wake
+ intptr_t wr_wait = 0; // set to kMuWrWait if we wake a reader and a
+ // later writer could have acquired the lock
+ // (starvation avoidance)
+ ABSL_RAW_CHECK(waitp == nullptr || waitp->thread->waitp == nullptr ||
+ waitp->thread->suppress_fatal_errors,
+ "detected illegal recursion into Mutex code");
+ // This loop finds threads wake_list to wakeup if any, and removes them from
+ // the list of waiters. In addition, it places waitp.thread on the queue of
+ // waiters if waitp is non-zero.
+ for (;;) {
+ v = mu_.load(std::memory_order_relaxed);
+ if ((v & kMuWriter) != 0 && (v & (kMuWait | kMuDesig)) != kMuWait &&
+ waitp == nullptr) {
+ // fast writer release (writer with no waiters or with designated waker)
+ if (mu_.compare_exchange_strong(v, v & ~(kMuWrWait | kMuWriter),
+ std::memory_order_release,
+ std::memory_order_relaxed)) {
+ return;
+ }
+ } else if ((v & (kMuReader | kMuWait)) == kMuReader && waitp == nullptr) {
+ // fast reader release (reader with no waiters)
+ intptr_t clear = ExactlyOneReader(v) ? kMuReader | kMuOne : kMuOne;
+ if (mu_.compare_exchange_strong(v, v - clear,
+ std::memory_order_release,
+ std::memory_order_relaxed)) {
+ return;
+ }
+ } else if ((v & kMuSpin) == 0 && // attempt to get spinlock
+ mu_.compare_exchange_strong(v, v | kMuSpin,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ if ((v & kMuWait) == 0) { // no one to wake
+ intptr_t nv;
+ bool do_enqueue = true; // always Enqueue() the first time
+ ABSL_RAW_CHECK(waitp != nullptr,
+ "UnlockSlow is confused"); // about to sleep
+ do { // must loop to release spinlock as reader count may change
+ v = mu_.load(std::memory_order_relaxed);
+ // decrement reader count if there are readers
+ intptr_t new_readers = (v >= kMuOne)? v - kMuOne : v;
+ PerThreadSynch *new_h = nullptr;
+ if (do_enqueue) {
+ // If we are enqueuing on a CondVar (waitp->cv_word != nullptr) then
+ // we must not retry here. The initial attempt will always have
+ // succeeded, further attempts would enqueue us against *this due to
+ // Fer() handling.
+ do_enqueue = (waitp->cv_word == nullptr);
+ new_h = Enqueue(nullptr, waitp, new_readers, kMuIsCond);
+ }
+ intptr_t clear = kMuWrWait | kMuWriter; // by default clear write bit
+ if ((v & kMuWriter) == 0 && ExactlyOneReader(v)) { // last reader
+ clear = kMuWrWait | kMuReader; // clear read bit
+ }
+ nv = (v & kMuLow & ~clear & ~kMuSpin);
+ if (new_h != nullptr) {
+ nv |= kMuWait | reinterpret_cast<intptr_t>(new_h);
+ } else { // new_h could be nullptr if we queued ourselves on a
+ // CondVar
+ // In that case, we must place the reader count back in the mutex
+ // word, as Enqueue() did not store it in the new waiter.
+ nv |= new_readers & kMuHigh;
+ }
+ // release spinlock & our lock; retry if reader-count changed
+ // (writer count cannot change since we hold lock)
+ } while (!mu_.compare_exchange_weak(v, nv,
+ std::memory_order_release,
+ std::memory_order_relaxed));
+ break;
+ }
+
+ // There are waiters.
+ // Set h to the head of the circular waiter list.
+ PerThreadSynch *h = GetPerThreadSynch(v);
+ if ((v & kMuReader) != 0 && (h->readers & kMuHigh) > kMuOne) {
+ // a reader but not the last
+ h->readers -= kMuOne; // release our lock
+ intptr_t nv = v; // normally just release spinlock
+ if (waitp != nullptr) { // but waitp!=nullptr => must queue ourselves
+ PerThreadSynch *new_h = Enqueue(h, waitp, v, kMuIsCond);
+ ABSL_RAW_CHECK(new_h != nullptr,
+ "waiters disappeared during Enqueue()!");
+ nv &= kMuLow;
+ nv |= kMuWait | reinterpret_cast<intptr_t>(new_h);
+ }
+ mu_.store(nv, std::memory_order_release); // release spinlock
+ // can release with a store because there were waiters
+ break;
+ }
+
+ // Either we didn't search before, or we marked the queue
+ // as "maybe_unlocking" and no one else should have changed it.
+ ABSL_RAW_CHECK(old_h == nullptr || h->maybe_unlocking,
+ "Mutex queue changed beneath us");
+
+ // The lock is becoming free, and there's a waiter
+ if (old_h != nullptr &&
+ !old_h->may_skip) { // we used old_h as a terminator
+ old_h->may_skip = true; // allow old_h to skip once mor
<TRUNCATED>
[31/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/char_map.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/char_map.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/char_map.h
new file mode 100644
index 0000000..8d92963
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/char_map.h
@@ -0,0 +1,154 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Character Map Class
+//
+// A fast, bit-vector map for 8-bit unsigned characters.
+// This class is useful for non-character purposes as well.
+
+#ifndef ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
+#define ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+
+namespace absl {
+namespace strings_internal {
+
+class Charmap {
+ public:
+ constexpr Charmap() : m_() {}
+
+ // Initializes with a given char*. Note that NUL is not treated as
+ // a terminator, but rather a char to be flicked.
+ Charmap(const char* str, int len) : m_() {
+ while (len--) SetChar(*str++);
+ }
+
+ // Initializes with a given char*. NUL is treated as a terminator
+ // and will not be in the charmap.
+ explicit Charmap(const char* str) : m_() {
+ while (*str) SetChar(*str++);
+ }
+
+ constexpr bool contains(unsigned char c) const {
+ return (m_[c / 64] >> (c % 64)) & 0x1;
+ }
+
+ // Returns true if and only if a character exists in both maps.
+ bool IntersectsWith(const Charmap& c) const {
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(m_); ++i) {
+ if ((m_[i] & c.m_[i]) != 0) return true;
+ }
+ return false;
+ }
+
+ bool IsZero() const {
+ for (uint64_t c : m_) {
+ if (c != 0) return false;
+ }
+ return true;
+ }
+
+ // Containing only a single specified char.
+ static constexpr Charmap Char(char x) {
+ return Charmap(CharMaskForWord(x, 0), CharMaskForWord(x, 1),
+ CharMaskForWord(x, 2), CharMaskForWord(x, 3));
+ }
+
+ // Containing all the chars in the C-std::string 's'.
+ // Note that this is expensively recursive because of the C++11 constexpr
+ // formulation. Use only in constexpr initializers.
+ static constexpr Charmap FromString(const char* s) {
+ return *s == 0 ? Charmap() : (Char(*s) | FromString(s + 1));
+ }
+
+ // Containing all the chars in the closed interval [lo,hi].
+ static constexpr Charmap Range(char lo, char hi) {
+ return Charmap(RangeForWord(lo, hi, 0), RangeForWord(lo, hi, 1),
+ RangeForWord(lo, hi, 2), RangeForWord(lo, hi, 3));
+ }
+
+ friend constexpr Charmap operator&(const Charmap& a, const Charmap& b) {
+ return Charmap(a.m_[0] & b.m_[0], a.m_[1] & b.m_[1], a.m_[2] & b.m_[2],
+ a.m_[3] & b.m_[3]);
+ }
+
+ friend constexpr Charmap operator|(const Charmap& a, const Charmap& b) {
+ return Charmap(a.m_[0] | b.m_[0], a.m_[1] | b.m_[1], a.m_[2] | b.m_[2],
+ a.m_[3] | b.m_[3]);
+ }
+
+ friend constexpr Charmap operator~(const Charmap& a) {
+ return Charmap(~a.m_[0], ~a.m_[1], ~a.m_[2], ~a.m_[3]);
+ }
+
+ private:
+ constexpr Charmap(uint64_t b0, uint64_t b1, uint64_t b2, uint64_t b3)
+ : m_{b0, b1, b2, b3} {}
+
+ static constexpr uint64_t RangeForWord(unsigned char lo, unsigned char hi,
+ uint64_t word) {
+ return OpenRangeFromZeroForWord(hi + 1, word) &
+ ~OpenRangeFromZeroForWord(lo, word);
+ }
+
+ // All the chars in the specified word of the range [0, upper).
+ static constexpr uint64_t OpenRangeFromZeroForWord(uint64_t upper,
+ uint64_t word) {
+ return (upper <= 64 * word)
+ ? 0
+ : (upper >= 64 * (word + 1))
+ ? ~static_cast<uint64_t>(0)
+ : (~static_cast<uint64_t>(0) >> (64 - upper % 64));
+ }
+
+ static constexpr uint64_t CharMaskForWord(unsigned char x, uint64_t word) {
+ return (x / 64 == word) ? (static_cast<uint64_t>(1) << (x % 64)) : 0;
+ }
+
+ private:
+ void SetChar(unsigned char c) {
+ m_[c / 64] |= static_cast<uint64_t>(1) << (c % 64);
+ }
+
+ uint64_t m_[4];
+};
+
+// Mirror the char-classifying predicates in <cctype>
+constexpr Charmap UpperCharmap() { return Charmap::Range('A', 'Z'); }
+constexpr Charmap LowerCharmap() { return Charmap::Range('a', 'z'); }
+constexpr Charmap DigitCharmap() { return Charmap::Range('0', '9'); }
+constexpr Charmap AlphaCharmap() { return LowerCharmap() | UpperCharmap(); }
+constexpr Charmap AlnumCharmap() { return DigitCharmap() | AlphaCharmap(); }
+constexpr Charmap XDigitCharmap() {
+ return DigitCharmap() | Charmap::Range('A', 'F') | Charmap::Range('a', 'f');
+}
+constexpr Charmap PrintCharmap() { return Charmap::Range(0x20, 0x7e); }
+constexpr Charmap SpaceCharmap() { return Charmap::FromString("\t\n\v\f\r "); }
+constexpr Charmap CntrlCharmap() {
+ return Charmap::Range(0, 0x7f) & ~PrintCharmap();
+}
+constexpr Charmap BlankCharmap() { return Charmap::FromString("\t "); }
+constexpr Charmap GraphCharmap() { return PrintCharmap() & ~SpaceCharmap(); }
+constexpr Charmap PunctCharmap() { return GraphCharmap() & ~AlnumCharmap(); }
+
+} // namespace strings_internal
+} // namespace absl
+
+#endif // ABSL_STRINGS_INTERNAL_CHAR_MAP_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/char_map_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/char_map_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/char_map_test.cc
new file mode 100644
index 0000000..c3601e1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/char_map_test.cc
@@ -0,0 +1,172 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/internal/char_map.h"
+
+#include <cctype>
+#include <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+constexpr absl::strings_internal::Charmap everything_map =
+ ~absl::strings_internal::Charmap();
+constexpr absl::strings_internal::Charmap nothing_map{};
+
+TEST(Charmap, AllTests) {
+ const absl::strings_internal::Charmap also_nothing_map("", 0);
+ ASSERT_TRUE(everything_map.contains('\0'));
+ ASSERT_TRUE(!nothing_map.contains('\0'));
+ ASSERT_TRUE(!also_nothing_map.contains('\0'));
+ for (unsigned char ch = 1; ch != 0; ++ch) {
+ ASSERT_TRUE(everything_map.contains(ch));
+ ASSERT_TRUE(!nothing_map.contains(ch));
+ ASSERT_TRUE(!also_nothing_map.contains(ch));
+ }
+
+ const absl::strings_internal::Charmap symbols("&@#@^!@?", 5);
+ ASSERT_TRUE(symbols.contains('&'));
+ ASSERT_TRUE(symbols.contains('@'));
+ ASSERT_TRUE(symbols.contains('#'));
+ ASSERT_TRUE(symbols.contains('^'));
+ ASSERT_TRUE(!symbols.contains('!'));
+ ASSERT_TRUE(!symbols.contains('?'));
+ int cnt = 0;
+ for (unsigned char ch = 1; ch != 0; ++ch)
+ cnt += symbols.contains(ch);
+ ASSERT_EQ(cnt, 4);
+
+ const absl::strings_internal::Charmap lets("^abcde", 3);
+ const absl::strings_internal::Charmap lets2("fghij\0klmnop", 10);
+ const absl::strings_internal::Charmap lets3("fghij\0klmnop");
+ ASSERT_TRUE(lets2.contains('k'));
+ ASSERT_TRUE(!lets3.contains('k'));
+
+ ASSERT_TRUE(symbols.IntersectsWith(lets));
+ ASSERT_TRUE(!lets2.IntersectsWith(lets));
+ ASSERT_TRUE(lets.IntersectsWith(symbols));
+ ASSERT_TRUE(!lets.IntersectsWith(lets2));
+
+ ASSERT_TRUE(nothing_map.IsZero());
+ ASSERT_TRUE(!lets.IsZero());
+}
+
+namespace {
+std::string Members(const absl::strings_internal::Charmap& m) {
+ std::string r;
+ for (size_t i = 0; i < 256; ++i)
+ if (m.contains(i)) r.push_back(i);
+ return r;
+}
+
+std::string ClosedRangeString(unsigned char lo, unsigned char hi) {
+ // Don't depend on lo<hi. Just increment until lo==hi.
+ std::string s;
+ while (true) {
+ s.push_back(lo);
+ if (lo == hi) break;
+ ++lo;
+ }
+ return s;
+}
+
+} // namespace
+
+TEST(Charmap, Constexpr) {
+ constexpr absl::strings_internal::Charmap kEmpty = nothing_map;
+ EXPECT_THAT(Members(kEmpty), "");
+ constexpr absl::strings_internal::Charmap kA =
+ absl::strings_internal::Charmap::Char('A');
+ EXPECT_THAT(Members(kA), "A");
+ constexpr absl::strings_internal::Charmap kAZ =
+ absl::strings_internal::Charmap::Range('A', 'Z');
+ EXPECT_THAT(Members(kAZ), "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+ constexpr absl::strings_internal::Charmap kIdentifier =
+ absl::strings_internal::Charmap::Range('0', '9') |
+ absl::strings_internal::Charmap::Range('A', 'Z') |
+ absl::strings_internal::Charmap::Range('a', 'z') |
+ absl::strings_internal::Charmap::Char('_');
+ EXPECT_THAT(Members(kIdentifier),
+ "0123456789"
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "_"
+ "abcdefghijklmnopqrstuvwxyz");
+ constexpr absl::strings_internal::Charmap kAll = everything_map;
+ for (size_t i = 0; i < 256; ++i) {
+ EXPECT_TRUE(kAll.contains(i)) << i;
+ }
+ constexpr absl::strings_internal::Charmap kHello =
+ absl::strings_internal::Charmap::FromString("Hello, world!");
+ EXPECT_THAT(Members(kHello), " !,Hdelorw");
+
+ // test negation and intersection
+ constexpr absl::strings_internal::Charmap kABC =
+ absl::strings_internal::Charmap::Range('A', 'Z') &
+ ~absl::strings_internal::Charmap::Range('D', 'Z');
+ EXPECT_THAT(Members(kABC), "ABC");
+}
+
+TEST(Charmap, Range) {
+ // Exhaustive testing takes too long, so test some of the boundaries that
+ // are perhaps going to cause trouble.
+ std::vector<size_t> poi = {0, 1, 2, 3, 4, 7, 8, 9, 15,
+ 16, 17, 30, 31, 32, 33, 63, 64, 65,
+ 127, 128, 129, 223, 224, 225, 254, 255};
+ for (auto lo = poi.begin(); lo != poi.end(); ++lo) {
+ SCOPED_TRACE(*lo);
+ for (auto hi = lo; hi != poi.end(); ++hi) {
+ SCOPED_TRACE(*hi);
+ EXPECT_THAT(Members(absl::strings_internal::Charmap::Range(*lo, *hi)),
+ ClosedRangeString(*lo, *hi));
+ }
+ }
+}
+
+bool AsBool(int x) { return static_cast<bool>(x); }
+
+TEST(CharmapCtype, Match) {
+ for (int c = 0; c < 256; ++c) {
+ SCOPED_TRACE(c);
+ SCOPED_TRACE(static_cast<char>(c));
+ EXPECT_EQ(AsBool(std::isupper(c)),
+ absl::strings_internal::UpperCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::islower(c)),
+ absl::strings_internal::LowerCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::isdigit(c)),
+ absl::strings_internal::DigitCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::isalpha(c)),
+ absl::strings_internal::AlphaCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::isalnum(c)),
+ absl::strings_internal::AlnumCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::isxdigit(c)),
+ absl::strings_internal::XDigitCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::isprint(c)),
+ absl::strings_internal::PrintCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::isspace(c)),
+ absl::strings_internal::SpaceCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::iscntrl(c)),
+ absl::strings_internal::CntrlCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::isblank(c)),
+ absl::strings_internal::BlankCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::isgraph(c)),
+ absl::strings_internal::GraphCharmap().contains(c));
+ EXPECT_EQ(AsBool(std::ispunct(c)),
+ absl::strings_internal::PunctCharmap().contains(c));
+ }
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/escaping_test_common.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/escaping_test_common.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/escaping_test_common.inc
new file mode 100644
index 0000000..6f29140
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/escaping_test_common.inc
@@ -0,0 +1,113 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This test contains common things needed by both escaping_test.cc and
+// escaping_benchmark.cc.
+
+namespace {
+
+struct {
+ absl::string_view plaintext;
+ absl::string_view cyphertext;
+} const base64_strings[] = {
+ // Some google quotes
+ // Cyphertext created with "uuencode (GNU sharutils) 4.6.3"
+ // (Note that we're testing the websafe encoding, though, so if
+ // you add messages, be sure to run "tr -- '+/' '-_'" on the output)
+ { "I was always good at math and science, and I never realized "
+ "that was unusual or somehow undesirable. So one of the things "
+ "I care a lot about is helping to remove that stigma, "
+ "to show girls that you can be feminine, you can like the things "
+ "that girls like, but you can also be really good at technology. "
+ "You can be really good at building things."
+ " - Marissa Meyer, Newsweek, 2010-12-22" "\n",
+
+ "SSB3YXMgYWx3YXlzIGdvb2QgYXQgbWF0aCBhbmQgc2NpZW5jZSwgYW5kIEkg"
+ "bmV2ZXIgcmVhbGl6ZWQgdGhhdCB3YXMgdW51c3VhbCBvciBzb21laG93IHVu"
+ "ZGVzaXJhYmxlLiBTbyBvbmUgb2YgdGhlIHRoaW5ncyBJIGNhcmUgYSBsb3Qg"
+ "YWJvdXQgaXMgaGVscGluZyB0byByZW1vdmUgdGhhdCBzdGlnbWEsIHRvIHNo"
+ "b3cgZ2lybHMgdGhhdCB5b3UgY2FuIGJlIGZlbWluaW5lLCB5b3UgY2FuIGxp"
+ "a2UgdGhlIHRoaW5ncyB0aGF0IGdpcmxzIGxpa2UsIGJ1dCB5b3UgY2FuIGFs"
+ "c28gYmUgcmVhbGx5IGdvb2QgYXQgdGVjaG5vbG9neS4gWW91IGNhbiBiZSBy"
+ "ZWFsbHkgZ29vZCBhdCBidWlsZGluZyB0aGluZ3MuIC0gTWFyaXNzYSBNZXll"
+ "ciwgTmV3c3dlZWssIDIwMTAtMTItMjIK" },
+
+ { "Typical first year for a new cluster: "
+ "~0.5 overheating "
+ "~1 PDU failure "
+ "~1 rack-move "
+ "~1 network rewiring "
+ "~20 rack failures "
+ "~5 racks go wonky "
+ "~8 network maintenances "
+ "~12 router reloads "
+ "~3 router failures "
+ "~dozens of minor 30-second blips for dns "
+ "~1000 individual machine failures "
+ "~thousands of hard drive failures "
+ "slow disks, bad memory, misconfigured machines, flaky machines, etc."
+ " - Jeff Dean, The Joys of Real Hardware" "\n",
+
+ "VHlwaWNhbCBmaXJzdCB5ZWFyIGZvciBhIG5ldyBjbHVzdGVyOiB-MC41IG92"
+ "ZXJoZWF0aW5nIH4xIFBEVSBmYWlsdXJlIH4xIHJhY2stbW92ZSB-MSBuZXR3"
+ "b3JrIHJld2lyaW5nIH4yMCByYWNrIGZhaWx1cmVzIH41IHJhY2tzIGdvIHdv"
+ "bmt5IH44IG5ldHdvcmsgbWFpbnRlbmFuY2VzIH4xMiByb3V0ZXIgcmVsb2Fk"
+ "cyB-MyByb3V0ZXIgZmFpbHVyZXMgfmRvemVucyBvZiBtaW5vciAzMC1zZWNv"
+ "bmQgYmxpcHMgZm9yIGRucyB-MTAwMCBpbmRpdmlkdWFsIG1hY2hpbmUgZmFp"
+ "bHVyZXMgfnRob3VzYW5kcyBvZiBoYXJkIGRyaXZlIGZhaWx1cmVzIHNsb3cg"
+ "ZGlza3MsIGJhZCBtZW1vcnksIG1pc2NvbmZpZ3VyZWQgbWFjaGluZXMsIGZs"
+ "YWt5IG1hY2hpbmVzLCBldGMuIC0gSmVmZiBEZWFuLCBUaGUgSm95cyBvZiBS"
+ "ZWFsIEhhcmR3YXJlCg" },
+
+ { "I'm the head of the webspam team at Google. "
+ "That means that if you type your name into Google and get porn back, "
+ "it's my fault. Unless you're a porn star, in which case porn is a "
+ "completely reasonable response."
+ " - Matt Cutts, Google Plus" "\n",
+
+ "SSdtIHRoZSBoZWFkIG9mIHRoZSB3ZWJzcGFtIHRlYW0gYXQgR29vZ2xlLiAg"
+ "VGhhdCBtZWFucyB0aGF0IGlmIHlvdSB0eXBlIHlvdXIgbmFtZSBpbnRvIEdv"
+ "b2dsZSBhbmQgZ2V0IHBvcm4gYmFjaywgaXQncyBteSBmYXVsdC4gVW5sZXNz"
+ "IHlvdSdyZSBhIHBvcm4gc3RhciwgaW4gd2hpY2ggY2FzZSBwb3JuIGlzIGEg"
+ "Y29tcGxldGVseSByZWFzb25hYmxlIHJlc3BvbnNlLiAtIE1hdHQgQ3V0dHMs"
+ "IEdvb2dsZSBQbHVzCg" },
+
+ { "It will still be a long time before machines approach human intelligence. "
+ "But luckily, machines don't actually have to be intelligent; "
+ "they just have to fake it. Access to a wealth of information, "
+ "combined with a rudimentary decision-making capacity, "
+ "can often be almost as useful. Of course, the results are better yet "
+ "when coupled with intelligence. A reference librarian with access to "
+ "a good search engine is a formidable tool."
+ " - Craig Silverstein, Siemens Pictures of the Future, Spring 2004" "\n",
+
+ "SXQgd2lsbCBzdGlsbCBiZSBhIGxvbmcgdGltZSBiZWZvcmUgbWFjaGluZXMg"
+ "YXBwcm9hY2ggaHVtYW4gaW50ZWxsaWdlbmNlLiBCdXQgbHVja2lseSwgbWFj"
+ "aGluZXMgZG9uJ3QgYWN0dWFsbHkgaGF2ZSB0byBiZSBpbnRlbGxpZ2VudDsg"
+ "dGhleSBqdXN0IGhhdmUgdG8gZmFrZSBpdC4gQWNjZXNzIHRvIGEgd2VhbHRo"
+ "IG9mIGluZm9ybWF0aW9uLCBjb21iaW5lZCB3aXRoIGEgcnVkaW1lbnRhcnkg"
+ "ZGVjaXNpb24tbWFraW5nIGNhcGFjaXR5LCBjYW4gb2Z0ZW4gYmUgYWxtb3N0"
+ "IGFzIHVzZWZ1bC4gT2YgY291cnNlLCB0aGUgcmVzdWx0cyBhcmUgYmV0dGVy"
+ "IHlldCB3aGVuIGNvdXBsZWQgd2l0aCBpbnRlbGxpZ2VuY2UuIEEgcmVmZXJl"
+ "bmNlIGxpYnJhcmlhbiB3aXRoIGFjY2VzcyB0byBhIGdvb2Qgc2VhcmNoIGVu"
+ "Z2luZSBpcyBhIGZvcm1pZGFibGUgdG9vbC4gLSBDcmFpZyBTaWx2ZXJzdGVp"
+ "biwgU2llbWVucyBQaWN0dXJlcyBvZiB0aGUgRnV0dXJlLCBTcHJpbmcgMjAw"
+ "NAo" },
+
+ // Degenerate edge case
+ { "",
+ "" },
+};
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil.cc
new file mode 100644
index 0000000..a0de70d
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil.cc
@@ -0,0 +1,110 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/internal/memutil.h"
+
+#include <cstdlib>
+
+namespace absl {
+namespace strings_internal {
+
+int memcasecmp(const char* s1, const char* s2, size_t len) {
+ const unsigned char* us1 = reinterpret_cast<const unsigned char*>(s1);
+ const unsigned char* us2 = reinterpret_cast<const unsigned char*>(s2);
+
+ for (size_t i = 0; i < len; i++) {
+ const int diff =
+ int{static_cast<unsigned char>(absl::ascii_tolower(us1[i]))} -
+ int{static_cast<unsigned char>(absl::ascii_tolower(us2[i]))};
+ if (diff != 0) return diff;
+ }
+ return 0;
+}
+
+char* memdup(const char* s, size_t slen) {
+ void* copy;
+ if ((copy = malloc(slen)) == nullptr) return nullptr;
+ memcpy(copy, s, slen);
+ return reinterpret_cast<char*>(copy);
+}
+
+char* memrchr(const char* s, int c, size_t slen) {
+ for (const char* e = s + slen - 1; e >= s; e--) {
+ if (*e == c) return const_cast<char*>(e);
+ }
+ return nullptr;
+}
+
+size_t memspn(const char* s, size_t slen, const char* accept) {
+ const char* p = s;
+ const char* spanp;
+ char c, sc;
+
+cont:
+ c = *p++;
+ if (slen-- == 0) return p - 1 - s;
+ for (spanp = accept; (sc = *spanp++) != '\0';)
+ if (sc == c) goto cont;
+ return p - 1 - s;
+}
+
+size_t memcspn(const char* s, size_t slen, const char* reject) {
+ const char* p = s;
+ const char* spanp;
+ char c, sc;
+
+ while (slen-- != 0) {
+ c = *p++;
+ for (spanp = reject; (sc = *spanp++) != '\0';)
+ if (sc == c) return p - 1 - s;
+ }
+ return p - s;
+}
+
+char* mempbrk(const char* s, size_t slen, const char* accept) {
+ const char* scanp;
+ int sc;
+
+ for (; slen; ++s, --slen) {
+ for (scanp = accept; (sc = *scanp++) != '\0';)
+ if (sc == *s) return const_cast<char*>(s);
+ }
+ return nullptr;
+}
+
+// This is significantly faster for case-sensitive matches with very
+// few possible matches. See unit test for benchmarks.
+const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle,
+ size_t neelen) {
+ if (0 == neelen) {
+ return phaystack; // even if haylen is 0
+ }
+ if (haylen < neelen) return nullptr;
+
+ const char* match;
+ const char* hayend = phaystack + haylen - neelen + 1;
+ // A static cast is used here to work around the fact that memchr returns
+ // a void* on Posix-compliant systems and const void* on Windows.
+ while ((match = static_cast<const char*>(
+ memchr(phaystack, pneedle[0], hayend - phaystack)))) {
+ if (memcmp(match, pneedle, neelen) == 0)
+ return match;
+ else
+ phaystack = match + 1;
+ }
+ return nullptr;
+}
+
+} // namespace strings_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil.h
new file mode 100644
index 0000000..a6f1c69
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil.h
@@ -0,0 +1,146 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// These routines provide mem versions of standard C std::string routines,
+// such as strpbrk. They function exactly the same as the str versions,
+// so if you wonder what they are, replace the word "mem" by
+// "str" and check out the man page. I could return void*, as the
+// strutil.h mem*() routines tend to do, but I return char* instead
+// since this is by far the most common way these functions are called.
+//
+// The difference between the mem and str versions is the mem version
+// takes a pointer and a length, rather than a '\0'-terminated std::string.
+// The memcase* routines defined here assume the locale is "C"
+// (they use absl::ascii_tolower instead of tolower).
+//
+// These routines are based on the BSD library.
+//
+// Here's a list of routines from std::string.h, and their mem analogues.
+// Functions in lowercase are defined in std::string.h; those in UPPERCASE
+// are defined here:
+//
+// strlen --
+// strcat strncat MEMCAT
+// strcpy strncpy memcpy
+// -- memccpy (very cool function, btw)
+// -- memmove
+// -- memset
+// strcmp strncmp memcmp
+// strcasecmp strncasecmp MEMCASECMP
+// strchr memchr
+// strcoll --
+// strxfrm --
+// strdup strndup MEMDUP
+// strrchr MEMRCHR
+// strspn MEMSPN
+// strcspn MEMCSPN
+// strpbrk MEMPBRK
+// strstr MEMSTR MEMMEM
+// (g)strcasestr MEMCASESTR MEMCASEMEM
+// strtok --
+// strprefix MEMPREFIX (strprefix is from strutil.h)
+// strcaseprefix MEMCASEPREFIX (strcaseprefix is from strutil.h)
+// strsuffix MEMSUFFIX (strsuffix is from strutil.h)
+// strcasesuffix MEMCASESUFFIX (strcasesuffix is from strutil.h)
+// -- MEMIS
+// -- MEMCASEIS
+// strcount MEMCOUNT (strcount is from strutil.h)
+
+#ifndef ABSL_STRINGS_INTERNAL_MEMUTIL_H_
+#define ABSL_STRINGS_INTERNAL_MEMUTIL_H_
+
+#include <cstddef>
+#include <cstring>
+
+#include "absl/base/port.h" // disable some warnings on Windows
+#include "absl/strings/ascii.h" // for absl::ascii_tolower
+
+namespace absl {
+namespace strings_internal {
+
+inline char* memcat(char* dest, size_t destlen, const char* src,
+ size_t srclen) {
+ return reinterpret_cast<char*>(memcpy(dest + destlen, src, srclen));
+}
+
+int memcasecmp(const char* s1, const char* s2, size_t len);
+char* memdup(const char* s, size_t slen);
+char* memrchr(const char* s, int c, size_t slen);
+size_t memspn(const char* s, size_t slen, const char* accept);
+size_t memcspn(const char* s, size_t slen, const char* reject);
+char* mempbrk(const char* s, size_t slen, const char* accept);
+
+// This is for internal use only. Don't call this directly
+template <bool case_sensitive>
+const char* int_memmatch(const char* haystack, size_t haylen,
+ const char* needle, size_t neelen) {
+ if (0 == neelen) {
+ return haystack; // even if haylen is 0
+ }
+ const char* hayend = haystack + haylen;
+ const char* needlestart = needle;
+ const char* needleend = needlestart + neelen;
+
+ for (; haystack < hayend; ++haystack) {
+ char hay = case_sensitive
+ ? *haystack
+ : absl::ascii_tolower(static_cast<unsigned char>(*haystack));
+ char nee = case_sensitive
+ ? *needle
+ : absl::ascii_tolower(static_cast<unsigned char>(*needle));
+ if (hay == nee) {
+ if (++needle == needleend) {
+ return haystack + 1 - neelen;
+ }
+ } else if (needle != needlestart) {
+ // must back up haystack in case a prefix matched (find "aab" in "aaab")
+ haystack -= needle - needlestart; // for loop will advance one more
+ needle = needlestart;
+ }
+ }
+ return nullptr;
+}
+
+// These are the guys you can call directly
+inline const char* memstr(const char* phaystack, size_t haylen,
+ const char* pneedle) {
+ return int_memmatch<true>(phaystack, haylen, pneedle, strlen(pneedle));
+}
+
+inline const char* memcasestr(const char* phaystack, size_t haylen,
+ const char* pneedle) {
+ return int_memmatch<false>(phaystack, haylen, pneedle, strlen(pneedle));
+}
+
+inline const char* memmem(const char* phaystack, size_t haylen,
+ const char* pneedle, size_t needlelen) {
+ return int_memmatch<true>(phaystack, haylen, pneedle, needlelen);
+}
+
+inline const char* memcasemem(const char* phaystack, size_t haylen,
+ const char* pneedle, size_t needlelen) {
+ return int_memmatch<false>(phaystack, haylen, pneedle, needlelen);
+}
+
+// This is significantly faster for case-sensitive matches with very
+// few possible matches. See unit test for benchmarks.
+const char* memmatch(const char* phaystack, size_t haylen, const char* pneedle,
+ size_t neelen);
+
+} // namespace strings_internal
+} // namespace absl
+
+#endif // ABSL_STRINGS_INTERNAL_MEMUTIL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil_test.cc
new file mode 100644
index 0000000..09424de
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/memutil_test.cc
@@ -0,0 +1,179 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Unit test for memutil.cc
+
+#include "absl/strings/internal/memutil.h"
+
+#include <cstdlib>
+
+#include "gtest/gtest.h"
+#include "absl/strings/ascii.h"
+
+namespace {
+
+static char* memcasechr(const char* s, int c, size_t slen) {
+ c = absl::ascii_tolower(c);
+ for (; slen; ++s, --slen) {
+ if (absl::ascii_tolower(*s) == c) return const_cast<char*>(s);
+ }
+ return nullptr;
+}
+
+static const char* memcasematch(const char* phaystack, size_t haylen,
+ const char* pneedle, size_t neelen) {
+ if (0 == neelen) {
+ return phaystack; // even if haylen is 0
+ }
+ if (haylen < neelen) return nullptr;
+
+ const char* match;
+ const char* hayend = phaystack + haylen - neelen + 1;
+ while ((match = static_cast<char*>(
+ memcasechr(phaystack, pneedle[0], hayend - phaystack)))) {
+ if (absl::strings_internal::memcasecmp(match, pneedle, neelen) == 0)
+ return match;
+ else
+ phaystack = match + 1;
+ }
+ return nullptr;
+}
+
+TEST(MemUtilTest, AllTests) {
+ // check memutil functions
+ char a[1000];
+ absl::strings_internal::memcat(a, 0, "hello", sizeof("hello") - 1);
+ absl::strings_internal::memcat(a, 5, " there", sizeof(" there") - 1);
+
+ EXPECT_EQ(absl::strings_internal::memcasecmp(a, "heLLO there",
+ sizeof("hello there") - 1),
+ 0);
+ EXPECT_EQ(absl::strings_internal::memcasecmp(a, "heLLO therf",
+ sizeof("hello there") - 1),
+ -1);
+ EXPECT_EQ(absl::strings_internal::memcasecmp(a, "heLLO therf",
+ sizeof("hello there") - 2),
+ 0);
+ EXPECT_EQ(absl::strings_internal::memcasecmp(a, "whatever", 0), 0);
+
+ char* p = absl::strings_internal::memdup("hello", 5);
+ free(p);
+
+ p = absl::strings_internal::memrchr("hello there", 'e',
+ sizeof("hello there") - 1);
+ EXPECT_TRUE(p && p[-1] == 'r');
+ p = absl::strings_internal::memrchr("hello there", 'e',
+ sizeof("hello there") - 2);
+ EXPECT_TRUE(p && p[-1] == 'h');
+ p = absl::strings_internal::memrchr("hello there", 'u',
+ sizeof("hello there") - 1);
+ EXPECT_TRUE(p == nullptr);
+
+ int len = absl::strings_internal::memspn("hello there",
+ sizeof("hello there") - 1, "hole");
+ EXPECT_EQ(len, sizeof("hello") - 1);
+ len = absl::strings_internal::memspn("hello there", sizeof("hello there") - 1,
+ "u");
+ EXPECT_EQ(len, 0);
+ len = absl::strings_internal::memspn("hello there", sizeof("hello there") - 1,
+ "");
+ EXPECT_EQ(len, 0);
+ len = absl::strings_internal::memspn("hello there", sizeof("hello there") - 1,
+ "trole h");
+ EXPECT_EQ(len, sizeof("hello there") - 1);
+ len = absl::strings_internal::memspn("hello there!",
+ sizeof("hello there!") - 1, "trole h");
+ EXPECT_EQ(len, sizeof("hello there") - 1);
+ len = absl::strings_internal::memspn("hello there!",
+ sizeof("hello there!") - 2, "trole h!");
+ EXPECT_EQ(len, sizeof("hello there!") - 2);
+
+ len = absl::strings_internal::memcspn("hello there",
+ sizeof("hello there") - 1, "leho");
+ EXPECT_EQ(len, 0);
+ len = absl::strings_internal::memcspn("hello there",
+ sizeof("hello there") - 1, "u");
+ EXPECT_EQ(len, sizeof("hello there") - 1);
+ len = absl::strings_internal::memcspn("hello there",
+ sizeof("hello there") - 1, "");
+ EXPECT_EQ(len, sizeof("hello there") - 1);
+ len = absl::strings_internal::memcspn("hello there",
+ sizeof("hello there") - 1, " ");
+ EXPECT_EQ(len, 5);
+
+ p = absl::strings_internal::mempbrk("hello there", sizeof("hello there") - 1,
+ "leho");
+ EXPECT_TRUE(p && p[1] == 'e' && p[2] == 'l');
+ p = absl::strings_internal::mempbrk("hello there", sizeof("hello there") - 1,
+ "nu");
+ EXPECT_TRUE(p == nullptr);
+ p = absl::strings_internal::mempbrk("hello there!",
+ sizeof("hello there!") - 2, "!");
+ EXPECT_TRUE(p == nullptr);
+ p = absl::strings_internal::mempbrk("hello there", sizeof("hello there") - 1,
+ " t ");
+ EXPECT_TRUE(p && p[-1] == 'o' && p[1] == 't');
+
+ {
+ const char kHaystack[] = "0123456789";
+ EXPECT_EQ(absl::strings_internal::memmem(kHaystack, 0, "", 0), kHaystack);
+ EXPECT_EQ(absl::strings_internal::memmem(kHaystack, 10, "012", 3),
+ kHaystack);
+ EXPECT_EQ(absl::strings_internal::memmem(kHaystack, 10, "0xx", 1),
+ kHaystack);
+ EXPECT_EQ(absl::strings_internal::memmem(kHaystack, 10, "789", 3),
+ kHaystack + 7);
+ EXPECT_EQ(absl::strings_internal::memmem(kHaystack, 10, "9xx", 1),
+ kHaystack + 9);
+ EXPECT_TRUE(absl::strings_internal::memmem(kHaystack, 10, "9xx", 3) ==
+ nullptr);
+ EXPECT_TRUE(absl::strings_internal::memmem(kHaystack, 10, "xxx", 1) ==
+ nullptr);
+ }
+ {
+ const char kHaystack[] = "aBcDeFgHiJ";
+ EXPECT_EQ(absl::strings_internal::memcasemem(kHaystack, 0, "", 0),
+ kHaystack);
+ EXPECT_EQ(absl::strings_internal::memcasemem(kHaystack, 10, "Abc", 3),
+ kHaystack);
+ EXPECT_EQ(absl::strings_internal::memcasemem(kHaystack, 10, "Axx", 1),
+ kHaystack);
+ EXPECT_EQ(absl::strings_internal::memcasemem(kHaystack, 10, "hIj", 3),
+ kHaystack + 7);
+ EXPECT_EQ(absl::strings_internal::memcasemem(kHaystack, 10, "jxx", 1),
+ kHaystack + 9);
+ EXPECT_TRUE(absl::strings_internal::memcasemem(kHaystack, 10, "jxx", 3) ==
+ nullptr);
+ EXPECT_TRUE(absl::strings_internal::memcasemem(kHaystack, 10, "xxx", 1) ==
+ nullptr);
+ }
+ {
+ const char kHaystack[] = "0123456789";
+ EXPECT_EQ(absl::strings_internal::memmatch(kHaystack, 0, "", 0), kHaystack);
+ EXPECT_EQ(absl::strings_internal::memmatch(kHaystack, 10, "012", 3),
+ kHaystack);
+ EXPECT_EQ(absl::strings_internal::memmatch(kHaystack, 10, "0xx", 1),
+ kHaystack);
+ EXPECT_EQ(absl::strings_internal::memmatch(kHaystack, 10, "789", 3),
+ kHaystack + 7);
+ EXPECT_EQ(absl::strings_internal::memmatch(kHaystack, 10, "9xx", 1),
+ kHaystack + 9);
+ EXPECT_TRUE(absl::strings_internal::memmatch(kHaystack, 10, "9xx", 3) ==
+ nullptr);
+ EXPECT_TRUE(absl::strings_internal::memmatch(kHaystack, 10, "xxx", 1) ==
+ nullptr);
+ }
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/numbers_test_common.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/numbers_test_common.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/numbers_test_common.inc
new file mode 100644
index 0000000..81d2a1b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/numbers_test_common.inc
@@ -0,0 +1,156 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file contains common things needed by numbers_test.cc,
+// numbers_legacy_test.cc and numbers_benchmark.cc.
+
+namespace {
+
+template <typename IntType>
+bool Itoa(IntType value, int base, std::string* destination) {
+ destination->clear();
+ if (base <= 1 || base > 36) {
+ return false;
+ }
+
+ if (value == 0) {
+ destination->push_back('0');
+ return true;
+ }
+
+ bool negative = value < 0;
+ while (value != 0) {
+ const IntType next_value = value / base;
+ // Can't use std::abs here because of problems when IntType is unsigned.
+ int remainder = value > next_value * base ? value - next_value * base
+ : next_value * base - value;
+ char c = remainder < 10 ? '0' + remainder : 'A' + remainder - 10;
+ destination->insert(0, 1, c);
+ value = next_value;
+ }
+
+ if (negative) {
+ destination->insert(0, 1, '-');
+ }
+ return true;
+}
+
+struct uint32_test_case {
+ const char* str;
+ bool expect_ok;
+ int base; // base to pass to the conversion function
+ uint32_t expected;
+} const strtouint32_test_cases[] = {
+ {"0xffffffff", true, 16, std::numeric_limits<uint32_t>::max()},
+ {"0x34234324", true, 16, 0x34234324},
+ {"34234324", true, 16, 0x34234324},
+ {"0", true, 16, 0},
+ {" \t\n 0xffffffff", true, 16, std::numeric_limits<uint32_t>::max()},
+ {" \f\v 46", true, 10, 46}, // must accept weird whitespace
+ {" \t\n 72717222", true, 8, 072717222},
+ {" \t\n 072717222", true, 8, 072717222},
+ {" \t\n 072717228", false, 8, 07271722},
+ {"0", true, 0, 0},
+
+ // Base-10 version.
+ {"34234324", true, 0, 34234324},
+ {"4294967295", true, 0, std::numeric_limits<uint32_t>::max()},
+ {"34234324 \n\t", true, 10, 34234324},
+
+ // Unusual base
+ {"0", true, 3, 0},
+ {"2", true, 3, 2},
+ {"11", true, 3, 4},
+
+ // Invalid uints.
+ {"", false, 0, 0},
+ {" ", false, 0, 0},
+ {"abc", false, 0, 0}, // would be valid hex, but prefix is missing
+ {"34234324a", false, 0, 34234324},
+ {"34234.3", false, 0, 34234},
+ {"-1", false, 0, 0},
+ {" -123", false, 0, 0},
+ {" \t\n -123", false, 0, 0},
+
+ // Out of bounds.
+ {"4294967296", false, 0, std::numeric_limits<uint32_t>::max()},
+ {"0x100000000", false, 0, std::numeric_limits<uint32_t>::max()},
+ {nullptr, false, 0, 0},
+};
+
+struct uint64_test_case {
+ const char* str;
+ bool expect_ok;
+ int base;
+ uint64_t expected;
+} const strtouint64_test_cases[] = {
+ {"0x3423432448783446", true, 16, int64_t{0x3423432448783446}},
+ {"3423432448783446", true, 16, int64_t{0x3423432448783446}},
+
+ {"0", true, 16, 0},
+ {"000", true, 0, 0},
+ {"0", true, 0, 0},
+ {" \t\n 0xffffffffffffffff", true, 16,
+ std::numeric_limits<uint64_t>::max()},
+
+ {"012345670123456701234", true, 8, int64_t{012345670123456701234}},
+ {"12345670123456701234", true, 8, int64_t{012345670123456701234}},
+
+ {"12845670123456701234", false, 8, 0},
+
+ // Base-10 version.
+ {"34234324487834466", true, 0, int64_t{34234324487834466}},
+
+ {" \t\n 18446744073709551615", true, 0,
+ std::numeric_limits<uint64_t>::max()},
+
+ {"34234324487834466 \n\t ", true, 0, int64_t{34234324487834466}},
+
+ {" \f\v 46", true, 10, 46}, // must accept weird whitespace
+
+ // Unusual base
+ {"0", true, 3, 0},
+ {"2", true, 3, 2},
+ {"11", true, 3, 4},
+
+ {"0", true, 0, 0},
+
+ // Invalid uints.
+ {"", false, 0, 0},
+ {" ", false, 0, 0},
+ {"abc", false, 0, 0},
+ {"34234324487834466a", false, 0, 0},
+ {"34234487834466.3", false, 0, 0},
+ {"-1", false, 0, 0},
+ {" -123", false, 0, 0},
+ {" \t\n -123", false, 0, 0},
+
+ // Out of bounds.
+ {"18446744073709551616", false, 10, 0},
+ {"18446744073709551616", false, 0, 0},
+ {"0x10000000000000000", false, 16, std::numeric_limits<uint64_t>::max()},
+ {"0X10000000000000000", false, 16,
+ std::numeric_limits<uint64_t>::max()}, // 0X versus 0x.
+ {"0x10000000000000000", false, 0, std::numeric_limits<uint64_t>::max()},
+ {"0X10000000000000000", false, 0,
+ std::numeric_limits<uint64_t>::max()}, // 0X versus 0x.
+
+ {"0x1234", true, 16, 0x1234},
+
+ // Base-10 std::string version.
+ {"1234", true, 0, 1234},
+ {nullptr, false, 0, 0},
+};
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream.cc
new file mode 100644
index 0000000..6ee2b10
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream.cc
@@ -0,0 +1,34 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/internal/ostringstream.h"
+
+namespace absl {
+namespace strings_internal {
+
+OStringStream::Buf::int_type OStringStream::overflow(int c) {
+ assert(s_);
+ if (!Buf::traits_type::eq_int_type(c, Buf::traits_type::eof()))
+ s_->push_back(static_cast<char>(c));
+ return 1;
+}
+
+std::streamsize OStringStream::xsputn(const char* s, std::streamsize n) {
+ assert(s_);
+ s_->append(s, n);
+ return n;
+}
+
+} // namespace strings_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream.h
new file mode 100644
index 0000000..6e1325b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream.h
@@ -0,0 +1,87 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
+#define ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
+
+#include <cassert>
+#include <ostream>
+#include <streambuf>
+#include <string>
+
+#include "absl/base/port.h"
+
+namespace absl {
+namespace strings_internal {
+
+// The same as std::ostringstream but appends to a user-specified std::string,
+// and is faster. It is ~70% faster to create, ~50% faster to write to, and
+// completely free to extract the result std::string.
+//
+// std::string s;
+// OStringStream strm(&s);
+// strm << 42 << ' ' << 3.14; // appends to `s`
+//
+// The stream object doesn't have to be named. Starting from C++11 operator<<
+// works with rvalues of std::ostream.
+//
+// std::string s;
+// OStringStream(&s) << 42 << ' ' << 3.14; // appends to `s`
+//
+// OStringStream is faster to create than std::ostringstream but it's still
+// relatively slow. Avoid creating multiple streams where a single stream will
+// do.
+//
+// Creates unnecessary instances of OStringStream: slow.
+//
+// std::string s;
+// OStringStream(&s) << 42;
+// OStringStream(&s) << ' ';
+// OStringStream(&s) << 3.14;
+//
+// Creates a single instance of OStringStream and reuses it: fast.
+//
+// std::string s;
+// OStringStream strm(&s);
+// strm << 42;
+// strm << ' ';
+// strm << 3.14;
+//
+// Note: flush() has no effect. No reason to call it.
+class OStringStream : private std::basic_streambuf<char>, public std::ostream {
+ public:
+ // The argument can be null, in which case you'll need to call str(p) with a
+ // non-null argument before you can write to the stream.
+ //
+ // The destructor of OStringStream doesn't use the std::string. It's OK to destroy
+ // the std::string before the stream.
+ explicit OStringStream(std::string* s) : std::ostream(this), s_(s) {}
+
+ std::string* str() { return s_; }
+ const std::string* str() const { return s_; }
+ void str(std::string* s) { s_ = s; }
+
+ private:
+ using Buf = std::basic_streambuf<char>;
+
+ Buf::int_type overflow(int c) override;
+ std::streamsize xsputn(const char* s, std::streamsize n) override;
+
+ std::string* s_;
+};
+
+} // namespace strings_internal
+} // namespace absl
+
+#endif // ABSL_STRINGS_INTERNAL_OSTRINGSTREAM_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream_test.cc
new file mode 100644
index 0000000..069a0e1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/ostringstream_test.cc
@@ -0,0 +1,102 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/internal/ostringstream.h"
+
+#include <memory>
+#include <ostream>
+#include <string>
+#include <type_traits>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+TEST(OStringStream, IsOStream) {
+ static_assert(
+ std::is_base_of<std::ostream, absl::strings_internal::OStringStream>(),
+ "");
+}
+
+TEST(OStringStream, ConstructDestroy) {
+ {
+ absl::strings_internal::OStringStream strm(nullptr);
+ EXPECT_EQ(nullptr, strm.str());
+ }
+ {
+ std::string s = "abc";
+ {
+ absl::strings_internal::OStringStream strm(&s);
+ EXPECT_EQ(&s, strm.str());
+ }
+ EXPECT_EQ("abc", s);
+ }
+ {
+ std::unique_ptr<std::string> s(new std::string);
+ absl::strings_internal::OStringStream strm(s.get());
+ s.reset();
+ }
+}
+
+TEST(OStringStream, Str) {
+ std::string s1;
+ absl::strings_internal::OStringStream strm(&s1);
+ const absl::strings_internal::OStringStream& c_strm(strm);
+
+ static_assert(std::is_same<decltype(strm.str()), std::string*>(), "");
+ static_assert(std::is_same<decltype(c_strm.str()), const std::string*>(), "");
+
+ EXPECT_EQ(&s1, strm.str());
+ EXPECT_EQ(&s1, c_strm.str());
+
+ strm.str(&s1);
+ EXPECT_EQ(&s1, strm.str());
+ EXPECT_EQ(&s1, c_strm.str());
+
+ std::string s2;
+ strm.str(&s2);
+ EXPECT_EQ(&s2, strm.str());
+ EXPECT_EQ(&s2, c_strm.str());
+
+ strm.str(nullptr);
+ EXPECT_EQ(nullptr, strm.str());
+ EXPECT_EQ(nullptr, c_strm.str());
+}
+
+TEST(OStreamStream, WriteToLValue) {
+ std::string s = "abc";
+ {
+ absl::strings_internal::OStringStream strm(&s);
+ EXPECT_EQ("abc", s);
+ strm << "";
+ EXPECT_EQ("abc", s);
+ strm << 42;
+ EXPECT_EQ("abc42", s);
+ strm << 'x' << 'y';
+ EXPECT_EQ("abc42xy", s);
+ }
+ EXPECT_EQ("abc42xy", s);
+}
+
+TEST(OStreamStream, WriteToRValue) {
+ std::string s = "abc";
+ absl::strings_internal::OStringStream(&s) << "";
+ EXPECT_EQ("abc", s);
+ absl::strings_internal::OStringStream(&s) << 42;
+ EXPECT_EQ("abc42", s);
+ absl::strings_internal::OStringStream(&s) << 'x' << 'y';
+ EXPECT_EQ("abc42xy", s);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/resize_uninitialized.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/resize_uninitialized.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/resize_uninitialized.h
new file mode 100644
index 0000000..0157ca0
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/resize_uninitialized.h
@@ -0,0 +1,69 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
+#define ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
+
+#include <string>
+#include <utility>
+
+#include "absl/base/port.h"
+#include "absl/meta/type_traits.h" // for void_t
+
+namespace absl {
+namespace strings_internal {
+
+// Is a subclass of true_type or false_type, depending on whether or not
+// T has a resize_uninitialized member.
+template <typename T, typename = void>
+struct HasResizeUninitialized : std::false_type {};
+template <typename T>
+struct HasResizeUninitialized<
+ T, absl::void_t<decltype(std::declval<T>().resize_uninitialized(237))>>
+ : std::true_type {};
+
+template <typename string_type>
+void ResizeUninit(string_type* s, size_t new_size, std::true_type) {
+ s->resize_uninitialized(new_size);
+}
+template <typename string_type>
+void ResizeUninit(string_type* s, size_t new_size, std::false_type) {
+ s->resize(new_size);
+}
+
+// Returns true if the std::string implementation supports a resize where
+// the new characters added to the std::string are left untouched.
+//
+// (A better name might be "STLStringSupportsUninitializedResize", alluding to
+// the previous function.)
+template <typename string_type>
+inline constexpr bool STLStringSupportsNontrashingResize(string_type*) {
+ return HasResizeUninitialized<string_type>();
+}
+
+// Like str->resize(new_size), except any new characters added to "*str" as a
+// result of resizing may be left uninitialized, rather than being filled with
+// '0' bytes. Typically used when code is then going to overwrite the backing
+// store of the std::string with known data. Uses a Google extension to std::string.
+template <typename string_type, typename = void>
+inline void STLStringResizeUninitialized(string_type* s, size_t new_size) {
+ ResizeUninit(s, new_size, HasResizeUninitialized<string_type>());
+}
+
+} // namespace strings_internal
+} // namespace absl
+
+#endif // ABSL_STRINGS_INTERNAL_RESIZE_UNINITIALIZED_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/resize_uninitialized_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/resize_uninitialized_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/resize_uninitialized_test.cc
new file mode 100644
index 0000000..ad282ef
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/resize_uninitialized_test.cc
@@ -0,0 +1,68 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/internal/resize_uninitialized.h"
+
+#include "gtest/gtest.h"
+
+namespace {
+
+int resize_call_count = 0;
+
+struct resizable_string {
+ void resize(size_t) { resize_call_count += 1; }
+};
+
+int resize_uninitialized_call_count = 0;
+
+struct resize_uninitializable_string {
+ void resize(size_t) { resize_call_count += 1; }
+ void resize_uninitialized(size_t) { resize_uninitialized_call_count += 1; }
+};
+
+TEST(ResizeUninit, WithAndWithout) {
+ resize_call_count = 0;
+ resize_uninitialized_call_count = 0;
+ {
+ resizable_string rs;
+
+ EXPECT_EQ(resize_call_count, 0);
+ EXPECT_EQ(resize_uninitialized_call_count, 0);
+ EXPECT_FALSE(
+ absl::strings_internal::STLStringSupportsNontrashingResize(&rs));
+ EXPECT_EQ(resize_call_count, 0);
+ EXPECT_EQ(resize_uninitialized_call_count, 0);
+ absl::strings_internal::STLStringResizeUninitialized(&rs, 237);
+ EXPECT_EQ(resize_call_count, 1);
+ EXPECT_EQ(resize_uninitialized_call_count, 0);
+ }
+
+ resize_call_count = 0;
+ resize_uninitialized_call_count = 0;
+ {
+ resize_uninitializable_string rus;
+
+ EXPECT_EQ(resize_call_count, 0);
+ EXPECT_EQ(resize_uninitialized_call_count, 0);
+ EXPECT_TRUE(
+ absl::strings_internal::STLStringSupportsNontrashingResize(&rus));
+ EXPECT_EQ(resize_call_count, 0);
+ EXPECT_EQ(resize_uninitialized_call_count, 0);
+ absl::strings_internal::STLStringResizeUninitialized(&rus, 237);
+ EXPECT_EQ(resize_call_count, 0);
+ EXPECT_EQ(resize_uninitialized_call_count, 1);
+ }
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/stl_type_traits.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/stl_type_traits.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/stl_type_traits.h
new file mode 100644
index 0000000..04c4a53
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/stl_type_traits.h
@@ -0,0 +1,246 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Thie file provides the IsStrictlyBaseOfAndConvertibleToSTLContainer type
+// trait metafunction to assist in working with the _GLIBCXX_DEBUG debug
+// wrappers of STL containers.
+//
+// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
+// absl/strings/str_split.h.
+//
+// IWYU pragma: private, include "absl/strings/str_split.h"
+
+#ifndef ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
+#define ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
+
+#include <array>
+#include <bitset>
+#include <deque>
+#include <forward_list>
+#include <list>
+#include <map>
+#include <set>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+namespace strings_internal {
+
+template <typename C, template <typename...> class T>
+struct IsSpecializationImpl : std::false_type {};
+template <template <typename...> class T, typename... Args>
+struct IsSpecializationImpl<T<Args...>, T> : std::true_type {};
+template <typename C, template <typename...> class T>
+using IsSpecialization = IsSpecializationImpl<absl::decay_t<C>, T>;
+
+template <typename C>
+struct IsArrayImpl : std::false_type {};
+template <template <typename, size_t> class A, typename T, size_t N>
+struct IsArrayImpl<A<T, N>> : std::is_same<A<T, N>, std::array<T, N>> {};
+template <typename C>
+using IsArray = IsArrayImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsBitsetImpl : std::false_type {};
+template <template <size_t> class B, size_t N>
+struct IsBitsetImpl<B<N>> : std::is_same<B<N>, std::bitset<N>> {};
+template <typename C>
+using IsBitset = IsBitsetImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsSTLContainer
+ : absl::disjunction<
+ IsArray<C>, IsBitset<C>, IsSpecialization<C, std::deque>,
+ IsSpecialization<C, std::forward_list>,
+ IsSpecialization<C, std::list>, IsSpecialization<C, std::map>,
+ IsSpecialization<C, std::multimap>, IsSpecialization<C, std::set>,
+ IsSpecialization<C, std::multiset>,
+ IsSpecialization<C, std::unordered_map>,
+ IsSpecialization<C, std::unordered_multimap>,
+ IsSpecialization<C, std::unordered_set>,
+ IsSpecialization<C, std::unordered_multiset>,
+ IsSpecialization<C, std::vector>> {};
+
+template <typename C, template <typename...> class T, typename = void>
+struct IsBaseOfSpecializationImpl : std::false_type {};
+// IsBaseOfSpecializationImpl needs multiple partial specializations to SFINAE
+// on the existence of container dependent types and plug them into the STL
+// template.
+template <typename C, template <typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+ C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
+ : std::is_base_of<C,
+ T<typename C::value_type, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+ C, T,
+ absl::void_t<typename C::key_type, typename C::key_compare,
+ typename C::allocator_type>>
+ : std::is_base_of<C, T<typename C::key_type, typename C::key_compare,
+ typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+ C, T,
+ absl::void_t<typename C::key_type, typename C::mapped_type,
+ typename C::key_compare, typename C::allocator_type>>
+ : std::is_base_of<C,
+ T<typename C::key_type, typename C::mapped_type,
+ typename C::key_compare, typename C::allocator_type>> {
+};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+ C, T,
+ absl::void_t<typename C::key_type, typename C::hasher,
+ typename C::key_equal, typename C::allocator_type>>
+ : std::is_base_of<C, T<typename C::key_type, typename C::hasher,
+ typename C::key_equal, typename C::allocator_type>> {
+};
+template <typename C,
+ template <typename, typename, typename, typename, typename> class T>
+struct IsBaseOfSpecializationImpl<
+ C, T,
+ absl::void_t<typename C::key_type, typename C::mapped_type,
+ typename C::hasher, typename C::key_equal,
+ typename C::allocator_type>>
+ : std::is_base_of<C, T<typename C::key_type, typename C::mapped_type,
+ typename C::hasher, typename C::key_equal,
+ typename C::allocator_type>> {};
+template <typename C, template <typename...> class T>
+using IsBaseOfSpecialization = IsBaseOfSpecializationImpl<absl::decay_t<C>, T>;
+
+template <typename C>
+struct IsBaseOfArrayImpl : std::false_type {};
+template <template <typename, size_t> class A, typename T, size_t N>
+struct IsBaseOfArrayImpl<A<T, N>> : std::is_base_of<A<T, N>, std::array<T, N>> {
+};
+template <typename C>
+using IsBaseOfArray = IsBaseOfArrayImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsBaseOfBitsetImpl : std::false_type {};
+template <template <size_t> class B, size_t N>
+struct IsBaseOfBitsetImpl<B<N>> : std::is_base_of<B<N>, std::bitset<N>> {};
+template <typename C>
+using IsBaseOfBitset = IsBaseOfBitsetImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsBaseOfSTLContainer
+ : absl::disjunction<IsBaseOfArray<C>, IsBaseOfBitset<C>,
+ IsBaseOfSpecialization<C, std::deque>,
+ IsBaseOfSpecialization<C, std::forward_list>,
+ IsBaseOfSpecialization<C, std::list>,
+ IsBaseOfSpecialization<C, std::map>,
+ IsBaseOfSpecialization<C, std::multimap>,
+ IsBaseOfSpecialization<C, std::set>,
+ IsBaseOfSpecialization<C, std::multiset>,
+ IsBaseOfSpecialization<C, std::unordered_map>,
+ IsBaseOfSpecialization<C, std::unordered_multimap>,
+ IsBaseOfSpecialization<C, std::unordered_set>,
+ IsBaseOfSpecialization<C, std::unordered_multiset>,
+ IsBaseOfSpecialization<C, std::vector>> {};
+
+template <typename C, template <typename...> class T, typename = void>
+struct IsConvertibleToSpecializationImpl : std::false_type {};
+// IsConvertibleToSpecializationImpl needs multiple partial specializations to
+// SFINAE on the existence of container dependent types and plug them into the
+// STL template.
+template <typename C, template <typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+ C, T, absl::void_t<typename C::value_type, typename C::allocator_type>>
+ : std::is_convertible<
+ C, T<typename C::value_type, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+ C, T,
+ absl::void_t<typename C::key_type, typename C::key_compare,
+ typename C::allocator_type>>
+ : std::is_convertible<C, T<typename C::key_type, typename C::key_compare,
+ typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+ C, T,
+ absl::void_t<typename C::key_type, typename C::mapped_type,
+ typename C::key_compare, typename C::allocator_type>>
+ : std::is_convertible<
+ C, T<typename C::key_type, typename C::mapped_type,
+ typename C::key_compare, typename C::allocator_type>> {};
+template <typename C, template <typename, typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+ C, T,
+ absl::void_t<typename C::key_type, typename C::hasher,
+ typename C::key_equal, typename C::allocator_type>>
+ : std::is_convertible<
+ C, T<typename C::key_type, typename C::hasher, typename C::key_equal,
+ typename C::allocator_type>> {};
+template <typename C,
+ template <typename, typename, typename, typename, typename> class T>
+struct IsConvertibleToSpecializationImpl<
+ C, T,
+ absl::void_t<typename C::key_type, typename C::mapped_type,
+ typename C::hasher, typename C::key_equal,
+ typename C::allocator_type>>
+ : std::is_convertible<C, T<typename C::key_type, typename C::mapped_type,
+ typename C::hasher, typename C::key_equal,
+ typename C::allocator_type>> {};
+template <typename C, template <typename...> class T>
+using IsConvertibleToSpecialization =
+ IsConvertibleToSpecializationImpl<absl::decay_t<C>, T>;
+
+template <typename C>
+struct IsConvertibleToArrayImpl : std::false_type {};
+template <template <typename, size_t> class A, typename T, size_t N>
+struct IsConvertibleToArrayImpl<A<T, N>>
+ : std::is_convertible<A<T, N>, std::array<T, N>> {};
+template <typename C>
+using IsConvertibleToArray = IsConvertibleToArrayImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsConvertibleToBitsetImpl : std::false_type {};
+template <template <size_t> class B, size_t N>
+struct IsConvertibleToBitsetImpl<B<N>>
+ : std::is_convertible<B<N>, std::bitset<N>> {};
+template <typename C>
+using IsConvertibleToBitset = IsConvertibleToBitsetImpl<absl::decay_t<C>>;
+
+template <typename C>
+struct IsConvertibleToSTLContainer
+ : absl::disjunction<
+ IsConvertibleToArray<C>, IsConvertibleToBitset<C>,
+ IsConvertibleToSpecialization<C, std::deque>,
+ IsConvertibleToSpecialization<C, std::forward_list>,
+ IsConvertibleToSpecialization<C, std::list>,
+ IsConvertibleToSpecialization<C, std::map>,
+ IsConvertibleToSpecialization<C, std::multimap>,
+ IsConvertibleToSpecialization<C, std::set>,
+ IsConvertibleToSpecialization<C, std::multiset>,
+ IsConvertibleToSpecialization<C, std::unordered_map>,
+ IsConvertibleToSpecialization<C, std::unordered_multimap>,
+ IsConvertibleToSpecialization<C, std::unordered_set>,
+ IsConvertibleToSpecialization<C, std::unordered_multiset>,
+ IsConvertibleToSpecialization<C, std::vector>> {};
+
+template <typename C>
+struct IsStrictlyBaseOfAndConvertibleToSTLContainer
+ : absl::conjunction<absl::negation<IsSTLContainer<C>>,
+ IsBaseOfSTLContainer<C>,
+ IsConvertibleToSTLContainer<C>> {};
+
+} // namespace strings_internal
+} // namespace absl
+#endif // ABSL_STRINGS_INTERNAL_STL_TYPE_TRAITS_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/str_join_internal.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/str_join_internal.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/str_join_internal.h
new file mode 100644
index 0000000..c5fdc28
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/str_join_internal.h
@@ -0,0 +1,309 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// This file declares INTERNAL parts of the Join API that are inlined/templated
+// or otherwise need to be available at compile time. The main abstractions
+// defined in this file are:
+//
+// - A handful of default Formatters
+// - JoinAlgorithm() overloads
+// - JoinRange() overloads
+// - JoinTuple()
+//
+// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
+// absl/strings/str_join.h
+//
+// IWYU pragma: private, include "absl/strings/str_join.h"
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
+#define ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
+
+#include <cstring>
+#include <iterator>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/strings/internal/ostringstream.h"
+#include "absl/strings/internal/resize_uninitialized.h"
+#include "absl/strings/str_cat.h"
+
+namespace absl {
+namespace strings_internal {
+
+//
+// Formatter objects
+//
+// The following are implementation classes for standard Formatter objects. The
+// factory functions that users will call to create and use these formatters are
+// defined and documented in strings/join.h.
+//
+
+// The default formatter. Converts alpha-numeric types to strings.
+struct AlphaNumFormatterImpl {
+ // This template is needed in order to support passing in a dereferenced
+ // vector<bool>::iterator
+ template <typename T>
+ void operator()(std::string* out, const T& t) const {
+ StrAppend(out, AlphaNum(t));
+ }
+
+ void operator()(std::string* out, const AlphaNum& t) const {
+ StrAppend(out, t);
+ }
+};
+
+// A type that's used to overload the JoinAlgorithm() function (defined below)
+// for ranges that do not require additional formatting (e.g., a range of
+// strings).
+
+struct NoFormatter : public AlphaNumFormatterImpl {};
+
+// Formats types to strings using the << operator.
+class StreamFormatterImpl {
+ public:
+ // The method isn't const because it mutates state. Making it const will
+ // render StreamFormatterImpl thread-hostile.
+ template <typename T>
+ void operator()(std::string* out, const T& t) {
+ // The stream is created lazily to avoid paying the relatively high cost
+ // of its construction when joining an empty range.
+ if (strm_) {
+ strm_->clear(); // clear the bad, fail and eof bits in case they were set
+ strm_->str(out);
+ } else {
+ strm_.reset(new strings_internal::OStringStream(out));
+ }
+ *strm_ << t;
+ }
+
+ private:
+ std::unique_ptr<strings_internal::OStringStream> strm_;
+};
+
+// Formats a std::pair<>. The 'first' member is formatted using f1_ and the
+// 'second' member is formatted using f2_. sep_ is the separator.
+template <typename F1, typename F2>
+class PairFormatterImpl {
+ public:
+ PairFormatterImpl(F1 f1, absl::string_view sep, F2 f2)
+ : f1_(std::move(f1)), sep_(sep), f2_(std::move(f2)) {}
+
+ template <typename T>
+ void operator()(std::string* out, const T& p) {
+ f1_(out, p.first);
+ out->append(sep_);
+ f2_(out, p.second);
+ }
+
+ template <typename T>
+ void operator()(std::string* out, const T& p) const {
+ f1_(out, p.first);
+ out->append(sep_);
+ f2_(out, p.second);
+ }
+
+ private:
+ F1 f1_;
+ std::string sep_;
+ F2 f2_;
+};
+
+// Wraps another formatter and dereferences the argument to operator() then
+// passes the dereferenced argument to the wrapped formatter. This can be
+// useful, for example, to join a std::vector<int*>.
+template <typename Formatter>
+class DereferenceFormatterImpl {
+ public:
+ DereferenceFormatterImpl() : f_() {}
+ explicit DereferenceFormatterImpl(Formatter&& f)
+ : f_(std::forward<Formatter>(f)) {}
+
+ template <typename T>
+ void operator()(std::string* out, const T& t) {
+ f_(out, *t);
+ }
+
+ template <typename T>
+ void operator()(std::string* out, const T& t) const {
+ f_(out, *t);
+ }
+
+ private:
+ Formatter f_;
+};
+
+// DefaultFormatter<T> is a traits class that selects a default Formatter to use
+// for the given type T. The ::Type member names the Formatter to use. This is
+// used by the strings::Join() functions that do NOT take a Formatter argument,
+// in which case a default Formatter must be chosen.
+//
+// AlphaNumFormatterImpl is the default in the base template, followed by
+// specializations for other types.
+template <typename ValueType>
+struct DefaultFormatter {
+ typedef AlphaNumFormatterImpl Type;
+};
+template <>
+struct DefaultFormatter<const char*> {
+ typedef AlphaNumFormatterImpl Type;
+};
+template <>
+struct DefaultFormatter<char*> {
+ typedef AlphaNumFormatterImpl Type;
+};
+template <>
+struct DefaultFormatter<std::string> {
+ typedef NoFormatter Type;
+};
+template <>
+struct DefaultFormatter<absl::string_view> {
+ typedef NoFormatter Type;
+};
+template <typename ValueType>
+struct DefaultFormatter<ValueType*> {
+ typedef DereferenceFormatterImpl<typename DefaultFormatter<ValueType>::Type>
+ Type;
+};
+
+template <typename ValueType>
+struct DefaultFormatter<std::unique_ptr<ValueType>>
+ : public DefaultFormatter<ValueType*> {};
+
+//
+// JoinAlgorithm() functions
+//
+
+// The main joining algorithm. This simply joins the elements in the given
+// iterator range, each separated by the given separator, into an output std::string,
+// and formats each element using the provided Formatter object.
+template <typename Iterator, typename Formatter>
+std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s,
+ Formatter&& f) {
+ std::string result;
+ absl::string_view sep("");
+ for (Iterator it = start; it != end; ++it) {
+ result.append(sep.data(), sep.size());
+ f(&result, *it);
+ sep = s;
+ }
+ return result;
+}
+
+// A joining algorithm that's optimized for a forward iterator range of
+// std::string-like objects that do not need any additional formatting. This is to
+// optimize the common case of joining, say, a std::vector<std::string> or a
+// std::vector<absl::string_view>.
+//
+// This is an overload of the previous JoinAlgorithm() function. Here the
+// Formatter argument is of type NoFormatter. Since NoFormatter is an internal
+// type, this overload is only invoked when strings::Join() is called with a
+// range of std::string-like objects (e.g., std::string, absl::string_view), and an
+// explicit Formatter argument was NOT specified.
+//
+// The optimization is that the needed space will be reserved in the output
+// std::string to avoid the need to resize while appending. To do this, the iterator
+// range will be traversed twice: once to calculate the total needed size, and
+// then again to copy the elements and delimiters to the output std::string.
+template <typename Iterator,
+ typename = typename std::enable_if<std::is_convertible<
+ typename std::iterator_traits<Iterator>::iterator_category,
+ std::forward_iterator_tag>::value>::type>
+std::string JoinAlgorithm(Iterator start, Iterator end, absl::string_view s,
+ NoFormatter) {
+ std::string result;
+ if (start != end) {
+ // Sums size
+ size_t result_size = start->size();
+ for (Iterator it = start; ++it != end;) {
+ result_size += s.size();
+ result_size += it->size();
+ }
+
+ STLStringResizeUninitialized(&result, result_size);
+
+ // Joins strings
+ char* result_buf = &*result.begin();
+ memcpy(result_buf, start->data(), start->size());
+ result_buf += start->size();
+ for (Iterator it = start; ++it != end;) {
+ memcpy(result_buf, s.data(), s.size());
+ result_buf += s.size();
+ memcpy(result_buf, it->data(), it->size());
+ result_buf += it->size();
+ }
+ }
+
+ return result;
+}
+
+// JoinTupleLoop implements a loop over the elements of a std::tuple, which
+// are heterogeneous. The primary template matches the tuple interior case. It
+// continues the iteration after appending a separator (for nonzero indices)
+// and formatting an element of the tuple. The specialization for the I=N case
+// matches the end-of-tuple, and terminates the iteration.
+template <size_t I, size_t N>
+struct JoinTupleLoop {
+ template <typename Tup, typename Formatter>
+ void operator()(std::string* out, const Tup& tup, absl::string_view sep,
+ Formatter&& fmt) {
+ if (I > 0) out->append(sep.data(), sep.size());
+ fmt(out, std::get<I>(tup));
+ JoinTupleLoop<I + 1, N>()(out, tup, sep, fmt);
+ }
+};
+template <size_t N>
+struct JoinTupleLoop<N, N> {
+ template <typename Tup, typename Formatter>
+ void operator()(std::string*, const Tup&, absl::string_view, Formatter&&) {}
+};
+
+template <typename... T, typename Formatter>
+std::string JoinAlgorithm(const std::tuple<T...>& tup, absl::string_view sep,
+ Formatter&& fmt) {
+ std::string result;
+ JoinTupleLoop<0, sizeof...(T)>()(&result, tup, sep, fmt);
+ return result;
+}
+
+template <typename Iterator>
+std::string JoinRange(Iterator first, Iterator last, absl::string_view separator) {
+ // No formatter was explicitly given, so a default must be chosen.
+ typedef typename std::iterator_traits<Iterator>::value_type ValueType;
+ typedef typename DefaultFormatter<ValueType>::Type Formatter;
+ return JoinAlgorithm(first, last, separator, Formatter());
+}
+
+template <typename Range, typename Formatter>
+std::string JoinRange(const Range& range, absl::string_view separator,
+ Formatter&& fmt) {
+ using std::begin;
+ using std::end;
+ return JoinAlgorithm(begin(range), end(range), separator, fmt);
+}
+
+template <typename Range>
+std::string JoinRange(const Range& range, absl::string_view separator) {
+ using std::begin;
+ using std::end;
+ return JoinRange(begin(range), end(range), separator);
+}
+
+} // namespace strings_internal
+} // namespace absl
+
+#endif // ABSL_STRINGS_INTERNAL_STR_JOIN_INTERNAL_H_
[47/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/call_once_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/call_once_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/call_once_test.cc
new file mode 100644
index 0000000..cd58ee1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/call_once_test.cc
@@ -0,0 +1,102 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/call_once.h"
+
+#include <thread>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+namespace {
+
+absl::once_flag once;
+Mutex counters_mu;
+
+int running_thread_count GUARDED_BY(counters_mu) = 0;
+int call_once_invoke_count GUARDED_BY(counters_mu) = 0;
+int call_once_finished_count GUARDED_BY(counters_mu) = 0;
+int call_once_return_count GUARDED_BY(counters_mu) = 0;
+bool done_blocking GUARDED_BY(counters_mu) = false;
+
+// Function to be called from absl::call_once. Waits for a notification.
+void WaitAndIncrement() {
+ counters_mu.Lock();
+ ++call_once_invoke_count;
+ counters_mu.Unlock();
+
+ counters_mu.LockWhen(Condition(&done_blocking));
+ ++call_once_finished_count;
+ counters_mu.Unlock();
+}
+
+void ThreadBody() {
+ counters_mu.Lock();
+ ++running_thread_count;
+ counters_mu.Unlock();
+
+ absl::call_once(once, WaitAndIncrement);
+
+ counters_mu.Lock();
+ ++call_once_return_count;
+ counters_mu.Unlock();
+}
+
+// Returns true if all threads are set up for the test.
+bool ThreadsAreSetup(void*) EXCLUSIVE_LOCKS_REQUIRED(counters_mu) {
+ // All ten threads must be running, and WaitAndIncrement should be blocked.
+ return running_thread_count == 10 && call_once_invoke_count == 1;
+}
+
+TEST(CallOnceTest, ExecutionCount) {
+ std::vector<std::thread> threads;
+
+ // Start 10 threads all calling call_once on the same once_flag.
+ for (int i = 0; i < 10; ++i) {
+ threads.emplace_back(ThreadBody);
+ }
+
+
+ // Wait until all ten threads have started, and WaitAndIncrement has been
+ // invoked.
+ counters_mu.LockWhen(Condition(ThreadsAreSetup, nullptr));
+
+ // WaitAndIncrement should have been invoked by exactly one call_once()
+ // instance. That thread should be blocking on a notification, and all other
+ // call_once instances should be blocking as well.
+ EXPECT_EQ(call_once_invoke_count, 1);
+ EXPECT_EQ(call_once_finished_count, 0);
+ EXPECT_EQ(call_once_return_count, 0);
+
+ // Allow WaitAndIncrement to finish executing. Once it does, the other
+ // call_once waiters will be unblocked.
+ done_blocking = true;
+ counters_mu.Unlock();
+
+ for (std::thread& thread : threads) {
+ thread.join();
+ }
+
+ counters_mu.Lock();
+ EXPECT_EQ(call_once_invoke_count, 1);
+ EXPECT_EQ(call_once_finished_count, 1);
+ EXPECT_EQ(call_once_return_count, 10);
+ counters_mu.Unlock();
+}
+
+} // namespace
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/casts.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/casts.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/casts.h
new file mode 100644
index 0000000..8bd5264
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/casts.h
@@ -0,0 +1,140 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: casts.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines casting templates to fit use cases not covered by
+// the standard casts provided in the C++ standard. As with all cast operations,
+// use these with caution and only if alternatives do not exist.
+
+#ifndef ABSL_BASE_CASTS_H_
+#define ABSL_BASE_CASTS_H_
+
+#include <cstring>
+#include <type_traits>
+
+#include "absl/base/internal/identity.h"
+
+namespace absl {
+
+// implicit_cast()
+//
+// Performs an implicit conversion between types following the language
+// rules for implicit conversion; if an implicit conversion is otherwise
+// allowed by the language in the given context, this function performs such an
+// implicit conversion.
+//
+// Example:
+//
+// // If the context allows implicit conversion:
+// From from;
+// To to = from;
+//
+// // Such code can be replaced by:
+// implicit_cast<To>(from);
+//
+// An `implicit_cast()` may also be used to annotate numeric type conversions
+// that, although safe, may produce compiler warnings (such as `long` to `int`).
+// Additionally, an `implicit_cast()` is also useful within return statements to
+// indicate a specific implicit conversion is being undertaken.
+//
+// Example:
+//
+// return implicit_cast<double>(size_in_bytes) / capacity_;
+//
+// Annotating code with `implicit_cast()` allows you to explicitly select
+// particular overloads and template instantiations, while providing a safer
+// cast than `reinterpret_cast()` or `static_cast()`.
+//
+// Additionally, an `implicit_cast()` can be used to allow upcasting within a
+// type hierarchy where incorrect use of `static_cast()` could accidentally
+// allow downcasting.
+//
+// Finally, an `implicit_cast()` can be used to perform implicit conversions
+// from unrelated types that otherwise couldn't be implicitly cast directly;
+// C++ will normally only implicitly cast "one step" in such conversions.
+//
+// That is, if C is a type which can be implicitly converted to B, with B being
+// a type that can be implicitly converted to A, an `implicit_cast()` can be
+// used to convert C to B (which the compiler can then implicitly convert to A
+// using language rules).
+//
+// Example:
+//
+// // Assume an object C is convertible to B, which is implicitly convertible
+// // to A
+// A a = implicit_cast<B>(C);
+//
+// Such implicit cast chaining may be useful within template logic.
+template <typename To>
+inline To implicit_cast(typename absl::internal::identity_t<To> to) {
+ return to;
+}
+
+// bit_cast()
+//
+// Performs a bitwise cast on a type without changing the underlying bit
+// representation of that type's value. The two types must be of the same size
+// and both types must be trivially copyable. As with most casts, use with
+// caution. A `bit_cast()` might be needed when you need to temporarily treat a
+// type as some other type, such as in the following cases:
+//
+// * Serialization (casting temporarily to `char *` for those purposes is
+// always allowed by the C++ standard)
+// * Managing the individual bits of a type within mathematical operations
+// that are not normally accessible through that type
+// * Casting non-pointer types to pointer types (casting the other way is
+// allowed by `reinterpret_cast()` but round-trips cannot occur the other
+// way).
+//
+// Example:
+//
+// float f = 3.14159265358979;
+// int i = bit_cast<int32_t>(f);
+// // i = 0x40490fdb
+//
+// Casting non-pointer types to pointer types and then dereferencing them
+// traditionally produces undefined behavior.
+//
+// Example:
+//
+// // WRONG
+// float f = 3.14159265358979; // WRONG
+// int i = * reinterpret_cast<int*>(&f); // WRONG
+//
+// The address-casting method produces undefined behavior according to the ISO
+// C++ specification section [basic.lval]. Roughly, this section says: if an
+// object in memory has one type, and a program accesses it with a different
+// type, the result is undefined behavior for most values of "different type".
+//
+// Such casting results in type punning: holding an object in memory of one type
+// and reading its bits back using a different type. A `bit_cast()` avoids this
+// issue by implementing its casts using `memcpy()`, which avoids introducing
+// this undefined behavior.
+template <typename Dest, typename Source>
+inline Dest bit_cast(const Source& source) {
+ static_assert(sizeof(Dest) == sizeof(Source),
+ "Source and destination types should have equal sizes.");
+
+ Dest dest;
+ memcpy(&dest, &source, sizeof(dest));
+ return dest;
+}
+
+} // namespace absl
+
+#endif // ABSL_BASE_CASTS_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/config.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/config.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/config.h
new file mode 100644
index 0000000..2f5f159
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/config.h
@@ -0,0 +1,427 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: config.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a set of macros for checking the presence of
+// important compiler and platform features. Such macros can be used to
+// produce portable code by parameterizing compilation based on the presence or
+// lack of a given feature.
+//
+// We define a "feature" as some interface we wish to program to: for example,
+// a library function or system call. A value of `1` indicates support for
+// that feature; any other value indicates the feature support is undefined.
+//
+// Example:
+//
+// Suppose a programmer wants to write a program that uses the 'mmap()' system
+// call. The Abseil macro for that feature (`ABSL_HAVE_MMAP`) allows you to
+// selectively include the `mmap.h` header and bracket code using that feature
+// in the macro:
+//
+// #include "absl/base/config.h"
+//
+// #ifdef ABSL_HAVE_MMAP
+// #include "sys/mman.h"
+// #endif //ABSL_HAVE_MMAP
+//
+// ...
+// #ifdef ABSL_HAVE_MMAP
+// void *ptr = mmap(...);
+// ...
+// #endif // ABSL_HAVE_MMAP
+
+#ifndef ABSL_BASE_CONFIG_H_
+#define ABSL_BASE_CONFIG_H_
+
+// Included for the __GLIBC__ macro (or similar macros on other systems).
+#include <limits.h>
+
+#ifdef __cplusplus
+// Included for __GLIBCXX__, _LIBCPP_VERSION
+#include <cstddef>
+#endif // __cplusplus
+
+#if defined(__APPLE__)
+// Included for TARGET_OS_IPHONE, __IPHONE_OS_VERSION_MIN_REQUIRED,
+// __IPHONE_8_0.
+#include <Availability.h>
+#include <TargetConditionals.h>
+#endif
+
+#include "absl/base/policy_checks.h"
+
+// -----------------------------------------------------------------------------
+// Compiler Feature Checks
+// -----------------------------------------------------------------------------
+
+// ABSL_HAVE_BUILTIN()
+//
+// Checks whether the compiler supports a Clang Feature Checking Macro, and if
+// so, checks whether it supports the provided builtin function "x" where x
+// is one of the functions noted in
+// https://clang.llvm.org/docs/LanguageExtensions.html
+//
+// Note: Use this macro to avoid an extra level of #ifdef __has_builtin check.
+// http://releases.llvm.org/3.3/tools/clang/docs/LanguageExtensions.html
+#ifdef __has_builtin
+#define ABSL_HAVE_BUILTIN(x) __has_builtin(x)
+#else
+#define ABSL_HAVE_BUILTIN(x) 0
+#endif
+
+// ABSL_HAVE_TLS is defined to 1 when __thread should be supported.
+// We assume __thread is supported on Linux when compiled with Clang or compiled
+// against libstdc++ with _GLIBCXX_HAVE_TLS defined.
+#ifdef ABSL_HAVE_TLS
+#error ABSL_HAVE_TLS cannot be directly set
+#elif defined(__linux__) && (defined(__clang__) || defined(_GLIBCXX_HAVE_TLS))
+#define ABSL_HAVE_TLS 1
+#endif
+
+// ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+//
+// Checks whether `std::is_trivially_destructible<T>` is supported.
+//
+// Notes: All supported compilers using libc++ support this feature, as does
+// gcc >= 4.8.1 using libstdc++, and Visual Studio.
+#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+#error ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE cannot be directly set
+#elif defined(_LIBCPP_VERSION) || \
+ (!defined(__clang__) && defined(__GNUC__) && defined(__GLIBCXX__) && \
+ (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))) || \
+ defined(_MSC_VER)
+#define ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE 1
+#endif
+
+// ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+//
+// Checks whether `std::is_trivially_default_constructible<T>` and
+// `std::is_trivially_copy_constructible<T>` are supported.
+
+// ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+//
+// Checks whether `std::is_trivially_copy_assignable<T>` is supported.
+
+// Notes: Clang with libc++ supports these features, as does gcc >= 5.1 with
+// either libc++ or libstdc++, and Visual Studio.
+#if defined(ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE)
+#error ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE cannot be directly set
+#elif defined(ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE)
+#error ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE cannot directly set
+#elif (defined(__clang__) && defined(_LIBCPP_VERSION)) || \
+ (!defined(__clang__) && defined(__GNUC__) && \
+ (__GNUC__ > 5 || (__GNUC__ == 5 && __GNUC_MINOR__ >= 1)) && \
+ (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__))) || \
+ defined(_MSC_VER)
+#define ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE 1
+#define ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE 1
+#endif
+
+// ABSL_HAVE_THREAD_LOCAL
+//
+// Checks whether C++11's `thread_local` storage duration specifier is
+// supported.
+#ifdef ABSL_HAVE_THREAD_LOCAL
+#error ABSL_HAVE_THREAD_LOCAL cannot be directly set
+#elif defined(__APPLE__)
+// Notes: Xcode's clang did not support `thread_local` until version
+// 8, and even then not for all iOS < 9.0. Also, Xcode 9.3 started disallowing
+// `thread_local` for 32-bit iOS simulator targeting iOS 9.x.
+// `__has_feature` is only supported by Clang so it has be inside
+// `defined(__APPLE__)` check.
+#if __has_feature(cxx_thread_local)
+#define ABSL_HAVE_THREAD_LOCAL 1
+#endif
+#else // !defined(__APPLE__)
+#define ABSL_HAVE_THREAD_LOCAL 1
+#endif
+
+// There are platforms for which TLS should not be used even though the compiler
+// makes it seem like it's supported (Android NDK < r12b for example).
+// This is primarily because of linker problems and toolchain misconfiguration:
+// Abseil does not intend to support this indefinitely. Currently, the newest
+// toolchain that we intend to support that requires this behavior is the
+// r11 NDK - allowing for a 5 year support window on that means this option
+// is likely to be removed around June of 2021.
+// TLS isn't supported until NDK r12b per
+// https://developer.android.com/ndk/downloads/revision_history.html
+// Since NDK r16, `__NDK_MAJOR__` and `__NDK_MINOR__` are defined in
+// <android/ndk-version.h>. For NDK < r16, users should define these macros,
+// e.g. `-D__NDK_MAJOR__=11 -D__NKD_MINOR__=0` for NDK r11.
+#if defined(__ANDROID__) && defined(__clang__)
+#if __has_include(<android/ndk-version.h>)
+#include <android/ndk-version.h>
+#endif // __has_include(<android/ndk-version.h>)
+#if defined(__ANDROID__) && defined(__clang__) && defined(__NDK_MAJOR__) && \
+ defined(__NDK_MINOR__) && \
+ ((__NDK_MAJOR__ < 12) || ((__NDK_MAJOR__ == 12) && (__NDK_MINOR__ < 1)))
+#undef ABSL_HAVE_TLS
+#undef ABSL_HAVE_THREAD_LOCAL
+#endif
+#endif // defined(__ANDROID__) && defined(__clang__)
+
+// ABSL_HAVE_INTRINSIC_INT128
+//
+// Checks whether the __int128 compiler extension for a 128-bit integral type is
+// supported.
+//
+// Note: __SIZEOF_INT128__ is defined by Clang and GCC when __int128 is
+// supported, but we avoid using it in certain cases:
+// * On Clang:
+// * Building using Clang for Windows, where the Clang runtime library has
+// 128-bit support only on LP64 architectures, but Windows is LLP64.
+// * Building for aarch64, where __int128 exists but has exhibits a sporadic
+// compiler crashing bug.
+// * On Nvidia's nvcc:
+// * nvcc also defines __GNUC__ and __SIZEOF_INT128__, but not all versions
+// actually support __int128.
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+#error ABSL_HAVE_INTRINSIC_INT128 cannot be directly set
+#elif defined(__SIZEOF_INT128__)
+#if (defined(__clang__) && !defined(_WIN32) && !defined(__aarch64__)) || \
+ (defined(__CUDACC__) && __CUDACC_VER_MAJOR__ >= 9) || \
+ (defined(__GNUC__) && !defined(__clang__) && !defined(__CUDACC__))
+#define ABSL_HAVE_INTRINSIC_INT128 1
+#elif defined(__CUDACC__)
+// __CUDACC_VER__ is a full version number before CUDA 9, and is defined to a
+// std::string explaining that it has been removed starting with CUDA 9. We use
+// nested #ifs because there is no short-circuiting in the preprocessor.
+// NOTE: `__CUDACC__` could be undefined while `__CUDACC_VER__` is defined.
+#if __CUDACC_VER__ >= 70000
+#define ABSL_HAVE_INTRINSIC_INT128 1
+#endif // __CUDACC_VER__ >= 70000
+#endif // defined(__CUDACC__)
+#endif // ABSL_HAVE_INTRINSIC_INT128
+
+// ABSL_HAVE_EXCEPTIONS
+//
+// Checks whether the compiler both supports and enables exceptions. Many
+// compilers support a "no exceptions" mode that disables exceptions.
+//
+// Generally, when ABSL_HAVE_EXCEPTIONS is not defined:
+//
+// * Code using `throw` and `try` may not compile.
+// * The `noexcept` specifier will still compile and behave as normal.
+// * The `noexcept` operator may still return `false`.
+//
+// For further details, consult the compiler's documentation.
+#ifdef ABSL_HAVE_EXCEPTIONS
+#error ABSL_HAVE_EXCEPTIONS cannot be directly set.
+
+#elif defined(__clang__)
+// TODO(calabrese)
+// Switch to using __cpp_exceptions when we no longer support versions < 3.6.
+// For details on this check, see:
+// http://releases.llvm.org/3.6.0/tools/clang/docs/ReleaseNotes.html#the-exceptions-macro
+#if defined(__EXCEPTIONS) && __has_feature(cxx_exceptions)
+#define ABSL_HAVE_EXCEPTIONS 1
+#endif // defined(__EXCEPTIONS) && __has_feature(cxx_exceptions)
+
+// Handle remaining special cases and default to exceptions being supported.
+#elif !(defined(__GNUC__) && (__GNUC__ < 5) && !defined(__EXCEPTIONS)) && \
+ !(defined(__GNUC__) && (__GNUC__ >= 5) && !defined(__cpp_exceptions)) && \
+ !(defined(_MSC_VER) && !defined(_CPPUNWIND))
+#define ABSL_HAVE_EXCEPTIONS 1
+#endif
+
+// -----------------------------------------------------------------------------
+// Platform Feature Checks
+// -----------------------------------------------------------------------------
+
+// Currently supported operating systems and associated preprocessor
+// symbols:
+//
+// Linux and Linux-derived __linux__
+// Android __ANDROID__ (implies __linux__)
+// Linux (non-Android) __linux__ && !__ANDROID__
+// Darwin (Mac OS X and iOS) __APPLE__
+// Akaros (http://akaros.org) __ros__
+// Windows _WIN32
+// NaCL __native_client__
+// AsmJS __asmjs__
+// WebAssembly __wasm__
+// Fuchsia __Fuchsia__
+//
+// Note that since Android defines both __ANDROID__ and __linux__, one
+// may probe for either Linux or Android by simply testing for __linux__.
+
+// ABSL_HAVE_MMAP
+//
+// Checks whether the platform has an mmap(2) implementation as defined in
+// POSIX.1-2001.
+#ifdef ABSL_HAVE_MMAP
+#error ABSL_HAVE_MMAP cannot be directly set
+#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
+ defined(__ros__) || defined(__native_client__) || defined(__asmjs__) || \
+ defined(__wasm__) || defined(__Fuchsia__)
+#define ABSL_HAVE_MMAP 1
+#endif
+
+// ABSL_HAVE_PTHREAD_GETSCHEDPARAM
+//
+// Checks whether the platform implements the pthread_(get|set)schedparam(3)
+// functions as defined in POSIX.1-2001.
+#ifdef ABSL_HAVE_PTHREAD_GETSCHEDPARAM
+#error ABSL_HAVE_PTHREAD_GETSCHEDPARAM cannot be directly set
+#elif defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
+ defined(__ros__)
+#define ABSL_HAVE_PTHREAD_GETSCHEDPARAM 1
+#endif
+
+// ABSL_HAVE_SCHED_YIELD
+//
+// Checks whether the platform implements sched_yield(2) as defined in
+// POSIX.1-2001.
+#ifdef ABSL_HAVE_SCHED_YIELD
+#error ABSL_HAVE_SCHED_YIELD cannot be directly set
+#elif defined(__linux__) || defined(__ros__) || defined(__native_client__)
+#define ABSL_HAVE_SCHED_YIELD 1
+#endif
+
+// ABSL_HAVE_SEMAPHORE_H
+//
+// Checks whether the platform supports the <semaphore.h> header and sem_open(3)
+// family of functions as standardized in POSIX.1-2001.
+//
+// Note: While Apple provides <semaphore.h> for both iOS and macOS, it is
+// explicitly deprecated and will cause build failures if enabled for those
+// platforms. We side-step the issue by not defining it here for Apple
+// platforms.
+#ifdef ABSL_HAVE_SEMAPHORE_H
+#error ABSL_HAVE_SEMAPHORE_H cannot be directly set
+#elif defined(__linux__) || defined(__ros__)
+#define ABSL_HAVE_SEMAPHORE_H 1
+#endif
+
+// ABSL_HAVE_ALARM
+//
+// Checks whether the platform supports the <signal.h> header and alarm(2)
+// function as standardized in POSIX.1-2001.
+#ifdef ABSL_HAVE_ALARM
+#error ABSL_HAVE_ALARM cannot be directly set
+#elif defined(__GOOGLE_GRTE_VERSION__)
+// feature tests for Google's GRTE
+#define ABSL_HAVE_ALARM 1
+#elif defined(__GLIBC__)
+// feature test for glibc
+#define ABSL_HAVE_ALARM 1
+#elif defined(_MSC_VER)
+// feature tests for Microsoft's library
+#elif defined(__native_client__)
+#else
+// other standard libraries
+#define ABSL_HAVE_ALARM 1
+#endif
+
+// ABSL_IS_LITTLE_ENDIAN
+// ABSL_IS_BIG_ENDIAN
+//
+// Checks the endianness of the platform.
+//
+// Notes: uses the built in endian macros provided by GCC (since 4.6) and
+// Clang (since 3.2); see
+// https://gcc.gnu.org/onlinedocs/cpp/Common-Predefined-Macros.html.
+// Otherwise, if _WIN32, assume little endian. Otherwise, bail with an error.
+#if defined(ABSL_IS_BIG_ENDIAN)
+#error "ABSL_IS_BIG_ENDIAN cannot be directly set."
+#endif
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+#error "ABSL_IS_LITTLE_ENDIAN cannot be directly set."
+#endif
+
+#if (defined(__BYTE_ORDER__) && defined(__ORDER_LITTLE_ENDIAN__) && \
+ __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__)
+#define ABSL_IS_LITTLE_ENDIAN 1
+#elif defined(__BYTE_ORDER__) && defined(__ORDER_BIG_ENDIAN__) && \
+ __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
+#define ABSL_IS_BIG_ENDIAN 1
+#elif defined(_WIN32)
+#define ABSL_IS_LITTLE_ENDIAN 1
+#else
+#error "absl endian detection needs to be set up for your compiler"
+#endif
+
+// ABSL_HAVE_STD_ANY
+//
+// Checks whether C++17 std::any is available by checking whether <any> exists.
+#ifdef ABSL_HAVE_STD_ANY
+#error "ABSL_HAVE_STD_ANY cannot be directly set."
+#endif
+
+#ifdef __has_include
+#if __has_include(<any>) && __cplusplus >= 201703L
+#define ABSL_HAVE_STD_ANY 1
+#endif
+#endif
+
+// ABSL_HAVE_STD_OPTIONAL
+//
+// Checks whether C++17 std::optional is available.
+#ifdef ABSL_HAVE_STD_OPTIONAL
+#error "ABSL_HAVE_STD_OPTIONAL cannot be directly set."
+#endif
+
+#ifdef __has_include
+#if __has_include(<optional>) && __cplusplus >= 201703L
+#define ABSL_HAVE_STD_OPTIONAL 1
+#endif
+#endif
+
+// ABSL_HAVE_STD_VARIANT
+//
+// Checks whether C++17 std::variant is available.
+#ifdef ABSL_HAVE_STD_VARIANT
+#error "ABSL_HAVE_STD_VARIANT cannot be directly set."
+#endif
+
+#ifdef __has_include
+#if __has_include(<variant>) && __cplusplus >= 201703L
+#define ABSL_HAVE_STD_VARIANT 1
+#endif
+#endif
+
+// ABSL_HAVE_STD_STRING_VIEW
+//
+// Checks whether C++17 std::string_view is available.
+#ifdef ABSL_HAVE_STD_STRING_VIEW
+#error "ABSL_HAVE_STD_STRING_VIEW cannot be directly set."
+#endif
+
+#ifdef __has_include
+#if __has_include(<string_view>) && __cplusplus >= 201703L
+#define ABSL_HAVE_STD_STRING_VIEW 1
+#endif
+#endif
+
+// For MSVC, `__has_include` is supported in VS 2017 15.3, which is later than
+// the support for <optional>, <any>, <string_view>, <variant>. So we use
+// _MSC_VER to check whether we have VS 2017 RTM (when <optional>, <any>,
+// <string_view>, <variant> is implemented) or higher. Also, `__cplusplus` is
+// not correctly set by MSVC, so we use `_MSVC_LANG` to check the language
+// version.
+// TODO(zhangxy): fix tests before enabling aliasing for `std::any`,
+// `std::string_view`.
+#if defined(_MSC_VER) && _MSC_VER >= 1910 && \
+ ((defined(_MSVC_LANG) && _MSVC_LANG > 201402) || __cplusplus > 201402)
+// #define ABSL_HAVE_STD_ANY 1
+#define ABSL_HAVE_STD_OPTIONAL 1
+#define ABSL_HAVE_STD_VARIANT 1
+// #define ABSL_HAVE_STD_STRING_VIEW 1
+#endif
+
+#endif // ABSL_BASE_CONFIG_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/config_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/config_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/config_test.cc
new file mode 100644
index 0000000..c839712
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/config_test.cc
@@ -0,0 +1,60 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/config.h"
+
+#include <cstdint>
+
+#include "gtest/gtest.h"
+#include "absl/synchronization/internal/thread_pool.h"
+
+namespace {
+
+TEST(ConfigTest, Endianness) {
+ union {
+ uint32_t value;
+ uint8_t data[sizeof(uint32_t)];
+ } number;
+ number.data[0] = 0x00;
+ number.data[1] = 0x01;
+ number.data[2] = 0x02;
+ number.data[3] = 0x03;
+#if defined(ABSL_IS_LITTLE_ENDIAN) && defined(ABSL_IS_BIG_ENDIAN)
+#error Both ABSL_IS_LITTLE_ENDIAN and ABSL_IS_BIG_ENDIAN are defined
+#elif defined(ABSL_IS_LITTLE_ENDIAN)
+ EXPECT_EQ(UINT32_C(0x03020100), number.value);
+#elif defined(ABSL_IS_BIG_ENDIAN)
+ EXPECT_EQ(UINT32_C(0x00010203), number.value);
+#else
+#error Unknown endianness
+#endif
+}
+
+#if defined(ABSL_HAVE_THREAD_LOCAL)
+TEST(ConfigTest, ThreadLocal) {
+ static thread_local int mine_mine_mine = 16;
+ EXPECT_EQ(16, mine_mine_mine);
+ {
+ absl::synchronization_internal::ThreadPool pool(1);
+ pool.Schedule([&] {
+ EXPECT_EQ(16, mine_mine_mine);
+ mine_mine_mine = 32;
+ EXPECT_EQ(32, mine_mine_mine);
+ });
+ }
+ EXPECT_EQ(16, mine_mine_mine);
+}
+#endif
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/dynamic_annotations.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/dynamic_annotations.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/dynamic_annotations.cc
new file mode 100644
index 0000000..08c27e5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/dynamic_annotations.cc
@@ -0,0 +1,129 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdlib.h>
+#include <string.h>
+
+#include "absl/base/dynamic_annotations.h"
+
+#ifndef __has_feature
+#define __has_feature(x) 0
+#endif
+
+/* Compiler-based ThreadSanitizer defines
+ DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL = 1
+ and provides its own definitions of the functions. */
+
+#ifndef DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL
+# define DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL 0
+#endif
+
+/* Each function is empty and called (via a macro) only in debug mode.
+ The arguments are captured by dynamic tools at runtime. */
+
+#if DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL == 0 && !defined(__native_client__)
+
+#if __has_feature(memory_sanitizer)
+#include <sanitizer/msan_interface.h>
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void AnnotateRWLockCreate(const char *, int,
+ const volatile void *){}
+void AnnotateRWLockDestroy(const char *, int,
+ const volatile void *){}
+void AnnotateRWLockAcquired(const char *, int,
+ const volatile void *, long){}
+void AnnotateRWLockReleased(const char *, int,
+ const volatile void *, long){}
+void AnnotateBenignRace(const char *, int,
+ const volatile void *,
+ const char *){}
+void AnnotateBenignRaceSized(const char *, int,
+ const volatile void *,
+ size_t,
+ const char *) {}
+void AnnotateThreadName(const char *, int,
+ const char *){}
+void AnnotateIgnoreReadsBegin(const char *, int){}
+void AnnotateIgnoreReadsEnd(const char *, int){}
+void AnnotateIgnoreWritesBegin(const char *, int){}
+void AnnotateIgnoreWritesEnd(const char *, int){}
+void AnnotateEnableRaceDetection(const char *, int, int){}
+void AnnotateMemoryIsInitialized(const char *, int,
+ const volatile void *mem, size_t size) {
+#if __has_feature(memory_sanitizer)
+ __msan_unpoison(mem, size);
+#else
+ (void)mem;
+ (void)size;
+#endif
+}
+
+void AnnotateMemoryIsUninitialized(const char *, int,
+ const volatile void *mem, size_t size) {
+#if __has_feature(memory_sanitizer)
+ __msan_allocated_memory(mem, size);
+#else
+ (void)mem;
+ (void)size;
+#endif
+}
+
+static int GetRunningOnValgrind(void) {
+#ifdef RUNNING_ON_VALGRIND
+ if (RUNNING_ON_VALGRIND) return 1;
+#endif
+ char *running_on_valgrind_str = getenv("RUNNING_ON_VALGRIND");
+ if (running_on_valgrind_str) {
+ return strcmp(running_on_valgrind_str, "0") != 0;
+ }
+ return 0;
+}
+
+/* See the comments in dynamic_annotations.h */
+int RunningOnValgrind(void) {
+ static volatile int running_on_valgrind = -1;
+ int local_running_on_valgrind = running_on_valgrind;
+ /* C doesn't have thread-safe initialization of statics, and we
+ don't want to depend on pthread_once here, so hack it. */
+ ANNOTATE_BENIGN_RACE(&running_on_valgrind, "safe hack");
+ if (local_running_on_valgrind == -1)
+ running_on_valgrind = local_running_on_valgrind = GetRunningOnValgrind();
+ return local_running_on_valgrind;
+}
+
+/* See the comments in dynamic_annotations.h */
+double ValgrindSlowdown(void) {
+ /* Same initialization hack as in RunningOnValgrind(). */
+ static volatile double slowdown = 0.0;
+ double local_slowdown = slowdown;
+ ANNOTATE_BENIGN_RACE(&slowdown, "safe hack");
+ if (RunningOnValgrind() == 0) {
+ return 1.0;
+ }
+ if (local_slowdown == 0.0) {
+ char *env = getenv("VALGRIND_SLOWDOWN");
+ slowdown = local_slowdown = env ? atof(env) : 50.0;
+ }
+ return local_slowdown;
+}
+
+#ifdef __cplusplus
+} // extern "C"
+#endif
+#endif /* DYNAMIC_ANNOTATIONS_EXTERNAL_IMPL == 0 */
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/dynamic_annotations.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/dynamic_annotations.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/dynamic_annotations.h
new file mode 100644
index 0000000..3b6d6ef
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/dynamic_annotations.h
@@ -0,0 +1,409 @@
+/*
+ * Copyright 2017 The Abseil Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+/* This file defines dynamic annotations for use with dynamic analysis
+ tool such as valgrind, PIN, etc.
+
+ Dynamic annotation is a source code annotation that affects
+ the generated code (that is, the annotation is not a comment).
+ Each such annotation is attached to a particular
+ instruction and/or to a particular object (address) in the program.
+
+ The annotations that should be used by users are macros in all upper-case
+ (e.g., ANNOTATE_THREAD_NAME).
+
+ Actual implementation of these macros may differ depending on the
+ dynamic analysis tool being used.
+
+ This file supports the following configurations:
+ - Dynamic Annotations enabled (with static thread-safety warnings disabled).
+ In this case, macros expand to functions implemented by Thread Sanitizer,
+ when building with TSan. When not provided an external implementation,
+ dynamic_annotations.cc provides no-op implementations.
+
+ - Static Clang thread-safety warnings enabled.
+ When building with a Clang compiler that supports thread-safety warnings,
+ a subset of annotations can be statically-checked at compile-time. We
+ expand these macros to static-inline functions that can be analyzed for
+ thread-safety, but afterwards elided when building the final binary.
+
+ - All annotations are disabled.
+ If neither Dynamic Annotations nor Clang thread-safety warnings are
+ enabled, then all annotation-macros expand to empty. */
+
+#ifndef ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
+#define ABSL_BASE_DYNAMIC_ANNOTATIONS_H_
+
+#ifndef DYNAMIC_ANNOTATIONS_ENABLED
+# define DYNAMIC_ANNOTATIONS_ENABLED 0
+#endif
+
+#if defined(__native_client__)
+ #include "nacl/dynamic_annotations.h"
+
+ // Stub out the macros missing from the NaCl version.
+ #ifndef ANNOTATE_CONTIGUOUS_CONTAINER
+ #define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)
+ #endif
+ #ifndef ANNOTATE_RWLOCK_CREATE_STATIC
+ #define ANNOTATE_RWLOCK_CREATE_STATIC(lock)
+ #endif
+ #ifndef ADDRESS_SANITIZER_REDZONE
+ #define ADDRESS_SANITIZER_REDZONE(name)
+ #endif
+ #ifndef ANNOTATE_MEMORY_IS_UNINITIALIZED
+ #define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size)
+ #endif
+
+#else /* !__native_client__ */
+
+#if DYNAMIC_ANNOTATIONS_ENABLED != 0
+
+ /* -------------------------------------------------------------
+ Annotations that suppress errors. It is usually better to express the
+ program's synchronization using the other annotations, but these can
+ be used when all else fails. */
+
+ /* Report that we may have a benign race at "pointer", with size
+ "sizeof(*(pointer))". "pointer" must be a non-void* pointer. Insert at the
+ point where "pointer" has been allocated, preferably close to the point
+ where the race happens. See also ANNOTATE_BENIGN_RACE_STATIC. */
+ #define ANNOTATE_BENIGN_RACE(pointer, description) \
+ AnnotateBenignRaceSized(__FILE__, __LINE__, pointer, \
+ sizeof(*(pointer)), description)
+
+ /* Same as ANNOTATE_BENIGN_RACE(address, description), but applies to
+ the memory range [address, address+size). */
+ #define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) \
+ AnnotateBenignRaceSized(__FILE__, __LINE__, address, size, description)
+
+ /* Enable (enable!=0) or disable (enable==0) race detection for all threads.
+ This annotation could be useful if you want to skip expensive race analysis
+ during some period of program execution, e.g. during initialization. */
+ #define ANNOTATE_ENABLE_RACE_DETECTION(enable) \
+ AnnotateEnableRaceDetection(__FILE__, __LINE__, enable)
+
+ /* -------------------------------------------------------------
+ Annotations useful for debugging. */
+
+ /* Report the current thread name to a race detector. */
+ #define ANNOTATE_THREAD_NAME(name) \
+ AnnotateThreadName(__FILE__, __LINE__, name)
+
+ /* -------------------------------------------------------------
+ Annotations useful when implementing locks. They are not
+ normally needed by modules that merely use locks.
+ The "lock" argument is a pointer to the lock object. */
+
+ /* Report that a lock has been created at address "lock". */
+ #define ANNOTATE_RWLOCK_CREATE(lock) \
+ AnnotateRWLockCreate(__FILE__, __LINE__, lock)
+
+ /* Report that a linker initialized lock has been created at address "lock".
+ */
+#ifdef THREAD_SANITIZER
+ #define ANNOTATE_RWLOCK_CREATE_STATIC(lock) \
+ AnnotateRWLockCreateStatic(__FILE__, __LINE__, lock)
+#else
+ #define ANNOTATE_RWLOCK_CREATE_STATIC(lock) ANNOTATE_RWLOCK_CREATE(lock)
+#endif
+
+ /* Report that the lock at address "lock" is about to be destroyed. */
+ #define ANNOTATE_RWLOCK_DESTROY(lock) \
+ AnnotateRWLockDestroy(__FILE__, __LINE__, lock)
+
+ /* Report that the lock at address "lock" has been acquired.
+ is_w=1 for writer lock, is_w=0 for reader lock. */
+ #define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) \
+ AnnotateRWLockAcquired(__FILE__, __LINE__, lock, is_w)
+
+ /* Report that the lock at address "lock" is about to be released. */
+ #define ANNOTATE_RWLOCK_RELEASED(lock, is_w) \
+ AnnotateRWLockReleased(__FILE__, __LINE__, lock, is_w)
+
+#else /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */
+
+ #define ANNOTATE_RWLOCK_CREATE(lock) /* empty */
+ #define ANNOTATE_RWLOCK_CREATE_STATIC(lock) /* empty */
+ #define ANNOTATE_RWLOCK_DESTROY(lock) /* empty */
+ #define ANNOTATE_RWLOCK_ACQUIRED(lock, is_w) /* empty */
+ #define ANNOTATE_RWLOCK_RELEASED(lock, is_w) /* empty */
+ #define ANNOTATE_BENIGN_RACE(address, description) /* empty */
+ #define ANNOTATE_BENIGN_RACE_SIZED(address, size, description) /* empty */
+ #define ANNOTATE_THREAD_NAME(name) /* empty */
+ #define ANNOTATE_ENABLE_RACE_DETECTION(enable) /* empty */
+
+#endif /* DYNAMIC_ANNOTATIONS_ENABLED */
+
+/* These annotations are also made available to LLVM's Memory Sanitizer */
+#if DYNAMIC_ANNOTATIONS_ENABLED == 1 || defined(MEMORY_SANITIZER)
+ #define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) \
+ AnnotateMemoryIsInitialized(__FILE__, __LINE__, address, size)
+
+ #define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) \
+ AnnotateMemoryIsUninitialized(__FILE__, __LINE__, address, size)
+#else
+ #define ANNOTATE_MEMORY_IS_INITIALIZED(address, size) /* empty */
+ #define ANNOTATE_MEMORY_IS_UNINITIALIZED(address, size) /* empty */
+#endif /* DYNAMIC_ANNOTATIONS_ENABLED || MEMORY_SANITIZER */
+/* TODO(delesley) -- Replace __CLANG_SUPPORT_DYN_ANNOTATION__ with the
+ appropriate feature ID. */
+#if defined(__clang__) && (!defined(SWIG)) \
+ && defined(__CLANG_SUPPORT_DYN_ANNOTATION__)
+
+ #if DYNAMIC_ANNOTATIONS_ENABLED == 0
+ #define ANNOTALYSIS_ENABLED
+ #endif
+
+ /* When running in opt-mode, GCC will issue a warning, if these attributes are
+ compiled. Only include them when compiling using Clang. */
+ #define ATTRIBUTE_IGNORE_READS_BEGIN \
+ __attribute((exclusive_lock_function("*")))
+ #define ATTRIBUTE_IGNORE_READS_END \
+ __attribute((unlock_function("*")))
+#else
+ #define ATTRIBUTE_IGNORE_READS_BEGIN /* empty */
+ #define ATTRIBUTE_IGNORE_READS_END /* empty */
+#endif /* defined(__clang__) && ... */
+
+#if (DYNAMIC_ANNOTATIONS_ENABLED != 0) || defined(ANNOTALYSIS_ENABLED)
+ #define ANNOTATIONS_ENABLED
+#endif
+
+#if (DYNAMIC_ANNOTATIONS_ENABLED != 0)
+
+ /* Request the analysis tool to ignore all reads in the current thread
+ until ANNOTATE_IGNORE_READS_END is called.
+ Useful to ignore intentional racey reads, while still checking
+ other reads and all writes.
+ See also ANNOTATE_UNPROTECTED_READ. */
+ #define ANNOTATE_IGNORE_READS_BEGIN() \
+ AnnotateIgnoreReadsBegin(__FILE__, __LINE__)
+
+ /* Stop ignoring reads. */
+ #define ANNOTATE_IGNORE_READS_END() \
+ AnnotateIgnoreReadsEnd(__FILE__, __LINE__)
+
+ /* Similar to ANNOTATE_IGNORE_READS_BEGIN, but ignore writes instead. */
+ #define ANNOTATE_IGNORE_WRITES_BEGIN() \
+ AnnotateIgnoreWritesBegin(__FILE__, __LINE__)
+
+ /* Stop ignoring writes. */
+ #define ANNOTATE_IGNORE_WRITES_END() \
+ AnnotateIgnoreWritesEnd(__FILE__, __LINE__)
+
+/* Clang provides limited support for static thread-safety analysis
+ through a feature called Annotalysis. We configure macro-definitions
+ according to whether Annotalysis support is available. */
+#elif defined(ANNOTALYSIS_ENABLED)
+
+ #define ANNOTATE_IGNORE_READS_BEGIN() \
+ StaticAnnotateIgnoreReadsBegin(__FILE__, __LINE__)
+
+ #define ANNOTATE_IGNORE_READS_END() \
+ StaticAnnotateIgnoreReadsEnd(__FILE__, __LINE__)
+
+ #define ANNOTATE_IGNORE_WRITES_BEGIN() \
+ StaticAnnotateIgnoreWritesBegin(__FILE__, __LINE__)
+
+ #define ANNOTATE_IGNORE_WRITES_END() \
+ StaticAnnotateIgnoreWritesEnd(__FILE__, __LINE__)
+
+#else
+ #define ANNOTATE_IGNORE_READS_BEGIN() /* empty */
+ #define ANNOTATE_IGNORE_READS_END() /* empty */
+ #define ANNOTATE_IGNORE_WRITES_BEGIN() /* empty */
+ #define ANNOTATE_IGNORE_WRITES_END() /* empty */
+#endif
+
+/* Implement the ANNOTATE_IGNORE_READS_AND_WRITES_* annotations using the more
+ primitive annotations defined above. */
+#if defined(ANNOTATIONS_ENABLED)
+
+ /* Start ignoring all memory accesses (both reads and writes). */
+ #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
+ do { \
+ ANNOTATE_IGNORE_READS_BEGIN(); \
+ ANNOTATE_IGNORE_WRITES_BEGIN(); \
+ }while (0)
+
+ /* Stop ignoring both reads and writes. */
+ #define ANNOTATE_IGNORE_READS_AND_WRITES_END() \
+ do { \
+ ANNOTATE_IGNORE_WRITES_END(); \
+ ANNOTATE_IGNORE_READS_END(); \
+ }while (0)
+
+#else
+ #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() /* empty */
+ #define ANNOTATE_IGNORE_READS_AND_WRITES_END() /* empty */
+#endif
+
+/* Use the macros above rather than using these functions directly. */
+#include <stddef.h>
+#ifdef __cplusplus
+extern "C" {
+#endif
+void AnnotateRWLockCreate(const char *file, int line,
+ const volatile void *lock);
+void AnnotateRWLockCreateStatic(const char *file, int line,
+ const volatile void *lock);
+void AnnotateRWLockDestroy(const char *file, int line,
+ const volatile void *lock);
+void AnnotateRWLockAcquired(const char *file, int line,
+ const volatile void *lock, long is_w); /* NOLINT */
+void AnnotateRWLockReleased(const char *file, int line,
+ const volatile void *lock, long is_w); /* NOLINT */
+void AnnotateBenignRace(const char *file, int line,
+ const volatile void *address,
+ const char *description);
+void AnnotateBenignRaceSized(const char *file, int line,
+ const volatile void *address,
+ size_t size,
+ const char *description);
+void AnnotateThreadName(const char *file, int line,
+ const char *name);
+void AnnotateEnableRaceDetection(const char *file, int line, int enable);
+void AnnotateMemoryIsInitialized(const char *file, int line,
+ const volatile void *mem, size_t size);
+void AnnotateMemoryIsUninitialized(const char *file, int line,
+ const volatile void *mem, size_t size);
+
+/* Annotations expand to these functions, when Dynamic Annotations are enabled.
+ These functions are either implemented as no-op calls, if no Sanitizer is
+ attached, or provided with externally-linked implementations by a library
+ like ThreadSanitizer. */
+void AnnotateIgnoreReadsBegin(const char *file, int line)
+ ATTRIBUTE_IGNORE_READS_BEGIN;
+void AnnotateIgnoreReadsEnd(const char *file, int line)
+ ATTRIBUTE_IGNORE_READS_END;
+void AnnotateIgnoreWritesBegin(const char *file, int line);
+void AnnotateIgnoreWritesEnd(const char *file, int line);
+
+#if defined(ANNOTALYSIS_ENABLED)
+/* When Annotalysis is enabled without Dynamic Annotations, the use of
+ static-inline functions allows the annotations to be read at compile-time,
+ while still letting the compiler elide the functions from the final build.
+
+ TODO(delesley) -- The exclusive lock here ignores writes as well, but
+ allows IGNORE_READS_AND_WRITES to work properly. */
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-function"
+static inline void StaticAnnotateIgnoreReadsBegin(const char *file, int line)
+ ATTRIBUTE_IGNORE_READS_BEGIN { (void)file; (void)line; }
+static inline void StaticAnnotateIgnoreReadsEnd(const char *file, int line)
+ ATTRIBUTE_IGNORE_READS_END { (void)file; (void)line; }
+static inline void StaticAnnotateIgnoreWritesBegin(
+ const char *file, int line) { (void)file; (void)line; }
+static inline void StaticAnnotateIgnoreWritesEnd(
+ const char *file, int line) { (void)file; (void)line; }
+#pragma GCC diagnostic pop
+#endif
+
+/* Return non-zero value if running under valgrind.
+
+ If "valgrind.h" is included into dynamic_annotations.cc,
+ the regular valgrind mechanism will be used.
+ See http://valgrind.org/docs/manual/manual-core-adv.html about
+ RUNNING_ON_VALGRIND and other valgrind "client requests".
+ The file "valgrind.h" may be obtained by doing
+ svn co svn://svn.valgrind.org/valgrind/trunk/include
+
+ If for some reason you can't use "valgrind.h" or want to fake valgrind,
+ there are two ways to make this function return non-zero:
+ - Use environment variable: export RUNNING_ON_VALGRIND=1
+ - Make your tool intercept the function RunningOnValgrind() and
+ change its return value.
+ */
+int RunningOnValgrind(void);
+
+/* ValgrindSlowdown returns:
+ * 1.0, if (RunningOnValgrind() == 0)
+ * 50.0, if (RunningOnValgrind() != 0 && getenv("VALGRIND_SLOWDOWN") == NULL)
+ * atof(getenv("VALGRIND_SLOWDOWN")) otherwise
+ This function can be used to scale timeout values:
+ EXAMPLE:
+ for (;;) {
+ DoExpensiveBackgroundTask();
+ SleepForSeconds(5 * ValgrindSlowdown());
+ }
+ */
+double ValgrindSlowdown(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+/* ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racey reads.
+
+ Instead of doing
+ ANNOTATE_IGNORE_READS_BEGIN();
+ ... = x;
+ ANNOTATE_IGNORE_READS_END();
+ one can use
+ ... = ANNOTATE_UNPROTECTED_READ(x); */
+#if defined(__cplusplus) && defined(ANNOTATIONS_ENABLED)
+template <typename T>
+inline T ANNOTATE_UNPROTECTED_READ(const volatile T &x) { /* NOLINT */
+ ANNOTATE_IGNORE_READS_BEGIN();
+ T res = x;
+ ANNOTATE_IGNORE_READS_END();
+ return res;
+ }
+#else
+ #define ANNOTATE_UNPROTECTED_READ(x) (x)
+#endif
+
+#if DYNAMIC_ANNOTATIONS_ENABLED != 0 && defined(__cplusplus)
+ /* Apply ANNOTATE_BENIGN_RACE_SIZED to a static variable. */
+ #define ANNOTATE_BENIGN_RACE_STATIC(static_var, description) \
+ namespace { \
+ class static_var ## _annotator { \
+ public: \
+ static_var ## _annotator() { \
+ ANNOTATE_BENIGN_RACE_SIZED(&static_var, \
+ sizeof(static_var), \
+ # static_var ": " description); \
+ } \
+ }; \
+ static static_var ## _annotator the ## static_var ## _annotator;\
+ } // namespace
+#else /* DYNAMIC_ANNOTATIONS_ENABLED == 0 */
+ #define ANNOTATE_BENIGN_RACE_STATIC(static_var, description) /* empty */
+#endif /* DYNAMIC_ANNOTATIONS_ENABLED */
+
+#ifdef ADDRESS_SANITIZER
+/* Describe the current state of a contiguous container such as e.g.
+ * std::vector or std::string. For more details see
+ * sanitizer/common_interface_defs.h, which is provided by the compiler. */
+#include <sanitizer/common_interface_defs.h>
+#define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid) \
+ __sanitizer_annotate_contiguous_container(beg, end, old_mid, new_mid)
+#define ADDRESS_SANITIZER_REDZONE(name) \
+ struct { char x[8] __attribute__ ((aligned (8))); } name
+#else
+#define ANNOTATE_CONTIGUOUS_CONTAINER(beg, end, old_mid, new_mid)
+#define ADDRESS_SANITIZER_REDZONE(name)
+#endif // ADDRESS_SANITIZER
+
+/* Undefine the macros intended only in this file. */
+#undef ANNOTALYSIS_ENABLED
+#undef ANNOTATIONS_ENABLED
+#undef ATTRIBUTE_IGNORE_READS_BEGIN
+#undef ATTRIBUTE_IGNORE_READS_END
+
+#endif /* !__native_client__ */
+
+#endif /* ABSL_BASE_DYNAMIC_ANNOTATIONS_H_ */
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/exception_safety_testing_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/exception_safety_testing_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/exception_safety_testing_test.cc
new file mode 100644
index 0000000..ab029e1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/exception_safety_testing_test.cc
@@ -0,0 +1,842 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/exception_safety_testing.h"
+
+#include <cstddef>
+#include <exception>
+#include <iostream>
+#include <list>
+#include <type_traits>
+#include <vector>
+
+#include "gtest/gtest-spi.h"
+#include "gtest/gtest.h"
+#include "absl/memory/memory.h"
+
+namespace absl {
+namespace {
+using ::absl::exceptions_internal::SetCountdown;
+using ::absl::exceptions_internal::TestException;
+using ::absl::exceptions_internal::UnsetCountdown;
+
+// EXPECT_NO_THROW can't inspect the thrown inspection in general.
+template <typename F>
+void ExpectNoThrow(const F& f) {
+ try {
+ f();
+ } catch (TestException e) {
+ ADD_FAILURE() << "Unexpected exception thrown from " << e.what();
+ }
+}
+
+TEST(ThrowingValueTest, Throws) {
+ SetCountdown();
+ EXPECT_THROW(ThrowingValue<> bomb, TestException);
+
+ // It's not guaranteed that every operator only throws *once*. The default
+ // ctor only throws once, though, so use it to make sure we only throw when
+ // the countdown hits 0
+ SetCountdown(2);
+ ExpectNoThrow([]() { ThrowingValue<> bomb; });
+ ExpectNoThrow([]() { ThrowingValue<> bomb; });
+ EXPECT_THROW(ThrowingValue<> bomb, TestException);
+
+ UnsetCountdown();
+}
+
+// Tests that an operation throws when the countdown is at 0, doesn't throw when
+// the countdown doesn't hit 0, and doesn't modify the state of the
+// ThrowingValue if it throws
+template <typename F>
+void TestOp(const F& f) {
+ ExpectNoThrow(f);
+
+ SetCountdown();
+ EXPECT_THROW(f(), TestException);
+ UnsetCountdown();
+}
+
+TEST(ThrowingValueTest, ThrowingCtors) {
+ ThrowingValue<> bomb;
+
+ TestOp([]() { ThrowingValue<> bomb(1); });
+ TestOp([&]() { ThrowingValue<> bomb1 = bomb; });
+ TestOp([&]() { ThrowingValue<> bomb1 = std::move(bomb); });
+}
+
+TEST(ThrowingValueTest, ThrowingAssignment) {
+ ThrowingValue<> bomb, bomb1;
+
+ TestOp([&]() { bomb = bomb1; });
+ TestOp([&]() { bomb = std::move(bomb1); });
+}
+
+TEST(ThrowingValueTest, ThrowingComparisons) {
+ ThrowingValue<> bomb1, bomb2;
+ TestOp([&]() { return bomb1 == bomb2; });
+ TestOp([&]() { return bomb1 != bomb2; });
+ TestOp([&]() { return bomb1 < bomb2; });
+ TestOp([&]() { return bomb1 <= bomb2; });
+ TestOp([&]() { return bomb1 > bomb2; });
+ TestOp([&]() { return bomb1 >= bomb2; });
+}
+
+TEST(ThrowingValueTest, ThrowingArithmeticOps) {
+ ThrowingValue<> bomb1(1), bomb2(2);
+
+ TestOp([&bomb1]() { +bomb1; });
+ TestOp([&bomb1]() { -bomb1; });
+ TestOp([&bomb1]() { ++bomb1; });
+ TestOp([&bomb1]() { bomb1++; });
+ TestOp([&bomb1]() { --bomb1; });
+ TestOp([&bomb1]() { bomb1--; });
+
+ TestOp([&]() { bomb1 + bomb2; });
+ TestOp([&]() { bomb1 - bomb2; });
+ TestOp([&]() { bomb1* bomb2; });
+ TestOp([&]() { bomb1 / bomb2; });
+ TestOp([&]() { bomb1 << 1; });
+ TestOp([&]() { bomb1 >> 1; });
+}
+
+TEST(ThrowingValueTest, ThrowingLogicalOps) {
+ ThrowingValue<> bomb1, bomb2;
+
+ TestOp([&bomb1]() { !bomb1; });
+ TestOp([&]() { bomb1&& bomb2; });
+ TestOp([&]() { bomb1 || bomb2; });
+}
+
+TEST(ThrowingValueTest, ThrowingBitwiseOps) {
+ ThrowingValue<> bomb1, bomb2;
+
+ TestOp([&bomb1]() { ~bomb1; });
+ TestOp([&]() { bomb1& bomb2; });
+ TestOp([&]() { bomb1 | bomb2; });
+ TestOp([&]() { bomb1 ^ bomb2; });
+}
+
+TEST(ThrowingValueTest, ThrowingCompoundAssignmentOps) {
+ ThrowingValue<> bomb1(1), bomb2(2);
+
+ TestOp([&]() { bomb1 += bomb2; });
+ TestOp([&]() { bomb1 -= bomb2; });
+ TestOp([&]() { bomb1 *= bomb2; });
+ TestOp([&]() { bomb1 /= bomb2; });
+ TestOp([&]() { bomb1 %= bomb2; });
+ TestOp([&]() { bomb1 &= bomb2; });
+ TestOp([&]() { bomb1 |= bomb2; });
+ TestOp([&]() { bomb1 ^= bomb2; });
+ TestOp([&]() { bomb1 *= bomb2; });
+}
+
+TEST(ThrowingValueTest, ThrowingStreamOps) {
+ ThrowingValue<> bomb;
+
+ TestOp([&]() { std::cin >> bomb; });
+ TestOp([&]() { std::cout << bomb; });
+}
+
+template <typename F>
+void TestAllocatingOp(const F& f) {
+ ExpectNoThrow(f);
+
+ SetCountdown();
+ EXPECT_THROW(f(), exceptions_internal::TestBadAllocException);
+ UnsetCountdown();
+}
+
+TEST(ThrowingValueTest, ThrowingAllocatingOps) {
+ // make_unique calls unqualified operator new, so these exercise the
+ // ThrowingValue overloads.
+ TestAllocatingOp([]() { return absl::make_unique<ThrowingValue<>>(1); });
+ TestAllocatingOp([]() { return absl::make_unique<ThrowingValue<>[]>(2); });
+}
+
+TEST(ThrowingValueTest, NonThrowingMoveCtor) {
+ ThrowingValue<NoThrow::kMoveCtor> nothrow_ctor;
+
+ SetCountdown();
+ ExpectNoThrow([¬hrow_ctor]() {
+ ThrowingValue<NoThrow::kMoveCtor> nothrow1 = std::move(nothrow_ctor);
+ });
+ UnsetCountdown();
+}
+
+TEST(ThrowingValueTest, NonThrowingMoveAssign) {
+ ThrowingValue<NoThrow::kMoveAssign> nothrow_assign1, nothrow_assign2;
+
+ SetCountdown();
+ ExpectNoThrow([¬hrow_assign1, ¬hrow_assign2]() {
+ nothrow_assign1 = std::move(nothrow_assign2);
+ });
+ UnsetCountdown();
+}
+
+TEST(ThrowingValueTest, ThrowingSwap) {
+ ThrowingValue<> bomb1, bomb2;
+ TestOp([&]() { std::swap(bomb1, bomb2); });
+
+ ThrowingValue<NoThrow::kMoveCtor> bomb3, bomb4;
+ TestOp([&]() { std::swap(bomb3, bomb4); });
+
+ ThrowingValue<NoThrow::kMoveAssign> bomb5, bomb6;
+ TestOp([&]() { std::swap(bomb5, bomb6); });
+}
+
+TEST(ThrowingValueTest, NonThrowingSwap) {
+ ThrowingValue<NoThrow::kMoveAssign | NoThrow::kMoveCtor> bomb1, bomb2;
+ ExpectNoThrow([&]() { std::swap(bomb1, bomb2); });
+}
+
+TEST(ThrowingValueTest, NonThrowingAllocation) {
+ ThrowingValue<NoThrow::kAllocation>* allocated;
+ ThrowingValue<NoThrow::kAllocation>* array;
+
+ ExpectNoThrow([&allocated]() {
+ allocated = new ThrowingValue<NoThrow::kAllocation>(1);
+ delete allocated;
+ });
+ ExpectNoThrow([&array]() {
+ array = new ThrowingValue<NoThrow::kAllocation>[2];
+ delete[] array;
+ });
+}
+
+TEST(ThrowingValueTest, NonThrowingDelete) {
+ auto* allocated = new ThrowingValue<>(1);
+ auto* array = new ThrowingValue<>[2];
+
+ SetCountdown();
+ ExpectNoThrow([allocated]() { delete allocated; });
+ SetCountdown();
+ ExpectNoThrow([array]() { delete[] array; });
+
+ UnsetCountdown();
+}
+
+using Storage =
+ absl::aligned_storage_t<sizeof(ThrowingValue<>), alignof(ThrowingValue<>)>;
+
+TEST(ThrowingValueTest, NonThrowingPlacementDelete) {
+ constexpr int kArrayLen = 2;
+ // We intentionally create extra space to store the tag allocated by placement
+ // new[].
+ constexpr int kStorageLen = 4;
+
+ Storage buf;
+ Storage array_buf[kStorageLen];
+ auto* placed = new (&buf) ThrowingValue<>(1);
+ auto placed_array = new (&array_buf) ThrowingValue<>[kArrayLen];
+
+ SetCountdown();
+ ExpectNoThrow([placed, &buf]() {
+ placed->~ThrowingValue<>();
+ ThrowingValue<>::operator delete(placed, &buf);
+ });
+
+ SetCountdown();
+ ExpectNoThrow([&, placed_array]() {
+ for (int i = 0; i < kArrayLen; ++i) placed_array[i].~ThrowingValue<>();
+ ThrowingValue<>::operator delete[](placed_array, &array_buf);
+ });
+
+ UnsetCountdown();
+}
+
+TEST(ThrowingValueTest, NonThrowingDestructor) {
+ auto* allocated = new ThrowingValue<>();
+
+ SetCountdown();
+ ExpectNoThrow([allocated]() { delete allocated; });
+ UnsetCountdown();
+}
+
+TEST(ThrowingBoolTest, ThrowingBool) {
+ ThrowingBool t = true;
+
+ // Test that it's contextually convertible to bool
+ if (t) { // NOLINT(whitespace/empty_if_body)
+ }
+ EXPECT_TRUE(t);
+
+ TestOp([&]() { (void)!t; });
+}
+
+TEST(ThrowingAllocatorTest, MemoryManagement) {
+ // Just exercise the memory management capabilities under LSan to make sure we
+ // don't leak.
+ ThrowingAllocator<int> int_alloc;
+ int* ip = int_alloc.allocate(1);
+ int_alloc.deallocate(ip, 1);
+ int* i_array = int_alloc.allocate(2);
+ int_alloc.deallocate(i_array, 2);
+
+ ThrowingAllocator<ThrowingValue<>> ef_alloc;
+ ThrowingValue<>* efp = ef_alloc.allocate(1);
+ ef_alloc.deallocate(efp, 1);
+ ThrowingValue<>* ef_array = ef_alloc.allocate(2);
+ ef_alloc.deallocate(ef_array, 2);
+}
+
+TEST(ThrowingAllocatorTest, CallsGlobalNew) {
+ ThrowingAllocator<ThrowingValue<>, NoThrow::kNoThrow> nothrow_alloc;
+ ThrowingValue<>* ptr;
+
+ SetCountdown();
+ // This will only throw if ThrowingValue::new is called.
+ ExpectNoThrow([&]() { ptr = nothrow_alloc.allocate(1); });
+ nothrow_alloc.deallocate(ptr, 1);
+
+ UnsetCountdown();
+}
+
+TEST(ThrowingAllocatorTest, ThrowingConstructors) {
+ ThrowingAllocator<int> int_alloc;
+ int* ip = nullptr;
+
+ SetCountdown();
+ EXPECT_THROW(ip = int_alloc.allocate(1), TestException);
+ ExpectNoThrow([&]() { ip = int_alloc.allocate(1); });
+
+ *ip = 1;
+ SetCountdown();
+ EXPECT_THROW(int_alloc.construct(ip, 2), TestException);
+ EXPECT_EQ(*ip, 1);
+ int_alloc.deallocate(ip, 1);
+
+ UnsetCountdown();
+}
+
+TEST(ThrowingAllocatorTest, NonThrowingConstruction) {
+ {
+ ThrowingAllocator<int, NoThrow::kNoThrow> int_alloc;
+ int* ip = nullptr;
+
+ SetCountdown();
+ ExpectNoThrow([&]() { ip = int_alloc.allocate(1); });
+
+ SetCountdown();
+ ExpectNoThrow([&]() { int_alloc.construct(ip, 2); });
+
+ EXPECT_EQ(*ip, 2);
+ int_alloc.deallocate(ip, 1);
+
+ UnsetCountdown();
+ }
+
+ {
+ ThrowingAllocator<int> int_alloc;
+ int* ip = nullptr;
+ ExpectNoThrow([&]() { ip = int_alloc.allocate(1); });
+ ExpectNoThrow([&]() { int_alloc.construct(ip, 2); });
+ EXPECT_EQ(*ip, 2);
+ int_alloc.deallocate(ip, 1);
+ }
+
+ {
+ ThrowingAllocator<ThrowingValue<NoThrow::kIntCtor>, NoThrow::kNoThrow>
+ ef_alloc;
+ ThrowingValue<NoThrow::kIntCtor>* efp;
+
+ SetCountdown();
+ ExpectNoThrow([&]() { efp = ef_alloc.allocate(1); });
+
+ SetCountdown();
+ ExpectNoThrow([&]() { ef_alloc.construct(efp, 2); });
+
+ EXPECT_EQ(efp->Get(), 2);
+ ef_alloc.destroy(efp);
+ ef_alloc.deallocate(efp, 1);
+
+ UnsetCountdown();
+ }
+
+ {
+ ThrowingAllocator<int> a;
+
+ SetCountdown();
+ ExpectNoThrow([&]() { ThrowingAllocator<double> a1 = a; });
+
+ SetCountdown();
+ ExpectNoThrow([&]() { ThrowingAllocator<double> a1 = std::move(a); });
+
+ UnsetCountdown();
+ }
+}
+
+TEST(ThrowingAllocatorTest, ThrowingAllocatorConstruction) {
+ ThrowingAllocator<int> a;
+ TestOp([]() { ThrowingAllocator<int> a; });
+ TestOp([&]() { a.select_on_container_copy_construction(); });
+}
+
+TEST(ThrowingAllocatorTest, State) {
+ ThrowingAllocator<int> a1, a2;
+ EXPECT_NE(a1, a2);
+
+ auto a3 = a1;
+ EXPECT_EQ(a3, a1);
+ int* ip = a1.allocate(1);
+ EXPECT_EQ(a3, a1);
+ a3.deallocate(ip, 1);
+ EXPECT_EQ(a3, a1);
+}
+
+TEST(ThrowingAllocatorTest, InVector) {
+ std::vector<ThrowingValue<>, ThrowingAllocator<ThrowingValue<>>> v;
+ for (int i = 0; i < 20; ++i) v.push_back({});
+ for (int i = 0; i < 20; ++i) v.pop_back();
+}
+
+TEST(ThrowingAllocatorTest, InList) {
+ std::list<ThrowingValue<>, ThrowingAllocator<ThrowingValue<>>> l;
+ for (int i = 0; i < 20; ++i) l.push_back({});
+ for (int i = 0; i < 20; ++i) l.pop_back();
+ for (int i = 0; i < 20; ++i) l.push_front({});
+ for (int i = 0; i < 20; ++i) l.pop_front();
+}
+
+template <typename TesterInstance, typename = void>
+struct NullaryTestValidator : public std::false_type {};
+
+template <typename TesterInstance>
+struct NullaryTestValidator<
+ TesterInstance,
+ absl::void_t<decltype(std::declval<TesterInstance>().Test())>>
+ : public std::true_type {};
+
+template <typename TesterInstance>
+bool HasNullaryTest(const TesterInstance&) {
+ return NullaryTestValidator<TesterInstance>::value;
+}
+
+void DummyOp(void*) {}
+
+template <typename TesterInstance, typename = void>
+struct UnaryTestValidator : public std::false_type {};
+
+template <typename TesterInstance>
+struct UnaryTestValidator<
+ TesterInstance,
+ absl::void_t<decltype(std::declval<TesterInstance>().Test(DummyOp))>>
+ : public std::true_type {};
+
+template <typename TesterInstance>
+bool HasUnaryTest(const TesterInstance&) {
+ return UnaryTestValidator<TesterInstance>::value;
+}
+
+TEST(ExceptionSafetyTesterTest, IncompleteTypesAreNotTestable) {
+ using T = exceptions_internal::UninitializedT;
+ auto op = [](T* t) {};
+ auto inv = [](T*) { return testing::AssertionSuccess(); };
+ auto fac = []() { return absl::make_unique<T>(); };
+
+ // Test that providing operation and inveriants still does not allow for the
+ // the invocation of .Test() and .Test(op) because it lacks a factory
+ auto without_fac =
+ absl::MakeExceptionSafetyTester().WithOperation(op).WithInvariants(
+ inv, absl::strong_guarantee);
+ EXPECT_FALSE(HasNullaryTest(without_fac));
+ EXPECT_FALSE(HasUnaryTest(without_fac));
+
+ // Test that providing invariants and factory allows the invocation of
+ // .Test(op) but does not allow for .Test() because it lacks an operation
+ auto without_op = absl::MakeExceptionSafetyTester()
+ .WithInvariants(inv, absl::strong_guarantee)
+ .WithFactory(fac);
+ EXPECT_FALSE(HasNullaryTest(without_op));
+ EXPECT_TRUE(HasUnaryTest(without_op));
+
+ // Test that providing operation and factory still does not allow for the
+ // the invocation of .Test() and .Test(op) because it lacks invariants
+ auto without_inv =
+ absl::MakeExceptionSafetyTester().WithOperation(op).WithFactory(fac);
+ EXPECT_FALSE(HasNullaryTest(without_inv));
+ EXPECT_FALSE(HasUnaryTest(without_inv));
+}
+
+struct ExampleStruct {};
+
+std::unique_ptr<ExampleStruct> ExampleFunctionFactory() {
+ return absl::make_unique<ExampleStruct>();
+}
+
+void ExampleFunctionOperation(ExampleStruct*) {}
+
+testing::AssertionResult ExampleFunctionInvariant(ExampleStruct*) {
+ return testing::AssertionSuccess();
+}
+
+struct {
+ std::unique_ptr<ExampleStruct> operator()() const {
+ return ExampleFunctionFactory();
+ }
+} example_struct_factory;
+
+struct {
+ void operator()(ExampleStruct*) const {}
+} example_struct_operation;
+
+struct {
+ testing::AssertionResult operator()(ExampleStruct* example_struct) const {
+ return ExampleFunctionInvariant(example_struct);
+ }
+} example_struct_invariant;
+
+auto example_lambda_factory = []() { return ExampleFunctionFactory(); };
+
+auto example_lambda_operation = [](ExampleStruct*) {};
+
+auto example_lambda_invariant = [](ExampleStruct* example_struct) {
+ return ExampleFunctionInvariant(example_struct);
+};
+
+// Testing that function references, pointers, structs with operator() and
+// lambdas can all be used with ExceptionSafetyTester
+TEST(ExceptionSafetyTesterTest, MixedFunctionTypes) {
+ // function reference
+ EXPECT_TRUE(absl::MakeExceptionSafetyTester()
+ .WithFactory(ExampleFunctionFactory)
+ .WithOperation(ExampleFunctionOperation)
+ .WithInvariants(ExampleFunctionInvariant)
+ .Test());
+
+ // function pointer
+ EXPECT_TRUE(absl::MakeExceptionSafetyTester()
+ .WithFactory(&ExampleFunctionFactory)
+ .WithOperation(&ExampleFunctionOperation)
+ .WithInvariants(&ExampleFunctionInvariant)
+ .Test());
+
+ // struct
+ EXPECT_TRUE(absl::MakeExceptionSafetyTester()
+ .WithFactory(example_struct_factory)
+ .WithOperation(example_struct_operation)
+ .WithInvariants(example_struct_invariant)
+ .Test());
+
+ // lambda
+ EXPECT_TRUE(absl::MakeExceptionSafetyTester()
+ .WithFactory(example_lambda_factory)
+ .WithOperation(example_lambda_operation)
+ .WithInvariants(example_lambda_invariant)
+ .Test());
+}
+
+struct NonNegative {
+ bool operator==(const NonNegative& other) const { return i == other.i; }
+ int i;
+};
+
+testing::AssertionResult CheckNonNegativeInvariants(NonNegative* g) {
+ if (g->i >= 0) {
+ return testing::AssertionSuccess();
+ }
+ return testing::AssertionFailure()
+ << "i should be non-negative but is " << g->i;
+}
+
+struct {
+ template <typename T>
+ void operator()(T* t) const {
+ (*t)();
+ }
+} invoker;
+
+auto tester =
+ absl::MakeExceptionSafetyTester().WithOperation(invoker).WithInvariants(
+ CheckNonNegativeInvariants);
+auto strong_tester = tester.WithInvariants(absl::strong_guarantee);
+
+struct FailsBasicGuarantee : public NonNegative {
+ void operator()() {
+ --i;
+ ThrowingValue<> bomb;
+ ++i;
+ }
+};
+
+TEST(ExceptionCheckTest, BasicGuaranteeFailure) {
+ EXPECT_FALSE(tester.WithInitialValue(FailsBasicGuarantee{}).Test());
+}
+
+struct FollowsBasicGuarantee : public NonNegative {
+ void operator()() {
+ ++i;
+ ThrowingValue<> bomb;
+ }
+};
+
+TEST(ExceptionCheckTest, BasicGuarantee) {
+ EXPECT_TRUE(tester.WithInitialValue(FollowsBasicGuarantee{}).Test());
+}
+
+TEST(ExceptionCheckTest, StrongGuaranteeFailure) {
+ EXPECT_FALSE(strong_tester.WithInitialValue(FailsBasicGuarantee{}).Test());
+ EXPECT_FALSE(strong_tester.WithInitialValue(FollowsBasicGuarantee{}).Test());
+}
+
+struct BasicGuaranteeWithExtraInvariants : public NonNegative {
+ // After operator(), i is incremented. If operator() throws, i is set to 9999
+ void operator()() {
+ int old_i = i;
+ i = kExceptionSentinel;
+ ThrowingValue<> bomb;
+ i = ++old_i;
+ }
+
+ static constexpr int kExceptionSentinel = 9999;
+};
+constexpr int BasicGuaranteeWithExtraInvariants::kExceptionSentinel;
+
+TEST(ExceptionCheckTest, BasicGuaranteeWithInvariants) {
+ auto tester_with_val =
+ tester.WithInitialValue(BasicGuaranteeWithExtraInvariants{});
+ EXPECT_TRUE(tester_with_val.Test());
+ EXPECT_TRUE(
+ tester_with_val
+ .WithInvariants([](BasicGuaranteeWithExtraInvariants* w) {
+ if (w->i == BasicGuaranteeWithExtraInvariants::kExceptionSentinel) {
+ return testing::AssertionSuccess();
+ }
+ return testing::AssertionFailure()
+ << "i should be "
+ << BasicGuaranteeWithExtraInvariants::kExceptionSentinel
+ << ", but is " << w->i;
+ })
+ .Test());
+}
+
+struct FollowsStrongGuarantee : public NonNegative {
+ void operator()() { ThrowingValue<> bomb; }
+};
+
+TEST(ExceptionCheckTest, StrongGuarantee) {
+ EXPECT_TRUE(tester.WithInitialValue(FollowsStrongGuarantee{}).Test());
+ EXPECT_TRUE(strong_tester.WithInitialValue(FollowsStrongGuarantee{}).Test());
+}
+
+struct HasReset : public NonNegative {
+ void operator()() {
+ i = -1;
+ ThrowingValue<> bomb;
+ i = 1;
+ }
+
+ void reset() { i = 0; }
+};
+
+testing::AssertionResult CheckHasResetInvariants(HasReset* h) {
+ h->reset();
+ return testing::AssertionResult(h->i == 0);
+}
+
+TEST(ExceptionCheckTest, ModifyingChecker) {
+ auto set_to_1000 = [](FollowsBasicGuarantee* g) {
+ g->i = 1000;
+ return testing::AssertionSuccess();
+ };
+ auto is_1000 = [](FollowsBasicGuarantee* g) {
+ return testing::AssertionResult(g->i == 1000);
+ };
+ auto increment = [](FollowsStrongGuarantee* g) {
+ ++g->i;
+ return testing::AssertionSuccess();
+ };
+
+ EXPECT_FALSE(tester.WithInitialValue(FollowsBasicGuarantee{})
+ .WithInvariants(set_to_1000, is_1000)
+ .Test());
+ EXPECT_TRUE(strong_tester.WithInitialValue(FollowsStrongGuarantee{})
+ .WithInvariants(increment)
+ .Test());
+ EXPECT_TRUE(absl::MakeExceptionSafetyTester()
+ .WithInitialValue(HasReset{})
+ .WithInvariants(CheckHasResetInvariants)
+ .Test(invoker));
+}
+
+struct NonCopyable : public NonNegative {
+ NonCopyable(const NonCopyable&) = delete;
+ NonCopyable() : NonNegative{0} {}
+
+ void operator()() { ThrowingValue<> bomb; }
+};
+
+TEST(ExceptionCheckTest, NonCopyable) {
+ auto factory = []() { return absl::make_unique<NonCopyable>(); };
+ EXPECT_TRUE(tester.WithFactory(factory).Test());
+ EXPECT_TRUE(strong_tester.WithFactory(factory).Test());
+}
+
+struct NonEqualityComparable : public NonNegative {
+ void operator()() { ThrowingValue<> bomb; }
+
+ void ModifyOnThrow() {
+ ++i;
+ ThrowingValue<> bomb;
+ static_cast<void>(bomb);
+ --i;
+ }
+};
+
+TEST(ExceptionCheckTest, NonEqualityComparable) {
+ auto nec_is_strong = [](NonEqualityComparable* nec) {
+ return testing::AssertionResult(nec->i == NonEqualityComparable().i);
+ };
+ auto strong_nec_tester = tester.WithInitialValue(NonEqualityComparable{})
+ .WithInvariants(nec_is_strong);
+
+ EXPECT_TRUE(strong_nec_tester.Test());
+ EXPECT_FALSE(strong_nec_tester.Test(
+ [](NonEqualityComparable* n) { n->ModifyOnThrow(); }));
+}
+
+template <typename T>
+struct ExhaustivenessTester {
+ void operator()() {
+ successes |= 1;
+ T b1;
+ static_cast<void>(b1);
+ successes |= (1 << 1);
+ T b2;
+ static_cast<void>(b2);
+ successes |= (1 << 2);
+ T b3;
+ static_cast<void>(b3);
+ successes |= (1 << 3);
+ }
+
+ bool operator==(const ExhaustivenessTester<ThrowingValue<>>&) const {
+ return true;
+ }
+
+ static unsigned char successes;
+};
+
+struct {
+ template <typename T>
+ testing::AssertionResult operator()(ExhaustivenessTester<T>*) const {
+ return testing::AssertionSuccess();
+ }
+} CheckExhaustivenessTesterInvariants;
+
+template <typename T>
+unsigned char ExhaustivenessTester<T>::successes = 0;
+
+TEST(ExceptionCheckTest, Exhaustiveness) {
+ auto exhaust_tester = absl::MakeExceptionSafetyTester()
+ .WithInvariants(CheckExhaustivenessTesterInvariants)
+ .WithOperation(invoker);
+
+ EXPECT_TRUE(
+ exhaust_tester.WithInitialValue(ExhaustivenessTester<int>{}).Test());
+ EXPECT_EQ(ExhaustivenessTester<int>::successes, 0xF);
+
+ EXPECT_TRUE(
+ exhaust_tester.WithInitialValue(ExhaustivenessTester<ThrowingValue<>>{})
+ .WithInvariants(absl::strong_guarantee)
+ .Test());
+ EXPECT_EQ(ExhaustivenessTester<ThrowingValue<>>::successes, 0xF);
+}
+
+struct LeaksIfCtorThrows : private exceptions_internal::TrackedObject {
+ LeaksIfCtorThrows() : TrackedObject(ABSL_PRETTY_FUNCTION) {
+ ++counter;
+ ThrowingValue<> v;
+ static_cast<void>(v);
+ --counter;
+ }
+ LeaksIfCtorThrows(const LeaksIfCtorThrows&) noexcept
+ : TrackedObject(ABSL_PRETTY_FUNCTION) {}
+ static int counter;
+};
+int LeaksIfCtorThrows::counter = 0;
+
+TEST(ExceptionCheckTest, TestLeakyCtor) {
+ absl::TestThrowingCtor<LeaksIfCtorThrows>();
+ EXPECT_EQ(LeaksIfCtorThrows::counter, 1);
+ LeaksIfCtorThrows::counter = 0;
+}
+
+struct Tracked : private exceptions_internal::TrackedObject {
+ Tracked() : TrackedObject(ABSL_PRETTY_FUNCTION) {}
+};
+
+TEST(ConstructorTrackerTest, CreatedBefore) {
+ Tracked a, b, c;
+ exceptions_internal::ConstructorTracker ct(exceptions_internal::countdown);
+}
+
+TEST(ConstructorTrackerTest, CreatedAfter) {
+ exceptions_internal::ConstructorTracker ct(exceptions_internal::countdown);
+ Tracked a, b, c;
+}
+
+TEST(ConstructorTrackerTest, NotDestroyedAfter) {
+ absl::aligned_storage_t<sizeof(Tracked), alignof(Tracked)> storage;
+ EXPECT_NONFATAL_FAILURE(
+ {
+ exceptions_internal::ConstructorTracker ct(
+ exceptions_internal::countdown);
+ new (&storage) Tracked;
+ },
+ "not destroyed");
+
+ // Manual destruction of the Tracked instance is not required because
+ // ~ConstructorTracker() handles that automatically when a leak is found
+}
+
+TEST(ConstructorTrackerTest, DestroyedTwice) {
+ EXPECT_NONFATAL_FAILURE(
+ {
+ Tracked t;
+ t.~Tracked();
+ },
+ "destroyed improperly");
+}
+
+TEST(ConstructorTrackerTest, ConstructedTwice) {
+ absl::aligned_storage_t<sizeof(Tracked), alignof(Tracked)> storage;
+ EXPECT_NONFATAL_FAILURE(
+ {
+ new (&storage) Tracked;
+ new (&storage) Tracked;
+ },
+ "re-constructed");
+ reinterpret_cast<Tracked*>(&storage)->~Tracked();
+}
+
+TEST(ThrowingValueTraitsTest, RelationalOperators) {
+ ThrowingValue<> a, b;
+ EXPECT_TRUE((std::is_convertible<decltype(a == b), bool>::value));
+ EXPECT_TRUE((std::is_convertible<decltype(a != b), bool>::value));
+ EXPECT_TRUE((std::is_convertible<decltype(a < b), bool>::value));
+ EXPECT_TRUE((std::is_convertible<decltype(a <= b), bool>::value));
+ EXPECT_TRUE((std::is_convertible<decltype(a > b), bool>::value));
+ EXPECT_TRUE((std::is_convertible<decltype(a >= b), bool>::value));
+}
+
+TEST(ThrowingAllocatorTraitsTest, Assignablility) {
+ EXPECT_TRUE(std::is_move_assignable<ThrowingAllocator<int>>::value);
+ EXPECT_TRUE(std::is_copy_assignable<ThrowingAllocator<int>>::value);
+ EXPECT_TRUE(std::is_nothrow_move_assignable<ThrowingAllocator<int>>::value);
+ EXPECT_TRUE(std::is_nothrow_copy_assignable<ThrowingAllocator<int>>::value);
+}
+
+} // namespace
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test.cc
new file mode 100644
index 0000000..5499189
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test.cc
@@ -0,0 +1,62 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <type_traits>
+
+#include "absl/base/internal/inline_variable.h"
+#include "absl/base/internal/inline_variable_testing.h"
+
+#include "gtest/gtest.h"
+
+namespace absl {
+namespace inline_variable_testing_internal {
+namespace {
+
+TEST(InlineVariableTest, Constexpr) {
+ static_assert(inline_variable_foo.value == 5, "");
+ static_assert(other_inline_variable_foo.value == 5, "");
+ static_assert(inline_variable_int == 5, "");
+ static_assert(other_inline_variable_int == 5, "");
+}
+
+TEST(InlineVariableTest, DefaultConstructedIdentityEquality) {
+ EXPECT_EQ(get_foo_a().value, 5);
+ EXPECT_EQ(get_foo_b().value, 5);
+ EXPECT_EQ(&get_foo_a(), &get_foo_b());
+}
+
+TEST(InlineVariableTest, DefaultConstructedIdentityInequality) {
+ EXPECT_NE(&inline_variable_foo, &other_inline_variable_foo);
+}
+
+TEST(InlineVariableTest, InitializedIdentityEquality) {
+ EXPECT_EQ(get_int_a(), 5);
+ EXPECT_EQ(get_int_b(), 5);
+ EXPECT_EQ(&get_int_a(), &get_int_b());
+}
+
+TEST(InlineVariableTest, InitializedIdentityInequality) {
+ EXPECT_NE(&inline_variable_int, &other_inline_variable_int);
+}
+
+TEST(InlineVariableTest, FunPtrType) {
+ static_assert(
+ std::is_same<void(*)(),
+ std::decay<decltype(inline_variable_fun_ptr)>::type>::value,
+ "");
+}
+
+} // namespace
+} // namespace inline_variable_testing_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test_a.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test_a.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test_a.cc
new file mode 100644
index 0000000..a3bf3b6
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test_a.cc
@@ -0,0 +1,25 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/inline_variable_testing.h"
+
+namespace absl {
+namespace inline_variable_testing_internal {
+
+const Foo& get_foo_a() { return inline_variable_foo; }
+
+const int& get_int_a() { return inline_variable_int; }
+
+} // namespace inline_variable_testing_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test_b.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test_b.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test_b.cc
new file mode 100644
index 0000000..b4b9393
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/inline_variable_test_b.cc
@@ -0,0 +1,25 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/inline_variable_testing.h"
+
+namespace absl {
+namespace inline_variable_testing_internal {
+
+const Foo& get_foo_b() { return inline_variable_foo; }
+
+const int& get_int_b() { return inline_variable_int; }
+
+} // namespace inline_variable_testing_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/atomic_hook.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/atomic_hook.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/atomic_hook.h
new file mode 100644
index 0000000..47d4013
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/atomic_hook.h
@@ -0,0 +1,150 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
+#define ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
+
+#include <atomic>
+#include <cassert>
+#include <cstdint>
+#include <utility>
+
+namespace absl {
+namespace base_internal {
+
+template <typename T>
+class AtomicHook;
+
+// AtomicHook is a helper class, templatized on a raw function pointer type, for
+// implementing Abseil customization hooks. It is a callable object that
+// dispatches to the registered hook, or performs a no-op (and returns a default
+// constructed object) if no hook has been registered.
+//
+// Reads and writes guarantee memory_order_acquire/memory_order_release
+// semantics.
+template <typename ReturnType, typename... Args>
+class AtomicHook<ReturnType (*)(Args...)> {
+ public:
+ using FnPtr = ReturnType (*)(Args...);
+
+ constexpr AtomicHook() : hook_(kInitialValue) {}
+
+ // Stores the provided function pointer as the value for this hook.
+ //
+ // This is intended to be called once. Multiple calls are legal only if the
+ // same function pointer is provided for each call. The store is implemented
+ // as a memory_order_release operation, and read accesses are implemented as
+ // memory_order_acquire.
+ void Store(FnPtr fn) {
+ bool success = DoStore(fn);
+ static_cast<void>(success);
+ assert(success);
+ }
+
+ // Invokes the registered callback. If no callback has yet been registered, a
+ // default-constructed object of the appropriate type is returned instead.
+ template <typename... CallArgs>
+ ReturnType operator()(CallArgs&&... args) const {
+ return DoLoad()(std::forward<CallArgs>(args)...);
+ }
+
+ // Returns the registered callback, or nullptr if none has been registered.
+ // Useful if client code needs to conditionalize behavior based on whether a
+ // callback was registered.
+ //
+ // Note that atomic_hook.Load()() and atomic_hook() have different semantics:
+ // operator()() will perform a no-op if no callback was registered, while
+ // Load()() will dereference a null function pointer. Prefer operator()() to
+ // Load()() unless you must conditionalize behavior on whether a hook was
+ // registered.
+ FnPtr Load() const {
+ FnPtr ptr = DoLoad();
+ return (ptr == DummyFunction) ? nullptr : ptr;
+ }
+
+ private:
+ static ReturnType DummyFunction(Args...) {
+ return ReturnType();
+ }
+
+ // Current versions of MSVC (as of September 2017) have a broken
+ // implementation of std::atomic<T*>: Its constructor attempts to do the
+ // equivalent of a reinterpret_cast in a constexpr context, which is not
+ // allowed.
+ //
+ // This causes an issue when building with LLVM under Windows. To avoid this,
+ // we use a less-efficient, intptr_t-based implementation on Windows.
+
+#ifdef _MSC_FULL_VER
+#define ABSL_HAVE_WORKING_ATOMIC_POINTER 0
+#else
+#define ABSL_HAVE_WORKING_ATOMIC_POINTER 1
+#endif
+
+#if ABSL_HAVE_WORKING_ATOMIC_POINTER
+ static constexpr FnPtr kInitialValue = &DummyFunction;
+
+ // Return the stored value, or DummyFunction if no value has been stored.
+ FnPtr DoLoad() const { return hook_.load(std::memory_order_acquire); }
+
+ // Store the given value. Returns false if a different value was already
+ // stored to this object.
+ bool DoStore(FnPtr fn) {
+ assert(fn);
+ FnPtr expected = DummyFunction;
+ hook_.compare_exchange_strong(expected, fn, std::memory_order_acq_rel,
+ std::memory_order_acquire);
+ const bool store_succeeded = (expected == DummyFunction);
+ const bool same_value_already_stored = (expected == fn);
+ return store_succeeded || same_value_already_stored;
+ }
+
+ std::atomic<FnPtr> hook_;
+#else // !ABSL_HAVE_WORKING_ATOMIC_POINTER
+ // Use a sentinel value unlikely to be the address of an actual function.
+ static constexpr intptr_t kInitialValue = 0;
+
+ static_assert(sizeof(intptr_t) >= sizeof(FnPtr),
+ "intptr_t can't contain a function pointer");
+
+ FnPtr DoLoad() const {
+ const intptr_t value = hook_.load(std::memory_order_acquire);
+ if (value == 0) {
+ return DummyFunction;
+ }
+ return reinterpret_cast<FnPtr>(value);
+ }
+
+ bool DoStore(FnPtr fn) {
+ assert(fn);
+ const auto value = reinterpret_cast<intptr_t>(fn);
+ intptr_t expected = 0;
+ hook_.compare_exchange_strong(expected, value, std::memory_order_acq_rel,
+ std::memory_order_acquire);
+ const bool store_succeeded = (expected == 0);
+ const bool same_value_already_stored = (expected == value);
+ return store_succeeded || same_value_already_stored;
+ }
+
+ std::atomic<intptr_t> hook_;
+#endif
+};
+
+#undef ABSL_HAVE_WORKING_ATOMIC_POINTER
+
+} // namespace base_internal
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_ATOMIC_HOOK_H_
[35/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/memory/memory.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/memory/memory.h b/libraries/ostrich/backend/3rdparty/abseil/absl/memory/memory.h
new file mode 100644
index 0000000..2220ee4
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/memory/memory.h
@@ -0,0 +1,640 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: memory.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains utility functions for managing the creation and
+// conversion of smart pointers. This file is an extension to the C++
+// standard <memory> library header file.
+
+#ifndef ABSL_MEMORY_MEMORY_H_
+#define ABSL_MEMORY_MEMORY_H_
+
+#include <cstddef>
+#include <limits>
+#include <memory>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/macros.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+
+// -----------------------------------------------------------------------------
+// Function Template: WrapUnique()
+// -----------------------------------------------------------------------------
+//
+// Adopts ownership from a raw pointer and transfers it to the returned
+// `std::unique_ptr`, whose type is deduced.
+//
+// Example:
+// X* NewX(int, int);
+// auto x = WrapUnique(NewX(1, 2)); // 'x' is std::unique_ptr<X>.
+//
+// `absl::WrapUnique` is useful for capturing the output of a raw pointer
+// factory. However, prefer 'absl::make_unique<T>(args...) over
+// 'absl::WrapUnique(new T(args...))'.
+//
+// auto x = WrapUnique(new X(1, 2)); // works, but nonideal.
+// auto x = make_unique<X>(1, 2); // safer, standard, avoids raw 'new'.
+//
+// Note that `absl::WrapUnique(p)` is valid only if `delete p` is a valid
+// expression. In particular, `absl::WrapUnique()` cannot wrap pointers to
+// arrays, functions or void, and it must not be used to capture pointers
+// obtained from array-new expressions (even though that would compile!).
+template <typename T>
+std::unique_ptr<T> WrapUnique(T* ptr) {
+ static_assert(!std::is_array<T>::value, "array types are unsupported");
+ static_assert(std::is_object<T>::value, "non-object types are unsupported");
+ return std::unique_ptr<T>(ptr);
+}
+
+namespace memory_internal {
+
+// Traits to select proper overload and return type for `absl::make_unique<>`.
+template <typename T>
+struct MakeUniqueResult {
+ using scalar = std::unique_ptr<T>;
+};
+template <typename T>
+struct MakeUniqueResult<T[]> {
+ using array = std::unique_ptr<T[]>;
+};
+template <typename T, size_t N>
+struct MakeUniqueResult<T[N]> {
+ using invalid = void;
+};
+
+} // namespace memory_internal
+
+#if __cplusplus >= 201402L || defined(_MSC_VER)
+using std::make_unique;
+#else
+// -----------------------------------------------------------------------------
+// Function Template: make_unique<T>()
+// -----------------------------------------------------------------------------
+//
+// Creates a `std::unique_ptr<>`, while avoiding issues creating temporaries
+// during the construction process. `absl::make_unique<>` also avoids redundant
+// type declarations, by avoiding the need to explicitly use the `new` operator.
+//
+// This implementation of `absl::make_unique<>` is designed for C++11 code and
+// will be replaced in C++14 by the equivalent `std::make_unique<>` abstraction.
+// `absl::make_unique<>` is designed to be 100% compatible with
+// `std::make_unique<>` so that the eventual migration will involve a simple
+// rename operation.
+//
+// For more background on why `std::unique_ptr<T>(new T(a,b))` is problematic,
+// see Herb Sutter's explanation on
+// (Exception-Safe Function Calls)[http://herbsutter.com/gotw/_102/].
+// (In general, reviewers should treat `new T(a,b)` with scrutiny.)
+//
+// Example usage:
+//
+// auto p = make_unique<X>(args...); // 'p' is a std::unique_ptr<X>
+// auto pa = make_unique<X[]>(5); // 'pa' is a std::unique_ptr<X[]>
+//
+// Three overloads of `absl::make_unique` are required:
+//
+// - For non-array T:
+//
+// Allocates a T with `new T(std::forward<Args> args...)`,
+// forwarding all `args` to T's constructor.
+// Returns a `std::unique_ptr<T>` owning that object.
+//
+// - For an array of unknown bounds T[]:
+//
+// `absl::make_unique<>` will allocate an array T of type U[] with
+// `new U[n]()` and return a `std::unique_ptr<U[]>` owning that array.
+//
+// Note that 'U[n]()' is different from 'U[n]', and elements will be
+// value-initialized. Note as well that `std::unique_ptr` will perform its
+// own destruction of the array elements upon leaving scope, even though
+// the array [] does not have a default destructor.
+//
+// NOTE: an array of unknown bounds T[] may still be (and often will be)
+// initialized to have a size, and will still use this overload. E.g:
+//
+// auto my_array = absl::make_unique<int[]>(10);
+//
+// - For an array of known bounds T[N]:
+//
+// `absl::make_unique<>` is deleted (like with `std::make_unique<>`) as
+// this overload is not useful.
+//
+// NOTE: an array of known bounds T[N] is not considered a useful
+// construction, and may cause undefined behavior in templates. E.g:
+//
+// auto my_array = absl::make_unique<int[10]>();
+//
+// In those cases, of course, you can still use the overload above and
+// simply initialize it to its desired size:
+//
+// auto my_array = absl::make_unique<int[]>(10);
+
+// `absl::make_unique` overload for non-array types.
+template <typename T, typename... Args>
+typename memory_internal::MakeUniqueResult<T>::scalar make_unique(
+ Args&&... args) {
+ return std::unique_ptr<T>(new T(std::forward<Args>(args)...));
+}
+
+// `absl::make_unique` overload for an array T[] of unknown bounds.
+// The array allocation needs to use the `new T[size]` form and cannot take
+// element constructor arguments. The `std::unique_ptr` will manage destructing
+// these array elements.
+template <typename T>
+typename memory_internal::MakeUniqueResult<T>::array make_unique(size_t n) {
+ return std::unique_ptr<T>(new typename absl::remove_extent_t<T>[n]());
+}
+
+// `absl::make_unique` overload for an array T[N] of known bounds.
+// This construction will be rejected.
+template <typename T, typename... Args>
+typename memory_internal::MakeUniqueResult<T>::invalid make_unique(
+ Args&&... /* args */) = delete;
+#endif
+
+// -----------------------------------------------------------------------------
+// Function Template: RawPtr()
+// -----------------------------------------------------------------------------
+//
+// Extracts the raw pointer from a pointer-like value `ptr`. `absl::RawPtr` is
+// useful within templates that need to handle a complement of raw pointers,
+// `std::nullptr_t`, and smart pointers.
+template <typename T>
+auto RawPtr(T&& ptr) -> decltype(&*ptr) {
+ // ptr is a forwarding reference to support Ts with non-const operators.
+ return (ptr != nullptr) ? &*ptr : nullptr;
+}
+inline std::nullptr_t RawPtr(std::nullptr_t) { return nullptr; }
+
+// -----------------------------------------------------------------------------
+// Function Template: ShareUniquePtr()
+// -----------------------------------------------------------------------------
+//
+// Adopts a `std::unique_ptr` rvalue and returns a `std::shared_ptr` of deduced
+// type. Ownership (if any) of the held value is transferred to the returned
+// shared pointer.
+//
+// Example:
+//
+// auto up = absl::make_unique<int>(10);
+// auto sp = absl::ShareUniquePtr(std::move(up)); // shared_ptr<int>
+// CHECK_EQ(*sp, 10);
+// CHECK(up == nullptr);
+//
+// Note that this conversion is correct even when T is an array type, and more
+// generally it works for *any* deleter of the `unique_ptr` (single-object
+// deleter, array deleter, or any custom deleter), since the deleter is adopted
+// by the shared pointer as well. The deleter is copied (unless it is a
+// reference).
+//
+// Implements the resolution of [LWG 2415](http://wg21.link/lwg2415), by which a
+// null shared pointer does not attempt to call the deleter.
+template <typename T, typename D>
+std::shared_ptr<T> ShareUniquePtr(std::unique_ptr<T, D>&& ptr) {
+ return ptr ? std::shared_ptr<T>(std::move(ptr)) : std::shared_ptr<T>();
+}
+
+// -----------------------------------------------------------------------------
+// Function Template: WeakenPtr()
+// -----------------------------------------------------------------------------
+//
+// Creates a weak pointer associated with a given shared pointer. The returned
+// value is a `std::weak_ptr` of deduced type.
+//
+// Example:
+//
+// auto sp = std::make_shared<int>(10);
+// auto wp = absl::WeakenPtr(sp);
+// CHECK_EQ(sp.get(), wp.lock().get());
+// sp.reset();
+// CHECK(wp.lock() == nullptr);
+//
+template <typename T>
+std::weak_ptr<T> WeakenPtr(const std::shared_ptr<T>& ptr) {
+ return std::weak_ptr<T>(ptr);
+}
+
+namespace memory_internal {
+
+// ExtractOr<E, O, D>::type evaluates to E<O> if possible. Otherwise, D.
+template <template <typename> class Extract, typename Obj, typename Default,
+ typename>
+struct ExtractOr {
+ using type = Default;
+};
+
+template <template <typename> class Extract, typename Obj, typename Default>
+struct ExtractOr<Extract, Obj, Default, void_t<Extract<Obj>>> {
+ using type = Extract<Obj>;
+};
+
+template <template <typename> class Extract, typename Obj, typename Default>
+using ExtractOrT = typename ExtractOr<Extract, Obj, Default, void>::type;
+
+// Extractors for the features of allocators.
+template <typename T>
+using GetPointer = typename T::pointer;
+
+template <typename T>
+using GetConstPointer = typename T::const_pointer;
+
+template <typename T>
+using GetVoidPointer = typename T::void_pointer;
+
+template <typename T>
+using GetConstVoidPointer = typename T::const_void_pointer;
+
+template <typename T>
+using GetDifferenceType = typename T::difference_type;
+
+template <typename T>
+using GetSizeType = typename T::size_type;
+
+template <typename T>
+using GetPropagateOnContainerCopyAssignment =
+ typename T::propagate_on_container_copy_assignment;
+
+template <typename T>
+using GetPropagateOnContainerMoveAssignment =
+ typename T::propagate_on_container_move_assignment;
+
+template <typename T>
+using GetPropagateOnContainerSwap = typename T::propagate_on_container_swap;
+
+template <typename T>
+using GetIsAlwaysEqual = typename T::is_always_equal;
+
+template <typename T>
+struct GetFirstArg;
+
+template <template <typename...> class Class, typename T, typename... Args>
+struct GetFirstArg<Class<T, Args...>> {
+ using type = T;
+};
+
+template <typename Ptr, typename = void>
+struct ElementType {
+ using type = typename GetFirstArg<Ptr>::type;
+};
+
+template <typename T>
+struct ElementType<T, void_t<typename T::element_type>> {
+ using type = typename T::element_type;
+};
+
+template <typename T, typename U>
+struct RebindFirstArg;
+
+template <template <typename...> class Class, typename T, typename... Args,
+ typename U>
+struct RebindFirstArg<Class<T, Args...>, U> {
+ using type = Class<U, Args...>;
+};
+
+template <typename T, typename U, typename = void>
+struct RebindPtr {
+ using type = typename RebindFirstArg<T, U>::type;
+};
+
+template <typename T, typename U>
+struct RebindPtr<T, U, void_t<typename T::template rebind<U>>> {
+ using type = typename T::template rebind<U>;
+};
+
+template <typename T, typename U>
+constexpr bool HasRebindAlloc(...) {
+ return false;
+}
+
+template <typename T, typename U>
+constexpr bool HasRebindAlloc(typename T::template rebind<U>::other*) {
+ return true;
+}
+
+template <typename T, typename U, bool = HasRebindAlloc<T, U>(nullptr)>
+struct RebindAlloc {
+ using type = typename RebindFirstArg<T, U>::type;
+};
+
+template <typename T, typename U>
+struct RebindAlloc<T, U, true> {
+ using type = typename T::template rebind<U>::other;
+};
+
+} // namespace memory_internal
+
+// -----------------------------------------------------------------------------
+// Class Template: pointer_traits
+// -----------------------------------------------------------------------------
+//
+// An implementation of C++11's std::pointer_traits.
+//
+// Provided for portability on toolchains that have a working C++11 compiler,
+// but the standard library is lacking in C++11 support. For example, some
+// version of the Android NDK.
+//
+
+template <typename Ptr>
+struct pointer_traits {
+ using pointer = Ptr;
+
+ // element_type:
+ // Ptr::element_type if present. Otherwise T if Ptr is a template
+ // instantiation Template<T, Args...>
+ using element_type = typename memory_internal::ElementType<Ptr>::type;
+
+ // difference_type:
+ // Ptr::difference_type if present, otherwise std::ptrdiff_t
+ using difference_type =
+ memory_internal::ExtractOrT<memory_internal::GetDifferenceType, Ptr,
+ std::ptrdiff_t>;
+
+ // rebind:
+ // Ptr::rebind<U> if exists, otherwise Template<U, Args...> if Ptr is a
+ // template instantiation Template<T, Args...>
+ template <typename U>
+ using rebind = typename memory_internal::RebindPtr<Ptr, U>::type;
+
+ // pointer_to:
+ // Calls Ptr::pointer_to(r)
+ static pointer pointer_to(element_type& r) { // NOLINT(runtime/references)
+ return Ptr::pointer_to(r);
+ }
+};
+
+// Specialization for T*.
+template <typename T>
+struct pointer_traits<T*> {
+ using pointer = T*;
+ using element_type = T;
+ using difference_type = std::ptrdiff_t;
+
+ template <typename U>
+ using rebind = U*;
+
+ // pointer_to:
+ // Calls std::addressof(r)
+ static pointer pointer_to(
+ element_type& r) noexcept { // NOLINT(runtime/references)
+ return std::addressof(r);
+ }
+};
+
+// -----------------------------------------------------------------------------
+// Class Template: allocator_traits
+// -----------------------------------------------------------------------------
+//
+// A C++11 compatible implementation of C++17's std::allocator_traits.
+//
+template <typename Alloc>
+struct allocator_traits {
+ using allocator_type = Alloc;
+
+ // value_type:
+ // Alloc::value_type
+ using value_type = typename Alloc::value_type;
+
+ // pointer:
+ // Alloc::pointer if present, otherwise value_type*
+ using pointer = memory_internal::ExtractOrT<memory_internal::GetPointer,
+ Alloc, value_type*>;
+
+ // const_pointer:
+ // Alloc::const_pointer if present, otherwise
+ // absl::pointer_traits<pointer>::rebind<const value_type>
+ using const_pointer =
+ memory_internal::ExtractOrT<memory_internal::GetConstPointer, Alloc,
+ typename absl::pointer_traits<pointer>::
+ template rebind<const value_type>>;
+
+ // void_pointer:
+ // Alloc::void_pointer if present, otherwise
+ // absl::pointer_traits<pointer>::rebind<void>
+ using void_pointer = memory_internal::ExtractOrT<
+ memory_internal::GetVoidPointer, Alloc,
+ typename absl::pointer_traits<pointer>::template rebind<void>>;
+
+ // const_void_pointer:
+ // Alloc::const_void_pointer if present, otherwise
+ // absl::pointer_traits<pointer>::rebind<const void>
+ using const_void_pointer = memory_internal::ExtractOrT<
+ memory_internal::GetConstVoidPointer, Alloc,
+ typename absl::pointer_traits<pointer>::template rebind<const void>>;
+
+ // difference_type:
+ // Alloc::difference_type if present, otherwise
+ // absl::pointer_traits<pointer>::difference_type
+ using difference_type = memory_internal::ExtractOrT<
+ memory_internal::GetDifferenceType, Alloc,
+ typename absl::pointer_traits<pointer>::difference_type>;
+
+ // size_type:
+ // Alloc::size_type if present, otherwise
+ // std::make_unsigned<difference_type>::type
+ using size_type = memory_internal::ExtractOrT<
+ memory_internal::GetSizeType, Alloc,
+ typename std::make_unsigned<difference_type>::type>;
+
+ // propagate_on_container_copy_assignment:
+ // Alloc::propagate_on_container_copy_assignment if present, otherwise
+ // std::false_type
+ using propagate_on_container_copy_assignment = memory_internal::ExtractOrT<
+ memory_internal::GetPropagateOnContainerCopyAssignment, Alloc,
+ std::false_type>;
+
+ // propagate_on_container_move_assignment:
+ // Alloc::propagate_on_container_move_assignment if present, otherwise
+ // std::false_type
+ using propagate_on_container_move_assignment = memory_internal::ExtractOrT<
+ memory_internal::GetPropagateOnContainerMoveAssignment, Alloc,
+ std::false_type>;
+
+ // propagate_on_container_swap:
+ // Alloc::propagate_on_container_swap if present, otherwise std::false_type
+ using propagate_on_container_swap =
+ memory_internal::ExtractOrT<memory_internal::GetPropagateOnContainerSwap,
+ Alloc, std::false_type>;
+
+ // is_always_equal:
+ // Alloc::is_always_equal if present, otherwise std::is_empty<Alloc>::type
+ using is_always_equal =
+ memory_internal::ExtractOrT<memory_internal::GetIsAlwaysEqual, Alloc,
+ typename std::is_empty<Alloc>::type>;
+
+ // rebind_alloc:
+ // Alloc::rebind<T>::other if present, otherwise Alloc<T, Args> if this Alloc
+ // is Alloc<U, Args>
+ template <typename T>
+ using rebind_alloc = typename memory_internal::RebindAlloc<Alloc, T>::type;
+
+ // rebind_traits:
+ // absl::allocator_traits<rebind_alloc<T>>
+ template <typename T>
+ using rebind_traits = absl::allocator_traits<rebind_alloc<T>>;
+
+ // allocate(Alloc& a, size_type n):
+ // Calls a.allocate(n)
+ static pointer allocate(Alloc& a, // NOLINT(runtime/references)
+ size_type n) {
+ return a.allocate(n);
+ }
+
+ // allocate(Alloc& a, size_type n, const_void_pointer hint):
+ // Calls a.allocate(n, hint) if possible.
+ // If not possible, calls a.allocate(n)
+ static pointer allocate(Alloc& a, size_type n, // NOLINT(runtime/references)
+ const_void_pointer hint) {
+ return allocate_impl(0, a, n, hint);
+ }
+
+ // deallocate(Alloc& a, pointer p, size_type n):
+ // Calls a.deallocate(p, n)
+ static void deallocate(Alloc& a, pointer p, // NOLINT(runtime/references)
+ size_type n) {
+ a.deallocate(p, n);
+ }
+
+ // construct(Alloc& a, T* p, Args&&... args):
+ // Calls a.construct(p, std::forward<Args>(args)...) if possible.
+ // If not possible, calls
+ // ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...)
+ template <typename T, typename... Args>
+ static void construct(Alloc& a, T* p, // NOLINT(runtime/references)
+ Args&&... args) {
+ construct_impl(0, a, p, std::forward<Args>(args)...);
+ }
+
+ // destroy(Alloc& a, T* p):
+ // Calls a.destroy(p) if possible. If not possible, calls p->~T().
+ template <typename T>
+ static void destroy(Alloc& a, T* p) { // NOLINT(runtime/references)
+ destroy_impl(0, a, p);
+ }
+
+ // max_size(const Alloc& a):
+ // Returns a.max_size() if possible. If not possible, returns
+ // std::numeric_limits<size_type>::max() / sizeof(value_type)
+ static size_type max_size(const Alloc& a) { return max_size_impl(0, a); }
+
+ // select_on_container_copy_construction(const Alloc& a):
+ // Returns a.select_on_container_copy_construction() if possible.
+ // If not possible, returns a.
+ static Alloc select_on_container_copy_construction(const Alloc& a) {
+ return select_on_container_copy_construction_impl(0, a);
+ }
+
+ private:
+ template <typename A>
+ static auto allocate_impl(int, A& a, // NOLINT(runtime/references)
+ size_type n, const_void_pointer hint)
+ -> decltype(a.allocate(n, hint)) {
+ return a.allocate(n, hint);
+ }
+ static pointer allocate_impl(char, Alloc& a, // NOLINT(runtime/references)
+ size_type n, const_void_pointer) {
+ return a.allocate(n);
+ }
+
+ template <typename A, typename... Args>
+ static auto construct_impl(int, A& a, // NOLINT(runtime/references)
+ Args&&... args)
+ -> decltype(a.construct(std::forward<Args>(args)...)) {
+ a.construct(std::forward<Args>(args)...);
+ }
+
+ template <typename T, typename... Args>
+ static void construct_impl(char, Alloc&, T* p, Args&&... args) {
+ ::new (static_cast<void*>(p)) T(std::forward<Args>(args)...);
+ }
+
+ template <typename A, typename T>
+ static auto destroy_impl(int, A& a, // NOLINT(runtime/references)
+ T* p) -> decltype(a.destroy(p)) {
+ a.destroy(p);
+ }
+ template <typename T>
+ static void destroy_impl(char, Alloc&, T* p) {
+ p->~T();
+ }
+
+ template <typename A>
+ static auto max_size_impl(int, const A& a) -> decltype(a.max_size()) {
+ return a.max_size();
+ }
+ static size_type max_size_impl(char, const Alloc&) {
+ return std::numeric_limits<size_type>::max() / sizeof(value_type);
+ }
+
+ template <typename A>
+ static auto select_on_container_copy_construction_impl(int, const A& a)
+ -> decltype(a.select_on_container_copy_construction()) {
+ return a.select_on_container_copy_construction();
+ }
+ static Alloc select_on_container_copy_construction_impl(char,
+ const Alloc& a) {
+ return a;
+ }
+};
+
+namespace memory_internal {
+
+// This template alias transforms Alloc::is_nothrow into a metafunction with
+// Alloc as a parameter so it can be used with ExtractOrT<>.
+template <typename Alloc>
+using GetIsNothrow = typename Alloc::is_nothrow;
+
+} // namespace memory_internal
+
+// ABSL_ALLOCATOR_NOTHROW is a build time configuration macro for user to
+// specify whether the default allocation function can throw or never throws.
+// If the allocation function never throws, user should define it to a non-zero
+// value (e.g. via `-DABSL_ALLOCATOR_NOTHROW`).
+// If the allocation function can throw, user should leave it undefined or
+// define it to zero.
+//
+// allocator_is_nothrow<Alloc> is a traits class that derives from
+// Alloc::is_nothrow if present, otherwise std::false_type. It's specialized
+// for Alloc = std::allocator<T> for any type T according to the state of
+// ABSL_ALLOCATOR_NOTHROW.
+//
+// default_allocator_is_nothrow is a class that derives from std::true_type
+// when the default allocator (global operator new) never throws, and
+// std::false_type when it can throw. It is a convenience shorthand for writing
+// allocator_is_nothrow<std::allocator<T>> (T can be any type).
+// NOTE: allocator_is_nothrow<std::allocator<T>> is guaranteed to derive from
+// the same type for all T, because users should specialize neither
+// allocator_is_nothrow nor std::allocator.
+template <typename Alloc>
+struct allocator_is_nothrow
+ : memory_internal::ExtractOrT<memory_internal::GetIsNothrow, Alloc,
+ std::false_type> {};
+
+#if ABSL_ALLOCATOR_NOTHROW
+template <typename T>
+struct allocator_is_nothrow<std::allocator<T>> : std::true_type {};
+struct default_allocator_is_nothrow : std::true_type {};
+#else
+struct default_allocator_is_nothrow : std::false_type {};
+#endif
+
+} // namespace absl
+
+#endif // ABSL_MEMORY_MEMORY_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/memory/memory_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/memory/memory_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/memory/memory_test.cc
new file mode 100644
index 0000000..dee9b48
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/memory/memory_test.cc
@@ -0,0 +1,614 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Tests for pointer utilities.
+
+#include "absl/memory/memory.h"
+
+#include <sys/types.h>
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+using ::testing::ElementsAre;
+using ::testing::Return;
+
+// This class creates observable behavior to verify that a destructor has
+// been called, via the instance_count variable.
+class DestructorVerifier {
+ public:
+ DestructorVerifier() { ++instance_count_; }
+ DestructorVerifier(const DestructorVerifier&) = delete;
+ DestructorVerifier& operator=(const DestructorVerifier&) = delete;
+ ~DestructorVerifier() { --instance_count_; }
+
+ // The number of instances of this class currently active.
+ static int instance_count() { return instance_count_; }
+
+ private:
+ // The number of instances of this class currently active.
+ static int instance_count_;
+};
+
+int DestructorVerifier::instance_count_ = 0;
+
+TEST(WrapUniqueTest, WrapUnique) {
+ // Test that the unique_ptr is constructed properly by verifying that the
+ // destructor for its payload gets called at the proper time.
+ {
+ auto dv = new DestructorVerifier;
+ EXPECT_EQ(1, DestructorVerifier::instance_count());
+ std::unique_ptr<DestructorVerifier> ptr = absl::WrapUnique(dv);
+ EXPECT_EQ(1, DestructorVerifier::instance_count());
+ }
+ EXPECT_EQ(0, DestructorVerifier::instance_count());
+}
+TEST(MakeUniqueTest, Basic) {
+ std::unique_ptr<std::string> p = absl::make_unique<std::string>();
+ EXPECT_EQ("", *p);
+ p = absl::make_unique<std::string>("hi");
+ EXPECT_EQ("hi", *p);
+}
+
+struct MoveOnly {
+ MoveOnly() = default;
+ explicit MoveOnly(int i1) : ip1{new int{i1}} {}
+ MoveOnly(int i1, int i2) : ip1{new int{i1}}, ip2{new int{i2}} {}
+ std::unique_ptr<int> ip1;
+ std::unique_ptr<int> ip2;
+};
+
+struct AcceptMoveOnly {
+ explicit AcceptMoveOnly(MoveOnly m) : m_(std::move(m)) {}
+ MoveOnly m_;
+};
+
+TEST(MakeUniqueTest, MoveOnlyTypeAndValue) {
+ using ExpectedType = std::unique_ptr<MoveOnly>;
+ {
+ auto p = absl::make_unique<MoveOnly>();
+ static_assert(std::is_same<decltype(p), ExpectedType>::value,
+ "unexpected return type");
+ EXPECT_TRUE(!p->ip1);
+ EXPECT_TRUE(!p->ip2);
+ }
+ {
+ auto p = absl::make_unique<MoveOnly>(1);
+ static_assert(std::is_same<decltype(p), ExpectedType>::value,
+ "unexpected return type");
+ EXPECT_TRUE(p->ip1 && *p->ip1 == 1);
+ EXPECT_TRUE(!p->ip2);
+ }
+ {
+ auto p = absl::make_unique<MoveOnly>(1, 2);
+ static_assert(std::is_same<decltype(p), ExpectedType>::value,
+ "unexpected return type");
+ EXPECT_TRUE(p->ip1 && *p->ip1 == 1);
+ EXPECT_TRUE(p->ip2 && *p->ip2 == 2);
+ }
+}
+
+TEST(MakeUniqueTest, AcceptMoveOnly) {
+ auto p = absl::make_unique<AcceptMoveOnly>(MoveOnly());
+ p = std::unique_ptr<AcceptMoveOnly>(new AcceptMoveOnly(MoveOnly()));
+}
+
+struct ArrayWatch {
+ void* operator new[](size_t n) {
+ allocs().push_back(n);
+ return ::operator new[](n);
+ }
+ void operator delete[](void* p) {
+ return ::operator delete[](p);
+ }
+ static std::vector<size_t>& allocs() {
+ static auto& v = *new std::vector<size_t>;
+ return v;
+ }
+};
+
+TEST(Make_UniqueTest, Array) {
+ // Ensure state is clean before we start so that these tests
+ // are order-agnostic.
+ ArrayWatch::allocs().clear();
+
+ auto p = absl::make_unique<ArrayWatch[]>(5);
+ static_assert(std::is_same<decltype(p),
+ std::unique_ptr<ArrayWatch[]>>::value,
+ "unexpected return type");
+ EXPECT_THAT(ArrayWatch::allocs(), ElementsAre(5 * sizeof(ArrayWatch)));
+}
+
+TEST(Make_UniqueTest, NotAmbiguousWithStdMakeUnique) {
+ // Ensure that absl::make_unique is not ambiguous with std::make_unique.
+ // In C++14 mode, the below call to make_unique has both types as candidates.
+ struct TakesStdType {
+ explicit TakesStdType(const std::vector<int> &vec) {}
+ };
+ using absl::make_unique;
+ make_unique<TakesStdType>(std::vector<int>());
+}
+
+#if 0
+// TODO(billydonahue): Make a proper NC test.
+// These tests shouldn't compile.
+TEST(MakeUniqueTestNC, AcceptMoveOnlyLvalue) {
+ auto m = MoveOnly();
+ auto p = absl::make_unique<AcceptMoveOnly>(m);
+}
+TEST(MakeUniqueTestNC, KnownBoundArray) {
+ auto p = absl::make_unique<ArrayWatch[5]>();
+}
+#endif
+
+TEST(RawPtrTest, RawPointer) {
+ int i = 5;
+ EXPECT_EQ(&i, absl::RawPtr(&i));
+}
+
+TEST(RawPtrTest, SmartPointer) {
+ int* o = new int(5);
+ std::unique_ptr<int> p(o);
+ EXPECT_EQ(o, absl::RawPtr(p));
+}
+
+class IntPointerNonConstDeref {
+ public:
+ explicit IntPointerNonConstDeref(int* p) : p_(p) {}
+ friend bool operator!=(const IntPointerNonConstDeref& a, std::nullptr_t) {
+ return a.p_ != nullptr;
+ }
+ int& operator*() { return *p_; }
+
+ private:
+ std::unique_ptr<int> p_;
+};
+
+TEST(RawPtrTest, SmartPointerNonConstDereference) {
+ int* o = new int(5);
+ IntPointerNonConstDeref p(o);
+ EXPECT_EQ(o, absl::RawPtr(p));
+}
+
+TEST(RawPtrTest, NullValuedRawPointer) {
+ int* p = nullptr;
+ EXPECT_EQ(nullptr, absl::RawPtr(p));
+}
+
+TEST(RawPtrTest, NullValuedSmartPointer) {
+ std::unique_ptr<int> p;
+ EXPECT_EQ(nullptr, absl::RawPtr(p));
+}
+
+TEST(RawPtrTest, Nullptr) {
+ auto p = absl::RawPtr(nullptr);
+ EXPECT_TRUE((std::is_same<std::nullptr_t, decltype(p)>::value));
+ EXPECT_EQ(nullptr, p);
+}
+
+TEST(RawPtrTest, Null) {
+ auto p = absl::RawPtr(nullptr);
+ EXPECT_TRUE((std::is_same<std::nullptr_t, decltype(p)>::value));
+ EXPECT_EQ(nullptr, p);
+}
+
+TEST(RawPtrTest, Zero) {
+ auto p = absl::RawPtr(nullptr);
+ EXPECT_TRUE((std::is_same<std::nullptr_t, decltype(p)>::value));
+ EXPECT_EQ(nullptr, p);
+}
+
+TEST(ShareUniquePtrTest, Share) {
+ auto up = absl::make_unique<int>();
+ int* rp = up.get();
+ auto sp = absl::ShareUniquePtr(std::move(up));
+ EXPECT_EQ(sp.get(), rp);
+}
+
+TEST(ShareUniquePtrTest, ShareNull) {
+ struct NeverDie {
+ using pointer = void*;
+ void operator()(pointer) {
+ ASSERT_TRUE(false) << "Deleter should not have been called.";
+ }
+ };
+
+ std::unique_ptr<void, NeverDie> up;
+ auto sp = absl::ShareUniquePtr(std::move(up));
+}
+
+TEST(WeakenPtrTest, Weak) {
+ auto sp = std::make_shared<int>();
+ auto wp = absl::WeakenPtr(sp);
+ EXPECT_EQ(sp.get(), wp.lock().get());
+ sp.reset();
+ EXPECT_TRUE(wp.expired());
+}
+
+// Should not compile.
+/*
+TEST(RawPtrTest, NotAPointer) {
+ absl::RawPtr(1.5);
+}
+*/
+
+template <typename T>
+struct SmartPointer {
+ using difference_type = char;
+};
+
+struct PointerWith {
+ using element_type = int32_t;
+ using difference_type = int16_t;
+ template <typename U>
+ using rebind = SmartPointer<U>;
+
+ static PointerWith pointer_to(
+ element_type& r) { // NOLINT(runtime/references)
+ return PointerWith{&r};
+ }
+
+ element_type* ptr;
+};
+
+template <typename... Args>
+struct PointerWithout {};
+
+TEST(PointerTraits, Types) {
+ using TraitsWith = absl::pointer_traits<PointerWith>;
+ EXPECT_TRUE((std::is_same<TraitsWith::pointer, PointerWith>::value));
+ EXPECT_TRUE((std::is_same<TraitsWith::element_type, int32_t>::value));
+ EXPECT_TRUE((std::is_same<TraitsWith::difference_type, int16_t>::value));
+ EXPECT_TRUE((
+ std::is_same<TraitsWith::rebind<int64_t>, SmartPointer<int64_t>>::value));
+
+ using TraitsWithout = absl::pointer_traits<PointerWithout<double, int>>;
+ EXPECT_TRUE((std::is_same<TraitsWithout::pointer,
+ PointerWithout<double, int>>::value));
+ EXPECT_TRUE((std::is_same<TraitsWithout::element_type, double>::value));
+ EXPECT_TRUE(
+ (std::is_same<TraitsWithout ::difference_type, std::ptrdiff_t>::value));
+ EXPECT_TRUE((std::is_same<TraitsWithout::rebind<int64_t>,
+ PointerWithout<int64_t, int>>::value));
+
+ using TraitsRawPtr = absl::pointer_traits<char*>;
+ EXPECT_TRUE((std::is_same<TraitsRawPtr::pointer, char*>::value));
+ EXPECT_TRUE((std::is_same<TraitsRawPtr::element_type, char>::value));
+ EXPECT_TRUE(
+ (std::is_same<TraitsRawPtr::difference_type, std::ptrdiff_t>::value));
+ EXPECT_TRUE((std::is_same<TraitsRawPtr::rebind<int64_t>, int64_t*>::value));
+}
+
+TEST(PointerTraits, Functions) {
+ int i;
+ EXPECT_EQ(&i, absl::pointer_traits<PointerWith>::pointer_to(i).ptr);
+ EXPECT_EQ(&i, absl::pointer_traits<int*>::pointer_to(i));
+}
+
+TEST(AllocatorTraits, Typedefs) {
+ struct A {
+ struct value_type {};
+ };
+ EXPECT_TRUE((
+ std::is_same<A,
+ typename absl::allocator_traits<A>::allocator_type>::value));
+ EXPECT_TRUE(
+ (std::is_same<A::value_type,
+ typename absl::allocator_traits<A>::value_type>::value));
+
+ struct X {};
+ struct HasPointer {
+ using value_type = X;
+ using pointer = SmartPointer<X>;
+ };
+ EXPECT_TRUE((std::is_same<SmartPointer<X>, typename absl::allocator_traits<
+ HasPointer>::pointer>::value));
+ EXPECT_TRUE(
+ (std::is_same<A::value_type*,
+ typename absl::allocator_traits<A>::pointer>::value));
+
+ EXPECT_TRUE(
+ (std::is_same<
+ SmartPointer<const X>,
+ typename absl::allocator_traits<HasPointer>::const_pointer>::value));
+ EXPECT_TRUE(
+ (std::is_same<const A::value_type*,
+ typename absl::allocator_traits<A>::const_pointer>::value));
+
+ struct HasVoidPointer {
+ using value_type = X;
+ struct void_pointer {};
+ };
+
+ EXPECT_TRUE((std::is_same<HasVoidPointer::void_pointer,
+ typename absl::allocator_traits<
+ HasVoidPointer>::void_pointer>::value));
+ EXPECT_TRUE(
+ (std::is_same<SmartPointer<void>, typename absl::allocator_traits<
+ HasPointer>::void_pointer>::value));
+
+ struct HasConstVoidPointer {
+ using value_type = X;
+ struct const_void_pointer {};
+ };
+
+ EXPECT_TRUE(
+ (std::is_same<HasConstVoidPointer::const_void_pointer,
+ typename absl::allocator_traits<
+ HasConstVoidPointer>::const_void_pointer>::value));
+ EXPECT_TRUE((std::is_same<SmartPointer<const void>,
+ typename absl::allocator_traits<
+ HasPointer>::const_void_pointer>::value));
+
+ struct HasDifferenceType {
+ using value_type = X;
+ using difference_type = int;
+ };
+ EXPECT_TRUE(
+ (std::is_same<int, typename absl::allocator_traits<
+ HasDifferenceType>::difference_type>::value));
+ EXPECT_TRUE((std::is_same<char, typename absl::allocator_traits<
+ HasPointer>::difference_type>::value));
+
+ struct HasSizeType {
+ using value_type = X;
+ using size_type = unsigned int;
+ };
+ EXPECT_TRUE((std::is_same<unsigned int, typename absl::allocator_traits<
+ HasSizeType>::size_type>::value));
+ EXPECT_TRUE((std::is_same<unsigned char, typename absl::allocator_traits<
+ HasPointer>::size_type>::value));
+
+ struct HasPropagateOnCopy {
+ using value_type = X;
+ struct propagate_on_container_copy_assignment {};
+ };
+
+ EXPECT_TRUE(
+ (std::is_same<HasPropagateOnCopy::propagate_on_container_copy_assignment,
+ typename absl::allocator_traits<HasPropagateOnCopy>::
+ propagate_on_container_copy_assignment>::value));
+ EXPECT_TRUE(
+ (std::is_same<std::false_type,
+ typename absl::allocator_traits<
+ A>::propagate_on_container_copy_assignment>::value));
+
+ struct HasPropagateOnMove {
+ using value_type = X;
+ struct propagate_on_container_move_assignment {};
+ };
+
+ EXPECT_TRUE(
+ (std::is_same<HasPropagateOnMove::propagate_on_container_move_assignment,
+ typename absl::allocator_traits<HasPropagateOnMove>::
+ propagate_on_container_move_assignment>::value));
+ EXPECT_TRUE(
+ (std::is_same<std::false_type,
+ typename absl::allocator_traits<
+ A>::propagate_on_container_move_assignment>::value));
+
+ struct HasPropagateOnSwap {
+ using value_type = X;
+ struct propagate_on_container_swap {};
+ };
+
+ EXPECT_TRUE(
+ (std::is_same<HasPropagateOnSwap::propagate_on_container_swap,
+ typename absl::allocator_traits<HasPropagateOnSwap>::
+ propagate_on_container_swap>::value));
+ EXPECT_TRUE(
+ (std::is_same<std::false_type, typename absl::allocator_traits<A>::
+ propagate_on_container_swap>::value));
+
+ struct HasIsAlwaysEqual {
+ using value_type = X;
+ struct is_always_equal {};
+ };
+
+ EXPECT_TRUE((std::is_same<HasIsAlwaysEqual::is_always_equal,
+ typename absl::allocator_traits<
+ HasIsAlwaysEqual>::is_always_equal>::value));
+ EXPECT_TRUE((std::is_same<std::true_type, typename absl::allocator_traits<
+ A>::is_always_equal>::value));
+ struct NonEmpty {
+ using value_type = X;
+ int i;
+ };
+ EXPECT_TRUE(
+ (std::is_same<std::false_type,
+ absl::allocator_traits<NonEmpty>::is_always_equal>::value));
+}
+
+template <typename T>
+struct AllocWithPrivateInheritance : private std::allocator<T> {
+ using value_type = T;
+};
+
+TEST(AllocatorTraits, RebindWithPrivateInheritance) {
+ // Regression test for some versions of gcc that do not like the sfinae we
+ // used in combination with private inheritance.
+ EXPECT_TRUE(
+ (std::is_same<AllocWithPrivateInheritance<int>,
+ absl::allocator_traits<AllocWithPrivateInheritance<char>>::
+ rebind_alloc<int>>::value));
+}
+
+template <typename T>
+struct Rebound {};
+
+struct AllocWithRebind {
+ using value_type = int;
+ template <typename T>
+ struct rebind {
+ using other = Rebound<T>;
+ };
+};
+
+template <typename T, typename U>
+struct AllocWithoutRebind {
+ using value_type = int;
+};
+
+TEST(AllocatorTraits, Rebind) {
+ EXPECT_TRUE(
+ (std::is_same<Rebound<int>,
+ typename absl::allocator_traits<
+ AllocWithRebind>::template rebind_alloc<int>>::value));
+ EXPECT_TRUE(
+ (std::is_same<absl::allocator_traits<Rebound<int>>,
+ typename absl::allocator_traits<
+ AllocWithRebind>::template rebind_traits<int>>::value));
+
+ EXPECT_TRUE(
+ (std::is_same<AllocWithoutRebind<double, char>,
+ typename absl::allocator_traits<AllocWithoutRebind<
+ int, char>>::template rebind_alloc<double>>::value));
+ EXPECT_TRUE(
+ (std::is_same<absl::allocator_traits<AllocWithoutRebind<double, char>>,
+ typename absl::allocator_traits<AllocWithoutRebind<
+ int, char>>::template rebind_traits<double>>::value));
+}
+
+struct TestValue {
+ TestValue() {}
+ explicit TestValue(int* trace) : trace(trace) { ++*trace; }
+ ~TestValue() {
+ if (trace) --*trace;
+ }
+ int* trace = nullptr;
+};
+
+struct MinimalMockAllocator {
+ MinimalMockAllocator() : value(0) {}
+ explicit MinimalMockAllocator(int value) : value(value) {}
+ MinimalMockAllocator(const MinimalMockAllocator& other)
+ : value(other.value) {}
+ using value_type = TestValue;
+ MOCK_METHOD1(allocate, value_type*(size_t));
+ MOCK_METHOD2(deallocate, void(value_type*, size_t));
+
+ int value;
+};
+
+TEST(AllocatorTraits, FunctionsMinimal) {
+ int trace = 0;
+ int hint;
+ TestValue x(&trace);
+ MinimalMockAllocator mock;
+ using Traits = absl::allocator_traits<MinimalMockAllocator>;
+ EXPECT_CALL(mock, allocate(7)).WillRepeatedly(Return(&x));
+ EXPECT_CALL(mock, deallocate(&x, 7));
+
+ EXPECT_EQ(&x, Traits::allocate(mock, 7));
+ Traits::allocate(mock, 7, static_cast<const void*>(&hint));
+ EXPECT_EQ(&x, Traits::allocate(mock, 7, static_cast<const void*>(&hint)));
+ Traits::deallocate(mock, &x, 7);
+
+ EXPECT_EQ(1, trace);
+ Traits::construct(mock, &x, &trace);
+ EXPECT_EQ(2, trace);
+ Traits::destroy(mock, &x);
+ EXPECT_EQ(1, trace);
+
+ EXPECT_EQ(std::numeric_limits<size_t>::max() / sizeof(TestValue),
+ Traits::max_size(mock));
+
+ EXPECT_EQ(0, mock.value);
+ EXPECT_EQ(0, Traits::select_on_container_copy_construction(mock).value);
+}
+
+struct FullMockAllocator {
+ FullMockAllocator() : value(0) {}
+ explicit FullMockAllocator(int value) : value(value) {}
+ FullMockAllocator(const FullMockAllocator& other) : value(other.value) {}
+ using value_type = TestValue;
+ MOCK_METHOD1(allocate, value_type*(size_t));
+ MOCK_METHOD2(allocate, value_type*(size_t, const void*));
+ MOCK_METHOD2(construct, void(value_type*, int*));
+ MOCK_METHOD1(destroy, void(value_type*));
+ MOCK_CONST_METHOD0(max_size, size_t());
+ MOCK_CONST_METHOD0(select_on_container_copy_construction,
+ FullMockAllocator());
+
+ int value;
+};
+
+TEST(AllocatorTraits, FunctionsFull) {
+ int trace = 0;
+ int hint;
+ TestValue x(&trace), y;
+ FullMockAllocator mock;
+ using Traits = absl::allocator_traits<FullMockAllocator>;
+ EXPECT_CALL(mock, allocate(7)).WillRepeatedly(Return(&x));
+ EXPECT_CALL(mock, allocate(13, &hint)).WillRepeatedly(Return(&y));
+ EXPECT_CALL(mock, construct(&x, &trace));
+ EXPECT_CALL(mock, destroy(&x));
+ EXPECT_CALL(mock, max_size()).WillRepeatedly(Return(17));
+ EXPECT_CALL(mock, select_on_container_copy_construction())
+ .WillRepeatedly(Return(FullMockAllocator(23)));
+
+ EXPECT_EQ(&x, Traits::allocate(mock, 7));
+ EXPECT_EQ(&y, Traits::allocate(mock, 13, static_cast<const void*>(&hint)));
+
+ EXPECT_EQ(1, trace);
+ Traits::construct(mock, &x, &trace);
+ EXPECT_EQ(1, trace);
+ Traits::destroy(mock, &x);
+ EXPECT_EQ(1, trace);
+
+ EXPECT_EQ(17, Traits::max_size(mock));
+
+ EXPECT_EQ(0, mock.value);
+ EXPECT_EQ(23, Traits::select_on_container_copy_construction(mock).value);
+}
+
+TEST(AllocatorNoThrowTest, DefaultAllocator) {
+#if ABSL_ALLOCATOR_NOTHROW
+ EXPECT_TRUE(absl::default_allocator_is_nothrow::value);
+#else
+ EXPECT_FALSE(absl::default_allocator_is_nothrow::value);
+#endif
+}
+
+TEST(AllocatorNoThrowTest, StdAllocator) {
+#if ABSL_ALLOCATOR_NOTHROW
+ EXPECT_TRUE(absl::allocator_is_nothrow<std::allocator<int>>::value);
+#else
+ EXPECT_FALSE(absl::allocator_is_nothrow<std::allocator<int>>::value);
+#endif
+}
+
+TEST(AllocatorNoThrowTest, CustomAllocator) {
+ struct NoThrowAllocator {
+ using is_nothrow = std::true_type;
+ };
+ struct CanThrowAllocator {
+ using is_nothrow = std::false_type;
+ };
+ struct UnspecifiedAllocator {
+ };
+ EXPECT_TRUE(absl::allocator_is_nothrow<NoThrowAllocator>::value);
+ EXPECT_FALSE(absl::allocator_is_nothrow<CanThrowAllocator>::value);
+ EXPECT_FALSE(absl::allocator_is_nothrow<UnspecifiedAllocator>::value);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/meta/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/meta/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/meta/BUILD.bazel
new file mode 100644
index 0000000..dbc9717
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/meta/BUILD.bazel
@@ -0,0 +1,29 @@
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "type_traits",
+ hdrs = ["type_traits.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/base:config",
+ ],
+)
+
+cc_test(
+ name = "type_traits_test",
+ srcs = ["type_traits_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":type_traits",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/meta/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/meta/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/meta/CMakeLists.txt
new file mode 100644
index 0000000..d56fced
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/meta/CMakeLists.txt
@@ -0,0 +1,49 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+list(APPEND META_PUBLIC_HEADERS
+ "type_traits.h"
+)
+
+
+#
+## TESTS
+#
+
+# test type_traits_test
+list(APPEND TYPE_TRAITS_TEST_SRC
+ "type_traits_test.cc"
+ ${META_PUBLIC_HEADERS}
+)
+
+absl_header_library(
+ TARGET
+ absl_meta
+ EXPORT_NAME
+ meta
+ )
+
+absl_test(
+ TARGET
+ type_traits_test
+ SOURCES
+ ${TYPE_TRAITS_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${TYPE_TRAITS_TEST_PUBLIC_LIBRARIES} absl::meta
+)
+
+
+
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/meta/type_traits.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/meta/type_traits.h b/libraries/ostrich/backend/3rdparty/abseil/absl/meta/type_traits.h
new file mode 100644
index 0000000..88af17c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/meta/type_traits.h
@@ -0,0 +1,372 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// type_traits.h
+// -----------------------------------------------------------------------------
+//
+// This file contains C++11-compatible versions of standard <type_traits> API
+// functions for determining the characteristics of types. Such traits can
+// support type inference, classification, and transformation, as well as
+// make it easier to write templates based on generic type behavior.
+//
+// See http://en.cppreference.com/w/cpp/header/type_traits
+//
+// WARNING: use of many of the constructs in this header will count as "complex
+// template metaprogramming", so before proceeding, please carefully consider
+// https://google.github.io/styleguide/cppguide.html#Template_metaprogramming
+//
+// WARNING: using template metaprogramming to detect or depend on API
+// features is brittle and not guaranteed. Neither the standard library nor
+// Abseil provides any guarantee that APIs are stable in the face of template
+// metaprogramming. Use with caution.
+#ifndef ABSL_META_TYPE_TRAITS_H_
+#define ABSL_META_TYPE_TRAITS_H_
+
+#include <stddef.h>
+#include <functional>
+#include <type_traits>
+
+#include "absl/base/config.h"
+
+namespace absl {
+
+namespace type_traits_internal {
+template <typename... Ts>
+struct VoidTImpl {
+ using type = void;
+};
+
+// This trick to retrieve a default alignment is necessary for our
+// implementation of aligned_storage_t to be consistent with any implementation
+// of std::aligned_storage.
+template <size_t Len, typename T = std::aligned_storage<Len>>
+struct default_alignment_of_aligned_storage;
+
+template <size_t Len, size_t Align>
+struct default_alignment_of_aligned_storage<Len,
+ std::aligned_storage<Len, Align>> {
+ static constexpr size_t value = Align;
+};
+
+} // namespace type_traits_internal
+
+// void_t()
+//
+// Ignores the type of any its arguments and returns `void`. In general, this
+// metafunction allows you to create a general case that maps to `void` while
+// allowing specializations that map to specific types.
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::void_t` metafunction.
+//
+// NOTE: `absl::void_t` does not use the standard-specified implementation so
+// that it can remain compatible with gcc < 5.1. This can introduce slightly
+// different behavior, such as when ordering partial specializations.
+template <typename... Ts>
+using void_t = typename type_traits_internal::VoidTImpl<Ts...>::type;
+
+// conjunction
+//
+// Performs a compile-time logical AND operation on the passed types (which
+// must have `::value` members convertible to `bool`. Short-circuits if it
+// encounters any `false` members (and does not compare the `::value` members
+// of any remaining arguments).
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::conjunction` metafunction.
+template <typename... Ts>
+struct conjunction;
+
+template <typename T, typename... Ts>
+struct conjunction<T, Ts...>
+ : std::conditional<T::value, conjunction<Ts...>, T>::type {};
+
+template <typename T>
+struct conjunction<T> : T {};
+
+template <>
+struct conjunction<> : std::true_type {};
+
+// disjunction
+//
+// Performs a compile-time logical OR operation on the passed types (which
+// must have `::value` members convertible to `bool`. Short-circuits if it
+// encounters any `true` members (and does not compare the `::value` members
+// of any remaining arguments).
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::disjunction` metafunction.
+template <typename... Ts>
+struct disjunction;
+
+template <typename T, typename... Ts>
+struct disjunction<T, Ts...> :
+ std::conditional<T::value, T, disjunction<Ts...>>::type {};
+
+template <typename T>
+struct disjunction<T> : T {};
+
+template <>
+struct disjunction<> : std::false_type {};
+
+// negation
+//
+// Performs a compile-time logical NOT operation on the passed type (which
+// must have `::value` members convertible to `bool`.
+//
+// This metafunction is designed to be a drop-in replacement for the C++17
+// `std::negation` metafunction.
+template <typename T>
+struct negation : std::integral_constant<bool, !T::value> {};
+
+// is_trivially_destructible()
+//
+// Determines whether the passed type `T` is trivially destructable.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_destructible()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
+//
+// NOTE: the extensions (__has_trivial_xxx) are implemented in gcc (version >=
+// 4.3) and clang. Since we are supporting libstdc++ > 4.7, they should always
+// be present. These extensions are documented at
+// https://gcc.gnu.org/onlinedocs/gcc/Type-Traits.html#Type-Traits.
+template <typename T>
+struct is_trivially_destructible
+ : std::integral_constant<bool, __has_trivial_destructor(T) &&
+ std::is_destructible<T>::value> {
+#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+ private:
+ static constexpr bool compliant = std::is_trivially_destructible<T>::value ==
+ is_trivially_destructible::value;
+ static_assert(compliant || std::is_trivially_destructible<T>::value,
+ "Not compliant with std::is_trivially_destructible; "
+ "Standard: false, Implementation: true");
+ static_assert(compliant || !std::is_trivially_destructible<T>::value,
+ "Not compliant with std::is_trivially_destructible; "
+ "Standard: true, Implementation: false");
+#endif // ABSL_HAVE_STD_IS_TRIVIALLY_DESTRUCTIBLE
+};
+
+// is_trivially_default_constructible()
+//
+// Determines whether the passed type `T` is trivially default constructible.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_default_constructible()` metafunction for platforms that
+// have incomplete C++11 support (such as libstdc++ 4.x). On any platforms that
+// do fully support C++11, we check whether this yields the same result as the
+// std implementation.
+//
+// NOTE: according to the C++ standard, Section: 20.15.4.3 [meta.unary.prop]
+// "The predicate condition for a template specialization is_constructible<T,
+// Args...> shall be satisfied if and only if the following variable
+// definition would be well-formed for some invented variable t:
+//
+// T t(declval<Args>()...);
+//
+// is_trivially_constructible<T, Args...> additionally requires that the
+// variable definition does not call any operation that is not trivial.
+// For the purposes of this check, the call to std::declval is considered
+// trivial."
+//
+// Notes from http://en.cppreference.com/w/cpp/types/is_constructible:
+// In many implementations, is_nothrow_constructible also checks if the
+// destructor throws because it is effectively noexcept(T(arg)). Same
+// applies to is_trivially_constructible, which, in these implementations, also
+// requires that the destructor is trivial.
+// GCC bug 51452: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452
+// LWG issue 2116: http://cplusplus.github.io/LWG/lwg-active.html#2116.
+//
+// "T obj();" need to be well-formed and not call any nontrivial operation.
+// Nontrivially destructible types will cause the expression to be nontrivial.
+template <typename T>
+struct is_trivially_default_constructible
+ : std::integral_constant<bool, __has_trivial_constructor(T) &&
+ std::is_default_constructible<T>::value &&
+ is_trivially_destructible<T>::value> {
+#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+ private:
+ static constexpr bool compliant =
+ std::is_trivially_default_constructible<T>::value ==
+ is_trivially_default_constructible::value;
+ static_assert(compliant || std::is_trivially_default_constructible<T>::value,
+ "Not compliant with std::is_trivially_default_constructible; "
+ "Standard: false, Implementation: true");
+ static_assert(compliant || !std::is_trivially_default_constructible<T>::value,
+ "Not compliant with std::is_trivially_default_constructible; "
+ "Standard: true, Implementation: false");
+#endif // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+};
+
+// is_trivially_copy_constructible()
+//
+// Determines whether the passed type `T` is trivially copy constructible.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_copy_constructible()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
+//
+// NOTE: `T obj(declval<const T&>());` needs to be well-formed and not call any
+// nontrivial operation. Nontrivially destructible types will cause the
+// expression to be nontrivial.
+template <typename T>
+struct is_trivially_copy_constructible
+ : std::integral_constant<bool, __has_trivial_copy(T) &&
+ std::is_copy_constructible<T>::value &&
+ is_trivially_destructible<T>::value> {
+#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+ private:
+ static constexpr bool compliant =
+ std::is_trivially_copy_constructible<T>::value ==
+ is_trivially_copy_constructible::value;
+ static_assert(compliant || std::is_trivially_copy_constructible<T>::value,
+ "Not compliant with std::is_trivially_copy_constructible; "
+ "Standard: false, Implementation: true");
+ static_assert(compliant || !std::is_trivially_copy_constructible<T>::value,
+ "Not compliant with std::is_trivially_copy_constructible; "
+ "Standard: true, Implementation: false");
+#endif // ABSL_HAVE_STD_IS_TRIVIALLY_CONSTRUCTIBLE
+};
+
+// is_trivially_copy_assignable()
+//
+// Determines whether the passed type `T` is trivially copy assignable.
+//
+// This metafunction is designed to be a drop-in replacement for the C++11
+// `std::is_trivially_copy_assignable()` metafunction for platforms that have
+// incomplete C++11 support (such as libstdc++ 4.x). On any platforms that do
+// fully support C++11, we check whether this yields the same result as the std
+// implementation.
+//
+// NOTE: `is_assignable<T, U>::value` is `true` if the expression
+// `declval<T>() = declval<U>()` is well-formed when treated as an unevaluated
+// operand. `is_trivially_assignable<T, U>` requires the assignment to call no
+// operation that is not trivial. `is_trivially_copy_assignable<T>` is simply
+// `is_trivially_assignable<T&, const T&>`.
+template <typename T>
+struct is_trivially_copy_assignable
+ : std::integral_constant<bool, __has_trivial_assign(T) &&
+ std::is_copy_assignable<T>::value> {
+#ifdef ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+ private:
+ static constexpr bool compliant =
+ std::is_trivially_copy_assignable<T>::value ==
+ is_trivially_copy_assignable::value;
+ static_assert(compliant || std::is_trivially_copy_assignable<T>::value,
+ "Not compliant with std::is_trivially_copy_assignable; "
+ "Standard: false, Implementation: true");
+ static_assert(compliant || !std::is_trivially_copy_assignable<T>::value,
+ "Not compliant with std::is_trivially_copy_assignable; "
+ "Standard: true, Implementation: false");
+#endif // ABSL_HAVE_STD_IS_TRIVIALLY_ASSIGNABLE
+};
+
+// -----------------------------------------------------------------------------
+// C++14 "_t" trait aliases
+// -----------------------------------------------------------------------------
+
+template <typename T>
+using remove_cv_t = typename std::remove_cv<T>::type;
+
+template <typename T>
+using remove_const_t = typename std::remove_const<T>::type;
+
+template <typename T>
+using remove_volatile_t = typename std::remove_volatile<T>::type;
+
+template <typename T>
+using add_cv_t = typename std::add_cv<T>::type;
+
+template <typename T>
+using add_const_t = typename std::add_const<T>::type;
+
+template <typename T>
+using add_volatile_t = typename std::add_volatile<T>::type;
+
+template <typename T>
+using remove_reference_t = typename std::remove_reference<T>::type;
+
+template <typename T>
+using add_lvalue_reference_t = typename std::add_lvalue_reference<T>::type;
+
+template <typename T>
+using add_rvalue_reference_t = typename std::add_rvalue_reference<T>::type;
+
+template <typename T>
+using remove_pointer_t = typename std::remove_pointer<T>::type;
+
+template <typename T>
+using add_pointer_t = typename std::add_pointer<T>::type;
+
+template <typename T>
+using make_signed_t = typename std::make_signed<T>::type;
+
+template <typename T>
+using make_unsigned_t = typename std::make_unsigned<T>::type;
+
+template <typename T>
+using remove_extent_t = typename std::remove_extent<T>::type;
+
+template <typename T>
+using remove_all_extents_t = typename std::remove_all_extents<T>::type;
+
+template <size_t Len, size_t Align = type_traits_internal::
+ default_alignment_of_aligned_storage<Len>::value>
+using aligned_storage_t = typename std::aligned_storage<Len, Align>::type;
+
+template <typename T>
+using decay_t = typename std::decay<T>::type;
+
+template <bool B, typename T = void>
+using enable_if_t = typename std::enable_if<B, T>::type;
+
+template <bool B, typename T, typename F>
+using conditional_t = typename std::conditional<B, T, F>::type;
+
+template <typename... T>
+using common_type_t = typename std::common_type<T...>::type;
+
+template <typename T>
+using underlying_type_t = typename std::underlying_type<T>::type;
+
+template <typename T>
+using result_of_t = typename std::result_of<T>::type;
+
+namespace type_traits_internal {
+template <typename Key, typename = size_t>
+struct IsHashable : std::false_type {};
+
+template <typename Key>
+struct IsHashable<Key,
+ decltype(std::declval<std::hash<Key>>()(std::declval<Key>()))>
+ : std::true_type {};
+
+template <typename Key>
+struct IsHashEnabled
+ : absl::conjunction<std::is_default_constructible<std::hash<Key>>,
+ std::is_copy_constructible<std::hash<Key>>,
+ std::is_destructible<std::hash<Key>>,
+ std::is_copy_assignable<std::hash<Key>>,
+ IsHashable<Key>> {};
+} // namespace type_traits_internal
+
+} // namespace absl
+#endif // ABSL_META_TYPE_TRAITS_H_
[04/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional_test.cc
new file mode 100644
index 0000000..179bfd6
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional_test.cc
@@ -0,0 +1,1625 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/types/optional.h"
+
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+
+struct Hashable {};
+
+namespace std {
+template <>
+struct hash<Hashable> {
+ size_t operator()(const Hashable&) { return 0; }
+};
+} // namespace std
+
+struct NonHashable {};
+
+namespace {
+
+std::string TypeQuals(std::string&) { return "&"; }
+std::string TypeQuals(std::string&&) { return "&&"; }
+std::string TypeQuals(const std::string&) { return "c&"; }
+std::string TypeQuals(const std::string&&) { return "c&&"; }
+
+struct StructorListener {
+ int construct0 = 0;
+ int construct1 = 0;
+ int construct2 = 0;
+ int listinit = 0;
+ int copy = 0;
+ int move = 0;
+ int copy_assign = 0;
+ int move_assign = 0;
+ int destruct = 0;
+ int volatile_copy = 0;
+ int volatile_move = 0;
+ int volatile_copy_assign = 0;
+ int volatile_move_assign = 0;
+};
+
+// Suppress MSVC warnings.
+// 4521: multiple copy constructors specified
+// 4522: multiple assignment operators specified
+// We wrote multiple of them to test that the correct overloads are selected.
+#ifdef _MSC_VER
+#pragma warning( push )
+#pragma warning( disable : 4521)
+#pragma warning( disable : 4522)
+#endif
+struct Listenable {
+ static StructorListener* listener;
+
+ Listenable() { ++listener->construct0; }
+ explicit Listenable(int /*unused*/) { ++listener->construct1; }
+ Listenable(int /*unused*/, int /*unused*/) { ++listener->construct2; }
+ Listenable(std::initializer_list<int> /*unused*/) { ++listener->listinit; }
+ Listenable(const Listenable& /*unused*/) { ++listener->copy; }
+ Listenable(const volatile Listenable& /*unused*/) {
+ ++listener->volatile_copy;
+ }
+ Listenable(volatile Listenable&& /*unused*/) { ++listener->volatile_move; }
+ Listenable(Listenable&& /*unused*/) { ++listener->move; }
+ Listenable& operator=(const Listenable& /*unused*/) {
+ ++listener->copy_assign;
+ return *this;
+ }
+ Listenable& operator=(Listenable&& /*unused*/) {
+ ++listener->move_assign;
+ return *this;
+ }
+ // use void return type instead of volatile T& to work around GCC warning
+ // when the assignment's returned reference is ignored.
+ void operator=(const volatile Listenable& /*unused*/) volatile {
+ ++listener->volatile_copy_assign;
+ }
+ void operator=(volatile Listenable&& /*unused*/) volatile {
+ ++listener->volatile_move_assign;
+ }
+ ~Listenable() { ++listener->destruct; }
+};
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+StructorListener* Listenable::listener = nullptr;
+
+// ABSL_HAVE_NO_CONSTEXPR_INITIALIZER_LIST is defined to 1 when the standard
+// library implementation doesn't marked initializer_list's default constructor
+// constexpr. The C++11 standard doesn't specify constexpr on it, but C++14
+// added it. However, libstdc++ 4.7 marked it constexpr.
+#if defined(_LIBCPP_VERSION) && \
+ (_LIBCPP_STD_VER <= 11 || defined(_LIBCPP_HAS_NO_CXX14_CONSTEXPR))
+#define ABSL_HAVE_NO_CONSTEXPR_INITIALIZER_LIST 1
+#endif
+
+struct ConstexprType {
+ enum CtorTypes {
+ kCtorDefault,
+ kCtorInt,
+ kCtorInitializerList,
+ kCtorConstChar
+ };
+ constexpr ConstexprType() : x(kCtorDefault) {}
+ constexpr explicit ConstexprType(int i) : x(kCtorInt) {}
+#ifndef ABSL_HAVE_NO_CONSTEXPR_INITIALIZER_LIST
+ constexpr ConstexprType(std::initializer_list<int> il)
+ : x(kCtorInitializerList) {}
+#endif
+ constexpr ConstexprType(const char*) // NOLINT(runtime/explicit)
+ : x(kCtorConstChar) {}
+ int x;
+};
+
+struct Copyable {
+ Copyable() {}
+ Copyable(const Copyable&) {}
+ Copyable& operator=(const Copyable&) { return *this; }
+};
+
+struct MoveableThrow {
+ MoveableThrow() {}
+ MoveableThrow(MoveableThrow&&) {}
+ MoveableThrow& operator=(MoveableThrow&&) { return *this; }
+};
+
+struct MoveableNoThrow {
+ MoveableNoThrow() {}
+ MoveableNoThrow(MoveableNoThrow&&) noexcept {}
+ MoveableNoThrow& operator=(MoveableNoThrow&&) noexcept { return *this; }
+};
+
+struct NonMovable {
+ NonMovable() {}
+ NonMovable(const NonMovable&) = delete;
+ NonMovable& operator=(const NonMovable&) = delete;
+ NonMovable(NonMovable&&) = delete;
+ NonMovable& operator=(NonMovable&&) = delete;
+};
+
+TEST(optionalTest, DefaultConstructor) {
+ absl::optional<int> empty;
+ EXPECT_FALSE(empty);
+ constexpr absl::optional<int> cempty;
+ static_assert(!cempty.has_value(), "");
+ EXPECT_TRUE(
+ std::is_nothrow_default_constructible<absl::optional<int>>::value);
+}
+
+TEST(optionalTest, nulloptConstructor) {
+ absl::optional<int> empty(absl::nullopt);
+ EXPECT_FALSE(empty);
+
+#ifdef ABSL_HAVE_STD_OPTIONAL
+ constexpr absl::optional<int> cempty{absl::nullopt};
+#else
+ // Creating a temporary absl::nullopt_t object instead of using absl::nullopt
+ // because absl::nullopt cannot be constexpr and have external linkage at the
+ // same time.
+ constexpr absl::optional<int> cempty{absl::nullopt_t(absl::nullopt_t::init)};
+#endif
+ static_assert(!cempty.has_value(), "");
+ EXPECT_TRUE((std::is_nothrow_constructible<absl::optional<int>,
+ absl::nullopt_t>::value));
+}
+
+TEST(optionalTest, CopyConstructor) {
+ {
+ absl::optional<int> empty, opt42 = 42;
+ absl::optional<int> empty_copy(empty);
+ EXPECT_FALSE(empty_copy);
+ absl::optional<int> opt42_copy(opt42);
+ EXPECT_TRUE(opt42_copy);
+ EXPECT_EQ(42, *opt42_copy);
+ }
+ {
+ absl::optional<const int> empty, opt42 = 42;
+ absl::optional<const int> empty_copy(empty);
+ EXPECT_FALSE(empty_copy);
+ absl::optional<const int> opt42_copy(opt42);
+ EXPECT_TRUE(opt42_copy);
+ EXPECT_EQ(42, *opt42_copy);
+ }
+ {
+ absl::optional<volatile int> empty, opt42 = 42;
+ absl::optional<volatile int> empty_copy(empty);
+ EXPECT_FALSE(empty_copy);
+ absl::optional<volatile int> opt42_copy(opt42);
+ EXPECT_TRUE(opt42_copy);
+ EXPECT_EQ(42, *opt42_copy);
+ }
+ // test copyablility
+ EXPECT_TRUE(std::is_copy_constructible<absl::optional<int>>::value);
+ EXPECT_TRUE(std::is_copy_constructible<absl::optional<Copyable>>::value);
+ EXPECT_FALSE(
+ std::is_copy_constructible<absl::optional<MoveableThrow>>::value);
+ EXPECT_FALSE(
+ std::is_copy_constructible<absl::optional<MoveableNoThrow>>::value);
+ EXPECT_FALSE(std::is_copy_constructible<absl::optional<NonMovable>>::value);
+
+ EXPECT_FALSE(
+ absl::is_trivially_copy_constructible<absl::optional<Copyable>>::value);
+#if defined(ABSL_HAVE_STD_OPTIONAL) && defined(__GLIBCXX__)
+ // libstdc++ std::optional implementation (as of 7.2) has a bug: when T is
+ // trivially copyable, optional<T> is not trivially copyable (due to one of
+ // its base class is unconditionally nontrivial).
+#define ABSL_GLIBCXX_OPTIONAL_TRIVIALITY_BUG 1
+#endif
+#ifndef ABSL_GLIBCXX_OPTIONAL_TRIVIALITY_BUG
+ EXPECT_TRUE(
+ absl::is_trivially_copy_constructible<absl::optional<int>>::value);
+ EXPECT_TRUE(
+ absl::is_trivially_copy_constructible<absl::optional<const int>>::value);
+#ifndef _MSC_VER
+ // See defect report "Trivial copy/move constructor for class with volatile
+ // member" at
+ // http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#2094
+ // A class with non-static data member of volatile-qualified type should still
+ // have a trivial copy constructor if the data member is trivial.
+ // Also a cv-qualified scalar type should be trivially copyable.
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<
+ absl::optional<volatile int>>::value);
+#endif // _MSC_VER
+#endif // ABSL_GLIBCXX_OPTIONAL_TRIVIALITY_BUG
+
+ // constexpr copy constructor for trivially copyable types
+ {
+ constexpr absl::optional<int> o1;
+ constexpr absl::optional<int> o2 = o1;
+ static_assert(!o2, "");
+ }
+ {
+ constexpr absl::optional<int> o1 = 42;
+ constexpr absl::optional<int> o2 = o1;
+ static_assert(o2, "");
+ static_assert(*o2 == 42, "");
+ }
+ {
+ struct TrivialCopyable {
+ constexpr TrivialCopyable() : x(0) {}
+ constexpr explicit TrivialCopyable(int i) : x(i) {}
+ int x;
+ };
+ constexpr absl::optional<TrivialCopyable> o1(42);
+ constexpr absl::optional<TrivialCopyable> o2 = o1;
+ static_assert(o2, "");
+ static_assert((*o2).x == 42, "");
+#ifndef ABSL_GLIBCXX_OPTIONAL_TRIVIALITY_BUG
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<
+ absl::optional<TrivialCopyable>>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<
+ absl::optional<const TrivialCopyable>>::value);
+#endif
+ // When testing with VS 2017 15.3, there seems to be a bug in MSVC
+ // std::optional when T is volatile-qualified. So skipping this test.
+ // Bug report:
+ // https://connect.microsoft.com/VisualStudio/feedback/details/3142534
+#if defined(ABSL_HAVE_STD_OPTIONAL) && defined(_MSC_VER) && _MSC_VER >= 1911
+#define ABSL_MSVC_OPTIONAL_VOLATILE_COPY_BUG 1
+#endif
+#ifndef ABSL_MSVC_OPTIONAL_VOLATILE_COPY_BUG
+ EXPECT_FALSE(std::is_copy_constructible<
+ absl::optional<volatile TrivialCopyable>>::value);
+#endif
+ }
+}
+
+TEST(optionalTest, MoveConstructor) {
+ absl::optional<int> empty, opt42 = 42;
+ absl::optional<int> empty_move(std::move(empty));
+ EXPECT_FALSE(empty_move);
+ absl::optional<int> opt42_move(std::move(opt42));
+ EXPECT_TRUE(opt42_move);
+ EXPECT_EQ(42, opt42_move);
+ // test movability
+ EXPECT_TRUE(std::is_move_constructible<absl::optional<int>>::value);
+ EXPECT_TRUE(std::is_move_constructible<absl::optional<Copyable>>::value);
+ EXPECT_TRUE(std::is_move_constructible<absl::optional<MoveableThrow>>::value);
+ EXPECT_TRUE(
+ std::is_move_constructible<absl::optional<MoveableNoThrow>>::value);
+ EXPECT_FALSE(std::is_move_constructible<absl::optional<NonMovable>>::value);
+ // test noexcept
+ EXPECT_TRUE(std::is_nothrow_move_constructible<absl::optional<int>>::value);
+#ifndef ABSL_HAVE_STD_OPTIONAL
+ EXPECT_EQ(
+ absl::default_allocator_is_nothrow::value,
+ std::is_nothrow_move_constructible<absl::optional<MoveableThrow>>::value);
+#endif
+ EXPECT_TRUE(std::is_nothrow_move_constructible<
+ absl::optional<MoveableNoThrow>>::value);
+}
+
+TEST(optionalTest, Destructor) {
+ struct Trivial {};
+
+ struct NonTrivial {
+ NonTrivial(const NonTrivial&) {}
+ NonTrivial& operator=(const NonTrivial&) { return *this; }
+ ~NonTrivial() {}
+ };
+
+ EXPECT_TRUE(std::is_trivially_destructible<absl::optional<int>>::value);
+ EXPECT_TRUE(std::is_trivially_destructible<absl::optional<Trivial>>::value);
+ EXPECT_FALSE(
+ std::is_trivially_destructible<absl::optional<NonTrivial>>::value);
+}
+
+TEST(optionalTest, InPlaceConstructor) {
+ constexpr absl::optional<ConstexprType> opt0{absl::in_place_t()};
+ static_assert(opt0, "");
+ static_assert((*opt0).x == ConstexprType::kCtorDefault, "");
+ constexpr absl::optional<ConstexprType> opt1{absl::in_place_t(), 1};
+ static_assert(opt1, "");
+ static_assert((*opt1).x == ConstexprType::kCtorInt, "");
+#ifndef ABSL_HAVE_NO_CONSTEXPR_INITIALIZER_LIST
+ constexpr absl::optional<ConstexprType> opt2{absl::in_place_t(), {1, 2}};
+ static_assert(opt2, "");
+ static_assert((*opt2).x == ConstexprType::kCtorInitializerList, "");
+#endif
+
+ // TODO(absl-team): uncomment these when std::is_constructible<T, Args&&...>
+ // SFINAE is added to optional::optional(absl::in_place_t, Args&&...).
+ // struct I {
+ // I(absl::in_place_t);
+ // };
+
+ // EXPECT_FALSE((std::is_constructible<absl::optional<I>,
+ // absl::in_place_t>::value));
+ // EXPECT_FALSE((std::is_constructible<absl::optional<I>, const
+ // absl::in_place_t&>::value));
+}
+
+// template<U=T> optional(U&&);
+TEST(optionalTest, ValueConstructor) {
+ constexpr absl::optional<int> opt0(0);
+ static_assert(opt0, "");
+ static_assert(*opt0 == 0, "");
+ EXPECT_TRUE((std::is_convertible<int, absl::optional<int>>::value));
+ // Copy initialization ( = "abc") won't work due to optional(optional&&)
+ // is not constexpr. Use list initialization instead. This invokes
+ // absl::optional<ConstexprType>::absl::optional<U>(U&&), with U = const char
+ // (&) [4], which direct-initializes the ConstexprType value held by the
+ // optional via ConstexprType::ConstexprType(const char*).
+ constexpr absl::optional<ConstexprType> opt1 = {"abc"};
+ static_assert(opt1, "");
+ static_assert(ConstexprType::kCtorConstChar == (*opt1).x, "");
+ EXPECT_TRUE(
+ (std::is_convertible<const char*, absl::optional<ConstexprType>>::value));
+ // direct initialization
+ constexpr absl::optional<ConstexprType> opt2{2};
+ static_assert(opt2, "");
+ static_assert(ConstexprType::kCtorInt == (*opt2).x, "");
+ EXPECT_FALSE(
+ (std::is_convertible<int, absl::optional<ConstexprType>>::value));
+
+ // this invokes absl::optional<int>::optional(int&&)
+ // NOTE: this has different behavior than assignment, e.g.
+ // "opt3 = {};" clears the optional rather than setting the value to 0
+ // According to C++17 standard N4659 [over.ics.list] 16.3.3.1.5, (9.2)- "if
+ // the initializer list has no elements, the implicit conversion is the
+ // identity conversion", so `optional(int&&)` should be a better match than
+ // `optional(optional&&)` which is a user-defined conversion.
+ // Note: GCC 7 has a bug with this overload selection when compiled with
+ // `-std=c++17`.
+#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ == 7 && \
+ __cplusplus == 201703L
+#define ABSL_GCC7_OVER_ICS_LIST_BUG 1
+#endif
+#ifndef ABSL_GCC7_OVER_ICS_LIST_BUG
+ constexpr absl::optional<int> opt3({});
+ static_assert(opt3, "");
+ static_assert(*opt3 == 0, "");
+#endif
+
+ // this invokes the move constructor with a default constructed optional
+ // because non-template function is a better match than template function.
+ absl::optional<ConstexprType> opt4({});
+ EXPECT_FALSE(opt4);
+}
+
+struct Implicit {};
+
+struct Explicit {};
+
+struct Convert {
+ Convert(const Implicit&) // NOLINT(runtime/explicit)
+ : implicit(true), move(false) {}
+ Convert(Implicit&&) // NOLINT(runtime/explicit)
+ : implicit(true), move(true) {}
+ explicit Convert(const Explicit&) : implicit(false), move(false) {}
+ explicit Convert(Explicit&&) : implicit(false), move(true) {}
+
+ bool implicit;
+ bool move;
+};
+
+struct ConvertFromOptional {
+ ConvertFromOptional(const Implicit&) // NOLINT(runtime/explicit)
+ : implicit(true), move(false), from_optional(false) {}
+ ConvertFromOptional(Implicit&&) // NOLINT(runtime/explicit)
+ : implicit(true), move(true), from_optional(false) {}
+ ConvertFromOptional(
+ const absl::optional<Implicit>&) // NOLINT(runtime/explicit)
+ : implicit(true), move(false), from_optional(true) {}
+ ConvertFromOptional(absl::optional<Implicit>&&) // NOLINT(runtime/explicit)
+ : implicit(true), move(true), from_optional(true) {}
+ explicit ConvertFromOptional(const Explicit&)
+ : implicit(false), move(false), from_optional(false) {}
+ explicit ConvertFromOptional(Explicit&&)
+ : implicit(false), move(true), from_optional(false) {}
+ explicit ConvertFromOptional(const absl::optional<Explicit>&)
+ : implicit(false), move(false), from_optional(true) {}
+ explicit ConvertFromOptional(absl::optional<Explicit>&&)
+ : implicit(false), move(true), from_optional(true) {}
+
+ bool implicit;
+ bool move;
+ bool from_optional;
+};
+
+TEST(optionalTest, ConvertingConstructor) {
+ absl::optional<Implicit> i_empty;
+ absl::optional<Implicit> i(absl::in_place);
+ absl::optional<Explicit> e_empty;
+ absl::optional<Explicit> e(absl::in_place);
+ {
+ // implicitly constructing absl::optional<Convert> from
+ // absl::optional<Implicit>
+ absl::optional<Convert> empty = i_empty;
+ EXPECT_FALSE(empty);
+ absl::optional<Convert> opt_copy = i;
+ EXPECT_TRUE(opt_copy);
+ EXPECT_TRUE(opt_copy->implicit);
+ EXPECT_FALSE(opt_copy->move);
+ absl::optional<Convert> opt_move = absl::optional<Implicit>(absl::in_place);
+ EXPECT_TRUE(opt_move);
+ EXPECT_TRUE(opt_move->implicit);
+ EXPECT_TRUE(opt_move->move);
+ }
+ {
+ // explicitly constructing absl::optional<Convert> from
+ // absl::optional<Explicit>
+ absl::optional<Convert> empty(e_empty);
+ EXPECT_FALSE(empty);
+ absl::optional<Convert> opt_copy(e);
+ EXPECT_TRUE(opt_copy);
+ EXPECT_FALSE(opt_copy->implicit);
+ EXPECT_FALSE(opt_copy->move);
+ EXPECT_FALSE((std::is_convertible<const absl::optional<Explicit>&,
+ absl::optional<Convert>>::value));
+ absl::optional<Convert> opt_move{absl::optional<Explicit>(absl::in_place)};
+ EXPECT_TRUE(opt_move);
+ EXPECT_FALSE(opt_move->implicit);
+ EXPECT_TRUE(opt_move->move);
+ EXPECT_FALSE((std::is_convertible<absl::optional<Explicit>&&,
+ absl::optional<Convert>>::value));
+ }
+ {
+ // implicitly constructing absl::optional<ConvertFromOptional> from
+ // absl::optional<Implicit> via
+ // ConvertFromOptional(absl::optional<Implicit>&&) check that
+ // ConvertFromOptional(Implicit&&) is NOT called
+ static_assert(
+ std::is_convertible<absl::optional<Implicit>,
+ absl::optional<ConvertFromOptional>>::value,
+ "");
+ absl::optional<ConvertFromOptional> opt0 = i_empty;
+ EXPECT_TRUE(opt0);
+ EXPECT_TRUE(opt0->implicit);
+ EXPECT_FALSE(opt0->move);
+ EXPECT_TRUE(opt0->from_optional);
+ absl::optional<ConvertFromOptional> opt1 = absl::optional<Implicit>();
+ EXPECT_TRUE(opt1);
+ EXPECT_TRUE(opt1->implicit);
+ EXPECT_TRUE(opt1->move);
+ EXPECT_TRUE(opt1->from_optional);
+ }
+ {
+ // implicitly constructing absl::optional<ConvertFromOptional> from
+ // absl::optional<Explicit> via
+ // ConvertFromOptional(absl::optional<Explicit>&&) check that
+ // ConvertFromOptional(Explicit&&) is NOT called
+ absl::optional<ConvertFromOptional> opt0(e_empty);
+ EXPECT_TRUE(opt0);
+ EXPECT_FALSE(opt0->implicit);
+ EXPECT_FALSE(opt0->move);
+ EXPECT_TRUE(opt0->from_optional);
+ EXPECT_FALSE(
+ (std::is_convertible<const absl::optional<Explicit>&,
+ absl::optional<ConvertFromOptional>>::value));
+ absl::optional<ConvertFromOptional> opt1{absl::optional<Explicit>()};
+ EXPECT_TRUE(opt1);
+ EXPECT_FALSE(opt1->implicit);
+ EXPECT_TRUE(opt1->move);
+ EXPECT_TRUE(opt1->from_optional);
+ EXPECT_FALSE(
+ (std::is_convertible<absl::optional<Explicit>&&,
+ absl::optional<ConvertFromOptional>>::value));
+ }
+}
+
+TEST(optionalTest, StructorBasic) {
+ StructorListener listener;
+ Listenable::listener = &listener;
+ {
+ absl::optional<Listenable> empty;
+ EXPECT_FALSE(empty);
+ absl::optional<Listenable> opt0(absl::in_place);
+ EXPECT_TRUE(opt0);
+ absl::optional<Listenable> opt1(absl::in_place, 1);
+ EXPECT_TRUE(opt1);
+ absl::optional<Listenable> opt2(absl::in_place, 1, 2);
+ EXPECT_TRUE(opt2);
+ }
+ EXPECT_EQ(1, listener.construct0);
+ EXPECT_EQ(1, listener.construct1);
+ EXPECT_EQ(1, listener.construct2);
+ EXPECT_EQ(3, listener.destruct);
+}
+
+TEST(optionalTest, CopyMoveStructor) {
+ StructorListener listener;
+ Listenable::listener = &listener;
+ absl::optional<Listenable> original(absl::in_place);
+ EXPECT_EQ(1, listener.construct0);
+ EXPECT_EQ(0, listener.copy);
+ EXPECT_EQ(0, listener.move);
+ absl::optional<Listenable> copy(original);
+ EXPECT_EQ(1, listener.construct0);
+ EXPECT_EQ(1, listener.copy);
+ EXPECT_EQ(0, listener.move);
+ absl::optional<Listenable> move(std::move(original));
+ EXPECT_EQ(1, listener.construct0);
+ EXPECT_EQ(1, listener.copy);
+ EXPECT_EQ(1, listener.move);
+}
+
+TEST(optionalTest, ListInit) {
+ StructorListener listener;
+ Listenable::listener = &listener;
+ absl::optional<Listenable> listinit1(absl::in_place, {1});
+ absl::optional<Listenable> listinit2(absl::in_place, {1, 2});
+ EXPECT_EQ(2, listener.listinit);
+}
+
+TEST(optionalTest, AssignFromNullopt) {
+ absl::optional<int> opt(1);
+ opt = absl::nullopt;
+ EXPECT_FALSE(opt);
+
+ StructorListener listener;
+ Listenable::listener = &listener;
+ absl::optional<Listenable> opt1(absl::in_place);
+ opt1 = absl::nullopt;
+ EXPECT_FALSE(opt1);
+ EXPECT_EQ(1, listener.construct0);
+ EXPECT_EQ(1, listener.destruct);
+
+ EXPECT_TRUE((
+ std::is_nothrow_assignable<absl::optional<int>, absl::nullopt_t>::value));
+ EXPECT_TRUE((std::is_nothrow_assignable<absl::optional<Listenable>,
+ absl::nullopt_t>::value));
+}
+
+TEST(optionalTest, CopyAssignment) {
+ const absl::optional<int> empty, opt1 = 1, opt2 = 2;
+ absl::optional<int> empty_to_opt1, opt1_to_opt2, opt2_to_empty;
+
+ EXPECT_FALSE(empty_to_opt1);
+ empty_to_opt1 = empty;
+ EXPECT_FALSE(empty_to_opt1);
+ empty_to_opt1 = opt1;
+ EXPECT_TRUE(empty_to_opt1);
+ EXPECT_EQ(1, empty_to_opt1.value());
+
+ EXPECT_FALSE(opt1_to_opt2);
+ opt1_to_opt2 = opt1;
+ EXPECT_TRUE(opt1_to_opt2);
+ EXPECT_EQ(1, opt1_to_opt2.value());
+ opt1_to_opt2 = opt2;
+ EXPECT_TRUE(opt1_to_opt2);
+ EXPECT_EQ(2, opt1_to_opt2.value());
+
+ EXPECT_FALSE(opt2_to_empty);
+ opt2_to_empty = opt2;
+ EXPECT_TRUE(opt2_to_empty);
+ EXPECT_EQ(2, opt2_to_empty.value());
+ opt2_to_empty = empty;
+ EXPECT_FALSE(opt2_to_empty);
+
+ EXPECT_FALSE(std::is_copy_assignable<absl::optional<const int>>::value);
+ EXPECT_TRUE(std::is_copy_assignable<absl::optional<Copyable>>::value);
+ EXPECT_FALSE(std::is_copy_assignable<absl::optional<MoveableThrow>>::value);
+ EXPECT_FALSE(std::is_copy_assignable<absl::optional<MoveableNoThrow>>::value);
+ EXPECT_FALSE(std::is_copy_assignable<absl::optional<NonMovable>>::value);
+
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<int>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<volatile int>::value);
+
+ struct Trivial {
+ int i;
+ };
+ struct NonTrivial {
+ NonTrivial& operator=(const NonTrivial&) { return *this; }
+ int i;
+ };
+
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial>::value);
+ EXPECT_FALSE(std::is_copy_assignable<const Trivial>::value);
+ EXPECT_FALSE(std::is_copy_assignable<volatile Trivial>::value);
+ EXPECT_TRUE(std::is_copy_assignable<NonTrivial>::value);
+ EXPECT_FALSE(absl::is_trivially_copy_assignable<NonTrivial>::value);
+
+ // std::optional doesn't support volatile nontrivial types.
+#ifndef ABSL_HAVE_STD_OPTIONAL
+ {
+ StructorListener listener;
+ Listenable::listener = &listener;
+
+ absl::optional<volatile Listenable> empty, set(absl::in_place);
+ EXPECT_EQ(1, listener.construct0);
+ absl::optional<volatile Listenable> empty_to_empty, empty_to_set,
+ set_to_empty(absl::in_place), set_to_set(absl::in_place);
+ EXPECT_EQ(3, listener.construct0);
+ empty_to_empty = empty; // no effect
+ empty_to_set = set; // copy construct
+ set_to_empty = empty; // destruct
+ set_to_set = set; // copy assign
+ EXPECT_EQ(1, listener.volatile_copy);
+ EXPECT_EQ(0, listener.volatile_move);
+ EXPECT_EQ(1, listener.destruct);
+ EXPECT_EQ(1, listener.volatile_copy_assign);
+ }
+#endif // ABSL_HAVE_STD_OPTIONAL
+}
+
+TEST(optionalTest, MoveAssignment) {
+ {
+ StructorListener listener;
+ Listenable::listener = &listener;
+
+ absl::optional<Listenable> empty1, empty2, set1(absl::in_place),
+ set2(absl::in_place);
+ EXPECT_EQ(2, listener.construct0);
+ absl::optional<Listenable> empty_to_empty, empty_to_set,
+ set_to_empty(absl::in_place), set_to_set(absl::in_place);
+ EXPECT_EQ(4, listener.construct0);
+ empty_to_empty = std::move(empty1);
+ empty_to_set = std::move(set1);
+ set_to_empty = std::move(empty2);
+ set_to_set = std::move(set2);
+ EXPECT_EQ(0, listener.copy);
+ EXPECT_EQ(1, listener.move);
+ EXPECT_EQ(1, listener.destruct);
+ EXPECT_EQ(1, listener.move_assign);
+ }
+ // std::optional doesn't support volatile nontrivial types.
+#ifndef ABSL_HAVE_STD_OPTIONAL
+ {
+ StructorListener listener;
+ Listenable::listener = &listener;
+
+ absl::optional<volatile Listenable> empty1, empty2, set1(absl::in_place),
+ set2(absl::in_place);
+ EXPECT_EQ(2, listener.construct0);
+ absl::optional<volatile Listenable> empty_to_empty, empty_to_set,
+ set_to_empty(absl::in_place), set_to_set(absl::in_place);
+ EXPECT_EQ(4, listener.construct0);
+ empty_to_empty = std::move(empty1); // no effect
+ empty_to_set = std::move(set1); // move construct
+ set_to_empty = std::move(empty2); // destruct
+ set_to_set = std::move(set2); // move assign
+ EXPECT_EQ(0, listener.volatile_copy);
+ EXPECT_EQ(1, listener.volatile_move);
+ EXPECT_EQ(1, listener.destruct);
+ EXPECT_EQ(1, listener.volatile_move_assign);
+ }
+#endif // ABSL_HAVE_STD_OPTIONAL
+ EXPECT_FALSE(std::is_move_assignable<absl::optional<const int>>::value);
+ EXPECT_TRUE(std::is_move_assignable<absl::optional<Copyable>>::value);
+ EXPECT_TRUE(std::is_move_assignable<absl::optional<MoveableThrow>>::value);
+ EXPECT_TRUE(std::is_move_assignable<absl::optional<MoveableNoThrow>>::value);
+ EXPECT_FALSE(std::is_move_assignable<absl::optional<NonMovable>>::value);
+
+ EXPECT_FALSE(
+ std::is_nothrow_move_assignable<absl::optional<MoveableThrow>>::value);
+ EXPECT_TRUE(
+ std::is_nothrow_move_assignable<absl::optional<MoveableNoThrow>>::value);
+}
+
+struct NoConvertToOptional {
+ // disable implicit conversion from const NoConvertToOptional&
+ // to absl::optional<NoConvertToOptional>.
+ NoConvertToOptional(const NoConvertToOptional&) = delete;
+};
+
+struct CopyConvert {
+ CopyConvert(const NoConvertToOptional&);
+ CopyConvert& operator=(const CopyConvert&) = delete;
+ CopyConvert& operator=(const NoConvertToOptional&);
+};
+
+struct CopyConvertFromOptional {
+ CopyConvertFromOptional(const NoConvertToOptional&);
+ CopyConvertFromOptional(const absl::optional<NoConvertToOptional>&);
+ CopyConvertFromOptional& operator=(const CopyConvertFromOptional&) = delete;
+ CopyConvertFromOptional& operator=(const NoConvertToOptional&);
+ CopyConvertFromOptional& operator=(
+ const absl::optional<NoConvertToOptional>&);
+};
+
+struct MoveConvert {
+ MoveConvert(NoConvertToOptional&&);
+ MoveConvert& operator=(const MoveConvert&) = delete;
+ MoveConvert& operator=(NoConvertToOptional&&);
+};
+
+struct MoveConvertFromOptional {
+ MoveConvertFromOptional(NoConvertToOptional&&);
+ MoveConvertFromOptional(absl::optional<NoConvertToOptional>&&);
+ MoveConvertFromOptional& operator=(const MoveConvertFromOptional&) = delete;
+ MoveConvertFromOptional& operator=(NoConvertToOptional&&);
+ MoveConvertFromOptional& operator=(absl::optional<NoConvertToOptional>&&);
+};
+
+// template <typename U = T> absl::optional<T>& operator=(U&& v);
+TEST(optionalTest, ValueAssignment) {
+ absl::optional<int> opt;
+ EXPECT_FALSE(opt);
+ opt = 42;
+ EXPECT_TRUE(opt);
+ EXPECT_EQ(42, opt.value());
+ opt = absl::nullopt;
+ EXPECT_FALSE(opt);
+ opt = 42;
+ EXPECT_TRUE(opt);
+ EXPECT_EQ(42, opt.value());
+ opt = 43;
+ EXPECT_TRUE(opt);
+ EXPECT_EQ(43, opt.value());
+ opt = {}; // this should clear optional
+ EXPECT_FALSE(opt);
+
+ opt = {44};
+ EXPECT_TRUE(opt);
+ EXPECT_EQ(44, opt.value());
+
+ // U = const NoConvertToOptional&
+ EXPECT_TRUE((std::is_assignable<absl::optional<CopyConvert>&,
+ const NoConvertToOptional&>::value));
+ // U = const absl::optional<NoConvertToOptional>&
+ EXPECT_TRUE((std::is_assignable<absl::optional<CopyConvertFromOptional>&,
+ const NoConvertToOptional&>::value));
+ // U = const NoConvertToOptional& triggers SFINAE because
+ // std::is_constructible_v<MoveConvert, const NoConvertToOptional&> is false
+ EXPECT_FALSE((std::is_assignable<absl::optional<MoveConvert>&,
+ const NoConvertToOptional&>::value));
+ // U = NoConvertToOptional
+ EXPECT_TRUE((std::is_assignable<absl::optional<MoveConvert>&,
+ NoConvertToOptional&&>::value));
+ // U = const NoConvertToOptional& triggers SFINAE because
+ // std::is_constructible_v<MoveConvertFromOptional, const
+ // NoConvertToOptional&> is false
+ EXPECT_FALSE((std::is_assignable<absl::optional<MoveConvertFromOptional>&,
+ const NoConvertToOptional&>::value));
+ // U = NoConvertToOptional
+ EXPECT_TRUE((std::is_assignable<absl::optional<MoveConvertFromOptional>&,
+ NoConvertToOptional&&>::value));
+ // U = const absl::optional<NoConvertToOptional>&
+ EXPECT_TRUE(
+ (std::is_assignable<absl::optional<CopyConvertFromOptional>&,
+ const absl::optional<NoConvertToOptional>&>::value));
+ // U = absl::optional<NoConvertToOptional>
+ EXPECT_TRUE(
+ (std::is_assignable<absl::optional<MoveConvertFromOptional>&,
+ absl::optional<NoConvertToOptional>&&>::value));
+}
+
+// template <typename U> absl::optional<T>& operator=(const absl::optional<U>&
+// rhs); template <typename U> absl::optional<T>& operator=(absl::optional<U>&&
+// rhs);
+TEST(optionalTest, ConvertingAssignment) {
+ absl::optional<int> opt_i;
+ absl::optional<char> opt_c('c');
+ opt_i = opt_c;
+ EXPECT_TRUE(opt_i);
+ EXPECT_EQ(*opt_c, *opt_i);
+ opt_i = absl::optional<char>();
+ EXPECT_FALSE(opt_i);
+ opt_i = absl::optional<char>('d');
+ EXPECT_TRUE(opt_i);
+ EXPECT_EQ('d', *opt_i);
+
+ absl::optional<std::string> opt_str;
+ absl::optional<const char*> opt_cstr("abc");
+ opt_str = opt_cstr;
+ EXPECT_TRUE(opt_str);
+ EXPECT_EQ(std::string("abc"), *opt_str);
+ opt_str = absl::optional<const char*>();
+ EXPECT_FALSE(opt_str);
+ opt_str = absl::optional<const char*>("def");
+ EXPECT_TRUE(opt_str);
+ EXPECT_EQ(std::string("def"), *opt_str);
+
+ // operator=(const absl::optional<U>&) with U = NoConvertToOptional
+ EXPECT_TRUE(
+ (std::is_assignable<absl::optional<CopyConvert>,
+ const absl::optional<NoConvertToOptional>&>::value));
+ // operator=(const absl::optional<U>&) with U = NoConvertToOptional
+ // triggers SFINAE because
+ // std::is_constructible_v<MoveConvert, const NoConvertToOptional&> is false
+ EXPECT_FALSE(
+ (std::is_assignable<absl::optional<MoveConvert>&,
+ const absl::optional<NoConvertToOptional>&>::value));
+ // operator=(absl::optional<U>&&) with U = NoConvertToOptional
+ EXPECT_TRUE(
+ (std::is_assignable<absl::optional<MoveConvert>&,
+ absl::optional<NoConvertToOptional>&&>::value));
+ // operator=(const absl::optional<U>&) with U = NoConvertToOptional triggers
+ // SFINAE because std::is_constructible_v<MoveConvertFromOptional, const
+ // NoConvertToOptional&> is false. operator=(U&&) with U = const
+ // absl::optional<NoConverToOptional>& triggers SFINAE because
+ // std::is_constructible<MoveConvertFromOptional,
+ // absl::optional<NoConvertToOptional>&&> is true.
+ EXPECT_FALSE(
+ (std::is_assignable<absl::optional<MoveConvertFromOptional>&,
+ const absl::optional<NoConvertToOptional>&>::value));
+}
+
+TEST(optionalTest, ResetAndHasValue) {
+ StructorListener listener;
+ Listenable::listener = &listener;
+ absl::optional<Listenable> opt;
+ EXPECT_FALSE(opt);
+ EXPECT_FALSE(opt.has_value());
+ opt.emplace();
+ EXPECT_TRUE(opt);
+ EXPECT_TRUE(opt.has_value());
+ opt.reset();
+ EXPECT_FALSE(opt);
+ EXPECT_FALSE(opt.has_value());
+ EXPECT_EQ(1, listener.destruct);
+ opt.reset();
+ EXPECT_FALSE(opt);
+ EXPECT_FALSE(opt.has_value());
+
+ constexpr absl::optional<int> empty;
+ static_assert(!empty.has_value(), "");
+ constexpr absl::optional<int> nonempty(1);
+ static_assert(nonempty.has_value(), "");
+}
+
+TEST(optionalTest, Emplace) {
+ StructorListener listener;
+ Listenable::listener = &listener;
+ absl::optional<Listenable> opt;
+ EXPECT_FALSE(opt);
+ opt.emplace(1);
+ EXPECT_TRUE(opt);
+ opt.emplace(1, 2);
+ EXPECT_EQ(1, listener.construct1);
+ EXPECT_EQ(1, listener.construct2);
+ EXPECT_EQ(1, listener.destruct);
+
+ absl::optional<std::string> o;
+ EXPECT_TRUE((std::is_same<std::string&, decltype(o.emplace("abc"))>::value));
+ std::string& ref = o.emplace("abc");
+ EXPECT_EQ(&ref, &o.value());
+}
+
+TEST(optionalTest, ListEmplace) {
+ StructorListener listener;
+ Listenable::listener = &listener;
+ absl::optional<Listenable> opt;
+ EXPECT_FALSE(opt);
+ opt.emplace({1});
+ EXPECT_TRUE(opt);
+ opt.emplace({1, 2});
+ EXPECT_EQ(2, listener.listinit);
+ EXPECT_EQ(1, listener.destruct);
+
+ absl::optional<Listenable> o;
+ EXPECT_TRUE((std::is_same<Listenable&, decltype(o.emplace({1}))>::value));
+ Listenable& ref = o.emplace({1});
+ EXPECT_EQ(&ref, &o.value());
+}
+
+TEST(optionalTest, Swap) {
+ absl::optional<int> opt_empty, opt1 = 1, opt2 = 2;
+ EXPECT_FALSE(opt_empty);
+ EXPECT_TRUE(opt1);
+ EXPECT_EQ(1, opt1.value());
+ EXPECT_TRUE(opt2);
+ EXPECT_EQ(2, opt2.value());
+ swap(opt_empty, opt1);
+ EXPECT_FALSE(opt1);
+ EXPECT_TRUE(opt_empty);
+ EXPECT_EQ(1, opt_empty.value());
+ EXPECT_TRUE(opt2);
+ EXPECT_EQ(2, opt2.value());
+ swap(opt_empty, opt1);
+ EXPECT_FALSE(opt_empty);
+ EXPECT_TRUE(opt1);
+ EXPECT_EQ(1, opt1.value());
+ EXPECT_TRUE(opt2);
+ EXPECT_EQ(2, opt2.value());
+ swap(opt1, opt2);
+ EXPECT_FALSE(opt_empty);
+ EXPECT_TRUE(opt1);
+ EXPECT_EQ(2, opt1.value());
+ EXPECT_TRUE(opt2);
+ EXPECT_EQ(1, opt2.value());
+
+ EXPECT_TRUE(noexcept(opt1.swap(opt2)));
+ EXPECT_TRUE(noexcept(swap(opt1, opt2)));
+}
+
+template <int v>
+struct DeletedOpAddr {
+ constexpr static const int value = v;
+ constexpr DeletedOpAddr() = default;
+ constexpr const DeletedOpAddr<v>* operator&() const = delete; // NOLINT
+ DeletedOpAddr<v>* operator&() = delete; // NOLINT
+};
+
+// The static_assert featuring a constexpr call to operator->() is commented out
+// to document the fact that the current implementation of absl::optional<T>
+// expects such usecases to be malformed and not compile.
+TEST(optionalTest, OperatorAddr) {
+ constexpr const int v = -1;
+ { // constexpr
+ constexpr const absl::optional<DeletedOpAddr<v>> opt(absl::in_place_t{});
+ static_assert(opt.has_value(), "");
+ // static_assert(opt->value == v, "");
+ static_assert((*opt).value == v, "");
+ }
+ { // non-constexpr
+ const absl::optional<DeletedOpAddr<v>> opt(absl::in_place_t{});
+ EXPECT_TRUE(opt.has_value());
+ EXPECT_TRUE(opt->value == v);
+ EXPECT_TRUE((*opt).value == v);
+ }
+}
+
+TEST(optionalTest, PointerStuff) {
+ absl::optional<std::string> opt(absl::in_place, "foo");
+ EXPECT_EQ("foo", *opt);
+ const auto& opt_const = opt;
+ EXPECT_EQ("foo", *opt_const);
+ EXPECT_EQ(opt->size(), 3);
+ EXPECT_EQ(opt_const->size(), 3);
+
+ constexpr absl::optional<ConstexprType> opt1(1);
+ static_assert((*opt1).x == ConstexprType::kCtorInt, "");
+}
+
+// gcc has a bug pre 4.9.1 where it doesn't do correct overload resolution
+// when overloads are const-qualified and *this is an raluve.
+// Skip that test to make the build green again when using the old compiler.
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=59296 is fixed in 4.9.1.
+#if defined(__GNUC__) && !defined(__clang__)
+#define GCC_VERSION (__GNUC__ * 10000 \
+ + __GNUC_MINOR__ * 100 \
+ + __GNUC_PATCHLEVEL__)
+#if GCC_VERSION < 40901
+#define ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG
+#endif
+#endif
+
+// MSVC has a bug with "cv-qualifiers in class construction", fixed in 2017. See
+// https://docs.microsoft.com/en-us/cpp/cpp-conformance-improvements-2017#bug-fixes
+// The compiler some incorrectly ingores the cv-qualifier when generating a
+// class object via a constructor call. For example:
+//
+// class optional {
+// constexpr T&& value() &&;
+// constexpr const T&& value() const &&;
+// }
+//
+// using COI = const absl::optional<int>;
+// static_assert(2 == COI(2).value(), ""); // const &&
+//
+// This should invoke the "const &&" overload but since it ignores the const
+// qualifier it finds the "&&" overload the best candidate.
+#if defined(_MSC_VER) && _MSC_VER < 1910
+#define ABSL_SKIP_OVERLOAD_TEST_DUE_TO_MSVC_BUG
+#endif
+
+TEST(optionalTest, Value) {
+ using O = absl::optional<std::string>;
+ using CO = const absl::optional<std::string>;
+ using OC = absl::optional<const std::string>;
+ O lvalue(absl::in_place, "lvalue");
+ CO clvalue(absl::in_place, "clvalue");
+ OC lvalue_c(absl::in_place, "lvalue_c");
+ EXPECT_EQ("lvalue", lvalue.value());
+ EXPECT_EQ("clvalue", clvalue.value());
+ EXPECT_EQ("lvalue_c", lvalue_c.value());
+ EXPECT_EQ("xvalue", O(absl::in_place, "xvalue").value());
+ EXPECT_EQ("xvalue_c", OC(absl::in_place, "xvalue_c").value());
+#ifndef ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG
+ EXPECT_EQ("cxvalue", CO(absl::in_place, "cxvalue").value());
+#endif
+ EXPECT_EQ("&", TypeQuals(lvalue.value()));
+ EXPECT_EQ("c&", TypeQuals(clvalue.value()));
+ EXPECT_EQ("c&", TypeQuals(lvalue_c.value()));
+ EXPECT_EQ("&&", TypeQuals(O(absl::in_place, "xvalue").value()));
+#if !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_MSVC_BUG) && \
+ !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG)
+ EXPECT_EQ("c&&", TypeQuals(CO(absl::in_place, "cxvalue").value()));
+#endif
+ EXPECT_EQ("c&&", TypeQuals(OC(absl::in_place, "xvalue_c").value()));
+
+ // test on volatile type
+ using OV = absl::optional<volatile int>;
+ OV lvalue_v(absl::in_place, 42);
+ EXPECT_EQ(42, lvalue_v.value());
+ EXPECT_EQ(42, OV(42).value());
+ EXPECT_TRUE((std::is_same<volatile int&, decltype(lvalue_v.value())>::value));
+ EXPECT_TRUE((std::is_same<volatile int&&, decltype(OV(42).value())>::value));
+
+ // test exception throw on value()
+ absl::optional<int> empty;
+#ifdef ABSL_HAVE_EXCEPTIONS
+ EXPECT_THROW(empty.value(), absl::bad_optional_access);
+#else
+ EXPECT_DEATH(empty.value(), "Bad optional access");
+#endif
+
+ // test constexpr value()
+ constexpr absl::optional<int> o1(1);
+ static_assert(1 == o1.value(), ""); // const &
+#if !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_MSVC_BUG) && \
+ !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG)
+ using COI = const absl::optional<int>;
+ static_assert(2 == COI(2).value(), ""); // const &&
+#endif
+}
+
+TEST(optionalTest, DerefOperator) {
+ using O = absl::optional<std::string>;
+ using CO = const absl::optional<std::string>;
+ using OC = absl::optional<const std::string>;
+ O lvalue(absl::in_place, "lvalue");
+ CO clvalue(absl::in_place, "clvalue");
+ OC lvalue_c(absl::in_place, "lvalue_c");
+ EXPECT_EQ("lvalue", *lvalue);
+ EXPECT_EQ("clvalue", *clvalue);
+ EXPECT_EQ("lvalue_c", *lvalue_c);
+ EXPECT_EQ("xvalue", *O(absl::in_place, "xvalue"));
+ EXPECT_EQ("xvalue_c", *OC(absl::in_place, "xvalue_c"));
+#ifndef ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG
+ EXPECT_EQ("cxvalue", *CO(absl::in_place, "cxvalue"));
+#endif
+ EXPECT_EQ("&", TypeQuals(*lvalue));
+ EXPECT_EQ("c&", TypeQuals(*clvalue));
+ EXPECT_EQ("&&", TypeQuals(*O(absl::in_place, "xvalue")));
+#if !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_MSVC_BUG) && \
+ !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG)
+ EXPECT_EQ("c&&", TypeQuals(*CO(absl::in_place, "cxvalue")));
+#endif
+ EXPECT_EQ("c&&", TypeQuals(*OC(absl::in_place, "xvalue_c")));
+
+ // test on volatile type
+ using OV = absl::optional<volatile int>;
+ OV lvalue_v(absl::in_place, 42);
+ EXPECT_EQ(42, *lvalue_v);
+ EXPECT_EQ(42, *OV(42));
+ EXPECT_TRUE((std::is_same<volatile int&, decltype(*lvalue_v)>::value));
+ EXPECT_TRUE((std::is_same<volatile int&&, decltype(*OV(42))>::value));
+
+ constexpr absl::optional<int> opt1(1);
+ static_assert(*opt1 == 1, "");
+#if !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_MSVC_BUG) && \
+ !defined(ABSL_SKIP_OVERLOAD_TEST_DUE_TO_GCC_BUG)
+ using COI = const absl::optional<int>;
+ static_assert(*COI(2) == 2, "");
+#endif
+}
+
+TEST(optionalTest, ValueOr) {
+ absl::optional<double> opt_empty, opt_set = 1.2;
+ EXPECT_EQ(42.0, opt_empty.value_or(42));
+ EXPECT_EQ(1.2, opt_set.value_or(42));
+ EXPECT_EQ(42.0, absl::optional<double>().value_or(42));
+ EXPECT_EQ(1.2, absl::optional<double>(1.2).value_or(42));
+
+ constexpr absl::optional<double> copt_empty, copt_set = {1.2};
+ static_assert(42.0 == copt_empty.value_or(42), "");
+ static_assert(1.2 == copt_set.value_or(42), "");
+#ifndef ABSL_SKIP_OVERLOAD_TEST_DUE_TO_MSVC_BUG
+ using COD = const absl::optional<double>;
+ static_assert(42.0 == COD().value_or(42), "");
+ static_assert(1.2 == COD(1.2).value_or(42), "");
+#endif
+}
+
+// make_optional cannot be constexpr until C++17
+TEST(optionalTest, make_optional) {
+ auto opt_int = absl::make_optional(42);
+ EXPECT_TRUE((std::is_same<decltype(opt_int), absl::optional<int>>::value));
+ EXPECT_EQ(42, opt_int);
+
+ StructorListener listener;
+ Listenable::listener = &listener;
+
+ absl::optional<Listenable> opt0 = absl::make_optional<Listenable>();
+ EXPECT_EQ(1, listener.construct0);
+ absl::optional<Listenable> opt1 = absl::make_optional<Listenable>(1);
+ EXPECT_EQ(1, listener.construct1);
+ absl::optional<Listenable> opt2 = absl::make_optional<Listenable>(1, 2);
+ EXPECT_EQ(1, listener.construct2);
+ absl::optional<Listenable> opt3 = absl::make_optional<Listenable>({1});
+ absl::optional<Listenable> opt4 = absl::make_optional<Listenable>({1, 2});
+ EXPECT_EQ(2, listener.listinit);
+
+ // Constexpr tests on trivially copyable types
+ // optional<T> has trivial copy/move ctors when T is trivially copyable.
+ // For nontrivial types with constexpr constructors, we need copy elision in
+ // C++17 for make_optional to be constexpr.
+ {
+ constexpr absl::optional<int> c_opt = absl::make_optional(42);
+ static_assert(c_opt.value() == 42, "");
+ }
+ {
+ struct TrivialCopyable {
+ constexpr TrivialCopyable() : x(0) {}
+ constexpr explicit TrivialCopyable(int i) : x(i) {}
+ int x;
+ };
+
+ constexpr TrivialCopyable v;
+ constexpr absl::optional<TrivialCopyable> c_opt0 = absl::make_optional(v);
+ static_assert((*c_opt0).x == 0, "");
+ constexpr absl::optional<TrivialCopyable> c_opt1 =
+ absl::make_optional<TrivialCopyable>();
+ static_assert((*c_opt1).x == 0, "");
+ constexpr absl::optional<TrivialCopyable> c_opt2 =
+ absl::make_optional<TrivialCopyable>(42);
+ static_assert((*c_opt2).x == 42, "");
+ }
+}
+
+template <typename T, typename U>
+void optionalTest_Comparisons_EXPECT_LESS(T x, U y) {
+ EXPECT_FALSE(x == y);
+ EXPECT_TRUE(x != y);
+ EXPECT_TRUE(x < y);
+ EXPECT_FALSE(x > y);
+ EXPECT_TRUE(x <= y);
+ EXPECT_FALSE(x >= y);
+}
+
+template <typename T, typename U>
+void optionalTest_Comparisons_EXPECT_SAME(T x, U y) {
+ EXPECT_TRUE(x == y);
+ EXPECT_FALSE(x != y);
+ EXPECT_FALSE(x < y);
+ EXPECT_FALSE(x > y);
+ EXPECT_TRUE(x <= y);
+ EXPECT_TRUE(x >= y);
+}
+
+template <typename T, typename U>
+void optionalTest_Comparisons_EXPECT_GREATER(T x, U y) {
+ EXPECT_FALSE(x == y);
+ EXPECT_TRUE(x != y);
+ EXPECT_FALSE(x < y);
+ EXPECT_TRUE(x > y);
+ EXPECT_FALSE(x <= y);
+ EXPECT_TRUE(x >= y);
+}
+
+
+template <typename T, typename U, typename V>
+void TestComparisons() {
+ absl::optional<T> ae, a2{2}, a4{4};
+ absl::optional<U> be, b2{2}, b4{4};
+ V v3 = 3;
+
+ // LHS: absl::nullopt, ae, a2, v3, a4
+ // RHS: absl::nullopt, be, b2, v3, b4
+
+ // optionalTest_Comparisons_EXPECT_NOT_TO_WORK(absl::nullopt,absl::nullopt);
+ optionalTest_Comparisons_EXPECT_SAME(absl::nullopt, be);
+ optionalTest_Comparisons_EXPECT_LESS(absl::nullopt, b2);
+ // optionalTest_Comparisons_EXPECT_NOT_TO_WORK(absl::nullopt,v3);
+ optionalTest_Comparisons_EXPECT_LESS(absl::nullopt, b4);
+
+ optionalTest_Comparisons_EXPECT_SAME(ae, absl::nullopt);
+ optionalTest_Comparisons_EXPECT_SAME(ae, be);
+ optionalTest_Comparisons_EXPECT_LESS(ae, b2);
+ optionalTest_Comparisons_EXPECT_LESS(ae, v3);
+ optionalTest_Comparisons_EXPECT_LESS(ae, b4);
+
+ optionalTest_Comparisons_EXPECT_GREATER(a2, absl::nullopt);
+ optionalTest_Comparisons_EXPECT_GREATER(a2, be);
+ optionalTest_Comparisons_EXPECT_SAME(a2, b2);
+ optionalTest_Comparisons_EXPECT_LESS(a2, v3);
+ optionalTest_Comparisons_EXPECT_LESS(a2, b4);
+
+ // optionalTest_Comparisons_EXPECT_NOT_TO_WORK(v3,absl::nullopt);
+ optionalTest_Comparisons_EXPECT_GREATER(v3, be);
+ optionalTest_Comparisons_EXPECT_GREATER(v3, b2);
+ optionalTest_Comparisons_EXPECT_SAME(v3, v3);
+ optionalTest_Comparisons_EXPECT_LESS(v3, b4);
+
+ optionalTest_Comparisons_EXPECT_GREATER(a4, absl::nullopt);
+ optionalTest_Comparisons_EXPECT_GREATER(a4, be);
+ optionalTest_Comparisons_EXPECT_GREATER(a4, b2);
+ optionalTest_Comparisons_EXPECT_GREATER(a4, v3);
+ optionalTest_Comparisons_EXPECT_SAME(a4, b4);
+}
+
+struct Int1 {
+ Int1() = default;
+ Int1(int i) : i(i) {} // NOLINT(runtime/explicit)
+ int i;
+};
+
+struct Int2 {
+ Int2() = default;
+ Int2(int i) : i(i) {} // NOLINT(runtime/explicit)
+ int i;
+};
+
+// comparison between Int1 and Int2
+constexpr bool operator==(const Int1& lhs, const Int2& rhs) {
+ return lhs.i == rhs.i;
+}
+constexpr bool operator!=(const Int1& lhs, const Int2& rhs) {
+ return !(lhs == rhs);
+}
+constexpr bool operator<(const Int1& lhs, const Int2& rhs) {
+ return lhs.i < rhs.i;
+}
+constexpr bool operator<=(const Int1& lhs, const Int2& rhs) {
+ return lhs < rhs || lhs == rhs;
+}
+constexpr bool operator>(const Int1& lhs, const Int2& rhs) {
+ return !(lhs <= rhs);
+}
+constexpr bool operator>=(const Int1& lhs, const Int2& rhs) {
+ return !(lhs < rhs);
+}
+
+TEST(optionalTest, Comparisons) {
+ TestComparisons<int, int, int>();
+ TestComparisons<const int, int, int>();
+ TestComparisons<Int1, int, int>();
+ TestComparisons<int, Int2, int>();
+ TestComparisons<Int1, Int2, int>();
+
+ // compare absl::optional<std::string> with const char*
+ absl::optional<std::string> opt_str = "abc";
+ const char* cstr = "abc";
+ EXPECT_TRUE(opt_str == cstr);
+ // compare absl::optional<std::string> with absl::optional<const char*>
+ absl::optional<const char*> opt_cstr = cstr;
+ EXPECT_TRUE(opt_str == opt_cstr);
+ // compare absl::optional<std::string> with absl::optional<absl::string_view>
+ absl::optional<absl::string_view> e1;
+ absl::optional<std::string> e2;
+ EXPECT_TRUE(e1 == e2);
+}
+
+
+TEST(optionalTest, SwapRegression) {
+ StructorListener listener;
+ Listenable::listener = &listener;
+
+ {
+ absl::optional<Listenable> a;
+ absl::optional<Listenable> b(absl::in_place);
+ a.swap(b);
+ }
+
+ EXPECT_EQ(1, listener.construct0);
+ EXPECT_EQ(1, listener.move);
+ EXPECT_EQ(2, listener.destruct);
+
+ {
+ absl::optional<Listenable> a(absl::in_place);
+ absl::optional<Listenable> b;
+ a.swap(b);
+ }
+
+ EXPECT_EQ(2, listener.construct0);
+ EXPECT_EQ(2, listener.move);
+ EXPECT_EQ(4, listener.destruct);
+}
+
+TEST(optionalTest, BigStringLeakCheck) {
+ constexpr size_t n = 1 << 16;
+
+ using OS = absl::optional<std::string>;
+
+ OS a;
+ OS b = absl::nullopt;
+ OS c = std::string(n, 'c');
+ std::string sd(n, 'd');
+ OS d = sd;
+ OS e(absl::in_place, n, 'e');
+ OS f;
+ f.emplace(n, 'f');
+
+ OS ca(a);
+ OS cb(b);
+ OS cc(c);
+ OS cd(d);
+ OS ce(e);
+
+ OS oa;
+ OS ob = absl::nullopt;
+ OS oc = std::string(n, 'c');
+ std::string sod(n, 'd');
+ OS od = sod;
+ OS oe(absl::in_place, n, 'e');
+ OS of;
+ of.emplace(n, 'f');
+
+ OS ma(std::move(oa));
+ OS mb(std::move(ob));
+ OS mc(std::move(oc));
+ OS md(std::move(od));
+ OS me(std::move(oe));
+ OS mf(std::move(of));
+
+ OS aa1;
+ OS ab1 = absl::nullopt;
+ OS ac1 = std::string(n, 'c');
+ std::string sad1(n, 'd');
+ OS ad1 = sad1;
+ OS ae1(absl::in_place, n, 'e');
+ OS af1;
+ af1.emplace(n, 'f');
+
+ OS aa2;
+ OS ab2 = absl::nullopt;
+ OS ac2 = std::string(n, 'c');
+ std::string sad2(n, 'd');
+ OS ad2 = sad2;
+ OS ae2(absl::in_place, n, 'e');
+ OS af2;
+ af2.emplace(n, 'f');
+
+ aa1 = af2;
+ ab1 = ae2;
+ ac1 = ad2;
+ ad1 = ac2;
+ ae1 = ab2;
+ af1 = aa2;
+
+ OS aa3;
+ OS ab3 = absl::nullopt;
+ OS ac3 = std::string(n, 'c');
+ std::string sad3(n, 'd');
+ OS ad3 = sad3;
+ OS ae3(absl::in_place, n, 'e');
+ OS af3;
+ af3.emplace(n, 'f');
+
+ aa3 = absl::nullopt;
+ ab3 = absl::nullopt;
+ ac3 = absl::nullopt;
+ ad3 = absl::nullopt;
+ ae3 = absl::nullopt;
+ af3 = absl::nullopt;
+
+ OS aa4;
+ OS ab4 = absl::nullopt;
+ OS ac4 = std::string(n, 'c');
+ std::string sad4(n, 'd');
+ OS ad4 = sad4;
+ OS ae4(absl::in_place, n, 'e');
+ OS af4;
+ af4.emplace(n, 'f');
+
+ aa4 = OS(absl::in_place, n, 'a');
+ ab4 = OS(absl::in_place, n, 'b');
+ ac4 = OS(absl::in_place, n, 'c');
+ ad4 = OS(absl::in_place, n, 'd');
+ ae4 = OS(absl::in_place, n, 'e');
+ af4 = OS(absl::in_place, n, 'f');
+
+ OS aa5;
+ OS ab5 = absl::nullopt;
+ OS ac5 = std::string(n, 'c');
+ std::string sad5(n, 'd');
+ OS ad5 = sad5;
+ OS ae5(absl::in_place, n, 'e');
+ OS af5;
+ af5.emplace(n, 'f');
+
+ std::string saa5(n, 'a');
+ std::string sab5(n, 'a');
+ std::string sac5(n, 'a');
+ std::string sad52(n, 'a');
+ std::string sae5(n, 'a');
+ std::string saf5(n, 'a');
+
+ aa5 = saa5;
+ ab5 = sab5;
+ ac5 = sac5;
+ ad5 = sad52;
+ ae5 = sae5;
+ af5 = saf5;
+
+ OS aa6;
+ OS ab6 = absl::nullopt;
+ OS ac6 = std::string(n, 'c');
+ std::string sad6(n, 'd');
+ OS ad6 = sad6;
+ OS ae6(absl::in_place, n, 'e');
+ OS af6;
+ af6.emplace(n, 'f');
+
+ aa6 = std::string(n, 'a');
+ ab6 = std::string(n, 'b');
+ ac6 = std::string(n, 'c');
+ ad6 = std::string(n, 'd');
+ ae6 = std::string(n, 'e');
+ af6 = std::string(n, 'f');
+
+ OS aa7;
+ OS ab7 = absl::nullopt;
+ OS ac7 = std::string(n, 'c');
+ std::string sad7(n, 'd');
+ OS ad7 = sad7;
+ OS ae7(absl::in_place, n, 'e');
+ OS af7;
+ af7.emplace(n, 'f');
+
+ aa7.emplace(n, 'A');
+ ab7.emplace(n, 'B');
+ ac7.emplace(n, 'C');
+ ad7.emplace(n, 'D');
+ ae7.emplace(n, 'E');
+ af7.emplace(n, 'F');
+}
+
+TEST(optionalTest, MoveAssignRegression) {
+ StructorListener listener;
+ Listenable::listener = &listener;
+
+ {
+ absl::optional<Listenable> a;
+ Listenable b;
+ a = std::move(b);
+ }
+
+ EXPECT_EQ(1, listener.construct0);
+ EXPECT_EQ(1, listener.move);
+ EXPECT_EQ(2, listener.destruct);
+}
+
+TEST(optionalTest, ValueType) {
+ EXPECT_TRUE((std::is_same<absl::optional<int>::value_type, int>::value));
+ EXPECT_TRUE(
+ (std::is_same<absl::optional<std::string>::value_type, std::string>::value));
+ EXPECT_FALSE(
+ (std::is_same<absl::optional<int>::value_type, absl::nullopt_t>::value));
+}
+
+template <typename T>
+struct is_hash_enabled_for {
+ template <typename U, typename = decltype(std::hash<U>()(std::declval<U>()))>
+ static std::true_type test(int);
+
+ template <typename U>
+ static std::false_type test(...);
+
+ static constexpr bool value = decltype(test<T>(0))::value;
+};
+
+TEST(optionalTest, Hash) {
+ std::hash<absl::optional<int>> hash;
+ std::set<size_t> hashcodes;
+ hashcodes.insert(hash(absl::nullopt));
+ for (int i = 0; i < 100; ++i) {
+ hashcodes.insert(hash(i));
+ }
+ EXPECT_GT(hashcodes.size(), 90);
+
+ static_assert(is_hash_enabled_for<absl::optional<int>>::value, "");
+ static_assert(is_hash_enabled_for<absl::optional<Hashable>>::value, "");
+
+#if defined(_MSC_VER) || (defined(_LIBCPP_VERSION) && \
+ _LIBCPP_VERSION < 4000 && _LIBCPP_STD_VER > 11)
+ // For MSVC and libc++ (< 4.0 and c++14), std::hash primary template has a
+ // static_assert to catch any user-defined type that doesn't provide a hash
+ // specialization. So instantiating std::hash<absl::optional<T>> will result
+ // in a hard error which is not SFINAE friendly.
+#define ABSL_STD_HASH_NOT_SFINAE_FRIENDLY 1
+#endif
+
+#ifndef ABSL_STD_HASH_NOT_SFINAE_FRIENDLY
+ static_assert(!is_hash_enabled_for<absl::optional<NonHashable>>::value, "");
+#endif
+
+ // libstdc++ std::optional is missing remove_const_t, i.e. it's using
+ // std::hash<T> rather than std::hash<std::remove_const_t<T>>.
+ // Reference: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=82262
+#ifndef __GLIBCXX__
+ static_assert(is_hash_enabled_for<absl::optional<const int>>::value, "");
+ static_assert(is_hash_enabled_for<absl::optional<const Hashable>>::value, "");
+ std::hash<absl::optional<const int>> c_hash;
+ for (int i = 0; i < 100; ++i) {
+ EXPECT_EQ(hash(i), c_hash(i));
+ }
+#endif
+}
+
+struct MoveMeNoThrow {
+ MoveMeNoThrow() : x(0) {}
+ [[noreturn]] MoveMeNoThrow(const MoveMeNoThrow& other) : x(other.x) {
+ ABSL_RAW_LOG(FATAL, "Should not be called.");
+ abort();
+ }
+ MoveMeNoThrow(MoveMeNoThrow&& other) noexcept : x(other.x) {}
+ int x;
+};
+
+struct MoveMeThrow {
+ MoveMeThrow() : x(0) {}
+ MoveMeThrow(const MoveMeThrow& other) : x(other.x) {}
+ MoveMeThrow(MoveMeThrow&& other) : x(other.x) {}
+ int x;
+};
+
+TEST(optionalTest, NoExcept) {
+ static_assert(
+ std::is_nothrow_move_constructible<absl::optional<MoveMeNoThrow>>::value,
+ "");
+#ifndef ABSL_HAVE_STD_OPTIONAL
+ static_assert(absl::default_allocator_is_nothrow::value ==
+ std::is_nothrow_move_constructible<
+ absl::optional<MoveMeThrow>>::value,
+ "");
+#endif
+ std::vector<absl::optional<MoveMeNoThrow>> v;
+ for (int i = 0; i < 10; ++i) v.emplace_back();
+}
+
+struct AnyLike {
+ AnyLike(AnyLike&&) = default;
+ AnyLike(const AnyLike&) = default;
+
+ template <typename ValueType,
+ typename T = typename std::decay<ValueType>::type,
+ typename std::enable_if<
+ !absl::disjunction<
+ std::is_same<AnyLike, T>,
+ absl::negation<std::is_copy_constructible<T>>>::value,
+ int>::type = 0>
+ AnyLike(ValueType&&) {} // NOLINT(runtime/explicit)
+
+ AnyLike& operator=(AnyLike&&) = default;
+ AnyLike& operator=(const AnyLike&) = default;
+
+ template <typename ValueType,
+ typename T = typename std::decay<ValueType>::type>
+ typename std::enable_if<
+ absl::conjunction<absl::negation<std::is_same<AnyLike, T>>,
+ std::is_copy_constructible<T>>::value,
+ AnyLike&>::type
+ operator=(ValueType&& /* rhs */) {
+ return *this;
+ }
+};
+
+TEST(optionalTest, ConstructionConstraints) {
+ EXPECT_TRUE((std::is_constructible<AnyLike, absl::optional<AnyLike>>::value));
+
+ EXPECT_TRUE(
+ (std::is_constructible<AnyLike, const absl::optional<AnyLike>&>::value));
+
+ EXPECT_TRUE((std::is_constructible<absl::optional<AnyLike>, AnyLike>::value));
+ EXPECT_TRUE(
+ (std::is_constructible<absl::optional<AnyLike>, const AnyLike&>::value));
+
+ EXPECT_TRUE((std::is_convertible<absl::optional<AnyLike>, AnyLike>::value));
+
+ EXPECT_TRUE(
+ (std::is_convertible<const absl::optional<AnyLike>&, AnyLike>::value));
+
+ EXPECT_TRUE((std::is_convertible<AnyLike, absl::optional<AnyLike>>::value));
+ EXPECT_TRUE(
+ (std::is_convertible<const AnyLike&, absl::optional<AnyLike>>::value));
+
+ EXPECT_TRUE(std::is_move_constructible<absl::optional<AnyLike>>::value);
+ EXPECT_TRUE(std::is_copy_constructible<absl::optional<AnyLike>>::value);
+}
+
+TEST(optionalTest, AssignmentConstraints) {
+ EXPECT_TRUE((std::is_assignable<AnyLike&, absl::optional<AnyLike>>::value));
+ EXPECT_TRUE(
+ (std::is_assignable<AnyLike&, const absl::optional<AnyLike>&>::value));
+ EXPECT_TRUE((std::is_assignable<absl::optional<AnyLike>&, AnyLike>::value));
+ EXPECT_TRUE(
+ (std::is_assignable<absl::optional<AnyLike>&, const AnyLike&>::value));
+ EXPECT_TRUE(std::is_move_assignable<absl::optional<AnyLike>>::value);
+ EXPECT_TRUE(std::is_copy_assignable<absl::optional<AnyLike>>::value);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/span.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/span.h b/libraries/ostrich/backend/3rdparty/abseil/absl/types/span.h
new file mode 100644
index 0000000..0ca30d1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/span.h
@@ -0,0 +1,748 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// span.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a `Span<T>` type for holding a view of an existing
+// array of data. The `Span` object, much like the `absl::string_view` object,
+// does not own such data itself. A span provides a lightweight way to pass
+// around view of such data.
+//
+// Additionally, this header file defines `MakeSpan()` and `MakeConstSpan()`
+// factory functions, for clearly creating spans of type `Span<T>` or read-only
+// `Span<const T>` when such types may be difficult to identify due to issues
+// with implicit conversion.
+//
+// The C++ standards committee currently has a proposal for a `std::span` type,
+// (http://wg21.link/p0122), which is not yet part of the standard (though may
+// become part of C++20). As of August 2017, the differences between
+// `absl::Span` and this proposal are:
+// * `absl::Span` uses `size_t` for `size_type`
+// * `absl::Span` has no `operator()`
+// * `absl::Span` has no constructors for `std::unique_ptr` or
+// `std::shared_ptr`
+// * `absl::Span` has the factory functions `MakeSpan()` and
+// `MakeConstSpan()`
+// * `absl::Span` has `front()` and `back()` methods
+// * bounds-checked access to `absl::Span` is accomplished with `at()`
+// * `absl::Span` has compiler-provided move and copy constructors and
+// assignment. This is due to them being specified as `constexpr`, but that
+// implies const in C++11.
+// * `absl::Span` has no `element_type` or `index_type` typedefs
+// * A read-only `absl::Span<const T>` can be implicitly constructed from an
+// initializer list.
+// * `absl::Span` has no `bytes()`, `size_bytes()`, `as_bytes()`, or
+// `as_mutable_bytes()` methods
+// * `absl::Span` has no static extent template parameter, nor constructors
+// which exist only because of the static extent parameter.
+// * `absl::Span` has an explicit mutable-reference constructor
+//
+// For more information, see the class comments below.
+#ifndef ABSL_TYPES_SPAN_H_
+#define ABSL_TYPES_SPAN_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/algorithm/algorithm.h"
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+
+template <typename T>
+class Span;
+
+namespace span_internal {
+// A constexpr min function
+constexpr size_t Min(size_t a, size_t b) noexcept { return a < b ? a : b; }
+
+// Wrappers for access to container data pointers.
+template <typename C>
+constexpr auto GetDataImpl(C& c, char) noexcept // NOLINT(runtime/references)
+ -> decltype(c.data()) {
+ return c.data();
+}
+
+// Before C++17, std::string::data returns a const char* in all cases.
+inline char* GetDataImpl(std::string& s, // NOLINT(runtime/references)
+ int) noexcept {
+ return &s[0];
+}
+
+template <typename C>
+constexpr auto GetData(C& c) noexcept // NOLINT(runtime/references)
+ -> decltype(GetDataImpl(c, 0)) {
+ return GetDataImpl(c, 0);
+}
+
+// Detection idioms for size() and data().
+template <typename C>
+using HasSize =
+ std::is_integral<absl::decay_t<decltype(std::declval<C&>().size())>>;
+
+// We want to enable conversion from vector<T*> to Span<const T* const> but
+// disable conversion from vector<Derived> to Span<Base>. Here we use
+// the fact that U** is convertible to Q* const* if and only if Q is the same
+// type or a more cv-qualified version of U. We also decay the result type of
+// data() to avoid problems with classes which have a member function data()
+// which returns a reference.
+template <typename T, typename C>
+using HasData =
+ std::is_convertible<absl::decay_t<decltype(GetData(std::declval<C&>()))>*,
+ T* const*>;
+
+// Extracts value type from a Container
+template <typename C>
+struct ElementType {
+ using type = typename absl::remove_reference_t<C>::value_type;
+};
+
+template <typename T, size_t N>
+struct ElementType<T (&)[N]> {
+ using type = T;
+};
+
+template <typename C>
+using ElementT = typename ElementType<C>::type;
+
+template <typename T>
+using EnableIfMutable =
+ typename std::enable_if<!std::is_const<T>::value, int>::type;
+
+template <typename T>
+bool EqualImpl(Span<T> a, Span<T> b) {
+ static_assert(std::is_const<T>::value, "");
+ return absl::equal(a.begin(), a.end(), b.begin(), b.end());
+}
+
+template <typename T>
+bool LessThanImpl(Span<T> a, Span<T> b) {
+ static_assert(std::is_const<T>::value, "");
+ return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
+}
+
+// The `IsConvertible` classes here are needed because of the
+// `std::is_convertible` bug in libcxx when compiled with GCC. This build
+// configuration is used by Android NDK toolchain. Reference link:
+// https://bugs.llvm.org/show_bug.cgi?id=27538.
+template <typename From, typename To>
+struct IsConvertibleHelper {
+ private:
+ static std::true_type testval(To);
+ static std::false_type testval(...);
+
+ public:
+ using type = decltype(testval(std::declval<From>()));
+};
+
+template <typename From, typename To>
+struct IsConvertible : IsConvertibleHelper<From, To>::type {};
+
+// TODO(zhangxy): replace `IsConvertible` with `std::is_convertible` once the
+// older version of libcxx is not supported.
+template <typename From, typename To>
+using EnableIfConvertibleToSpanConst =
+ typename std::enable_if<IsConvertible<From, Span<const To>>::value>::type;
+} // namespace span_internal
+
+//------------------------------------------------------------------------------
+// Span
+//------------------------------------------------------------------------------
+//
+// A `Span` is an "array view" type for holding a view of a contiguous data
+// array; the `Span` object does not and cannot own such data itself. A span
+// provides an easy way to provide overloads for anything operating on
+// contiguous sequences without needing to manage pointers and array lengths
+// manually.
+
+// A span is conceptually a pointer (ptr) and a length (size) into an already
+// existing array of contiguous memory; the array it represents references the
+// elements "ptr[0] .. ptr[size-1]". Passing a properly-constructed `Span`
+// instead of raw pointers avoids many issues related to index out of bounds
+// errors.
+//
+// Spans may also be constructed from containers holding contiguous sequences.
+// Such containers must supply `data()` and `size() const` methods (e.g
+// `std::vector<T>`, `absl::InlinedVector<T, N>`). All implicit conversions to
+// `absl::Span` from such containers will create spans of type `const T`;
+// spans which can mutate their values (of type `T`) must use explicit
+// constructors.
+//
+// A `Span<T>` is somewhat analogous to an `absl::string_view`, but for an array
+// of elements of type `T`. A user of `Span` must ensure that the data being
+// pointed to outlives the `Span` itself.
+//
+// You can construct a `Span<T>` in several ways:
+//
+// * Explicitly from a reference to a container type
+// * Explicitly from a pointer and size
+// * Implicitly from a container type (but only for spans of type `const T`)
+// * Using the `MakeSpan()` or `MakeConstSpan()` factory functions.
+//
+// Examples:
+//
+// // Construct a Span explicitly from a container:
+// std::vector<int> v = {1, 2, 3, 4, 5};
+// auto span = absl::Span<const int>(v);
+//
+// // Construct a Span explicitly from a C-style array:
+// int a[5] = {1, 2, 3, 4, 5};
+// auto span = absl::Span<const int>(a);
+//
+// // Construct a Span implicitly from a container
+// void MyRoutine(absl::Span<const int> a) {
+// ...
+// }
+// std::vector v = {1,2,3,4,5};
+// MyRoutine(v) // convert to Span<const T>
+//
+// Note that `Span` objects, in addition to requiring that the memory they
+// point to remains alive, must also ensure that such memory does not get
+// reallocated. Therefore, to avoid undefined behavior, containers with
+// associated span views should not invoke operations that may reallocate memory
+// (such as resizing) or invalidate iterators into the container.
+//
+// One common use for a `Span` is when passing arguments to a routine that can
+// accept a variety of array types (e.g. a `std::vector`, `absl::InlinedVector`,
+// a C-style array, etc.). Instead of creating overloads for each case, you
+// can simply specify a `Span` as the argument to such a routine.
+//
+// Example:
+//
+// void MyRoutine(absl::Span<const int> a) {
+// ...
+// }
+//
+// std::vector v = {1,2,3,4,5};
+// MyRoutine(v);
+//
+// absl::InlinedVector<int, 4> my_inline_vector;
+// MyRoutine(my_inline_vector);
+//
+// // Explicit constructor from pointer,size
+// int* my_array = new int[10];
+// MyRoutine(absl::Span<const int>(my_array, 10));
+template <typename T>
+class Span {
+ private:
+ // Used to determine whether a Span can be constructed from a container of
+ // type C.
+ template <typename C>
+ using EnableIfConvertibleFrom =
+ typename std::enable_if<span_internal::HasData<T, C>::value &&
+ span_internal::HasSize<C>::value>::type;
+
+ // Used to SFINAE-enable a function when the slice elements are const.
+ template <typename U>
+ using EnableIfConstView =
+ typename std::enable_if<std::is_const<T>::value, U>::type;
+
+ // Used to SFINAE-enable a function when the slice elements are mutable.
+ template <typename U>
+ using EnableIfMutableView =
+ typename std::enable_if<!std::is_const<T>::value, U>::type;
+
+ public:
+ using value_type = absl::remove_cv_t<T>;
+ using pointer = T*;
+ using const_pointer = const T*;
+ using reference = T&;
+ using const_reference = const T&;
+ using iterator = pointer;
+ using const_iterator = const_pointer;
+ using reverse_iterator = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+ using size_type = size_t;
+ using difference_type = ptrdiff_t;
+
+ static const size_type npos = ~size_type{0};
+
+ constexpr Span() noexcept : Span(nullptr, 0) {}
+ constexpr Span(pointer array, size_type length) noexcept
+ : ptr_(array), len_(length) {}
+
+ // Implicit conversion constructors
+ template <size_t N>
+ constexpr Span(T (&a)[N]) noexcept // NOLINT(runtime/explicit)
+ : Span(a, N) {}
+
+ // Explicit reference constructor for a mutable `Span<T>` type
+ template <typename V, typename = EnableIfConvertibleFrom<V>,
+ typename = EnableIfMutableView<V>>
+ explicit Span(V& v) noexcept // NOLINT(runtime/references)
+ : Span(span_internal::GetData(v), v.size()) {}
+
+ // Implicit reference constructor for a read-only `Span<const T>` type
+ template <typename V, typename = EnableIfConvertibleFrom<V>,
+ typename = EnableIfConstView<V>>
+ constexpr Span(const V& v) noexcept // NOLINT(runtime/explicit)
+ : Span(span_internal::GetData(v), v.size()) {}
+
+ // Implicit constructor from an initializer list, making it possible to pass a
+ // brace-enclosed initializer list to a function expecting a `Span`. Such
+ // spans constructed from an initializer list must be of type `Span<const T>`.
+ //
+ // void Process(absl::Span<const int> x);
+ // Process({1, 2, 3});
+ //
+ // Note that as always the array referenced by the span must outlive the span.
+ // Since an initializer list constructor acts as if it is fed a temporary
+ // array (cf. C++ standard [dcl.init.list]/5), it's safe to use this
+ // constructor only when the `std::initializer_list` itself outlives the span.
+ // In order to meet this requirement it's sufficient to ensure that neither
+ // the span nor a copy of it is used outside of the expression in which it's
+ // created:
+ //
+ // // Assume that this function uses the array directly, not retaining any
+ // // copy of the span or pointer to any of its elements.
+ // void Process(absl::Span<const int> ints);
+ //
+ // // Okay: the std::initializer_list<int> will reference a temporary array
+ // // that isn't destroyed until after the call to Process returns.
+ // Process({ 17, 19 });
+ //
+ // // Not okay: the storage used by the std::initializer_list<int> is not
+ // // allowed to be referenced after the first line.
+ // absl::Span<const int> ints = { 17, 19 };
+ // Process(ints);
+ //
+ // // Not okay for the same reason as above: even when the elements of the
+ // // initializer list expression are not temporaries the underlying array
+ // // is, so the initializer list must still outlive the span.
+ // const int foo = 17;
+ // absl::Span<const int> ints = { foo };
+ // Process(ints);
+ //
+ template <typename LazyT = T,
+ typename = EnableIfConstView<LazyT>>
+ Span(
+ std::initializer_list<value_type> v) noexcept // NOLINT(runtime/explicit)
+ : Span(v.begin(), v.size()) {}
+
+ // Accessors
+
+ // Span::data()
+ //
+ // Returns a pointer to the span's underlying array of data (which is held
+ // outside the span).
+ constexpr pointer data() const noexcept { return ptr_; }
+
+ // Span::size()
+ //
+ // Returns the size of this span.
+ constexpr size_type size() const noexcept { return len_; }
+
+ // Span::length()
+ //
+ // Returns the length (size) of this span.
+ constexpr size_type length() const noexcept { return size(); }
+
+ // Span::empty()
+ //
+ // Returns a boolean indicating whether or not this span is considered empty.
+ constexpr bool empty() const noexcept { return size() == 0; }
+
+ // Span::operator[]
+ //
+ // Returns a reference to the i'th element of this span.
+ constexpr reference operator[](size_type i) const noexcept {
+ // MSVC 2015 accepts this as constexpr, but not ptr_[i]
+ return *(data() + i);
+ }
+
+ // Span::at()
+ //
+ // Returns a reference to the i'th element of this span.
+ constexpr reference at(size_type i) const {
+ return ABSL_PREDICT_TRUE(i < size())
+ ? ptr_[i]
+ : (base_internal::ThrowStdOutOfRange(
+ "Span::at failed bounds check"),
+ ptr_[i]);
+ }
+
+ // Span::front()
+ //
+ // Returns a reference to the first element of this span.
+ reference front() const noexcept { return ABSL_ASSERT(size() > 0), ptr_[0]; }
+
+ // Span::back()
+ //
+ // Returns a reference to the last element of this span.
+ reference back() const noexcept {
+ return ABSL_ASSERT(size() > 0), ptr_[size() - 1];
+ }
+
+ // Span::begin()
+ //
+ // Returns an iterator to the first element of this span.
+ constexpr iterator begin() const noexcept { return ptr_; }
+
+ // Span::cbegin()
+ //
+ // Returns a const iterator to the first element of this span.
+ constexpr const_iterator cbegin() const noexcept { return ptr_; }
+
+ // Span::end()
+ //
+ // Returns an iterator to the last element of this span.
+ iterator end() const noexcept { return ptr_ + len_; }
+
+ // Span::cend()
+ //
+ // Returns a const iterator to the last element of this span.
+ const_iterator cend() const noexcept { return end(); }
+
+ // Span::rbegin()
+ //
+ // Returns a reverse iterator starting at the last element of this span.
+ reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
+
+ // Span::crbegin()
+ //
+ // Returns a reverse const iterator starting at the last element of this span.
+ const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+
+ // Span::rend()
+ //
+ // Returns a reverse iterator starting at the first element of this span.
+ reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
+
+ // Span::crend()
+ //
+ // Returns a reverse iterator starting at the first element of this span.
+ const_reverse_iterator crend() const noexcept { return rend(); }
+
+ // Span mutations
+
+ // Span::remove_prefix()
+ //
+ // Removes the first `n` elements from the span.
+ void remove_prefix(size_type n) noexcept {
+ assert(len_ >= n);
+ ptr_ += n;
+ len_ -= n;
+ }
+
+ // Span::remove_suffix()
+ //
+ // Removes the last `n` elements from the span.
+ void remove_suffix(size_type n) noexcept {
+ assert(len_ >= n);
+ len_ -= n;
+ }
+
+ // Span::subspan()
+ //
+ // Returns a `Span` starting at element `pos` and of length `len`. Both `pos`
+ // and `len` are of type `size_type` and thus non-negative. Parameter `pos`
+ // must be <= size(). Any `len` value that points past the end of the span
+ // will be trimmed to at most size() - `pos`. A default `len` value of `npos`
+ // ensures the returned subspan continues until the end of the span.
+ //
+ // Examples:
+ //
+ // std::vector<int> vec = {10, 11, 12, 13};
+ // absl::MakeSpan(vec).subspan(1, 2); // {11, 12}
+ // absl::MakeSpan(vec).subspan(2, 8); // {12, 13}
+ // absl::MakeSpan(vec).subspan(1); // {11, 12, 13}
+ // absl::MakeSpan(vec).subspan(4); // {}
+ // absl::MakeSpan(vec).subspan(5); // throws std::out_of_range
+ constexpr Span subspan(size_type pos = 0, size_type len = npos) const {
+ return (pos <= len_)
+ ? Span(ptr_ + pos, span_internal::Min(len_ - pos, len))
+ : (base_internal::ThrowStdOutOfRange("pos > size()"), Span());
+ }
+
+ private:
+ pointer ptr_;
+ size_type len_;
+};
+
+template <typename T>
+const typename Span<T>::size_type Span<T>::npos;
+
+// Span relationals
+
+// Equality is compared element-by-element, while ordering is lexicographical.
+// We provide three overloads for each operator to cover any combination on the
+// left or right hand side of mutable Span<T>, read-only Span<const T>, and
+// convertible-to-read-only Span<T>.
+// TODO(zhangxy): Due to MSVC overload resolution bug with partial ordering
+// template functions, 5 overloads per operator is needed as a workaround. We
+// should update them to 3 overloads per operator using non-deduced context like
+// string_view, i.e.
+// - (Span<T>, Span<T>)
+// - (Span<T>, non_deduced<Span<const T>>)
+// - (non_deduced<Span<const T>>, Span<T>)
+
+// operator==
+template <typename T>
+bool operator==(Span<T> a, Span<T> b) {
+ return span_internal::EqualImpl<const T>(a, b);
+}
+template <typename T>
+bool operator==(Span<const T> a, Span<T> b) {
+ return span_internal::EqualImpl<const T>(a, b);
+}
+template <typename T>
+bool operator==(Span<T> a, Span<const T> b) {
+ return span_internal::EqualImpl<const T>(a, b);
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator==(const U& a, Span<T> b) {
+ return span_internal::EqualImpl<const T>(a, b);
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator==(Span<T> a, const U& b) {
+ return span_internal::EqualImpl<const T>(a, b);
+}
+
+// operator!=
+template <typename T>
+bool operator!=(Span<T> a, Span<T> b) {
+ return !(a == b);
+}
+template <typename T>
+bool operator!=(Span<const T> a, Span<T> b) {
+ return !(a == b);
+}
+template <typename T>
+bool operator!=(Span<T> a, Span<const T> b) {
+ return !(a == b);
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator!=(const U& a, Span<T> b) {
+ return !(a == b);
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator!=(Span<T> a, const U& b) {
+ return !(a == b);
+}
+
+// operator<
+template <typename T>
+bool operator<(Span<T> a, Span<T> b) {
+ return span_internal::LessThanImpl<const T>(a, b);
+}
+template <typename T>
+bool operator<(Span<const T> a, Span<T> b) {
+ return span_internal::LessThanImpl<const T>(a, b);
+}
+template <typename T>
+bool operator<(Span<T> a, Span<const T> b) {
+ return span_internal::LessThanImpl<const T>(a, b);
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<(const U& a, Span<T> b) {
+ return span_internal::LessThanImpl<const T>(a, b);
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<(Span<T> a, const U& b) {
+ return span_internal::LessThanImpl<const T>(a, b);
+}
+
+// operator>
+template <typename T>
+bool operator>(Span<T> a, Span<T> b) {
+ return b < a;
+}
+template <typename T>
+bool operator>(Span<const T> a, Span<T> b) {
+ return b < a;
+}
+template <typename T>
+bool operator>(Span<T> a, Span<const T> b) {
+ return b < a;
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>(const U& a, Span<T> b) {
+ return b < a;
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>(Span<T> a, const U& b) {
+ return b < a;
+}
+
+// operator<=
+template <typename T>
+bool operator<=(Span<T> a, Span<T> b) {
+ return !(b < a);
+}
+template <typename T>
+bool operator<=(Span<const T> a, Span<T> b) {
+ return !(b < a);
+}
+template <typename T>
+bool operator<=(Span<T> a, Span<const T> b) {
+ return !(b < a);
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<=(const U& a, Span<T> b) {
+ return !(b < a);
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator<=(Span<T> a, const U& b) {
+ return !(b < a);
+}
+
+// operator>=
+template <typename T>
+bool operator>=(Span<T> a, Span<T> b) {
+ return !(a < b);
+}
+template <typename T>
+bool operator>=(Span<const T> a, Span<T> b) {
+ return !(a < b);
+}
+template <typename T>
+bool operator>=(Span<T> a, Span<const T> b) {
+ return !(a < b);
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>=(const U& a, Span<T> b) {
+ return !(a < b);
+}
+template <typename T, typename U,
+ typename = span_internal::EnableIfConvertibleToSpanConst<U, T>>
+bool operator>=(Span<T> a, const U& b) {
+ return !(a < b);
+}
+
+// MakeSpan()
+//
+// Constructs a mutable `Span<T>`, deducing `T` automatically from either a
+// container or pointer+size.
+//
+// Because a read-only `Span<const T>` is implicitly constructed from container
+// types regardless of whether the container itself is a const container,
+// constructing mutable spans of type `Span<T>` from containers requires
+// explicit constructors. The container-accepting version of `MakeSpan()`
+// deduces the type of `T` by the constness of the pointer received from the
+// container's `data()` member. Similarly, the pointer-accepting version returns
+// a `Span<const T>` if `T` is `const`, and a `Span<T>` otherwise.
+//
+// Examples:
+//
+// void MyRoutine(absl::Span<MyComplicatedType> a) {
+// ...
+// };
+// // my_vector is a container of non-const types
+// std::vector<MyComplicatedType> my_vector;
+//
+// // Constructing a Span implicitly attempts to create a Span of type
+// // `Span<const T>`
+// MyRoutine(my_vector); // error, type mismatch
+//
+// // Explicitly constructing the Span is verbose
+// MyRoutine(absl::Span<MyComplicatedType>(my_vector));
+//
+// // Use MakeSpan() to make an absl::Span<T>
+// MyRoutine(absl::MakeSpan(my_vector));
+//
+// // Construct a span from an array ptr+size
+// absl::Span<T> my_span() {
+// return absl::MakeSpan(&array[0], num_elements_);
+// }
+//
+template <int&... ExplicitArgumentBarrier, typename T>
+constexpr Span<T> MakeSpan(T* ptr, size_t size) noexcept {
+ return Span<T>(ptr, size);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T>
+Span<T> MakeSpan(T* begin, T* end) noexcept {
+ return ABSL_ASSERT(begin <= end), Span<T>(begin, end - begin);
+}
+
+template <int&... ExplicitArgumentBarrier, typename C>
+constexpr auto MakeSpan(C& c) noexcept // NOLINT(runtime/references)
+ -> decltype(absl::MakeSpan(span_internal::GetData(c), c.size())) {
+ return MakeSpan(span_internal::GetData(c), c.size());
+}
+
+template <int&... ExplicitArgumentBarrier, typename T, size_t N>
+constexpr Span<T> MakeSpan(T (&array)[N]) noexcept {
+ return Span<T>(array, N);
+}
+
+// MakeConstSpan()
+//
+// Constructs a `Span<const T>` as with `MakeSpan`, deducing `T` automatically,
+// but always returning a `Span<const T>`.
+//
+// Examples:
+//
+// void ProcessInts(absl::Span<const int> some_ints);
+//
+// // Call with a pointer and size.
+// int array[3] = { 0, 0, 0 };
+// ProcessInts(absl::MakeConstSpan(&array[0], 3));
+//
+// // Call with a [begin, end) pair.
+// ProcessInts(absl::MakeConstSpan(&array[0], &array[3]));
+//
+// // Call directly with an array.
+// ProcessInts(absl::MakeConstSpan(array));
+//
+// // Call with a contiguous container.
+// std::vector<int> some_ints = ...;
+// ProcessInts(absl::MakeConstSpan(some_ints));
+// ProcessInts(absl::MakeConstSpan(std::vector<int>{ 0, 0, 0 }));
+//
+template <int&... ExplicitArgumentBarrier, typename T>
+constexpr Span<const T> MakeConstSpan(T* ptr, size_t size) noexcept {
+ return Span<const T>(ptr, size);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T>
+Span<const T> MakeConstSpan(T* begin, T* end) noexcept {
+ return ABSL_ASSERT(begin <= end), Span<const T>(begin, end - begin);
+}
+
+template <int&... ExplicitArgumentBarrier, typename C>
+constexpr auto MakeConstSpan(const C& c) noexcept -> decltype(MakeSpan(c)) {
+ return MakeSpan(c);
+}
+
+template <int&... ExplicitArgumentBarrier, typename T, size_t N>
+constexpr Span<const T> MakeConstSpan(const T (&array)[N]) noexcept {
+ return Span<const T>(array, N);
+}
+} // namespace absl
+#endif // ABSL_TYPES_SPAN_H_
[60/62] [abbrv] marmotta git commit: Merge tag '3.4.0'
Posted by ja...@apache.org.
Merge tag '3.4.0'
[maven-release-plugin] copy for tag 3.4.0
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/28c9b8b0
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/28c9b8b0
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/28c9b8b0
Branch: refs/heads/master
Commit: 28c9b8b0791ea1693578af302981a1358e56933d
Parents: 6a10c48 b0e5b93
Author: Jakob Frank <ja...@apache.org>
Authored: Mon Jun 18 20:31:12 2018 +0200
Committer: Jakob Frank <ja...@apache.org>
Committed: Mon Jun 18 20:31:12 2018 +0200
----------------------------------------------------------------------
.dockerignore | 2 +
.github/PULL_REQUEST_TEMPLATE.md | 12 +
.travis.yml | 35 +
Dockerfile | 98 +
KEYS | 250 +-
LICENSE.txt | 100 +-
NOTICE.txt | 17 +-
README.md | 132 +
README.txt | 119 -
.../marmotta-archetype-module/pom.xml | 2 +-
.../main/java/exceptions/DoThisException.java | 2 +-
.../marmotta-archetype-webapp/pom.xml | 2 +-
.../src/main/webapp/WEB-INF/web.xml | 2 +-
.../src/test/resources/test-config.properties | 2 +-
build/archetypes/pom.xml | 2 +-
build/checkstyle-resources/pom.xml | 2 +-
build/dependency-resource-supplement/pom.xml | 2 +-
build/plugins/buildinfo-maven-plugin/pom.xml | 2 +-
.../plugins/buildinfo/AbstractInfoProvider.java | 2 +-
.../maven/plugins/buildinfo/BuildInfoMojo.java | 2 +-
.../plugins/buildinfo/GitInfoProvider.java | 2 +-
.../maven/plugins/buildinfo/InfoProvider.java | 2 +-
.../buildinfo/MercurialInfoProvider.java | 2 +-
.../plugins/buildinfo/ProjectInfoProvider.java | 2 +-
build/plugins/marmotta-maven-plugin/pom.xml | 2 +-
build/plugins/pom.xml | 17 +-
build/plugins/refpack-maven-plugin/pom.xml | 31 +-
.../maven/plugins/refpack/RefPackMojo.java | 26 +-
build/plugins/repocheck-maven-plugin/pom.xml | 8 +-
.../plugins/repochecker/LogMatrixPrinter.java | 2 +-
.../plugins/repochecker/MatrixPrinter.java | 12 +-
.../repochecker/RepositoryCheckerMojo.java | 2 +-
.../repochecker/SilentMatrixPrinter.java | 2 +-
build/pom.xml | 2 +-
client/marmotta-client-java/pom.xml | 11 +-
.../marmotta/client/ClientConfiguration.java | 2 +-
.../apache/marmotta/client/MarmottaClient.java | 2 +-
.../client/clients/ConfigurationClient.java | 2 +-
.../marmotta/client/clients/ContextClient.java | 2 +-
.../marmotta/client/clients/ImportClient.java | 2 +-
.../marmotta/client/clients/LDPathClient.java | 2 +-
.../marmotta/client/clients/ResourceClient.java | 2 +-
.../marmotta/client/clients/SPARQLClient.java | 2 +-
.../exception/ContentFormatException.java | 2 +-
.../exception/MarmottaClientException.java | 2 +-
.../client/exception/NotFoundException.java | 2 +-
.../client/exception/ParseException.java | 2 +-
.../model/classification/Classification.java | 2 +-
.../client/model/config/Configuration.java | 2 +-
.../client/model/content/ByteContent.java | 2 +-
.../marmotta/client/model/content/Content.java | 2 +-
.../client/model/content/StreamContent.java | 2 +-
.../client/model/content/StringContent.java | 2 +-
.../marmotta/client/model/meta/Metadata.java | 2 +-
.../apache/marmotta/client/model/rdf/BNode.java | 5 +-
.../marmotta/client/model/rdf/Literal.java | 5 +-
.../marmotta/client/model/rdf/RDFNode.java | 2 +-
.../apache/marmotta/client/model/rdf/URI.java | 5 +-
.../client/model/sparql/SPARQLResult.java | 2 +-
.../marmotta/client/util/CollectionUtils.java | 11 +-
.../apache/marmotta/client/util/HTTPUtil.java | 7 +-
.../apache/marmotta/client/util/MetaUtil.java | 2 +-
.../marmotta/client/util/RDFJSONParser.java | 2 +-
.../marmotta/client/test/AbstractClientIT.java | 2 +-
.../client/test/config/ConfigurationIT.java | 2 +-
.../marmotta/client/test/io/ImportIT.java | 2 +-
.../marmotta/client/test/ldpath/LDPathIT.java | 2 +-
.../marmotta/client/test/sparql/SPARQLIT.java | 2 +-
client/marmotta-client-js-sample-webapp/pom.xml | 2 +-
client/marmotta-client-js/pom.xml | 2 +-
.../marmotta-client-js/src/main/js/marmotta.js | 34 +
client/marmotta-client-php/pom.xml | 2 +-
client/pom.xml | 4 +-
commons/marmotta-commons/pom.xml | 3 +-
.../src/ext/java/javolution/lang/Immutable.java | 2 +-
.../src/ext/java/javolution/lang/Realtime.java | 2 +-
.../src/ext/java/javolution/lang/ValueType.java | 2 +-
.../java/javolution/util/FastCollection.java | 2 +-
.../src/ext/java/javolution/util/FastSet.java | 2 +-
.../ext/java/javolution/util/FastSortedSet.java | 2 +-
.../java/javolution/util/FastSortedTable.java | 2 +-
.../src/ext/java/javolution/util/FastTable.java | 2 +-
.../java/javolution/util/function/Consumer.java | 2 +-
.../javolution/util/function/Equalities.java | 2 +-
.../java/javolution/util/function/Function.java | 2 +-
.../javolution/util/function/Iteration.java | 6 +-
.../javolution/util/function/MultiVariable.java | 2 +-
.../javolution/util/function/Predicate.java | 2 +-
.../java/javolution/util/function/Reducer.java | 2 +-
.../java/javolution/util/function/Reducers.java | 2 +-
.../javolution/util/function/Splittable.java | 2 +-
.../java/javolution/util/function/Supplier.java | 2 +-
.../collection/AtomicCollectionImpl.java | 16 +-
.../internal/collection/CollectionView.java | 3 +-
.../util/internal/map/AtomicMapImpl.java | 20 +-
.../util/internal/table/AtomicTableImpl.java | 28 +-
.../util/internal/table/FractalTableImpl.java | 2 +-
.../util/internal/table/SharedTableImpl.java | 2 +-
.../table/sorted/AtomicSortedTableImpl.java | 2 +-
.../table/sorted/SharedSortedTableImpl.java | 2 +-
.../util/service/CollectionService.java | 2 +-
.../javolution/util/service/MapService.java | 2 +-
.../util/service/SortedTableService.java | 2 +-
.../marmotta/commons/http/ContentType.java | 2 +-
.../marmotta/commons/http/ETagGenerator.java | 2 +-
.../commons/http/MarmottaHttpUtils.java | 28 +-
.../apache/marmotta/commons/http/UriUtil.java | 31 +-
.../commons/nio/watch/AbstractTreeWatcher.java | 20 +-
.../commons/sesame/model/BNodeCommons.java | 2 +-
.../commons/sesame/model/LiteralKey.java | 3 +-
.../commons/sesame/model/Namespaces.java | 7 +-
.../commons/sesame/model/URICommons.java | 2 +-
.../sesame/repository/ExceptionUtils.java | 2 +-
.../sesame/repository/ResourceConnection.java | 2 +-
.../sesame/repository/ResourceUtils.java | 5 +-
.../commons/sesame/repository/ResultUtils.java | 2 +-
.../apache/marmotta/commons/util/DateUtils.java | 2 +-
.../apache/marmotta/commons/util/JSONUtils.java | 2 +-
.../src/main/resources/META-INF/NOTICE | 2 +-
.../commons/http/ContentTypeMatchingTest.java | 2 +-
.../commons/http/ETagGeneratorTest.java | 2 +-
.../commons/http/MarmottaHttpUtilsTest.java | 29 +-
.../marmotta/commons/http/UriUtilTest.java | 2 +-
.../sesame/model/LiteralCommonsTest.java | 2 +-
.../commons/sesame/model/ResourceUtilsTest.java | 2 +-
.../commons/sesame/model/URICommonsTest.java | 2 +-
.../marmotta/commons/util/DateUtilsTest.java | 2 +-
.../marmotta-model-vocabs/pom.xml | 18 +-
.../marmotta-rio-api/pom.xml | 2 +-
.../commons/sesame/rio/ical/ICalFormat.java | 3 +-
.../commons/sesame/rio/rss/RSSFormat.java | 3 +-
.../commons/sesame/rio/vcard/VCardFormat.java | 3 +-
.../marmotta-rio-ical/pom.xml | 2 +-
.../commons/sesame/rio/ical/ICalParser.java | 36 +-
.../sesame/rio/ical/ICalParserFactory.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../marmotta-rio-rss/pom.xml | 2 +-
.../java/com/sun/syndication/feed/CopyFrom.java | 4 +-
.../java/com/sun/syndication/feed/WireFeed.java | 8 +-
.../com/sun/syndication/feed/atom/Content.java | 2 +-
.../com/sun/syndication/feed/atom/Entry.java | 12 +-
.../com/sun/syndication/feed/atom/Feed.java | 10 +-
.../syndication/feed/impl/BeanIntrospector.java | 54 +-
.../syndication/feed/impl/CloneableBean.java | 32 +-
.../syndication/feed/impl/CopyFromHelper.java | 39 +-
.../sun/syndication/feed/impl/ToStringBean.java | 20 +-
.../sun/syndication/feed/module/DCSubject.java | 2 +-
.../sun/syndication/feed/module/Extendable.java | 2 +-
.../com/sun/syndication/feed/module/Module.java | 3 +-
.../sun/syndication/feed/module/SyModule.java | 12 +-
.../syndication/feed/module/SyModuleImpl.java | 2 +-
.../feed/module/impl/ModuleUtils.java | 2 +-
.../com/sun/syndication/feed/rss/Channel.java | 23 +-
.../java/com/sun/syndication/feed/rss/Item.java | 10 +-
.../sun/syndication/feed/synd/Converter.java | 7 +-
.../sun/syndication/feed/synd/SyndCategory.java | 2 +-
.../syndication/feed/synd/SyndCategoryImpl.java | 12 +-
.../sun/syndication/feed/synd/SyndContent.java | 2 +-
.../syndication/feed/synd/SyndEnclosure.java | 12 +-
.../sun/syndication/feed/synd/SyndEntry.java | 20 +-
.../syndication/feed/synd/SyndEntryImpl.java | 12 +-
.../com/sun/syndication/feed/synd/SyndFeed.java | 14 +-
.../sun/syndication/feed/synd/SyndImage.java | 2 +-
.../com/sun/syndication/feed/synd/SyndLink.java | 34 +-
.../sun/syndication/feed/synd/SyndPerson.java | 14 +-
.../feed/synd/impl/ConverterForAtom03.java | 66 +-
.../feed/synd/impl/ConverterForAtom10.java | 83 +-
.../feed/synd/impl/ConverterForRSS090.java | 8 +-
.../feed/synd/impl/ConverterForRSS092.java | 30 +-
.../com/sun/syndication/io/ModuleGenerator.java | 7 +-
.../com/sun/syndication/io/ModuleParser.java | 4 +-
.../sun/syndication/io/WireFeedGenerator.java | 5 +-
.../com/sun/syndication/io/WireFeedInput.java | 48 +-
.../com/sun/syndication/io/WireFeedParser.java | 7 +-
.../syndication/io/impl/Atom03Generator.java | 47 +-
.../sun/syndication/io/impl/Atom03Parser.java | 63 +-
.../syndication/io/impl/Atom10Generator.java | 69 +-
.../sun/syndication/io/impl/Atom10Parser.java | 72 +-
.../com/sun/syndication/io/impl/Base64.java | 6 +-
.../io/impl/BaseWireFeedGenerator.java | 12 +-
.../syndication/io/impl/BaseWireFeedParser.java | 34 +-
.../syndication/io/impl/DCModuleGenerator.java | 28 +-
.../sun/syndication/io/impl/DCModuleParser.java | 30 +-
.../sun/syndication/io/impl/FeedGenerators.java | 2 +-
.../syndication/io/impl/ModuleGenerators.java | 10 +-
.../sun/syndication/io/impl/ModuleParsers.java | 4 +-
.../sun/syndication/io/impl/NumberParser.java | 10 +-
.../sun/syndication/io/impl/PluginManager.java | 16 +-
.../syndication/io/impl/PropertiesLoader.java | 14 +-
.../sun/syndication/io/impl/RSS090Parser.java | 6 +-
.../io/impl/RSS091UserlandGenerator.java | 13 +-
.../io/impl/RSS091UserlandParser.java | 22 +-
.../syndication/io/impl/RSS092Generator.java | 4 +-
.../sun/syndication/io/impl/RSS092Parser.java | 24 +-
.../sun/syndication/io/impl/RSS094Parser.java | 6 +-
.../sun/syndication/io/impl/RSS10Generator.java | 12 +-
.../sun/syndication/io/impl/RSS20Generator.java | 4 +-
.../sun/syndication/io/impl/XmlFixerReader.java | 4 +-
.../activitystreams/ActivityStreamModule.java | 16 +-
.../activitystreams/types/HasLocation.java | 8 +-
.../org/rometools/feed/module/base/Article.java | 16 +-
.../org/rometools/feed/module/base/Course.java | 24 +-
.../rometools/feed/module/base/CustomTag.java | 4 +-
.../feed/module/base/CustomTagImpl.java | 4 +-
.../rometools/feed/module/base/CustomTags.java | 7 +-
.../org/rometools/feed/module/base/Event.java | 59 +-
.../feed/module/base/GlobalInterface.java | 20 +-
.../rometools/feed/module/base/GoogleBase.java | 2 +-
.../feed/module/base/GoogleBaseImpl.java | 20 +-
.../org/rometools/feed/module/base/Housing.java | 75 +-
.../org/rometools/feed/module/base/Job.java | 40 +-
.../org/rometools/feed/module/base/Person.java | 40 +-
.../org/rometools/feed/module/base/Product.java | 135 +-
.../org/rometools/feed/module/base/Review.java | 38 +-
.../feed/module/base/ScholarlyArticle.java | 20 +-
.../org/rometools/feed/module/base/Service.java | 58 +-
.../org/rometools/feed/module/base/Travel.java | 63 +-
.../org/rometools/feed/module/base/Unknown.java | 28 +-
.../org/rometools/feed/module/base/Vehicle.java | 87 +-
.../org/rometools/feed/module/base/Wanted.java | 12 +-
.../feed/module/base/io/CustomTagGenerator.java | 90 +-
.../feed/module/base/io/CustomTagParser.java | 114 +-
.../module/base/io/GoogleBaseGenerator.java | 76 +-
.../feed/module/base/io/GoogleBaseParser.java | 58 +-
.../feed/module/base/types/CloneableType.java | 2 +-
.../feed/module/base/types/DateTimeRange.java | 4 +-
.../feed/module/base/types/FloatUnit.java | 9 +-
.../feed/module/base/types/IntUnit.java | 4 +-
.../feed/module/cc/CreativeCommons.java | 10 +-
.../feed/module/cc/CreativeCommonsImpl.java | 5 +-
.../feed/module/cc/io/CCModuleGenerator.java | 51 +-
.../feed/module/cc/io/ModuleParserRSS1.java | 72 +-
.../feed/module/cc/io/ModuleParserRSS2.java | 38 +-
.../rometools/feed/module/cc/types/License.java | 5 +-
.../feed/module/content/ContentItem.java | 8 +-
.../feed/module/content/ContentModule.java | 21 +-
.../content/io/ContentModuleGenerator.java | 28 +-
.../module/content/io/ContentModuleParser.java | 21 +-
.../feed/module/feedburner/FeedBurner.java | 18 +-
.../feed/module/georss/GMLGenerator.java | 20 +-
.../rometools/feed/module/georss/GMLParser.java | 23 +-
.../feed/module/georss/GeoRSSUtils.java | 2 +-
.../feed/module/georss/SimpleGenerator.java | 13 +-
.../feed/module/georss/SimpleParser.java | 7 +-
.../feed/module/georss/W3CGeoParser.java | 9 +-
.../feed/module/georss/geometries/Polygon.java | 9 +-
.../module/itunes/AbstractITunesObject.java | 4 +-
.../feed/module/itunes/EntryInformation.java | 4 +-
.../module/itunes/EntryInformationImpl.java | 2 +-
.../feed/module/itunes/FeedInformation.java | 16 +-
.../feed/module/itunes/FeedInformationImpl.java | 4 +-
.../rometools/feed/module/itunes/ITunes.java | 27 +-
.../feed/module/itunes/io/ITunesGenerator.java | 14 +-
.../feed/module/itunes/io/ITunesParser.java | 26 +-
.../feed/module/itunes/types/Category.java | 4 +-
.../feed/module/mediarss/MediaEntryModule.java | 4 +-
.../feed/module/mediarss/MediaModule.java | 6 +-
.../mediarss/io/MediaModuleGenerator.java | 99 +-
.../module/mediarss/io/MediaModuleParser.java | 46 +-
.../feed/module/mediarss/types/MediaGroup.java | 6 +-
.../module/opensearch/OpenSearchModule.java | 2 +-
.../module/opensearch/OpenSearchResponse.java | 26 +-
.../impl/OpenSearchModuleGenerator.java | 32 +-
.../opensearch/impl/OpenSearchModuleParser.java | 45 +-
.../feed/module/photocast/PhotocastModule.java | 23 +-
.../feed/module/photocast/io/Parser.java | 71 +-
.../feed/module/photocast/types/PhotoDate.java | 5 +-
.../org/rometools/feed/module/slash/Slash.java | 19 +-
.../rometools/feed/module/slash/SlashImpl.java | 4 +-
.../module/slash/io/SlashModuleGenerator.java | 7 +-
.../feed/module/sle/SimpleListExtension.java | 14 +-
.../org/rometools/feed/module/sle/SleEntry.java | 12 +-
.../rometools/feed/module/sle/SleEntryImpl.java | 16 +-
.../rometools/feed/module/sle/SleUtility.java | 14 +-
.../feed/module/sle/io/ItemParser.java | 16 +-
.../module/sle/io/LabelNamespaceElement.java | 2 +-
.../feed/module/sle/io/ModuleGenerator.java | 19 +-
.../feed/module/sle/io/ModuleParser.java | 55 +-
.../feed/module/sle/types/EntryValue.java | 11 +-
.../feed/module/sse/SSE091Generator.java | 11 +-
.../rometools/feed/module/sse/SSE091Parser.java | 30 +-
.../feed/module/sse/modules/SSEModule.java | 5 +-
.../yahooweather/YWeatherEntryModule.java | 8 +-
.../module/yahooweather/YWeatherFeedModule.java | 26 +-
.../module/yahooweather/YWeatherModule.java | 2 +-
.../module/yahooweather/YWeatherModuleImpl.java | 10 +-
.../yahooweather/types/ConditionCode.java | 9 +-
.../commons/sesame/rio/rss/AtomParser.java | 2 +-
.../sesame/rio/rss/AtomParserFactory.java | 2 +-
.../commons/sesame/rio/rss/FeedParserBase.java | 2 +-
.../commons/sesame/rio/rss/RSSParser.java | 2 +-
.../sesame/rio/rss/RSSParserFactory.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../marmotta-rio-vcard/pom.xml | 2 +-
.../commons/sesame/rio/vcard/VCardParser.java | 6 +-
.../sesame/rio/vcard/VCardParserFactory.java | 2 +-
.../sesame/rio/vcard/TestVCardParser.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../marmotta-sail-contextaware/pom.xml | 2 +-
.../sesame/contextaware/ContextAwareSail.java | 2 +-
.../ContextAwareSailConnection.java | 4 +-
.../marmotta-sail-transactions/pom.xml | 2 +-
.../transactions/api/TransactionListener.java | 8 +-
.../transactions/api/TransactionalSail.java | 10 +-
.../api/TransactionalSailConnection.java | 6 +-
.../transactions/model/TransactionData.java | 6 +-
.../sail/KiWiTransactionalConnection.java | 2 +-
.../sail/KiWiTransactionalSail.java | 4 +-
.../TransactionalSailConnectionWrapper.java | 2 +-
.../wrapper/TransactionalSailWrapper.java | 2 +-
.../marmotta/kiwi/test/TransactionTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../marmotta-sesame-matchers/pom.xml | 2 +-
.../sesame/test/base/RdfStringMatcher.java | 4 +-
.../sesame/test/base/RepositoryMatcher.java | 6 +-
.../test/connection/HasStatementMatcher.java | 2 +-
.../sesame/test/sparql/SparqlAskMatcher.java | 2 +-
.../test/sparql/SparqlGraphQueryMatcher.java | 4 +-
.../test/sparql/SparqlTupleQueryMatcher.java | 4 +-
.../marmotta-util-facading/pom.xml | 2 +-
.../commons/sesame/facading/api/Facading.java | 12 +-
.../facading/api/FacadingPredicateBuilder.java | 6 +-
.../sesame/facading/impl/FacadingImpl.java | 12 +-
.../impl/FacadingInvocationHandler.java | 21 +-
.../facading/impl/FacadingInvocationHelper.java | 10 +-
.../commons/sesame/facading/model/Facade.java | 2 +-
.../sesame/facading/util/FacadeUtils.java | 15 +-
.../src/test/resources/logback.xml | 4 +-
.../marmotta-util-filter/pom.xml | 2 +-
.../commons/sesame/filter/AllOfFilter.java | 5 +-
.../sesame/filter/AlwaysFalseFilter.java | 2 +-
.../commons/sesame/filter/AlwaysTrueFilter.java | 2 +-
.../commons/sesame/filter/NotFilter.java | 2 +-
.../commons/sesame/filter/OneOfFilter.java | 5 +-
.../commons/sesame/filter/SesameFilter.java | 4 +-
.../sesame/filter/resource/ResourceFilter.java | 2 +-
.../sesame/filter/resource/UriPrefixFilter.java | 4 +-
.../sesame/filter/resource/UriRegexFilter.java | 4 +-
.../filter/statement/StatementFilter.java | 2 +-
.../marmotta-util-rdfpatch/pom.xml | 2 +-
.../platform/ldp/patch/model/PatchLine.java | 3 +-
.../ldp/patch/parser/RdfPatchParser.java | 6 +-
.../marmotta-util-tripletable/pom.xml | 2 +-
.../commons/sesame/tripletable/ByteArray.java | 2 +-
.../commons/sesame/tripletable/IntArray.java | 2 +-
.../commons/sesame/tripletable/TripleTable.java | 13 +-
commons/marmotta-sesame-tools/pom.xml | 2 +-
commons/pom.xml | 2 +-
extras/pom.xml | 2 +-
extras/webjars/codemirror/pom.xml | 2 +-
extras/webjars/pom.xml | 2 +-
extras/webjars/strftime/pom.xml | 2 +-
launchers/marmotta-installer/assembly.xml | 4 -
launchers/marmotta-installer/pom.xml | 6 +-
.../src/main/resources/images/splashscreen.png | Bin 69972 -> 89064 bytes
.../src/main/resources/installer/NOTICE.txt | 2 +-
launchers/marmotta-splash/pom.xml | 2 +-
.../splash/systray/SystrayListener.java | 35 +-
launchers/marmotta-webapp/README.md | 50 +
launchers/marmotta-webapp/assembly.xml | 4 -
launchers/marmotta-webapp/pom.xml | 108 +-
.../marmotta-webapp/src/deb/control/control | 4 +-
launchers/marmotta-webapp/src/deb/pkg/copyright | 2 +-
.../marmotta-webapp/src/docker/entrypoint.sh | 38 +
.../src/main/webapp/META-INF/NOTICE | 2 +-
.../src/main/webapp/WEB-INF/web.xml | 6 +-
.../src/test/resources/test-config.properties | 2 +-
launchers/pom.xml | 2 +-
libraries/kiwi/README.txt | 2 -
libraries/kiwi/kiwi-caching-ehcache/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-hazelcast/pom.xml | 2 +-
.../caching/HazelcastCacheManager.java | 2 +-
libraries/kiwi/kiwi-caching-infinispan/pom.xml | 2 +-
.../InfinispanEmbeddedCacheManager.java | 9 +-
.../remote/CustomClassExternalizerFactory.java | 4 +-
.../infinispan/remote/CustomClassTable.java | 6 +-
.../marmotta/kiwi/infinispan/util/AsyncMap.java | 2 +-
.../kiwi/test/embedded/EmbeddedClusterTest.java | 7 +-
.../EmbeddedRepositoryConnectionTest.java | 6 +
libraries/kiwi/kiwi-loader/pom.xml | 4 +-
.../kiwi/loader/csv/SQLBooleanProcessor.java | 2 +-
.../kiwi/loader/csv/SQLDateTimeProcessor.java | 6 +-
.../kiwi/loader/generic/KiWiBatchHandler.java | 6 +-
.../kiwi/loader/generic/KiWiHandler.java | 4 +-
.../marmotta/kiwi/loader/pgsql/PGCopyUtil.java | 6 +-
.../kiwi-loader/src/main/resources/logback.xml | 4 +-
.../src/test/resources/logback-test.xml | 4 +-
libraries/kiwi/kiwi-reasoner/pom.xml | 2 +-
.../reasoner/engine/ReasoningConfiguration.java | 2 +-
.../kiwi/reasoner/engine/ReasoningEngine.java | 45 +-
.../kiwi/reasoner/model/program/Field.java | 10 +-
.../kiwi/reasoner/model/program/Filter.java | 2 +-
.../reasoner/model/program/Justification.java | 8 +-
.../reasoner/model/program/LiteralField.java | 5 +-
.../kiwi/reasoner/model/program/Pattern.java | 5 +-
.../kiwi/reasoner/model/program/Program.java | 9 +-
.../reasoner/model/program/ResourceField.java | 5 +-
.../kiwi/reasoner/model/program/Rule.java | 6 +-
.../reasoner/model/program/VariableField.java | 5 +-
.../kiwi/reasoner/model/query/QueryResult.java | 5 +-
.../model/query/QueryResultIterator.java | 4 +-
.../reasoner/parser/KWRLProgramParserBase.java | 8 +-
.../persistence/KiWiReasoningConnection.java | 100 +-
.../persistence/KiWiReasoningPersistence.java | 2 +-
.../kiwi/reasoner/sail/KiWiReasoningSail.java | 37 +-
.../kiwi/reasoner/parser/KWRLProgramParser.jj | 26 +-
.../engine/JustificationResolutionTest.java | 19 +-
.../test/engine/ReasoningEngineTest.java | 2 +-
.../reasoner/test/model/JustificationTest.java | 9 -
.../test/parser/KWRLProgramParserTest.java | 2 +-
.../test/parser/KWRLRuleParserTest.java | 43 +-
.../JustificationPersistenceTest.java | 2 +-
.../persistence/KWRLProgramPersistenceTest.java | 4 +-
.../test/persistence/PatternQueryTest.java | 2 +-
.../reasoner/test/sail/ReasoningLargeTest.java | 2 +-
.../reasoner/test/sail/ReasoningSailTest.java | 2 +-
libraries/kiwi/kiwi-sparql/pom.xml | 4 +-
.../kiwi/sparql/builder/SQLBuilder.java | 206 +-
.../kiwi/sparql/builder/ValueConverter.java | 2 +-
.../sparql/builder/collect/ConditionFinder.java | 10 +-
.../sparql/builder/collect/DistinctFinder.java | 10 +-
.../sparql/builder/collect/ExtensionFinder.java | 9 +-
.../sparql/builder/collect/GroupFinder.java | 9 +-
.../sparql/builder/collect/OrderFinder.java | 8 +-
.../builder/collect/PatternCollector.java | 9 +-
.../sparql/builder/collect/VariableFinder.java | 7 +-
.../builder/eval/ValueExpressionEvaluator.java | 22 +-
.../builder/model/SQLAbstractSubquery.java | 3 +-
.../kiwi/sparql/builder/model/SQLClause.java | 15 +-
.../kiwi/sparql/builder/model/SQLFragment.java | 14 +-
.../kiwi/sparql/builder/model/SQLPattern.java | 10 +-
.../kiwi/sparql/builder/model/SQLUnion.java | 14 +-
.../kiwi/sparql/builder/model/SQLVariable.java | 11 +-
.../evaluation/KiWiEvaluationStrategy.java | 43 +-
.../kiwi/sparql/function/NativeFunction.java | 12 +-
.../optimizer/DistinctLimitOptimizer.java | 21 +-
.../sparql/optimizer/NativeFilterOptimizer.java | 215 +
.../kiwi/sparql/sail/KiWiSparqlSail.java | 35 +-
.../sparql/sail/KiWiSparqlSailConnection.java | 7 +-
.../sparql/test/ComplexKiWiSparqlQueryTest.java | 17 +-
.../kiwi/sparql/test/ContextAwareTest.java | 2 -
.../kiwi/sparql/test/KiWiSparqlTest.java | 399 +
.../kiwi/sparql/test/KiWiSparqlUpdateTest.java | 3 +-
.../testsuite/KiWiSparqlComplianceTest.java | 1 -
.../kiwi/sparql/test/MARMOTTA-578.sparql | 27 +
.../kiwi/sparql/test/MARMOTTA-617.sparql | 28 +
.../marmotta/kiwi/sparql/test/MARMOTTA-617.ttl | 41 +
.../kiwi/sparql/test/MARMOTTA-640_1.sparql | 33 +
.../kiwi/sparql/test/MARMOTTA-640_2.sparql | 51 +
.../kiwi/sparql/test/MARMOTTA-651_1.sparql | 26 +
.../kiwi/sparql/test/MARMOTTA-657.sparql | 25 +
libraries/kiwi/kiwi-triplestore/pom.xml | 23 +-
.../kiwi/persistence/util/ScriptRunner.java | 289 +
.../marmotta/kiwi/caching/CacheManager.java | 40 +-
.../kiwi/caching/CacheManagerFactory.java | 2 +-
.../kiwi/caching/GuavaCacheManager.java | 2 +-
.../marmotta/kiwi/config/KiWiConfiguration.java | 4 +-
.../kiwi/exception/DriverNotFoundException.java | 2 +-
.../marmotta/kiwi/generator/IDGenerator.java | 4 +-
.../kiwi/generator/SnowflakeIDGenerator.java | 8 +-
.../kiwi/generator/UUIDRandomIDGenerator.java | 4 +-
.../marmotta/kiwi/hashing/TripleFunnel.java | 2 +-
.../org/apache/marmotta/kiwi/io/KiWiIO.java | 176 +-
.../kiwi/model/rdf/KiWiAnonResource.java | 2 +-
.../kiwi/model/rdf/KiWiBooleanLiteral.java | 2 +-
.../kiwi/model/rdf/KiWiDateLiteral.java | 3 +-
.../kiwi/model/rdf/KiWiDoubleLiteral.java | 8 +-
.../marmotta/kiwi/model/rdf/KiWiIntLiteral.java | 4 +-
.../marmotta/kiwi/model/rdf/KiWiLiteral.java | 8 +-
.../marmotta/kiwi/model/rdf/KiWiNamespace.java | 5 +-
.../marmotta/kiwi/model/rdf/KiWiNode.java | 2 +-
.../marmotta/kiwi/model/rdf/KiWiResource.java | 2 +-
.../kiwi/model/rdf/KiWiStringLiteral.java | 2 +-
.../marmotta/kiwi/model/rdf/KiWiTriple.java | 14 +-
.../kiwi/model/rdf/KiWiUriResource.java | 2 +-
.../kiwi/persistence/KiWiConnection.java | 629 +-
.../marmotta/kiwi/persistence/KiWiDialect.java | 42 +-
.../kiwi/persistence/KiWiGarbageCollector.java | 25 +-
.../kiwi/persistence/KiWiPersistence.java | 91 +-
.../marmotta/kiwi/persistence/h2/H2Dialect.java | 7 +-
.../kiwi/persistence/mysql/MySQLDialect.java | 7 +-
.../persistence/pgsql/PostgreSQLDialect.java | 9 +-
.../registry/LocalTripleRegistry.java | 7 +-
.../persistence/util/ResultSetIteration.java | 4 +-
.../util/ResultTransformerFunction.java | 4 +-
.../kiwi/persistence/util/ScriptRunner.java | 302 -
.../marmotta/kiwi/sail/KiWiSailConnection.java | 49 +-
.../apache/marmotta/kiwi/sail/KiWiStore.java | 2 +-
.../marmotta/kiwi/sail/KiWiValueFactory.java | 58 +-
.../kiwi/test/cluster/BaseClusterTest.java | 4 +
.../kiwi/test/junit/KiWiDatabaseRunner.java | 4 +-
.../src/test/resources/logback.xml | 4 +-
libraries/kiwi/kiwi-versioning/pom.xml | 2 +-
.../kiwi/versioning/api/VersioningSail.java | 8 +-
.../marmotta/kiwi/versioning/model/Version.java | 2 +-
.../persistence/KiWiVersioningConnection.java | 4 +-
.../persistence/KiWiVersioningPersistence.java | 2 +-
.../repository/SnapshotRepository.java | 2 +-
.../SnapshotRepositoryConnection.java | 2 +-
.../versioning/sail/KiWiSnapshotConnection.java | 27 +-
.../versioning/sail/KiWiVersionListener.java | 2 +-
.../versioning/sail/KiWiVersioningSail.java | 24 +-
.../versioning/test/SnapshotRepositoryTest.java | 2 +-
.../test/VersioningPersistenceTest.java | 2 +-
.../test/VersioningRepositoryTest.java | 2 +-
libraries/kiwi/pom.xml | 2 +-
libraries/ldcache/ldcache-api/pom.xml | 2 +-
.../marmotta/ldcache/api/LDCachingBackend.java | 12 +-
.../ldcache/api/LDCachingConnection.java | 8 +-
.../marmotta/ldcache/api/LDCachingService.java | 14 +-
.../ldcache/model/CacheConfiguration.java | 2 +-
.../marmotta/ldcache/model/CacheEntry.java | 2 +-
libraries/ldcache/ldcache-backend-file/pom.xml | 19 +-
.../backend/file/LDCachingFileBackend.java | 2 +-
.../backend/file/util/FileBackendUtils.java | 17 +-
.../backend/file/test/LDCacheFileTest.java | 31 +-
.../src/test/resources/logback.xml | 7 +-
.../ldcache/ldcache-backend-infinispan/pom.xml | 23 +-
.../infinispan/io/ModelExternalizer.java | 2 +-
.../infinispan/io/ValueExternalizer.java | 2 +-
libraries/ldcache/ldcache-backend-kiwi/pom.xml | 15 +-
.../backend/kiwi/model/KiWiCacheEntry.java | 2 +-
.../persistence/LDCachingKiWiPersistence.java | 2 +-
.../LDCachingKiWiPersistenceConnection.java | 15 +-
.../kiwi/test/LDCachePersistenceTest.java | 2 +-
.../src/test/resources/logback.xml | 7 +-
libraries/ldcache/ldcache-core/pom.xml | 15 +-
.../services/test/dummy/DummyEndpoint.java | 2 +-
.../ldcache/services/test/dummy/DummyTest.java | 2 +-
.../services/test/ng/BaseLDCacheTest.java | 20 +-
.../ldcache-core/src/test/resources/logback.xml | 7 +-
libraries/ldcache/ldcache-sail-generic/pom.xml | 2 +-
.../sail/GenericLinkedDataSailConnection.java | 4 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldcache/ldcache-sail-kiwi/pom.xml | 2 +-
.../ldcache/sail/KiWiLinkedDataSail.java | 2 +-
.../sail/KiWiLinkedDataSailConnection.java | 2 +-
.../test/KiWiLinkedDataSailOfflineTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldcache/pom.xml | 2 +-
libraries/ldclient/ldclient-api/pom.xml | 8 +-
.../ldclient/api/endpoint/Endpoint.java | 2 +-
.../ldclient/api/ldclient/LDClientService.java | 2 +-
.../ldclient/api/provider/DataProvider.java | 2 +-
.../ldclient/api/provider/ValueMapper.java | 2 +-
.../exception/DataRetrievalException.java | 2 +-
.../ldclient/model/ClientConfiguration.java | 2 +-
.../marmotta/ldclient/model/ClientResponse.java | 2 +-
libraries/ldclient/ldclient-core/pom.xml | 16 +-
.../ldclient/services/ldclient/LDClient.java | 8 +-
.../services/provider/AbstractHttpProvider.java | 2 +-
.../services/provider/BlockingProvider.java | 2 +-
.../marmotta/ldclient/dummy/DummyEndpoint.java | 2 +-
.../marmotta/ldclient/dummy/DummyProvider.java | 2 +-
.../ldclient/test/TestLDClientTest.java | 2 +-
.../ldclient/test/helper/TestLDClient.java | 2 +-
.../test/provider/ProviderTestBase.java | 20 +-
.../src/test/resources/logback.xml | 4 +-
.../ldclient/ldclient-provider-facebook/pom.xml | 21 +-
.../src/test/resources/logback.xml | 4 +-
.../ldclient/ldclient-provider-freebase/pom.xml | 78 -
.../endpoint/freebase/FreebaseEndpoint.java | 39 -
.../provider/freebase/FreebaseProvider.java | 227 -
...ache.marmotta.ldclient.api.endpoint.Endpoint | 1 -
....marmotta.ldclient.api.provider.DataProvider | 1 -
.../test/freebase/TestFreebaseProvider.java | 142 -
.../src/test/resources/logback.xml | 27 -
.../ldclient/test/freebase/m.07zqbwz.sparql | 26 -
.../ldclient/test/freebase/m.0h21k1c.sparql | 26 -
.../ldclient/test/freebase/m.0nzm.sparql | 27 -
.../ldclient/test/freebase/m.0wqhskn.sparql | 27 -
.../ldclient/ldclient-provider-html/pom.xml | 20 +-
.../provider/html/AbstractHTMLDataProvider.java | 2 +-
.../html/mapping/CssDateLiteralMapper.java | 2 +-
.../html/mapping/CssLiteralAttrMapper.java | 2 +-
.../html/mapping/CssSelectorMapper.java | 2 +-
.../html/mapping/CssTextLiteralMapper.java | 2 +-
.../CssUriAttrBlacklistQueryParamsMapper.java | 2 +-
.../provider/html/mapping/CssUriAttrMapper.java | 2 +-
.../CssUriAttrWhitelistQueryParamsMapper.java | 2 +-
.../provider/html/mapping/JSoupMapper.java | 2 +-
.../ldclient/ldclient-provider-ldap/pom.xml | 20 +-
.../ldclient/provider/ldap/LdapEndpoint.java | 2 +-
.../provider/ldap/LdapFoafProvider.java | 2 +-
.../ldap/mapping/LiteralPredicateFactory.java | 2 +-
.../ldap/mapping/PredicateObjectFactory.java | 2 +-
.../ldap/mapping/UriPredicateFactory.java | 2 +-
.../provider/ldap/TestLdapFoafProvider.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../ldclient-provider-mediawiki/pom.xml | 22 +-
.../mediawiki/WikipediaIndexEndpoint.java | 4 +-
.../mediawiki/WikipediaPageEndpoint.java | 4 +-
.../provider/mediawiki/MediawikiProvider.java | 2 +-
.../test/mediawiki/TestMediawikiProvider.java | 10 +-
.../src/test/resources/logback.xml | 4 +-
.../test/mediawiki/wikipedia-marmot-http.sparql | 29 +
.../test/mediawiki/wikipedia-marmot.sparql | 4 +-
.../ldclient/ldclient-provider-phpbb/pom.xml | 21 +-
.../ldclient/endpoint/phpbb/PHPBBEndpoints.java | 2 +-
.../endpoint/phpbb/PHPBBForumEndpoint.java | 2 +-
.../endpoint/phpbb/PHPBBPostEndpoint.java | 2 +-
.../endpoint/phpbb/PHPBBTopicEndpoint.java | 2 +-
.../provider/phpbb/PHPBBForumProvider.java | 2 +-
.../provider/phpbb/PHPBBPostProvider.java | 2 +-
.../provider/phpbb/PHPBBTopicProvider.java | 2 +-
.../provider/phpbb/mapping/PHPBBDateMapper.java | 2 +-
.../phpbb/mapping/PHPBBForumHrefMapper.java | 2 +-
.../phpbb/mapping/PHPBBPostIdMapper.java | 2 +-
.../phpbb/mapping/PHPBBTopicHrefMapper.java | 2 +-
.../ldclient/ldclient-provider-rdf/pom.xml | 16 +-
.../endpoint/rdf/LinkedDataEndpoint.java | 2 +-
.../ldclient/endpoint/rdf/SPARQLEndpoint.java | 2 +-
.../ldclient/endpoint/rdf/StanbolEndpoint.java | 2 +-
.../provider/rdf/AbstractRDFProvider.java | 2 +-
.../ldclient/provider/rdf/CacheProvider.java | 2 +-
.../provider/rdf/LinkedDataProvider.java | 2 +-
.../ldclient/provider/rdf/RegexUriProvider.java | 2 +-
.../ldclient/provider/rdf/SPARQLProvider.java | 2 +-
.../test/rdf/TestLinkedDataProvider.java | 3 +-
.../ldclient/test/rdf/TestSPARQLProvider.java | 2 +-
.../ldclient/test/rdf/TestStanbolProvider.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../ldclient/ldclient-provider-rdfa/pom.xml | 2 +-
.../ldclient/ldclient-provider-vimeo/pom.xml | 21 +-
.../endpoint/vimeo/VimeoChannelEndpoint.java | 2 +-
.../endpoint/vimeo/VimeoGroupEndpoint.java | 2 +-
.../endpoint/vimeo/VimeoVideoEndpoint.java | 2 +-
.../provider/vimeo/VimeoChannelProvider.java | 2 +-
.../provider/vimeo/VimeoVideoProvider.java | 2 +-
.../provider/vimeo/mapping/VimeoDateMapper.java | 2 +-
.../ldclient/test/vimeo/TestVimeoProvider.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../ldclient/test/vimeo/vimeo-channel.sparql | 2 +-
.../ldclient/ldclient-provider-xml/pom.xml | 19 +-
.../provider/xml/AbstractXMLDataProvider.java | 2 +-
.../xml/mapping/CommaSeparatedMapper.java | 2 +-
.../xml/mapping/XPathLiteralMapper.java | 2 +-
.../provider/xml/mapping/XPathURIMapper.java | 2 +-
.../provider/xml/mapping/XPathValueMapper.java | 2 +-
.../ldclient/ldclient-provider-youtube/pom.xml | 22 +-
.../youtube/YoutubeChannelEndpointGData.java | 2 +-
.../youtube/YoutubeChannelEndpointWeb.java | 2 +-
.../youtube/YoutubePlaylistEndpointGData.java | 2 +-
.../youtube/YoutubePlaylistEndpointWeb.java | 2 +-
.../youtube/YoutubePlaylistEndpointWebLong.java | 2 +-
.../endpoint/youtube/YoutubeVideoEndpoint.java | 2 +-
.../youtube/YoutubeVideoPageEndpointGData.java | 2 +-
.../youtube/YoutubeVideoPageEndpointWatch.java | 2 +-
.../youtube/YoutubeVideoPageEndpointWeb.java | 2 +-
.../youtube/YoutubeChannelProvider.java | 2 +-
.../youtube/YoutubePlaylistProvider.java | 2 +-
.../youtube/YoutubeVideoPagesProvider.java | 2 +-
.../provider/youtube/YoutubeVideoProvider.java | 2 +-
.../youtube/mapping/YoutubeCategoryMapper.java | 2 +-
.../youtube/mapping/YoutubeLatitudeMapper.java | 2 +-
.../youtube/mapping/YoutubeLongitudeMapper.java | 2 +-
.../youtube/mapping/YoutubeUriMapper.java | 2 +-
.../test/youtube/TestYoutubeProvider.java | 4 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldclient/pom.xml | 3 +-
libraries/ldpath/ldpath-api/pom.xml | 2 +-
.../marmotta/ldpath/api/LDPathConstruct.java | 4 +-
.../ldpath/api/backend/NodeBackend.java | 42 +-
.../marmotta/ldpath/api/backend/RDFBackend.java | 10 +-
.../ldpath/api/functions/NodeFunction.java | 12 +-
.../ldpath/api/functions/SelectorFunction.java | 2 +-
.../ldpath/api/functions/TestFunction.java | 2 +-
.../ldpath/api/selectors/NodeSelector.java | 14 +-
.../marmotta/ldpath/api/tests/NodeTest.java | 2 +-
.../api/transformers/NodeTransformer.java | 8 +-
libraries/ldpath/ldpath-backend-file/pom.xml | 2 +-
.../ldpath/backend/file/FileBackend.java | 2 +-
.../marmotta/ldpath/backend/file/FileQuery.java | 31 +-
.../ldpath/backend/file/ParserTest.java | 2 +-
.../marmotta/ldpath/backend/file/PathTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-backend-jena/pom.xml | 4 +-
.../ldpath/backend/jena/GenericJenaBackend.java | 16 +-
.../ldpath/ldpath-backend-linkeddata/pom.xml | 2 +-
.../backend/linkeddata/LDCacheBackend.java | 12 +-
libraries/ldpath/ldpath-backend-sesame/pom.xml | 2 +-
.../backend/sesame/AbstractSesameBackend.java | 21 +-
.../backend/sesame/SesameRepositoryBackend.java | 2 +-
.../backend/sesame/SesameValueBackend.java | 23 +-
.../backend/sesame/ThreadingSesameBackend.java | 2 +-
libraries/ldpath/ldpath-core-bundle/pom.xml | 3 +-
libraries/ldpath/ldpath-core/pom.xml | 2 +-
.../java/org/apache/marmotta/ldpath/LDPath.java | 38 +-
.../ldpath/exception/LDPathParseException.java | 2 +-
.../apache/marmotta/ldpath/model/Constants.java | 2 +-
.../ldpath/model/backend/AbstractBackend.java | 42 +-
.../ldpath/model/fields/FieldMapping.java | 13 +-
.../functions/AbstractTextFilterFunction.java | 19 +-
.../model/functions/ConcatenateFunction.java | 12 +-
.../ldpath/model/functions/CountFunction.java | 4 +-
.../ldpath/model/functions/FirstFunction.java | 9 +-
.../ldpath/model/functions/LastFunction.java | 9 +-
.../ldpath/model/functions/SortFunction.java | 24 +-
.../marmotta/ldpath/model/programs/Program.java | 22 +-
.../model/selectors/FunctionSelector.java | 40 +-
.../ldpath/model/selectors/GroupedSelector.java | 20 +-
.../model/selectors/IntersectionSelector.java | 29 +-
.../ldpath/model/selectors/PathSelector.java | 38 +-
.../model/selectors/PropertySelector.java | 22 +-
.../model/selectors/RecursivePathSelector.java | 49 +-
.../selectors/ReversePropertySelector.java | 21 +-
.../ldpath/model/selectors/SelfSelector.java | 2 +-
.../model/selectors/StringConstantSelector.java | 23 +-
.../ldpath/model/selectors/TestingSelector.java | 36 +-
.../ldpath/model/selectors/UnionSelector.java | 32 +-
.../model/selectors/WildcardSelector.java | 5 +-
.../marmotta/ldpath/model/tests/AndTest.java | 29 +-
.../ldpath/model/tests/ComplexTest.java | 2 +-
.../ldpath/model/tests/FunctionTest.java | 28 +-
.../marmotta/ldpath/model/tests/IsATest.java | 6 +-
.../ldpath/model/tests/LiteralLanguageTest.java | 22 +-
.../ldpath/model/tests/LiteralTypeTest.java | 26 +-
.../marmotta/ldpath/model/tests/NotTest.java | 15 +-
.../marmotta/ldpath/model/tests/OrTest.java | 25 +-
.../ldpath/model/tests/PathEqualityTest.java | 24 +-
.../marmotta/ldpath/model/tests/PathTest.java | 20 +-
.../tests/functions/BinaryNumericTest.java | 4 +-
.../ldpath/model/tests/functions/EqualTest.java | 2 +-
.../model/tests/functions/GreaterEqualTest.java | 2 +-
.../model/tests/functions/GreaterThanTest.java | 2 +-
.../model/tests/functions/LessEqualTest.java | 2 +-
.../model/tests/functions/LessThanTest.java | 2 +-
.../model/tests/functions/NotEqualTest.java | 2 +-
.../transformers/BigDecimalTransformer.java | 2 +-
.../transformers/BigIntegerTransformer.java | 2 +-
.../model/transformers/BooleanTransformer.java | 2 +-
.../model/transformers/ByteTransformer.java | 2 +-
.../model/transformers/DateTimeTransformer.java | 2 +-
.../model/transformers/DateTransformer.java | 2 +-
.../model/transformers/DoubleTransformer.java | 2 +-
.../model/transformers/DurationTransformer.java | 2 +-
.../model/transformers/FloatTransformer.java | 2 +-
.../model/transformers/IdentityTransformer.java | 2 +-
.../model/transformers/IntTransformer.java | 2 +-
.../model/transformers/LongTransformer.java | 2 +-
.../model/transformers/ShortTransformer.java | 2 +-
.../model/transformers/StringTransformer.java | 2 +-
.../model/transformers/TimeTransformer.java | 2 +-
.../marmotta/ldpath/parser/Configuration.java | 10 +-
.../ldpath/parser/DefaultConfiguration.java | 31 +-
.../marmotta/ldpath/util/Collections.java | 4 +-
.../marmotta/ldpath/util/FormatUtils.java | 2 +-
.../org/apache/marmotta/ldpath/parser/ldpath.jj | 140 +-
.../BinaryNumericTestFunctionsTest.java | 2 +-
.../ldpath/model/functions/FunctionsTest.java | 2 +-
.../ldpath/parser/EmptyTestingBackend.java | 2 +-
.../marmotta/ldpath/parser/ProgramTest.java | 3 +-
.../marmotta/ldpath/test/AbstractTestBase.java | 2 +-
.../ldpath-core/src/test/resources/logback.xml | 4 +-
.../ldpath/ldpath-functions-collections/pom.xml | 2 +-
.../functions/coll/AbstractCollFunction.java | 2 +-
.../model/functions/coll/FlattenFunction.java | 15 +-
.../model/functions/coll/GetFunction.java | 13 +-
.../model/functions/coll/SubListFunction.java | 13 +-
.../model/functions/coll/CollectionsTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-date/pom.xml | 2 +-
.../model/functions/date/DateFunction.java | 2 +-
.../functions/date/EarliestDateFunction.java | 15 +-
.../functions/date/LatestDateFunction.java | 15 +-
.../model/functions/date/DateFunctionsTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-html/pom.xml | 2 +-
.../model/functions/html/CleanHtmlFunction.java | 2 +-
.../model/functions/html/CssSelectFunction.java | 43 +-
.../model/functions/html/HtmlFunctionsTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-json/pom.xml | 2 +-
.../model/functions/json/JsonPathFunction.java | 30 +-
.../functions/json/JsonPathFunctionTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-math/pom.xml | 2 +-
.../model/functions/math/MathFunction.java | 4 +-
.../model/functions/math/MaxFunction.java | 20 +-
.../model/functions/math/MinFunction.java | 18 +-
.../model/functions/math/RoundFunction.java | 20 +-
.../model/functions/math/SumFunction.java | 22 +-
.../model/functions/math/MathFunctionTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-text/pom.xml | 2 +-
.../model/functions/text/ReplaceFunction.java | 17 +-
.../model/functions/text/StrJoinFunction.java | 13 +-
.../model/functions/text/StrLeftFunction.java | 17 +-
.../model/functions/text/StrLenFunction.java | 12 +-
.../model/functions/text/StrRightFunction.java | 17 +-
.../model/functions/text/SubstringFunction.java | 17 +-
.../model/functions/text/WordCountFunction.java | 12 +-
.../text/AbstractBinaryStringTest.java | 9 +-
.../functions/text/AbstractStringTest.java | 16 +-
.../functions/text/StringContainsTest.java | 2 +-
.../functions/text/StringEndsWithTest.java | 2 +-
.../tests/functions/text/StringEqualsIC.java | 2 +-
.../tests/functions/text/StringEqualsTest.java | 2 +-
.../tests/functions/text/StringIsEmptyTest.java | 9 +-
.../functions/text/StringStartsWithTest.java | 2 +-
.../model/functions/text/TextFunctionsTest.java | 2 +-
.../tests/functions/text/StringTestTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-xml/pom.xml | 2 +-
.../model/functions/xml/XPathFunction.java | 28 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-ldquery-cli/pom.xml | 4 +-
.../ldpath-ldquery-cli/src/main/doc/NOTICE.txt | 2 +-
.../apache/marmotta/ldpath/ldquery/LDQuery.java | 4 +-
.../ldpath/ldpath-template-linkeddata/pom.xml | 2 +-
.../marmotta/ldpath/template/LDTemplate.java | 4 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-template/pom.xml | 2 +-
.../ldpath/template/engine/LDPathDirective.java | 21 +-
.../ldpath/template/engine/LDPathMethod.java | 20 +-
.../template/engine/NamespaceDirective.java | 30 +-
.../ldpath/template/engine/TemplateEngine.java | 2 +-
.../model/freemarker/TemplateNodeModel.java | 2 +-
.../model/freemarker/TemplateStackModel.java | 4 +-
.../model/freemarker/TemplateWrapperModel.java | 2 +-
.../TemplateBooleanTransformer.java | 9 +-
.../transformers/TemplateDateTransformer.java | 11 +-
.../transformers/TemplateDoubleTransformer.java | 9 +-
.../transformers/TemplateFloatTransformer.java | 9 +-
.../TemplateIntegerTransformer.java | 9 +-
.../transformers/TemplateLongTransformer.java | 2 +-
.../transformers/TemplateScalarTransformer.java | 9 +-
.../ldpath/template/util/FormatUtil.java | 2 +-
libraries/ldpath/pom.xml | 2 +-
libraries/ostrich/Dockerfile | 94 +
libraries/ostrich/README.md | 116 +
libraries/ostrich/backend/.dockerignore | 1 +
.../backend/3rdparty/abseil/.clang-format | 4 +
.../ostrich/backend/3rdparty/abseil/.gitignore | 2 +
.../3rdparty/abseil/ABSEIL_ISSUE_TEMPLATE.md | 22 +
.../ostrich/backend/3rdparty/abseil/AUTHORS | 6 +
.../3rdparty/abseil/CMake/AbseilHelpers.cmake | 157 +
.../backend/3rdparty/abseil/CMake/README.md | 79 +
.../backend/3rdparty/abseil/CMakeLists.txt | 86 +
.../backend/3rdparty/abseil/CONTRIBUTING.md | 91 +
.../ostrich/backend/3rdparty/abseil/LICENSE | 204 +
.../ostrich/backend/3rdparty/abseil/README.md | 108 +
.../ostrich/backend/3rdparty/abseil/WORKSPACE | 25 +
.../backend/3rdparty/abseil/absl/BUILD.bazel | 52 +
.../backend/3rdparty/abseil/absl/CMakeLists.txt | 30 +
.../3rdparty/abseil/absl/algorithm/BUILD.bazel | 69 +
.../abseil/absl/algorithm/CMakeLists.txt | 63 +
.../3rdparty/abseil/absl/algorithm/algorithm.h | 150 +
.../abseil/absl/algorithm/algorithm_test.cc | 182 +
.../3rdparty/abseil/absl/algorithm/container.h | 1642 ++++
.../abseil/absl/algorithm/container_test.cc | 997 +++
.../3rdparty/abseil/absl/base/BUILD.bazel | 395 +
.../3rdparty/abseil/absl/base/CMakeLists.txt | 358 +
.../3rdparty/abseil/absl/base/attributes.h | 567 ++
.../3rdparty/abseil/absl/base/bit_cast_test.cc | 107 +
.../3rdparty/abseil/absl/base/call_once.h | 216 +
.../3rdparty/abseil/absl/base/call_once_test.cc | 102 +
.../backend/3rdparty/abseil/absl/base/casts.h | 140 +
.../backend/3rdparty/abseil/absl/base/config.h | 427 +
.../3rdparty/abseil/absl/base/config_test.cc | 60 +
.../abseil/absl/base/dynamic_annotations.cc | 129 +
.../abseil/absl/base/dynamic_annotations.h | 409 +
.../absl/base/exception_safety_testing_test.cc | 842 ++
.../abseil/absl/base/inline_variable_test.cc | 62 +
.../abseil/absl/base/inline_variable_test_a.cc | 25 +
.../abseil/absl/base/inline_variable_test_b.cc | 25 +
.../abseil/absl/base/internal/atomic_hook.h | 150 +
.../abseil/absl/base/internal/cycleclock.cc | 81 +
.../abseil/absl/base/internal/cycleclock.h | 77 +
.../abseil/absl/base/internal/direct_mmap.h | 151 +
.../3rdparty/abseil/absl/base/internal/endian.h | 269 +
.../abseil/absl/base/internal/endian_test.cc | 279 +
.../base/internal/exception_safety_testing.cc | 41 +
.../base/internal/exception_safety_testing.h | 997 +++
.../absl/base/internal/exception_testing.h | 38 +
.../abseil/absl/base/internal/identity.h | 33 +
.../abseil/absl/base/internal/inline_variable.h | 107 +
.../base/internal/inline_variable_testing.h | 44 +
.../3rdparty/abseil/absl/base/internal/invoke.h | 188 +
.../absl/base/internal/low_level_alloc.cc | 604 ++
.../abseil/absl/base/internal/low_level_alloc.h | 119 +
.../absl/base/internal/low_level_alloc_test.cc | 157 +
.../absl/base/internal/low_level_scheduling.h | 104 +
.../abseil/absl/base/internal/per_thread_tls.h | 48 +
.../abseil/absl/base/internal/pretty_function.h | 33 +
.../abseil/absl/base/internal/raw_logging.cc | 218 +
.../abseil/absl/base/internal/raw_logging.h | 137 +
.../abseil/absl/base/internal/scheduling_mode.h | 54 +
.../abseil/absl/base/internal/spinlock.cc | 238 +
.../abseil/absl/base/internal/spinlock.h | 239 +
.../absl/base/internal/spinlock_akaros.inc | 35 +
.../absl/base/internal/spinlock_posix.inc | 46 +
.../abseil/absl/base/internal/spinlock_wait.cc | 79 +
.../abseil/absl/base/internal/spinlock_wait.h | 91 +
.../absl/base/internal/spinlock_win32.inc | 37 +
.../abseil/absl/base/internal/sysinfo.cc | 404 +
.../abseil/absl/base/internal/sysinfo.h | 63 +
.../abseil/absl/base/internal/sysinfo_test.cc | 98 +
.../absl/base/internal/thread_identity.cc | 123 +
.../abseil/absl/base/internal/thread_identity.h | 240 +
.../absl/base/internal/thread_identity_test.cc | 126 +
.../abseil/absl/base/internal/throw_delegate.cc | 106 +
.../abseil/absl/base/internal/throw_delegate.h | 71 +
.../absl/base/internal/tsan_mutex_interface.h | 66 +
.../absl/base/internal/unaligned_access.h | 256 +
.../absl/base/internal/unscaledcycleclock.cc | 101 +
.../absl/base/internal/unscaledcycleclock.h | 119 +
.../3rdparty/abseil/absl/base/invoke_test.cc | 200 +
.../3rdparty/abseil/absl/base/log_severity.h | 67 +
.../backend/3rdparty/abseil/absl/base/macros.h | 202 +
.../3rdparty/abseil/absl/base/optimization.h | 165 +
.../3rdparty/abseil/absl/base/policy_checks.h | 121 +
.../backend/3rdparty/abseil/absl/base/port.h | 26 +
.../abseil/absl/base/raw_logging_test.cc | 50 +
.../abseil/absl/base/spinlock_test_common.cc | 266 +
.../abseil/absl/base/thread_annotations.h | 258 +
.../abseil/absl/base/throw_delegate_test.cc | 94 +
.../3rdparty/abseil/absl/container/BUILD.bazel | 128 +
.../abseil/absl/container/CMakeLists.txt | 126 +
.../abseil/absl/container/fixed_array.h | 498 ++
.../abseil/absl/container/fixed_array_test.cc | 659 ++
.../abseil/absl/container/inlined_vector.h | 1384 ++++
.../absl/container/inlined_vector_test.cc | 1766 ++++
.../container/internal/test_instance_tracker.cc | 26 +
.../container/internal/test_instance_tracker.h | 220 +
.../internal/test_instance_tracker_test.cc | 160 +
.../backend/3rdparty/abseil/absl/copts.bzl | 155 +
.../3rdparty/abseil/absl/debugging/BUILD.bazel | 305 +
.../abseil/absl/debugging/CMakeLists.txt | 193 +
.../absl/debugging/failure_signal_handler.cc | 351 +
.../absl/debugging/failure_signal_handler.h | 103 +
.../debugging/failure_signal_handler_test.cc | 146 +
.../debugging/internal/address_is_readable.cc | 133 +
.../debugging/internal/address_is_readable.h | 29 +
.../abseil/absl/debugging/internal/demangle.cc | 1862 +++++
.../abseil/absl/debugging/internal/demangle.h | 67 +
.../absl/debugging/internal/demangle_test.cc | 191 +
.../absl/debugging/internal/elf_mem_image.cc | 398 +
.../absl/debugging/internal/elf_mem_image.h | 130 +
.../absl/debugging/internal/examine_stack.cc | 147 +
.../absl/debugging/internal/examine_stack.h | 38 +
.../debugging/internal/stack_consumption.cc | 172 +
.../absl/debugging/internal/stack_consumption.h | 45 +
.../internal/stack_consumption_test.cc | 48 +
.../internal/stacktrace_aarch64-inl.inc | 189 +
.../debugging/internal/stacktrace_arm-inl.inc | 123 +
.../absl/debugging/internal/stacktrace_config.h | 74 +
.../internal/stacktrace_generic-inl.inc | 59 +
.../internal/stacktrace_powerpc-inl.inc | 243 +
.../internal/stacktrace_unimplemented-inl.inc | 22 +
.../debugging/internal/stacktrace_win32-inl.inc | 83 +
.../debugging/internal/stacktrace_x86-inl.inc | 337 +
.../abseil/absl/debugging/internal/symbolize.h | 122 +
.../absl/debugging/internal/vdso_support.cc | 192 +
.../absl/debugging/internal/vdso_support.h | 155 +
.../abseil/absl/debugging/leak_check.cc | 48 +
.../3rdparty/abseil/absl/debugging/leak_check.h | 111 +
.../abseil/absl/debugging/leak_check_disable.cc | 20 +
.../absl/debugging/leak_check_fail_test.cc | 41 +
.../abseil/absl/debugging/leak_check_test.cc | 42 +
.../abseil/absl/debugging/stacktrace.cc | 133 +
.../3rdparty/abseil/absl/debugging/stacktrace.h | 167 +
.../3rdparty/abseil/absl/debugging/symbolize.cc | 28 +
.../3rdparty/abseil/absl/debugging/symbolize.h | 35 +
.../abseil/absl/debugging/symbolize_elf.inc | 1473 ++++
.../abseil/absl/debugging/symbolize_test.cc | 517 ++
.../absl/debugging/symbolize_unimplemented.inc | 35 +
.../abseil/absl/debugging/symbolize_win32.inc | 74 +
.../3rdparty/abseil/absl/memory/BUILD.bazel | 47 +
.../3rdparty/abseil/absl/memory/CMakeLists.txt | 52 +
.../3rdparty/abseil/absl/memory/memory.h | 640 ++
.../3rdparty/abseil/absl/memory/memory_test.cc | 614 ++
.../3rdparty/abseil/absl/meta/BUILD.bazel | 29 +
.../3rdparty/abseil/absl/meta/CMakeLists.txt | 49 +
.../3rdparty/abseil/absl/meta/type_traits.h | 372 +
.../abseil/absl/meta/type_traits_test.cc | 799 ++
.../3rdparty/abseil/absl/numeric/BUILD.bazel | 41 +
.../3rdparty/abseil/absl/numeric/CMakeLists.txt | 62 +
.../3rdparty/abseil/absl/numeric/int128.cc | 225 +
.../3rdparty/abseil/absl/numeric/int128.h | 656 ++
.../absl/numeric/int128_have_intrinsic.inc | 18 +
.../abseil/absl/numeric/int128_no_intrinsic.inc | 18 +
.../abseil/absl/numeric/int128_stream_test.cc | 666 ++
.../3rdparty/abseil/absl/numeric/int128_test.cc | 431 +
.../3rdparty/abseil/absl/strings/BUILD.bazel | 322 +
.../3rdparty/abseil/absl/strings/CMakeLists.txt | 304 +
.../3rdparty/abseil/absl/strings/ascii.cc | 198 +
.../3rdparty/abseil/absl/strings/ascii.h | 239 +
.../3rdparty/abseil/absl/strings/ascii_test.cc | 354 +
.../3rdparty/abseil/absl/strings/escaping.cc | 1109 +++
.../3rdparty/abseil/absl/strings/escaping.h | 161 +
.../abseil/absl/strings/escaping_test.cc | 641 ++
.../abseil/absl/strings/internal/char_map.h | 154 +
.../absl/strings/internal/char_map_test.cc | 172 +
.../strings/internal/escaping_test_common.inc | 113 +
.../abseil/absl/strings/internal/memutil.cc | 110 +
.../abseil/absl/strings/internal/memutil.h | 146 +
.../absl/strings/internal/memutil_test.cc | 179 +
.../strings/internal/numbers_test_common.inc | 156 +
.../absl/strings/internal/ostringstream.cc | 34 +
.../absl/strings/internal/ostringstream.h | 87 +
.../absl/strings/internal/ostringstream_test.cc | 102 +
.../strings/internal/resize_uninitialized.h | 69 +
.../internal/resize_uninitialized_test.cc | 68 +
.../absl/strings/internal/stl_type_traits.h | 246 +
.../absl/strings/internal/str_join_internal.h | 309 +
.../absl/strings/internal/str_split_internal.h | 435 +
.../abseil/absl/strings/internal/utf8.cc | 51 +
.../abseil/absl/strings/internal/utf8.h | 47 +
.../abseil/absl/strings/internal/utf8_test.cc | 57 +
.../3rdparty/abseil/absl/strings/match.cc | 40 +
.../3rdparty/abseil/absl/strings/match.h | 84 +
.../3rdparty/abseil/absl/strings/match_test.cc | 99 +
.../3rdparty/abseil/absl/strings/numbers.cc | 919 +++
.../3rdparty/abseil/absl/strings/numbers.h | 172 +
.../abseil/absl/strings/numbers_test.cc | 1186 +++
.../3rdparty/abseil/absl/strings/str_cat.cc | 239 +
.../3rdparty/abseil/absl/strings/str_cat.h | 385 +
.../abseil/absl/strings/str_cat_test.cc | 539 ++
.../3rdparty/abseil/absl/strings/str_join.h | 288 +
.../abseil/absl/strings/str_join_test.cc | 473 ++
.../3rdparty/abseil/absl/strings/str_replace.cc | 79 +
.../3rdparty/abseil/absl/strings/str_replace.h | 213 +
.../abseil/absl/strings/str_replace_test.cc | 341 +
.../3rdparty/abseil/absl/strings/str_split.cc | 136 +
.../3rdparty/abseil/absl/strings/str_split.h | 511 ++
.../abseil/absl/strings/str_split_test.cc | 907 ++
.../3rdparty/abseil/absl/strings/string_view.cc | 247 +
.../3rdparty/abseil/absl/strings/string_view.h | 570 ++
.../abseil/absl/strings/string_view_test.cc | 1136 +++
.../3rdparty/abseil/absl/strings/strip.h | 89 +
.../3rdparty/abseil/absl/strings/strip_test.cc | 201 +
.../3rdparty/abseil/absl/strings/substitute.cc | 170 +
.../3rdparty/abseil/absl/strings/substitute.h | 668 ++
.../abseil/absl/strings/substitute_test.cc | 192 +
.../abseil/absl/strings/testdata/getline-1.txt | 3 +
.../abseil/absl/strings/testdata/getline-2.txt | 1 +
.../abseil/absl/synchronization/BUILD.bazel | 206 +
.../abseil/absl/synchronization/CMakeLists.txt | 154 +
.../abseil/absl/synchronization/barrier.cc | 50 +
.../abseil/absl/synchronization/barrier.h | 77 +
.../abseil/absl/synchronization/barrier_test.cc | 75 +
.../absl/synchronization/blocking_counter.cc | 55 +
.../absl/synchronization/blocking_counter.h | 97 +
.../synchronization/blocking_counter_test.cc | 66 +
.../internal/create_thread_identity.cc | 112 +
.../internal/create_thread_identity.h | 53 +
.../synchronization/internal/graphcycles.cc | 709 ++
.../absl/synchronization/internal/graphcycles.h | 136 +
.../internal/graphcycles_test.cc | 462 ++
.../synchronization/internal/kernel_timeout.h | 149 +
.../synchronization/internal/mutex_nonprod.cc | 318 +
.../synchronization/internal/mutex_nonprod.inc | 256 +
.../synchronization/internal/per_thread_sem.cc | 99 +
.../synchronization/internal/per_thread_sem.h | 107 +
.../internal/per_thread_sem_test.cc | 172 +
.../absl/synchronization/internal/thread_pool.h | 90 +
.../absl/synchronization/internal/waiter.cc | 412 +
.../absl/synchronization/internal/waiter.h | 139 +
.../absl/synchronization/lifetime_test.cc | 132 +
.../abseil/absl/synchronization/mutex.cc | 2688 ++++++
.../abseil/absl/synchronization/mutex.h | 1022 +++
.../abseil/absl/synchronization/mutex_test.cc | 1539 ++++
.../abseil/absl/synchronization/notification.cc | 84 +
.../abseil/absl/synchronization/notification.h | 112 +
.../absl/synchronization/notification_test.cc | 124 +
.../3rdparty/abseil/absl/time/BUILD.bazel | 97 +
.../3rdparty/abseil/absl/time/CMakeLists.txt | 96 +
.../backend/3rdparty/abseil/absl/time/clock.cc | 563 ++
.../backend/3rdparty/abseil/absl/time/clock.h | 72 +
.../3rdparty/abseil/absl/time/clock_test.cc | 70 +
.../3rdparty/abseil/absl/time/duration.cc | 908 ++
.../3rdparty/abseil/absl/time/duration_test.cc | 1688 ++++
.../backend/3rdparty/abseil/absl/time/format.cc | 142 +
.../3rdparty/abseil/absl/time/format_test.cc | 437 +
.../abseil/absl/time/internal/cctz/BUILD.bazel | 105 +
.../internal/cctz/include/cctz/civil_time.h | 329 +
.../cctz/include/cctz/civil_time_detail.h | 564 ++
.../time/internal/cctz/include/cctz/time_zone.h | 316 +
.../cctz/include/cctz/zone_info_source.h | 91 +
.../time/internal/cctz/src/civil_time_detail.cc | 90 +
.../time/internal/cctz/src/civil_time_test.cc | 1049 +++
.../time/internal/cctz/src/time_zone_fixed.cc | 133 +
.../time/internal/cctz/src/time_zone_fixed.h | 49 +
.../time/internal/cctz/src/time_zone_format.cc | 848 ++
.../internal/cctz/src/time_zone_format_test.cc | 1408 ++++
.../absl/time/internal/cctz/src/time_zone_if.cc | 41 +
.../absl/time/internal/cctz/src/time_zone_if.h | 70 +
.../time/internal/cctz/src/time_zone_impl.cc | 117 +
.../time/internal/cctz/src/time_zone_impl.h | 97 +
.../time/internal/cctz/src/time_zone_info.cc | 956 +++
.../time/internal/cctz/src/time_zone_info.h | 132 +
.../time/internal/cctz/src/time_zone_libc.cc | 156 +
.../time/internal/cctz/src/time_zone_libc.h | 50 +
.../time/internal/cctz/src/time_zone_lookup.cc | 142 +
.../internal/cctz/src/time_zone_lookup_test.cc | 1259 +++
.../time/internal/cctz/src/time_zone_posix.cc | 155 +
.../time/internal/cctz/src/time_zone_posix.h | 118 +
.../abseil/absl/time/internal/cctz/src/tzfile.h | 117 +
.../time/internal/cctz/src/zone_info_source.cc | 70 +
.../time/internal/cctz/testdata/README.zoneinfo | 37 +
.../absl/time/internal/cctz/testdata/version | 1 +
.../cctz/testdata/zoneinfo/Africa/Abidjan | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Accra | Bin 0 -> 842 bytes
.../cctz/testdata/zoneinfo/Africa/Addis_Ababa | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Algiers | Bin 0 -> 760 bytes
.../cctz/testdata/zoneinfo/Africa/Asmara | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Asmera | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Bamako | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Bangui | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Banjul | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Bissau | Bin 0 -> 208 bytes
.../cctz/testdata/zoneinfo/Africa/Blantyre | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Brazzaville | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Bujumbura | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Cairo | Bin 0 -> 1972 bytes
.../cctz/testdata/zoneinfo/Africa/Casablanca | Bin 0 -> 1643 bytes
.../cctz/testdata/zoneinfo/Africa/Ceuta | Bin 0 -> 2059 bytes
.../cctz/testdata/zoneinfo/Africa/Conakry | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Dakar | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Dar_es_Salaam | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Djibouti | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Douala | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/El_Aaiun | Bin 0 -> 1473 bytes
.../cctz/testdata/zoneinfo/Africa/Freetown | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Gaborone | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Harare | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Johannesburg | Bin 0 -> 271 bytes
.../internal/cctz/testdata/zoneinfo/Africa/Juba | Bin 0 -> 683 bytes
.../cctz/testdata/zoneinfo/Africa/Kampala | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Khartoum | Bin 0 -> 713 bytes
.../cctz/testdata/zoneinfo/Africa/Kigali | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Kinshasa | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lagos | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Libreville | Bin 0 -> 171 bytes
.../internal/cctz/testdata/zoneinfo/Africa/Lome | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Luanda | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lubumbashi | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lusaka | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Malabo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Maputo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Maseru | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/Africa/Mbabane | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/Africa/Mogadishu | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Monrovia | Bin 0 -> 233 bytes
.../cctz/testdata/zoneinfo/Africa/Nairobi | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Ndjamena | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Africa/Niamey | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Nouakchott | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Ouagadougou | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Porto-Novo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Sao_Tome | Bin 0 -> 234 bytes
.../cctz/testdata/zoneinfo/Africa/Timbuktu | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Tripoli | Bin 0 -> 655 bytes
.../cctz/testdata/zoneinfo/Africa/Tunis | Bin 0 -> 710 bytes
.../cctz/testdata/zoneinfo/Africa/Windhoek | Bin 0 -> 1030 bytes
.../cctz/testdata/zoneinfo/America/Adak | Bin 0 -> 2365 bytes
.../cctz/testdata/zoneinfo/America/Anchorage | Bin 0 -> 2380 bytes
.../cctz/testdata/zoneinfo/America/Anguilla | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Antigua | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Araguaina | Bin 0 -> 910 bytes
.../zoneinfo/America/Argentina/Buenos_Aires | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/Catamarca | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/ComodRivadavia | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Cordoba | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Jujuy | Bin 0 -> 1081 bytes
.../zoneinfo/America/Argentina/La_Rioja | Bin 0 -> 1123 bytes
.../testdata/zoneinfo/America/Argentina/Mendoza | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/Rio_Gallegos | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Salta | Bin 0 -> 1081 bytes
.../zoneinfo/America/Argentina/San_Juan | Bin 0 -> 1123 bytes
.../zoneinfo/America/Argentina/San_Luis | Bin 0 -> 1139 bytes
.../testdata/zoneinfo/America/Argentina/Tucuman | Bin 0 -> 1137 bytes
.../testdata/zoneinfo/America/Argentina/Ushuaia | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Aruba | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Asuncion | Bin 0 -> 2077 bytes
.../cctz/testdata/zoneinfo/America/Atikokan | Bin 0 -> 345 bytes
.../cctz/testdata/zoneinfo/America/Atka | Bin 0 -> 2365 bytes
.../cctz/testdata/zoneinfo/America/Bahia | Bin 0 -> 1050 bytes
.../testdata/zoneinfo/America/Bahia_Banderas | Bin 0 -> 1588 bytes
.../cctz/testdata/zoneinfo/America/Barbados | Bin 0 -> 344 bytes
.../cctz/testdata/zoneinfo/America/Belem | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/America/Belize | Bin 0 -> 978 bytes
.../cctz/testdata/zoneinfo/America/Blanc-Sablon | Bin 0 -> 307 bytes
.../cctz/testdata/zoneinfo/America/Boa_Vista | Bin 0 -> 658 bytes
.../cctz/testdata/zoneinfo/America/Bogota | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/America/Boise | Bin 0 -> 2403 bytes
.../cctz/testdata/zoneinfo/America/Buenos_Aires | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Cambridge_Bay | Bin 0 -> 2098 bytes
.../cctz/testdata/zoneinfo/America/Campo_Grande | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/America/Cancun | Bin 0 -> 816 bytes
.../cctz/testdata/zoneinfo/America/Caracas | Bin 0 -> 289 bytes
.../cctz/testdata/zoneinfo/America/Catamarca | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Cayenne | Bin 0 -> 224 bytes
.../cctz/testdata/zoneinfo/America/Cayman | Bin 0 -> 203 bytes
.../cctz/testdata/zoneinfo/America/Chicago | Bin 0 -> 3585 bytes
.../cctz/testdata/zoneinfo/America/Chihuahua | Bin 0 -> 1522 bytes
.../testdata/zoneinfo/America/Coral_Harbour | Bin 0 -> 345 bytes
.../cctz/testdata/zoneinfo/America/Cordoba | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Costa_Rica | Bin 0 -> 341 bytes
.../cctz/testdata/zoneinfo/America/Creston | Bin 0 -> 233 bytes
.../cctz/testdata/zoneinfo/America/Cuiaba | Bin 0 -> 1988 bytes
.../cctz/testdata/zoneinfo/America/Curacao | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Danmarkshavn | Bin 0 -> 712 bytes
.../cctz/testdata/zoneinfo/America/Dawson | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/America/Dawson_Creek | Bin 0 -> 1059 bytes
.../cctz/testdata/zoneinfo/America/Denver | Bin 0 -> 2453 bytes
.../cctz/testdata/zoneinfo/America/Detroit | Bin 0 -> 2188 bytes
.../cctz/testdata/zoneinfo/America/Dominica | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Edmonton | Bin 0 -> 2402 bytes
.../cctz/testdata/zoneinfo/America/Eirunepe | Bin 0 -> 690 bytes
.../cctz/testdata/zoneinfo/America/El_Salvador | Bin 0 -> 250 bytes
.../cctz/testdata/zoneinfo/America/Ensenada | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Fort_Nelson | Bin 0 -> 2249 bytes
.../cctz/testdata/zoneinfo/America/Fort_Wayne | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Fortaleza | Bin 0 -> 742 bytes
.../cctz/testdata/zoneinfo/America/Glace_Bay | Bin 0 -> 2206 bytes
.../cctz/testdata/zoneinfo/America/Godthab | Bin 0 -> 1892 bytes
.../cctz/testdata/zoneinfo/America/Goose_Bay | Bin 0 -> 3219 bytes
.../cctz/testdata/zoneinfo/America/Grand_Turk | Bin 0 -> 1881 bytes
.../cctz/testdata/zoneinfo/America/Grenada | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Guadeloupe | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Guatemala | Bin 0 -> 306 bytes
.../cctz/testdata/zoneinfo/America/Guayaquil | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/America/Guyana | Bin 0 -> 266 bytes
.../cctz/testdata/zoneinfo/America/Halifax | Bin 0 -> 3438 bytes
.../cctz/testdata/zoneinfo/America/Havana | Bin 0 -> 2437 bytes
.../cctz/testdata/zoneinfo/America/Hermosillo | Bin 0 -> 454 bytes
.../zoneinfo/America/Indiana/Indianapolis | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Indiana/Knox | Bin 0 -> 2437 bytes
.../testdata/zoneinfo/America/Indiana/Marengo | Bin 0 -> 1731 bytes
.../zoneinfo/America/Indiana/Petersburg | Bin 0 -> 1913 bytes
.../testdata/zoneinfo/America/Indiana/Tell_City | Bin 0 -> 1735 bytes
.../testdata/zoneinfo/America/Indiana/Vevay | Bin 0 -> 1423 bytes
.../testdata/zoneinfo/America/Indiana/Vincennes | Bin 0 -> 1703 bytes
.../testdata/zoneinfo/America/Indiana/Winamac | Bin 0 -> 1787 bytes
.../cctz/testdata/zoneinfo/America/Indianapolis | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Inuvik | Bin 0 -> 1928 bytes
.../cctz/testdata/zoneinfo/America/Iqaluit | Bin 0 -> 2046 bytes
.../cctz/testdata/zoneinfo/America/Jamaica | Bin 0 -> 507 bytes
.../cctz/testdata/zoneinfo/America/Jujuy | Bin 0 -> 1081 bytes
.../cctz/testdata/zoneinfo/America/Juneau | Bin 0 -> 2362 bytes
.../zoneinfo/America/Kentucky/Louisville | Bin 0 -> 2781 bytes
.../zoneinfo/America/Kentucky/Monticello | Bin 0 -> 2361 bytes
.../cctz/testdata/zoneinfo/America/Knox_IN | Bin 0 -> 2437 bytes
.../cctz/testdata/zoneinfo/America/Kralendijk | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/La_Paz | Bin 0 -> 257 bytes
.../cctz/testdata/zoneinfo/America/Lima | Bin 0 -> 431 bytes
.../cctz/testdata/zoneinfo/America/Los_Angeles | Bin 0 -> 2845 bytes
.../cctz/testdata/zoneinfo/America/Louisville | Bin 0 -> 2781 bytes
.../testdata/zoneinfo/America/Lower_Princes | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Maceio | Bin 0 -> 770 bytes
.../cctz/testdata/zoneinfo/America/Managua | Bin 0 -> 463 bytes
.../cctz/testdata/zoneinfo/America/Manaus | Bin 0 -> 630 bytes
.../cctz/testdata/zoneinfo/America/Marigot | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Martinique | Bin 0 -> 257 bytes
.../cctz/testdata/zoneinfo/America/Matamoros | Bin 0 -> 1416 bytes
.../cctz/testdata/zoneinfo/America/Mazatlan | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/America/Mendoza | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Menominee | Bin 0 -> 2283 bytes
.../cctz/testdata/zoneinfo/America/Merida | Bin 0 -> 1456 bytes
.../cctz/testdata/zoneinfo/America/Metlakatla | Bin 0 -> 1418 bytes
.../cctz/testdata/zoneinfo/America/Mexico_City | Bin 0 -> 1618 bytes
.../cctz/testdata/zoneinfo/America/Miquelon | Bin 0 -> 1696 bytes
.../cctz/testdata/zoneinfo/America/Moncton | Bin 0 -> 3163 bytes
.../cctz/testdata/zoneinfo/America/Monterrey | Bin 0 -> 1416 bytes
.../cctz/testdata/zoneinfo/America/Montevideo | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/America/Montreal | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/America/Montserrat | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Nassau | Bin 0 -> 2284 bytes
.../cctz/testdata/zoneinfo/America/New_York | Bin 0 -> 3545 bytes
.../cctz/testdata/zoneinfo/America/Nipigon | Bin 0 -> 2131 bytes
.../cctz/testdata/zoneinfo/America/Nome | Bin 0 -> 2376 bytes
.../cctz/testdata/zoneinfo/America/Noronha | Bin 0 -> 742 bytes
.../zoneinfo/America/North_Dakota/Beulah | Bin 0 -> 2389 bytes
.../zoneinfo/America/North_Dakota/Center | Bin 0 -> 2389 bytes
.../zoneinfo/America/North_Dakota/New_Salem | Bin 0 -> 2389 bytes
.../cctz/testdata/zoneinfo/America/Ojinaga | Bin 0 -> 1522 bytes
.../cctz/testdata/zoneinfo/America/Panama | Bin 0 -> 203 bytes
.../cctz/testdata/zoneinfo/America/Pangnirtung | Bin 0 -> 2108 bytes
.../cctz/testdata/zoneinfo/America/Paramaribo | Bin 0 -> 296 bytes
.../cctz/testdata/zoneinfo/America/Phoenix | Bin 0 -> 353 bytes
.../testdata/zoneinfo/America/Port-au-Prince | Bin 0 -> 1455 bytes
.../testdata/zoneinfo/America/Port_of_Spain | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Porto_Acre | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/America/Porto_Velho | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/America/Puerto_Rico | Bin 0 -> 255 bytes
.../cctz/testdata/zoneinfo/America/Punta_Arenas | Bin 0 -> 1911 bytes
.../cctz/testdata/zoneinfo/America/Rainy_River | Bin 0 -> 2131 bytes
.../cctz/testdata/zoneinfo/America/Rankin_Inlet | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Recife | Bin 0 -> 742 bytes
.../cctz/testdata/zoneinfo/America/Regina | Bin 0 -> 994 bytes
.../cctz/testdata/zoneinfo/America/Resolute | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Rio_Branco | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/America/Rosario | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Santa_Isabel | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Santarem | Bin 0 -> 632 bytes
.../cctz/testdata/zoneinfo/America/Santiago | Bin 0 -> 2538 bytes
.../testdata/zoneinfo/America/Santo_Domingo | Bin 0 -> 491 bytes
.../cctz/testdata/zoneinfo/America/Sao_Paulo | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/America/Scoresbysund | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Shiprock | Bin 0 -> 2453 bytes
.../cctz/testdata/zoneinfo/America/Sitka | Bin 0 -> 2350 bytes
.../testdata/zoneinfo/America/St_Barthelemy | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Johns | Bin 0 -> 3664 bytes
.../cctz/testdata/zoneinfo/America/St_Kitts | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Lucia | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Thomas | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Vincent | Bin 0 -> 170 bytes
.../testdata/zoneinfo/America/Swift_Current | Bin 0 -> 574 bytes
.../cctz/testdata/zoneinfo/America/Tegucigalpa | Bin 0 -> 278 bytes
.../cctz/testdata/zoneinfo/America/Thule | Bin 0 -> 1528 bytes
.../cctz/testdata/zoneinfo/America/Thunder_Bay | Bin 0 -> 2211 bytes
.../cctz/testdata/zoneinfo/America/Tijuana | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Toronto | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/America/Tortola | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Vancouver | Bin 0 -> 2901 bytes
.../cctz/testdata/zoneinfo/America/Virgin | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Whitehorse | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/America/Winnipeg | Bin 0 -> 2891 bytes
.../cctz/testdata/zoneinfo/America/Yakutat | Bin 0 -> 2314 bytes
.../cctz/testdata/zoneinfo/America/Yellowknife | Bin 0 -> 1980 bytes
.../cctz/testdata/zoneinfo/Antarctica/Casey | Bin 0 -> 311 bytes
.../cctz/testdata/zoneinfo/Antarctica/Davis | Bin 0 -> 311 bytes
.../testdata/zoneinfo/Antarctica/DumontDUrville | Bin 0 -> 216 bytes
.../cctz/testdata/zoneinfo/Antarctica/Macquarie | Bin 0 -> 1543 bytes
.../cctz/testdata/zoneinfo/Antarctica/Mawson | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Antarctica/McMurdo | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Antarctica/Palmer | Bin 0 -> 1432 bytes
.../cctz/testdata/zoneinfo/Antarctica/Rothera | Bin 0 -> 186 bytes
.../testdata/zoneinfo/Antarctica/South_Pole | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Antarctica/Syowa | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Antarctica/Troll | Bin 0 -> 1176 bytes
.../cctz/testdata/zoneinfo/Antarctica/Vostok | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Arctic/Longyearbyen | Bin 0 -> 2251 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aden | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Almaty | Bin 0 -> 1031 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Amman | Bin 0 -> 1877 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Anadyr | Bin 0 -> 1222 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aqtau | Bin 0 -> 1017 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aqtobe | Bin 0 -> 1047 bytes
.../cctz/testdata/zoneinfo/Asia/Ashgabat | Bin 0 -> 651 bytes
.../cctz/testdata/zoneinfo/Asia/Ashkhabad | Bin 0 -> 651 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Atyrau | Bin 0 -> 1025 bytes
.../cctz/testdata/zoneinfo/Asia/Baghdad | Bin 0 -> 1004 bytes
.../cctz/testdata/zoneinfo/Asia/Bahrain | Bin 0 -> 225 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Baku | Bin 0 -> 1269 bytes
.../cctz/testdata/zoneinfo/Asia/Bangkok | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Barnaul | Bin 0 -> 1255 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Beirut | Bin 0 -> 2175 bytes
.../cctz/testdata/zoneinfo/Asia/Bishkek | Bin 0 -> 1045 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Brunei | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Calcutta | Bin 0 -> 312 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Chita | Bin 0 -> 1257 bytes
.../cctz/testdata/zoneinfo/Asia/Choibalsan | Bin 0 -> 991 bytes
.../cctz/testdata/zoneinfo/Asia/Chongqing | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Chungking | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Colombo | Bin 0 -> 413 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dacca | Bin 0 -> 370 bytes
.../cctz/testdata/zoneinfo/Asia/Damascus | Bin 0 -> 2320 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dhaka | Bin 0 -> 370 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dili | Bin 0 -> 253 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dubai | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Dushanbe | Bin 0 -> 621 bytes
.../cctz/testdata/zoneinfo/Asia/Famagusta | Bin 0 -> 2042 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Gaza | Bin 0 -> 2295 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Harbin | Bin 0 -> 414 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Hebron | Bin 0 -> 2323 bytes
.../cctz/testdata/zoneinfo/Asia/Ho_Chi_Minh | Bin 0 -> 389 bytes
.../cctz/testdata/zoneinfo/Asia/Hong_Kong | Bin 0 -> 1189 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Hovd | Bin 0 -> 921 bytes
.../cctz/testdata/zoneinfo/Asia/Irkutsk | Bin 0 -> 1276 bytes
.../cctz/testdata/zoneinfo/Asia/Istanbul | Bin 0 -> 2166 bytes
.../cctz/testdata/zoneinfo/Asia/Jakarta | Bin 0 -> 392 bytes
.../cctz/testdata/zoneinfo/Asia/Jayapura | Bin 0 -> 251 bytes
.../cctz/testdata/zoneinfo/Asia/Jerusalem | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Kabul | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Kamchatka | Bin 0 -> 1198 bytes
.../cctz/testdata/zoneinfo/Asia/Karachi | Bin 0 -> 417 bytes
.../cctz/testdata/zoneinfo/Asia/Kashgar | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Kathmandu | Bin 0 -> 238 bytes
.../cctz/testdata/zoneinfo/Asia/Katmandu | Bin 0 -> 238 bytes
.../cctz/testdata/zoneinfo/Asia/Khandyga | Bin 0 -> 1311 bytes
.../cctz/testdata/zoneinfo/Asia/Kolkata | Bin 0 -> 312 bytes
.../cctz/testdata/zoneinfo/Asia/Krasnoyarsk | Bin 0 -> 1243 bytes
.../cctz/testdata/zoneinfo/Asia/Kuala_Lumpur | Bin 0 -> 424 bytes
.../cctz/testdata/zoneinfo/Asia/Kuching | Bin 0 -> 521 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Kuwait | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Macao | Bin 0 -> 771 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Macau | Bin 0 -> 771 bytes
.../cctz/testdata/zoneinfo/Asia/Magadan | Bin 0 -> 1258 bytes
.../cctz/testdata/zoneinfo/Asia/Makassar | Bin 0 -> 288 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Manila | Bin 0 -> 367 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Muscat | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Nicosia | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/Asia/Novokuznetsk | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Asia/Novosibirsk | Bin 0 -> 1255 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Omsk | Bin 0 -> 1243 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Oral | Bin 0 -> 1039 bytes
.../cctz/testdata/zoneinfo/Asia/Phnom_Penh | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Pontianak | Bin 0 -> 395 bytes
.../cctz/testdata/zoneinfo/Asia/Pyongyang | Bin 0 -> 272 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Qatar | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Asia/Qyzylorda | Bin 0 -> 1047 bytes
.../cctz/testdata/zoneinfo/Asia/Rangoon | Bin 0 -> 297 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Riyadh | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Saigon | Bin 0 -> 389 bytes
.../cctz/testdata/zoneinfo/Asia/Sakhalin | Bin 0 -> 1234 bytes
.../cctz/testdata/zoneinfo/Asia/Samarkand | Bin 0 -> 619 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Seoul | Bin 0 -> 531 bytes
.../cctz/testdata/zoneinfo/Asia/Shanghai | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Singapore | Bin 0 -> 424 bytes
.../cctz/testdata/zoneinfo/Asia/Srednekolymsk | Bin 0 -> 1244 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Taipei | Bin 0 -> 790 bytes
.../cctz/testdata/zoneinfo/Asia/Tashkent | Bin 0 -> 635 bytes
.../cctz/testdata/zoneinfo/Asia/Tbilisi | Bin 0 -> 1080 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tehran | Bin 0 -> 1718 bytes
.../cctz/testdata/zoneinfo/Asia/Tel_Aviv | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Thimbu | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Thimphu | Bin 0 -> 229 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tokyo | Bin 0 -> 318 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tomsk | Bin 0 -> 1255 bytes
.../cctz/testdata/zoneinfo/Asia/Ujung_Pandang | Bin 0 -> 288 bytes
.../cctz/testdata/zoneinfo/Asia/Ulaanbaatar | Bin 0 -> 921 bytes
.../cctz/testdata/zoneinfo/Asia/Ulan_Bator | Bin 0 -> 921 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Urumqi | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Ust-Nera | Bin 0 -> 1290 bytes
.../cctz/testdata/zoneinfo/Asia/Vientiane | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Vladivostok | Bin 0 -> 1244 bytes
.../cctz/testdata/zoneinfo/Asia/Yakutsk | Bin 0 -> 1243 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Yangon | Bin 0 -> 297 bytes
.../cctz/testdata/zoneinfo/Asia/Yekaterinburg | Bin 0 -> 1281 bytes
.../cctz/testdata/zoneinfo/Asia/Yerevan | Bin 0 -> 1213 bytes
.../cctz/testdata/zoneinfo/Atlantic/Azores | Bin 0 -> 3493 bytes
.../cctz/testdata/zoneinfo/Atlantic/Bermuda | Bin 0 -> 2004 bytes
.../cctz/testdata/zoneinfo/Atlantic/Canary | Bin 0 -> 1911 bytes
.../cctz/testdata/zoneinfo/Atlantic/Cape_Verde | Bin 0 -> 284 bytes
.../cctz/testdata/zoneinfo/Atlantic/Faeroe | Bin 0 -> 1829 bytes
.../cctz/testdata/zoneinfo/Atlantic/Faroe | Bin 0 -> 1829 bytes
.../cctz/testdata/zoneinfo/Atlantic/Jan_Mayen | Bin 0 -> 2251 bytes
.../cctz/testdata/zoneinfo/Atlantic/Madeira | Bin 0 -> 3484 bytes
.../cctz/testdata/zoneinfo/Atlantic/Reykjavik | Bin 0 -> 1188 bytes
.../testdata/zoneinfo/Atlantic/South_Georgia | Bin 0 -> 181 bytes
.../cctz/testdata/zoneinfo/Atlantic/St_Helena | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Atlantic/Stanley | Bin 0 -> 1251 bytes
.../cctz/testdata/zoneinfo/Australia/ACT | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Adelaide | Bin 0 -> 2238 bytes
.../cctz/testdata/zoneinfo/Australia/Brisbane | Bin 0 -> 452 bytes
.../testdata/zoneinfo/Australia/Broken_Hill | Bin 0 -> 2274 bytes
.../cctz/testdata/zoneinfo/Australia/Canberra | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Currie | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Darwin | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Australia/Eucla | Bin 0 -> 503 bytes
.../cctz/testdata/zoneinfo/Australia/Hobart | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Australia/LHI | Bin 0 -> 1889 bytes
.../cctz/testdata/zoneinfo/Australia/Lindeman | Bin 0 -> 522 bytes
.../cctz/testdata/zoneinfo/Australia/Lord_Howe | Bin 0 -> 1889 bytes
.../cctz/testdata/zoneinfo/Australia/Melbourne | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/NSW | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/North | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Australia/Perth | Bin 0 -> 479 bytes
.../cctz/testdata/zoneinfo/Australia/Queensland | Bin 0 -> 452 bytes
.../cctz/testdata/zoneinfo/Australia/South | Bin 0 -> 2238 bytes
.../cctz/testdata/zoneinfo/Australia/Sydney | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Tasmania | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Australia/Victoria | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/West | Bin 0 -> 479 bytes
.../cctz/testdata/zoneinfo/Australia/Yancowinna | Bin 0 -> 2274 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/Acre | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/Brazil/DeNoronha | Bin 0 -> 742 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/East | Bin 0 -> 2016 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/West | Bin 0 -> 630 bytes
.../time/internal/cctz/testdata/zoneinfo/CET | Bin 0 -> 2102 bytes
.../internal/cctz/testdata/zoneinfo/CST6CDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Canada/Atlantic | Bin 0 -> 3438 bytes
.../cctz/testdata/zoneinfo/Canada/Central | Bin 0 -> 2891 bytes
.../cctz/testdata/zoneinfo/Canada/Eastern | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/Canada/Mountain | Bin 0 -> 2402 bytes
.../cctz/testdata/zoneinfo/Canada/Newfoundland | Bin 0 -> 3664 bytes
.../cctz/testdata/zoneinfo/Canada/Pacific | Bin 0 -> 2901 bytes
.../cctz/testdata/zoneinfo/Canada/Saskatchewan | Bin 0 -> 994 bytes
.../cctz/testdata/zoneinfo/Canada/Yukon | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/Chile/Continental | Bin 0 -> 2538 bytes
.../cctz/testdata/zoneinfo/Chile/EasterIsland | Bin 0 -> 2242 bytes
.../time/internal/cctz/testdata/zoneinfo/Cuba | Bin 0 -> 2437 bytes
.../time/internal/cctz/testdata/zoneinfo/EET | Bin 0 -> 1876 bytes
.../time/internal/cctz/testdata/zoneinfo/EST | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/EST5EDT | Bin 0 -> 2294 bytes
.../time/internal/cctz/testdata/zoneinfo/Egypt | Bin 0 -> 1972 bytes
.../time/internal/cctz/testdata/zoneinfo/Eire | Bin 0 -> 3531 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+1 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+10 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+11 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+12 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+2 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+3 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+4 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+5 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+6 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+7 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+8 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+9 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-1 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-10 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-11 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-12 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-13 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-14 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-2 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-3 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-4 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-5 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-6 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-7 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-8 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-9 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT0 | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Etc/Greenwich | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/UCT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/UTC | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Etc/Universal | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/Zulu | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Europe/Amsterdam | Bin 0 -> 2949 bytes
.../cctz/testdata/zoneinfo/Europe/Andorra | Bin 0 -> 1751 bytes
.../cctz/testdata/zoneinfo/Europe/Astrakhan | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Europe/Athens | Bin 0 -> 2271 bytes
.../cctz/testdata/zoneinfo/Europe/Belfast | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Belgrade | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Berlin | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Europe/Bratislava | Bin 0 -> 2272 bytes
.../cctz/testdata/zoneinfo/Europe/Brussels | Bin 0 -> 2970 bytes
.../cctz/testdata/zoneinfo/Europe/Bucharest | Bin 0 -> 2221 bytes
.../cctz/testdata/zoneinfo/Europe/Budapest | Bin 0 -> 2405 bytes
.../cctz/testdata/zoneinfo/Europe/Busingen | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Chisinau | Bin 0 -> 2445 bytes
.../cctz/testdata/zoneinfo/Europe/Copenhagen | Bin 0 -> 2160 bytes
.../cctz/testdata/zoneinfo/Europe/Dublin | Bin 0 -> 3531 bytes
.../cctz/testdata/zoneinfo/Europe/Gibraltar | Bin 0 -> 3061 bytes
.../cctz/testdata/zoneinfo/Europe/Guernsey | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Helsinki | Bin 0 -> 1909 bytes
.../cctz/testdata/zoneinfo/Europe/Isle_of_Man | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Istanbul | Bin 0 -> 2166 bytes
.../cctz/testdata/zoneinfo/Europe/Jersey | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Kaliningrad | Bin 0 -> 1518 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Kiev | Bin 0 -> 2097 bytes
.../cctz/testdata/zoneinfo/Europe/Kirov | Bin 0 -> 1167 bytes
.../cctz/testdata/zoneinfo/Europe/Lisbon | Bin 0 -> 3469 bytes
.../cctz/testdata/zoneinfo/Europe/Ljubljana | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/London | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Luxembourg | Bin 0 -> 2974 bytes
.../cctz/testdata/zoneinfo/Europe/Madrid | Bin 0 -> 2637 bytes
.../cctz/testdata/zoneinfo/Europe/Malta | Bin 0 -> 2629 bytes
.../cctz/testdata/zoneinfo/Europe/Mariehamn | Bin 0 -> 1909 bytes
.../cctz/testdata/zoneinfo/Europe/Minsk | Bin 0 -> 1370 bytes
.../cctz/testdata/zoneinfo/Europe/Monaco | Bin 0 -> 2953 bytes
.../cctz/testdata/zoneinfo/Europe/Moscow | Bin 0 -> 1544 bytes
.../cctz/testdata/zoneinfo/Europe/Nicosia | Bin 0 -> 2016 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Oslo | Bin 0 -> 2251 bytes
.../cctz/testdata/zoneinfo/Europe/Paris | Bin 0 -> 2971 bytes
.../cctz/testdata/zoneinfo/Europe/Podgorica | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Prague | Bin 0 -> 2272 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Riga | Bin 0 -> 2235 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Rome | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Samara | Bin 0 -> 1253 bytes
.../cctz/testdata/zoneinfo/Europe/San_Marino | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Sarajevo | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Saratov | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Europe/Simferopol | Bin 0 -> 1490 bytes
.../cctz/testdata/zoneinfo/Europe/Skopje | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Sofia | Bin 0 -> 2130 bytes
.../cctz/testdata/zoneinfo/Europe/Stockholm | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Tallinn | Bin 0 -> 2187 bytes
.../cctz/testdata/zoneinfo/Europe/Tirane | Bin 0 -> 2098 bytes
.../cctz/testdata/zoneinfo/Europe/Tiraspol | Bin 0 -> 2445 bytes
.../cctz/testdata/zoneinfo/Europe/Ulyanovsk | Bin 0 -> 1281 bytes
.../cctz/testdata/zoneinfo/Europe/Uzhgorod | Bin 0 -> 2103 bytes
.../cctz/testdata/zoneinfo/Europe/Vaduz | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Vatican | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Vienna | Bin 0 -> 2237 bytes
.../cctz/testdata/zoneinfo/Europe/Vilnius | Bin 0 -> 2199 bytes
.../cctz/testdata/zoneinfo/Europe/Volgograd | Bin 0 -> 1167 bytes
.../cctz/testdata/zoneinfo/Europe/Warsaw | Bin 0 -> 2705 bytes
.../cctz/testdata/zoneinfo/Europe/Zagreb | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Zaporozhye | Bin 0 -> 2115 bytes
.../cctz/testdata/zoneinfo/Europe/Zurich | Bin 0 -> 1918 bytes
.../internal/cctz/testdata/zoneinfo/Factory | Bin 0 -> 148 bytes
.../time/internal/cctz/testdata/zoneinfo/GB | Bin 0 -> 3687 bytes
.../internal/cctz/testdata/zoneinfo/GB-Eire | Bin 0 -> 3687 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT+0 | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT-0 | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Greenwich | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/HST | Bin 0 -> 128 bytes
.../internal/cctz/testdata/zoneinfo/Hongkong | Bin 0 -> 1189 bytes
.../internal/cctz/testdata/zoneinfo/Iceland | Bin 0 -> 1188 bytes
.../cctz/testdata/zoneinfo/Indian/Antananarivo | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Chagos | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Indian/Christmas | Bin 0 -> 182 bytes
.../cctz/testdata/zoneinfo/Indian/Cocos | Bin 0 -> 191 bytes
.../cctz/testdata/zoneinfo/Indian/Comoro | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Kerguelen | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Indian/Mahe | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Indian/Maldives | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Indian/Mauritius | Bin 0 -> 267 bytes
.../cctz/testdata/zoneinfo/Indian/Mayotte | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Reunion | Bin 0 -> 187 bytes
.../time/internal/cctz/testdata/zoneinfo/Iran | Bin 0 -> 1718 bytes
.../time/internal/cctz/testdata/zoneinfo/Israel | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Jamaica | Bin 0 -> 507 bytes
.../time/internal/cctz/testdata/zoneinfo/Japan | Bin 0 -> 318 bytes
.../internal/cctz/testdata/zoneinfo/Kwajalein | Bin 0 -> 259 bytes
.../time/internal/cctz/testdata/zoneinfo/Libya | Bin 0 -> 655 bytes
.../time/internal/cctz/testdata/zoneinfo/MET | Bin 0 -> 2102 bytes
.../time/internal/cctz/testdata/zoneinfo/MST | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/MST7MDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Mexico/BajaNorte | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/Mexico/BajaSur | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/Mexico/General | Bin 0 -> 1618 bytes
.../time/internal/cctz/testdata/zoneinfo/NZ | Bin 0 -> 2460 bytes
.../internal/cctz/testdata/zoneinfo/NZ-CHAT | Bin 0 -> 2087 bytes
.../time/internal/cctz/testdata/zoneinfo/Navajo | Bin 0 -> 2453 bytes
.../time/internal/cctz/testdata/zoneinfo/PRC | Bin 0 -> 414 bytes
.../internal/cctz/testdata/zoneinfo/PST8PDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Pacific/Apia | Bin 0 -> 1134 bytes
.../cctz/testdata/zoneinfo/Pacific/Auckland | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Pacific/Bougainville | Bin 0 -> 296 bytes
.../cctz/testdata/zoneinfo/Pacific/Chatham | Bin 0 -> 2087 bytes
.../cctz/testdata/zoneinfo/Pacific/Chuuk | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Easter | Bin 0 -> 2242 bytes
.../cctz/testdata/zoneinfo/Pacific/Efate | Bin 0 -> 492 bytes
.../cctz/testdata/zoneinfo/Pacific/Enderbury | Bin 0 -> 259 bytes
.../cctz/testdata/zoneinfo/Pacific/Fakaofo | Bin 0 -> 221 bytes
.../cctz/testdata/zoneinfo/Pacific/Fiji | Bin 0 -> 1104 bytes
.../cctz/testdata/zoneinfo/Pacific/Funafuti | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Galapagos | Bin 0 -> 268 bytes
.../cctz/testdata/zoneinfo/Pacific/Gambier | Bin 0 -> 186 bytes
.../cctz/testdata/zoneinfo/Pacific/Guadalcanal | Bin 0 -> 188 bytes
.../cctz/testdata/zoneinfo/Pacific/Guam | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Pacific/Honolulu | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/Pacific/Johnston | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/Pacific/Kiritimati | Bin 0 -> 263 bytes
.../cctz/testdata/zoneinfo/Pacific/Kosrae | Bin 0 -> 251 bytes
.../cctz/testdata/zoneinfo/Pacific/Kwajalein | Bin 0 -> 259 bytes
.../cctz/testdata/zoneinfo/Pacific/Majuro | Bin 0 -> 221 bytes
.../cctz/testdata/zoneinfo/Pacific/Marquesas | Bin 0 -> 195 bytes
.../cctz/testdata/zoneinfo/Pacific/Midway | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Nauru | Bin 0 -> 282 bytes
.../cctz/testdata/zoneinfo/Pacific/Niue | Bin 0 -> 266 bytes
.../cctz/testdata/zoneinfo/Pacific/Norfolk | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Pacific/Noumea | Bin 0 -> 328 bytes
.../cctz/testdata/zoneinfo/Pacific/Pago_Pago | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Palau | Bin 0 -> 182 bytes
.../cctz/testdata/zoneinfo/Pacific/Pitcairn | Bin 0 -> 223 bytes
.../cctz/testdata/zoneinfo/Pacific/Pohnpei | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Ponape | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Port_Moresby | Bin 0 -> 206 bytes
.../cctz/testdata/zoneinfo/Pacific/Rarotonga | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/Pacific/Saipan | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Pacific/Samoa | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Tahiti | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Pacific/Tarawa | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Tongatapu | Bin 0 -> 393 bytes
.../cctz/testdata/zoneinfo/Pacific/Truk | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Wake | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Wallis | Bin 0 -> 183 bytes
.../internal/cctz/testdata/zoneinfo/Pacific/Yap | Bin 0 -> 183 bytes
.../time/internal/cctz/testdata/zoneinfo/Poland | Bin 0 -> 2705 bytes
.../internal/cctz/testdata/zoneinfo/Portugal | Bin 0 -> 3469 bytes
.../time/internal/cctz/testdata/zoneinfo/ROC | Bin 0 -> 790 bytes
.../time/internal/cctz/testdata/zoneinfo/ROK | Bin 0 -> 531 bytes
.../internal/cctz/testdata/zoneinfo/Singapore | Bin 0 -> 424 bytes
.../time/internal/cctz/testdata/zoneinfo/Turkey | Bin 0 -> 2166 bytes
.../time/internal/cctz/testdata/zoneinfo/UCT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/US/Alaska | Bin 0 -> 2380 bytes
.../internal/cctz/testdata/zoneinfo/US/Aleutian | Bin 0 -> 2365 bytes
.../internal/cctz/testdata/zoneinfo/US/Arizona | Bin 0 -> 353 bytes
.../internal/cctz/testdata/zoneinfo/US/Central | Bin 0 -> 3585 bytes
.../cctz/testdata/zoneinfo/US/East-Indiana | Bin 0 -> 1675 bytes
.../internal/cctz/testdata/zoneinfo/US/Eastern | Bin 0 -> 3545 bytes
.../internal/cctz/testdata/zoneinfo/US/Hawaii | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/US/Indiana-Starke | Bin 0 -> 2437 bytes
.../internal/cctz/testdata/zoneinfo/US/Michigan | Bin 0 -> 2188 bytes
.../internal/cctz/testdata/zoneinfo/US/Mountain | Bin 0 -> 2453 bytes
.../internal/cctz/testdata/zoneinfo/US/Pacific | Bin 0 -> 2845 bytes
.../internal/cctz/testdata/zoneinfo/US/Samoa | Bin 0 -> 196 bytes
.../time/internal/cctz/testdata/zoneinfo/UTC | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Universal | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/W-SU | Bin 0 -> 1544 bytes
.../time/internal/cctz/testdata/zoneinfo/WET | Bin 0 -> 1873 bytes
.../time/internal/cctz/testdata/zoneinfo/Zulu | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/iso3166.tab | 274 +
.../internal/cctz/testdata/zoneinfo/localtime | Bin 0 -> 148 bytes
.../cctz/testdata/zoneinfo/zone1970.tab | 382 +
.../absl/time/internal/get_current_time_ios.inc | 80 +
.../time/internal/get_current_time_posix.inc | 22 +
.../time/internal/get_current_time_windows.inc | 17 +
.../abseil/absl/time/internal/test_util.cc | 123 +
.../abseil/absl/time/internal/test_util.h | 49 +
.../abseil/absl/time/internal/zoneinfo.inc | 729 ++
.../backend/3rdparty/abseil/absl/time/time.cc | 385 +
.../backend/3rdparty/abseil/absl/time/time.h | 1342 +++
.../3rdparty/abseil/absl/time/time_norm_test.cc | 306 +
.../3rdparty/abseil/absl/time/time_test.cc | 1088 +++
.../3rdparty/abseil/absl/time/time_zone_test.cc | 97 +
.../3rdparty/abseil/absl/types/BUILD.bazel | 225 +
.../3rdparty/abseil/absl/types/CMakeLists.txt | 201 +
.../backend/3rdparty/abseil/absl/types/any.h | 539 ++
.../absl/types/any_exception_safety_test.cc | 166 +
.../3rdparty/abseil/absl/types/any_test.cc | 724 ++
.../3rdparty/abseil/absl/types/bad_any_cast.cc | 40 +
.../3rdparty/abseil/absl/types/bad_any_cast.h | 57 +
.../abseil/absl/types/bad_optional_access.cc | 42 +
.../abseil/absl/types/bad_optional_access.h | 60 +
.../abseil/absl/types/bad_variant_access.cc | 58 +
.../abseil/absl/types/bad_variant_access.h | 64 +
.../abseil/absl/types/internal/variant.h | 1387 ++++
.../3rdparty/abseil/absl/types/optional.cc | 24 +
.../3rdparty/abseil/absl/types/optional.h | 1131 +++
.../3rdparty/abseil/absl/types/optional_test.cc | 1625 ++++
.../backend/3rdparty/abseil/absl/types/span.h | 748 ++
.../3rdparty/abseil/absl/types/span_test.cc | 781 ++
.../3rdparty/abseil/absl/types/variant.h | 838 ++
.../3rdparty/abseil/absl/types/variant_test.cc | 2612 ++++++
.../3rdparty/abseil/absl/utility/BUILD.bazel | 33 +
.../3rdparty/abseil/absl/utility/CMakeLists.txt | 45 +
.../3rdparty/abseil/absl/utility/utility.h | 291 +
.../abseil/absl/utility/utility_test.cc | 345 +
.../ostrich/backend/3rdparty/gtest/.gitignore | 40 +
.../ostrich/backend/3rdparty/gtest/.travis.yml | 78 +
.../ostrich/backend/3rdparty/gtest/BUILD.bazel | 175 +
.../backend/3rdparty/gtest/CMakeLists.txt | 33 +
.../backend/3rdparty/gtest/CONTRIBUTING.md | 160 +
.../ostrich/backend/3rdparty/gtest/LICENSE | 28 +
.../ostrich/backend/3rdparty/gtest/Makefile.am | 14 +
.../ostrich/backend/3rdparty/gtest/README.md | 122 +
.../ostrich/backend/3rdparty/gtest/WORKSPACE | 8 +
.../ostrich/backend/3rdparty/gtest/appveyor.yml | 99 +
.../3rdparty/gtest/ci/build-linux-autotools.sh | 44 +
.../3rdparty/gtest/ci/build-linux-bazel.sh | 36 +
.../backend/3rdparty/gtest/ci/env-linux.sh | 41 +
.../backend/3rdparty/gtest/ci/env-osx.sh | 40 +
.../3rdparty/gtest/ci/get-nprocessors.sh | 48 +
.../backend/3rdparty/gtest/ci/install-linux.sh | 49 +
.../backend/3rdparty/gtest/ci/install-osx.sh | 39 +
.../backend/3rdparty/gtest/ci/log-config.sh | 51 +
.../ostrich/backend/3rdparty/gtest/ci/travis.sh | 36 +
.../ostrich/backend/3rdparty/gtest/configure.ac | 16 +
.../backend/3rdparty/gtest/googlemock/CHANGES | 126 +
.../3rdparty/gtest/googlemock/CMakeLists.txt | 242 +
.../3rdparty/gtest/googlemock/CONTRIBUTORS | 40 +
.../backend/3rdparty/gtest/googlemock/LICENSE | 28 +
.../3rdparty/gtest/googlemock/Makefile.am | 224 +
.../backend/3rdparty/gtest/googlemock/README.md | 344 +
.../3rdparty/gtest/googlemock/cmake/gmock.pc.in | 9 +
.../gtest/googlemock/cmake/gmock_main.pc.in | 9 +
.../3rdparty/gtest/googlemock/configure.ac | 146 +
.../gtest/googlemock/docs/CheatSheet.md | 564 ++
.../3rdparty/gtest/googlemock/docs/CookBook.md | 3660 +++++++++
.../3rdparty/gtest/googlemock/docs/DesignDoc.md | 280 +
.../gtest/googlemock/docs/Documentation.md | 15 +
.../gtest/googlemock/docs/ForDummies.md | 447 +
.../googlemock/docs/FrequentlyAskedQuestions.md | 628 ++
.../gtest/googlemock/docs/KnownIssues.md | 19 +
.../googlemock/include/gmock/gmock-actions.h | 1262 +++
.../include/gmock/gmock-cardinalities.h | 147 +
.../include/gmock/gmock-generated-actions.h | 2571 ++++++
.../gmock/gmock-generated-actions.h.pump | 833 ++
.../gmock/gmock-generated-function-mockers.h | 1379 ++++
.../gmock-generated-function-mockers.h.pump | 347 +
.../include/gmock/gmock-generated-matchers.h | 2258 +++++
.../gmock/gmock-generated-matchers.h.pump | 675 ++
.../include/gmock/gmock-generated-nice-strict.h | 458 ++
.../gmock/gmock-generated-nice-strict.h.pump | 178 +
.../googlemock/include/gmock/gmock-matchers.h | 5255 ++++++++++++
.../include/gmock/gmock-more-actions.h | 246 +
.../include/gmock/gmock-more-matchers.h | 91 +
.../include/gmock/gmock-spec-builders.h | 1918 +++++
.../gtest/googlemock/include/gmock/gmock.h | 95 +
.../internal/custom/gmock-generated-actions.h | 8 +
.../custom/gmock-generated-actions.h.pump | 10 +
.../gmock/internal/custom/gmock-matchers.h | 38 +
.../include/gmock/internal/custom/gmock-port.h | 46 +
.../internal/gmock-generated-internal-utils.h | 286 +
.../gmock-generated-internal-utils.h.pump | 136 +
.../gmock/internal/gmock-internal-utils.h | 574 ++
.../include/gmock/internal/gmock-port.h | 87 +
.../3rdparty/gtest/googlemock/make/Makefile | 101 +
.../gtest/googlemock/msvc/2005/gmock.sln | 32 +
.../gtest/googlemock/msvc/2005/gmock.vcproj | 191 +
.../googlemock/msvc/2005/gmock_config.vsprops | 15 +
.../googlemock/msvc/2005/gmock_main.vcproj | 187 +
.../googlemock/msvc/2005/gmock_test.vcproj | 201 +
.../gtest/googlemock/msvc/2010/gmock.sln | 46 +
.../gtest/googlemock/msvc/2010/gmock.vcxproj | 145 +
.../googlemock/msvc/2010/gmock_config.props | 19 +
.../googlemock/msvc/2010/gmock_main.vcxproj | 151 +
.../googlemock/msvc/2010/gmock_test.vcxproj | 176 +
.../gtest/googlemock/msvc/2015/gmock.sln | 46 +
.../gtest/googlemock/msvc/2015/gmock.vcxproj | 145 +
.../googlemock/msvc/2015/gmock_config.props | 19 +
.../googlemock/msvc/2015/gmock_main.vcxproj | 151 +
.../googlemock/msvc/2015/gmock_test.vcxproj | 176 +
.../googlemock/scripts/fuse_gmock_files.py | 240 +
.../gtest/googlemock/scripts/generator/LICENSE | 203 +
.../gtest/googlemock/scripts/generator/README | 35 +
.../scripts/generator/README.cppclean | 115 +
.../scripts/generator/cpp/__init__.py | 0
.../googlemock/scripts/generator/cpp/ast.py | 1733 ++++
.../scripts/generator/cpp/gmock_class.py | 227 +
.../scripts/generator/cpp/gmock_class_test.py | 448 +
.../scripts/generator/cpp/keywords.py | 59 +
.../scripts/generator/cpp/tokenize.py | 287 +
.../googlemock/scripts/generator/cpp/utils.py | 41 +
.../googlemock/scripts/generator/gmock_gen.py | 31 +
.../gtest/googlemock/scripts/gmock-config.in | 303 +
.../gtest/googlemock/scripts/gmock_doctor.py | 640 ++
.../3rdparty/gtest/googlemock/scripts/upload.py | 1387 ++++
.../gtest/googlemock/scripts/upload_gmock.py | 78 +
.../3rdparty/gtest/googlemock/src/gmock-all.cc | 47 +
.../gtest/googlemock/src/gmock-cardinalities.cc | 156 +
.../googlemock/src/gmock-internal-utils.cc | 204 +
.../gtest/googlemock/src/gmock-matchers.cc | 573 ++
.../gtest/googlemock/src/gmock-spec-builders.cc | 883 ++
.../3rdparty/gtest/googlemock/src/gmock.cc | 205 +
.../3rdparty/gtest/googlemock/src/gmock_main.cc | 54 +
.../3rdparty/gtest/googlemock/test/BUILD.bazel | 123 +
.../gtest/googlemock/test/gmock-actions_test.cc | 1575 ++++
.../googlemock/test/gmock-cardinalities_test.cc | 428 +
.../test/gmock-generated-actions_test.cc | 1230 +++
.../gmock-generated-function-mockers_test.cc | 647 ++
.../test/gmock-generated-internal-utils_test.cc | 129 +
.../test/gmock-generated-matchers_test.cc | 1341 +++
.../test/gmock-internal-utils_test.cc | 718 ++
.../googlemock/test/gmock-matchers_test.cc | 6769 +++++++++++++++
.../googlemock/test/gmock-more-actions_test.cc | 710 ++
.../googlemock/test/gmock-nice-strict_test.cc | 511 ++
.../gtest/googlemock/test/gmock-port_test.cc | 43 +
.../googlemock/test/gmock-spec-builders_test.cc | 2771 +++++++
.../gtest/googlemock/test/gmock_all_test.cc | 51 +
.../gtest/googlemock/test/gmock_ex_test.cc | 81 +
.../gtest/googlemock/test/gmock_leak_test.py | 108 +
.../gtest/googlemock/test/gmock_leak_test_.cc | 100 +
.../gtest/googlemock/test/gmock_link2_test.cc | 40 +
.../gtest/googlemock/test/gmock_link_test.cc | 40 +
.../gtest/googlemock/test/gmock_link_test.h | 691 ++
.../gtest/googlemock/test/gmock_output_test.py | 183 +
.../gtest/googlemock/test/gmock_output_test_.cc | 310 +
.../test/gmock_output_test_golden.txt | 317 +
.../gtest/googlemock/test/gmock_stress_test.cc | 323 +
.../gtest/googlemock/test/gmock_test.cc | 262 +
.../gtest/googlemock/test/gmock_test_utils.py | 110 +
.../backend/3rdparty/gtest/googletest/CHANGES | 157 +
.../3rdparty/gtest/googletest/CMakeLists.txt | 312 +
.../3rdparty/gtest/googletest/CONTRIBUTORS | 37 +
.../backend/3rdparty/gtest/googletest/LICENSE | 28 +
.../3rdparty/gtest/googletest/Makefile.am | 339 +
.../backend/3rdparty/gtest/googletest/README.md | 360 +
.../3rdparty/gtest/googletest/cmake/gtest.pc.in | 9 +
.../gtest/googletest/cmake/gtest_main.pc.in | 10 +
.../gtest/googletest/cmake/internal_utils.cmake | 280 +
.../gtest/googletest/codegear/gtest.cbproj | 138 +
.../gtest/googletest/codegear/gtest.groupproj | 54 +
.../gtest/googletest/codegear/gtest_all.cc | 38 +
.../gtest/googletest/codegear/gtest_link.cc | 40 +
.../gtest/googletest/codegear/gtest_main.cbproj | 82 +
.../googletest/codegear/gtest_unittest.cbproj | 88 +
.../3rdparty/gtest/googletest/configure.ac | 68 +
.../gtest/googletest/docs/AdvancedGuide.md | 2416 ++++++
.../gtest/googletest/docs/Documentation.md | 16 +
.../3rdparty/gtest/googletest/docs/FAQ.md | 1092 +++
.../3rdparty/gtest/googletest/docs/Pkgconfig.md | 146 +
.../3rdparty/gtest/googletest/docs/Primer.md | 536 ++
.../gtest/googletest/docs/PumpManual.md | 177 +
.../3rdparty/gtest/googletest/docs/Samples.md | 14 +
.../gtest/googletest/docs/XcodeGuide.md | 93 +
.../googletest/include/gtest/gtest-death-test.h | 342 +
.../googletest/include/gtest/gtest-message.h | 249 +
.../googletest/include/gtest/gtest-param-test.h | 1438 ++++
.../include/gtest/gtest-param-test.h.pump | 501 ++
.../googletest/include/gtest/gtest-printers.h | 1078 +++
.../gtest/googletest/include/gtest/gtest-spi.h | 231 +
.../googletest/include/gtest/gtest-test-part.h | 179 +
.../googletest/include/gtest/gtest-typed-test.h | 264 +
.../gtest/googletest/include/gtest/gtest.h | 2330 ++++++
.../googletest/include/gtest/gtest_pred_impl.h | 357 +
.../gtest/googletest/include/gtest/gtest_prod.h | 61 +
.../include/gtest/internal/custom/gtest-port.h | 75 +
.../gtest/internal/custom/gtest-printers.h | 42 +
.../include/gtest/internal/custom/gtest.h | 45 +
.../gtest/internal/gtest-death-test-internal.h | 275 +
.../include/gtest/internal/gtest-filepath.h | 205 +
.../include/gtest/internal/gtest-internal.h | 1277 +++
.../include/gtest/internal/gtest-linked_ptr.h | 243 +
.../gtest/internal/gtest-param-util-generated.h | 5139 ++++++++++++
.../internal/gtest-param-util-generated.h.pump | 279 +
.../include/gtest/internal/gtest-param-util.h | 723 ++
.../include/gtest/internal/gtest-port-arch.h | 100 +
.../include/gtest/internal/gtest-port.h | 2686 ++++++
.../include/gtest/internal/gtest-string.h | 167 +
.../include/gtest/internal/gtest-tuple.h | 1020 +++
.../include/gtest/internal/gtest-tuple.h.pump | 347 +
.../include/gtest/internal/gtest-type-util.h | 3331 ++++++++
.../gtest/internal/gtest-type-util.h.pump | 297 +
.../3rdparty/gtest/googletest/m4/acx_pthread.m4 | 363 +
.../3rdparty/gtest/googletest/m4/gtest.m4 | 74 +
.../3rdparty/gtest/googletest/make/Makefile | 82 +
.../gtest/googletest/msvc/2010/gtest-md.sln | 55 +
.../gtest/googletest/msvc/2010/gtest-md.vcxproj | 149 +
.../msvc/2010/gtest-md.vcxproj.filters | 18 +
.../gtest/googletest/msvc/2010/gtest.sln | 55 +
.../gtest/googletest/msvc/2010/gtest.vcxproj | 149 +
.../googletest/msvc/2010/gtest.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_main-md.vcxproj | 154 +
.../msvc/2010/gtest_main-md.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_main.vcxproj | 162 +
.../msvc/2010/gtest_main.vcxproj.filters | 18 +
.../msvc/2010/gtest_prod_test-md.vcxproj | 199 +
.../2010/gtest_prod_test-md.vcxproj.filters | 26 +
.../msvc/2010/gtest_prod_test.vcxproj | 191 +
.../msvc/2010/gtest_prod_test.vcxproj.filters | 26 +
.../msvc/2010/gtest_unittest-md.vcxproj | 188 +
.../msvc/2010/gtest_unittest-md.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_unittest.vcxproj | 180 +
.../msvc/2010/gtest_unittest.vcxproj.filters | 18 +
.../gtest/googletest/samples/prime_tables.h | 127 +
.../gtest/googletest/samples/sample1.cc | 68 +
.../3rdparty/gtest/googletest/samples/sample1.h | 43 +
.../googletest/samples/sample10_unittest.cc | 140 +
.../googletest/samples/sample1_unittest.cc | 154 +
.../gtest/googletest/samples/sample2.cc | 56 +
.../3rdparty/gtest/googletest/samples/sample2.h | 85 +
.../googletest/samples/sample2_unittest.cc | 110 +
.../gtest/googletest/samples/sample3-inl.h | 172 +
.../googletest/samples/sample3_unittest.cc | 152 +
.../gtest/googletest/samples/sample4.cc | 46 +
.../3rdparty/gtest/googletest/samples/sample4.h | 53 +
.../googletest/samples/sample4_unittest.cc | 49 +
.../googletest/samples/sample5_unittest.cc | 199 +
.../googletest/samples/sample6_unittest.cc | 225 +
.../googletest/samples/sample7_unittest.cc | 118 +
.../googletest/samples/sample8_unittest.cc | 174 +
.../googletest/samples/sample9_unittest.cc | 157 +
.../3rdparty/gtest/googletest/scripts/common.py | 83 +
.../googletest/scripts/fuse_gtest_files.py | 253 +
.../googletest/scripts/gen_gtest_pred_impl.py | 730 ++
.../gtest/googletest/scripts/gtest-config.in | 274 +
.../3rdparty/gtest/googletest/scripts/pump.py | 855 ++
.../gtest/googletest/scripts/release_docs.py | 158 +
.../gtest/googletest/scripts/test/Makefile | 59 +
.../3rdparty/gtest/googletest/scripts/upload.py | 1387 ++++
.../gtest/googletest/scripts/upload_gtest.py | 78 +
.../3rdparty/gtest/googletest/src/gtest-all.cc | 48 +
.../gtest/googletest/src/gtest-death-test.cc | 1346 +++
.../gtest/googletest/src/gtest-filepath.cc | 385 +
.../gtest/googletest/src/gtest-internal-inl.h | 1175 +++
.../3rdparty/gtest/googletest/src/gtest-port.cc | 1253 +++
.../gtest/googletest/src/gtest-printers.cc | 458 ++
.../gtest/googletest/src/gtest-test-part.cc | 102 +
.../gtest/googletest/src/gtest-typed-test.cc | 119 +
.../3rdparty/gtest/googletest/src/gtest.cc | 5841 +++++++++++++
.../3rdparty/gtest/googletest/src/gtest_main.cc | 38 +
.../3rdparty/gtest/googletest/test/BUILD.bazel | 380 +
.../googletest/test/gtest-death-test_ex_test.cc | 93 +
.../googletest/test/gtest-death-test_test.cc | 1423 ++++
.../googletest/test/gtest-filepath_test.cc | 652 ++
.../googletest/test/gtest-linked_ptr_test.cc | 154 +
.../googletest/test/gtest-listener_test.cc | 311 +
.../gtest/googletest/test/gtest-message_test.cc | 159 +
.../gtest/googletest/test/gtest-options_test.cc | 207 +
.../googletest/test/gtest-param-test2_test.cc | 61 +
.../googletest/test/gtest-param-test_test.cc | 1110 +++
.../googletest/test/gtest-param-test_test.h | 53 +
.../gtest/googletest/test/gtest-port_test.cc | 1303 +++
.../googletest/test/gtest-printers_test.cc | 1731 ++++
.../googletest/test/gtest-test-part_test.cc | 208 +
.../gtest/googletest/test/gtest-tuple_test.cc | 320 +
.../googletest/test/gtest-typed-test2_test.cc | 45 +
.../googletest/test/gtest-typed-test_test.cc | 380 +
.../googletest/test/gtest-typed-test_test.h | 66 +
.../googletest/test/gtest-unittest-api_test.cc | 341 +
.../gtest/googletest/test/gtest_all_test.cc | 47 +
.../test/gtest_assert_by_exception_test.cc | 119 +
.../test/gtest_break_on_failure_unittest.py | 210 +
.../test/gtest_break_on_failure_unittest_.cc | 87 +
.../test/gtest_catch_exceptions_test.py | 235 +
.../test/gtest_catch_exceptions_test_.cc | 311 +
.../gtest/googletest/test/gtest_color_test.py | 129 +
.../gtest/googletest/test/gtest_color_test_.cc | 63 +
.../gtest/googletest/test/gtest_env_var_test.py | 119 +
.../googletest/test/gtest_env_var_test_.cc | 124 +
.../googletest/test/gtest_environment_test.cc | 189 +
.../googletest/test/gtest_filter_unittest.py | 638 ++
.../googletest/test/gtest_filter_unittest_.cc | 138 +
.../gtest/googletest/test/gtest_help_test.py | 172 +
.../gtest/googletest/test/gtest_help_test_.cc | 46 +
.../googletest/test/gtest_json_outfiles_test.py | 162 +
.../test/gtest_json_output_unittest.py | 611 ++
.../googletest/test/gtest_json_test_utils.py | 60 +
.../test/gtest_list_tests_unittest.py | 207 +
.../test/gtest_list_tests_unittest_.cc | 157 +
.../googletest/test/gtest_main_unittest.cc | 45 +
.../googletest/test/gtest_no_test_unittest.cc | 56 +
.../gtest/googletest/test/gtest_output_test.py | 344 +
.../gtest/googletest/test/gtest_output_test_.cc | 1067 +++
.../test/gtest_output_test_golden_lin.txt | 781 ++
.../googletest/test/gtest_pred_impl_unittest.cc | 2427 ++++++
.../test/gtest_premature_exit_test.cc | 127 +
.../gtest/googletest/test/gtest_prod_test.cc | 57 +
.../gtest/googletest/test/gtest_repeat_test.cc | 236 +
.../gtest/googletest/test/gtest_shuffle_test.py | 325 +
.../googletest/test/gtest_shuffle_test_.cc | 103 +
.../googletest/test/gtest_sole_header_test.cc | 57 +
.../gtest/googletest/test/gtest_stress_test.cc | 250 +
.../gtest/googletest/test/gtest_test_utils.py | 318 +
.../test/gtest_throw_on_failure_ex_test.cc | 92 +
.../test/gtest_throw_on_failure_test.py | 171 +
.../test/gtest_throw_on_failure_test_.cc | 72 +
.../googletest/test/gtest_uninitialized_test.py | 69 +
.../test/gtest_uninitialized_test_.cc | 43 +
.../gtest/googletest/test/gtest_unittest.cc | 7750 ++++++++++++++++++
.../googletest/test/gtest_xml_outfile1_test_.cc | 48 +
.../googletest/test/gtest_xml_outfile2_test_.cc | 48 +
.../googletest/test/gtest_xml_outfiles_test.py | 140 +
.../test/gtest_xml_output_unittest.py | 378 +
.../test/gtest_xml_output_unittest_.cc | 179 +
.../googletest/test/gtest_xml_test_utils.py | 196 +
.../gtest/googletest/test/production.cc | 36 +
.../3rdparty/gtest/googletest/test/production.h | 55 +
.../xcode/Config/DebugProject.xcconfig | 30 +
.../xcode/Config/FrameworkTarget.xcconfig | 17 +
.../googletest/xcode/Config/General.xcconfig | 41 +
.../xcode/Config/ReleaseProject.xcconfig | 32 +
.../xcode/Config/StaticLibraryTarget.xcconfig | 18 +
.../googletest/xcode/Config/TestTarget.xcconfig | 8 +
.../gtest/googletest/xcode/Resources/Info.plist | 30 +
.../xcode/Samples/FrameworkSample/Info.plist | 28 +
.../WidgetFramework.xcodeproj/project.pbxproj | 457 ++
.../xcode/Samples/FrameworkSample/runtests.sh | 62 +
.../xcode/Samples/FrameworkSample/widget.cc | 63 +
.../xcode/Samples/FrameworkSample/widget.h | 59 +
.../Samples/FrameworkSample/widget_test.cc | 68 +
.../gtest/googletest/xcode/Scripts/runtests.sh | 65 +
.../googletest/xcode/Scripts/versiongenerate.py | 100 +
.../xcode/gtest.xcodeproj/project.pbxproj | 1182 +++
libraries/ostrich/backend/CMakeLists.txt | 57 +
libraries/ostrich/backend/client/CMakeLists.txt | 9 +
libraries/ostrich/backend/client/client.cc | 386 +
.../ostrich/backend/cmake/FindGFlags.cmake | 48 +
libraries/ostrich/backend/cmake/FindGLog.cmake | 18 +
libraries/ostrich/backend/cmake/FindGRPC.cmake | 67 +
.../ostrich/backend/cmake/FindLevelDB.cmake | 18 +
.../ostrich/backend/cmake/FindRAPTOR.cmake | 103 +
.../ostrich/backend/cmake/FindRasqal.cmake | 99 +
.../ostrich/backend/cmake/FindRocksDB.cmake | 18 +
.../ostrich/backend/cmake/FindTcmalloc.cmake | 39 +
libraries/ostrich/backend/model/CMakeLists.txt | 6 +
libraries/ostrich/backend/model/model.proto | 77 +
libraries/ostrich/backend/model/rdf_model.cc | 349 +
libraries/ostrich/backend/model/rdf_model.h | 709 ++
.../ostrich/backend/model/rdf_namespaces.cc | 67 +
.../ostrich/backend/model/rdf_namespaces.h | 169 +
.../ostrich/backend/model/rdf_operators.cc | 65 +
libraries/ostrich/backend/model/rdf_operators.h | 240 +
libraries/ostrich/backend/parser/CMakeLists.txt | 6 +
libraries/ostrich/backend/parser/rdf_parser.cc | 168 +
libraries/ostrich/backend/parser/rdf_parser.h | 94 +
.../ostrich/backend/persistence/CMakeLists.txt | 28 +
.../backend/persistence/base_persistence.cc | 194 +
.../backend/persistence/base_persistence.h | 220 +
.../backend/persistence/leveldb_persistence.cc | 560 ++
.../backend/persistence/leveldb_persistence.h | 176 +
.../backend/persistence/leveldb_server.cc | 76 +
.../backend/persistence/leveldb_service.cc | 304 +
.../backend/persistence/leveldb_service.h | 128 +
.../backend/persistence/leveldb_sparql.cc | 87 +
.../backend/persistence/leveldb_sparql.h | 58 +
.../backend/persistence/marmotta_updatedb.cc | 217 +
.../ostrich/backend/serializer/CMakeLists.txt | 10 +
.../ostrich/backend/serializer/serializer.cc | 49 +
.../ostrich/backend/serializer/serializer.h | 54 +
.../backend/serializer/serializer_base.cc | 76 +
.../backend/serializer/serializer_base.h | 104 +
.../backend/serializer/serializer_proto.cc | 56 +
.../backend/serializer/serializer_proto.h | 50 +
.../backend/serializer/serializer_raptor.cc | 175 +
.../backend/serializer/serializer_raptor.h | 55 +
.../ostrich/backend/service/CMakeLists.txt | 9 +
libraries/ostrich/backend/service/sail.proto | 102 +
libraries/ostrich/backend/service/sparql.proto | 53 +
.../ostrich/backend/sharding/CMakeLists.txt | 11 +
libraries/ostrich/backend/sharding/server.cc | 66 +
libraries/ostrich/backend/sharding/sharding.cc | 335 +
libraries/ostrich/backend/sharding/sharding.h | 174 +
libraries/ostrich/backend/sparql/CMakeLists.txt | 8 +
.../ostrich/backend/sparql/rasqal_adapter.cc | 380 +
.../ostrich/backend/sparql/rasqal_adapter.h | 127 +
.../ostrich/backend/sparql/rasqal_model.cc | 205 +
libraries/ostrich/backend/sparql/rasqal_model.h | 73 +
libraries/ostrich/backend/test/CMakeLists.txt | 25 +
libraries/ostrich/backend/test/LevelDBTest.cc | 457 ++
libraries/ostrich/backend/test/NamespaceTest.cc | 78 +
.../ostrich/backend/test/PersistenceTest.cc | 80 +
libraries/ostrich/backend/test/SparqlTest.cc | 307 +
libraries/ostrich/backend/test/StatementTest.cc | 148 +
libraries/ostrich/backend/util/CMakeLists.txt | 7 +
libraries/ostrich/backend/util/iterator.h | 315 +
libraries/ostrich/backend/util/murmur3.cc | 313 +
libraries/ostrich/backend/util/murmur3.h | 18 +
libraries/ostrich/backend/util/raptor_util.cc | 190 +
libraries/ostrich/backend/util/raptor_util.h | 74 +
libraries/ostrich/backend/util/threadpool.h | 251 +
libraries/ostrich/backend/util/time_logger.cc | 30 +
libraries/ostrich/backend/util/time_logger.h | 45 +
libraries/ostrich/client/pom.xml | 217 +
.../ostrich/sail/ClosableResponseStream.java | 163 +
.../marmotta/ostrich/sail/OstrichSail.java | 87 +
.../ostrich/sail/OstrichSailConnection.java | 618 ++
.../ostrich/sail/OstrichValueFactory.java | 260 +
.../ostrich/sail/test/CMarmottaSailTest.java | 74 +
.../ostrich/sail/test/TestSailConnection.java | 80 +
libraries/ostrich/model/pom.xml | 202 +
.../marmotta/ostrich/model/ProtoBNode.java | 79 +
.../ostrich/model/ProtoDatatypeLiteral.java | 106 +
.../ostrich/model/ProtoLiteralBase.java | 186 +
.../marmotta/ostrich/model/ProtoNamespace.java | 86 +
.../marmotta/ostrich/model/ProtoStatement.java | 221 +
.../ostrich/model/ProtoStringLiteral.java | 101 +
.../apache/marmotta/ostrich/model/ProtoURI.java | 113 +
.../ostrich/model/test/StatementTest.java | 68 +
.../marmotta/ostrich/model/test/URITest.java | 57 +
.../model/src/test/resources/logback.xml | 28 +
libraries/ostrich/pom.xml | 66 +
libraries/pom.xml | 11 +-
loader/marmotta-loader-berkeley/pom.xml | 2 +-
.../src/main/resources/logback.xml | 4 +-
loader/marmotta-loader-core/pom.xml | 2 +-
.../marmotta/loader/api/LoaderBackend.java | 6 +-
.../marmotta/loader/api/LoaderHandler.java | 4 +-
.../marmotta/loader/core/MarmottaLoader.java | 15 +-
loader/marmotta-loader-hbase/pom.xml | 2 +-
.../src/main/resources/logback.xml | 4 +-
loader/marmotta-loader-kiwi/pom.xml | 2 +-
loader/marmotta-loader-ostrich/pom.xml | 83 +
.../loader/ostrich/OstrichLoaderBackend.java | 100 +
.../loader/ostrich/OstrichLoaderHandler.java | 156 +
...org.apache.marmotta.loader.api.LoaderBackend | 18 +
.../src/main/resources/logback.xml | 32 +
loader/marmotta-loader-titan/pom.xml | 2 +-
loader/pom.xml | 12 +-
parent/pom.xml | 65 +-
.../marmotta-backend-accumulograph/pom.xml | 60 +
.../AccumuloGraphLoggingModule.java | 79 +
.../accumulograph/AccumuloGraphProvider.java | 122 +
.../src/main/resources/META-INF/beans.xml | 28 +
.../main/resources/config-defaults.properties | 28 +
.../resources/config-descriptions.properties | 133 +
.../src/main/resources/kiwi-module.properties | 37 +
.../src/main/resources/web/admin/about.html | 36 +
.../main/resources/web/admin/configuration.html | 54 +
.../backends/marmotta-backend-bigdata/pom.xml | 2 +-
.../bigdata/BigDataSesame27Repository.java | 2 +-
platform/backends/marmotta-backend-http/pom.xml | 2 +-
platform/backends/marmotta-backend-kiwi/pom.xml | 2 +-
.../backend/kiwi/KiWiStoreProvider.java | 1 -
.../main/resources/config-defaults.properties | 13 +-
.../resources/config-descriptions.properties | 4 -
.../src/main/resources/web/admin/about.html | 41 +-
.../main/resources/web/admin/configuration.html | 9 +-
.../src/main/resources/web/admin/console.html | 2 +-
.../src/main/resources/web/admin/database.html | 2 +-
.../backends/marmotta-backend-memory/pom.xml | 2 +-
.../backends/marmotta-backend-native/pom.xml | 2 +-
.../backends/marmotta-backend-ostrich/pom.xml | 176 +
.../backend/ostrich/OstrichProvider.java | 97 +
.../backend/ostrich/OstrichSailRepository.java | 171 +
.../src/main/resources/META-INF/beans.xml | 28 +
.../main/resources/config-defaults.properties | 25 +
.../resources/config-descriptions.properties | 31 +
.../src/main/resources/kiwi-module.properties | 38 +
.../src/main/resources/web/admin/about.html | 36 +
.../main/resources/web/admin/configuration.html | 52 +
.../backends/marmotta-backend-sparql/pom.xml | 2 +-
.../backends/marmotta-backend-titan/pom.xml | 4 +-
platform/backends/pom.xml | 4 +-
.../ldcache/marmotta-ldcache-common/pom.xml | 2 +-
.../api/endpoint/LinkedDataEndpointService.java | 16 +-
.../model/filter/MarmottaNotCachedFilter.java | 2 +-
.../endpoint/LinkedDataEndpointServiceImpl.java | 2 +-
.../LinkedDataCachingWebService.java | 4 +-
platform/ldcache/marmotta-ldcache-file/pom.xml | 2 +-
.../services/kiwi/FileLDCacheSailProvider.java | 14 +-
platform/ldcache/marmotta-ldcache-kiwi/pom.xml | 2 +-
.../services/kiwi/KiWiLDCacheSailProvider.java | 2 +-
platform/ldcache/pom.xml | 2 +-
platform/marmotta-core/pom.xml | 2 +-
.../platform/core/api/cache/CachingService.java | 10 +-
.../core/api/config/ConfigurationService.java | 42 +-
.../core/api/config/DependenciesService.java | 2 +-
.../core/api/content/ContentReader.java | 14 +-
.../core/api/content/ContentService.java | 20 +-
.../core/api/content/ContentWriter.java | 10 +-
.../core/api/exporter/ExportService.java | 16 +-
.../core/api/http/HttpClientService.java | 30 +-
.../core/api/importer/ImportService.java | 10 +-
.../core/api/importer/ImportWatchService.java | 2 +-
.../platform/core/api/importer/Importer.java | 14 +-
.../platform/core/api/io/MarmottaIOService.java | 10 +-
.../platform/core/api/io/RDFHtmlWriter.java | 4 +-
.../platform/core/api/io/RDFWriterPriority.java | 4 +-
.../core/api/logging/LoggingModule.java | 20 +-
.../core/api/logging/LoggingService.java | 16 +-
.../core/api/modules/MarmottaHttpFilter.java | 16 +-
.../api/modules/MarmottaResourceService.java | 6 +-
.../core/api/modules/ModuleService.java | 33 +-
.../core/api/modules/ResourceEntry.java | 2 +-
.../core/api/prefix/PrefixProvider.java | 9 +-
.../platform/core/api/prefix/PrefixService.java | 2 +-
.../platform/core/api/ssl/SSLService.java | 4 +-
.../core/api/statistics/StatisticsModule.java | 14 +-
.../core/api/statistics/StatisticsService.java | 22 +-
.../marmotta/platform/core/api/task/Task.java | 2 +-
.../platform/core/api/task/TaskInfo.java | 8 +-
.../core/api/task/TaskManagerService.java | 20 +-
.../api/templating/AdminInterfaceService.java | 8 +-
.../core/api/templating/TemplatingService.java | 30 +-
.../core/api/triplestore/ContextService.java | 8 +-
.../triplestore/GarbageCollectionProvider.java | 2 +-
.../api/triplestore/NotifyingSailProvider.java | 4 +-
.../core/api/triplestore/SailProvider.java | 6 +-
.../core/api/triplestore/SesameService.java | 2 +-
.../api/triplestore/StandardSailProvider.java | 4 +-
.../core/api/triplestore/StoreProvider.java | 4 +-
.../triplestore/TransactionalSailProvider.java | 4 +-
.../core/api/ui/MarmottaSystrayLink.java | 10 +-
.../platform/core/api/user/UserService.java | 24 +-
.../events/ConfigurationServiceInitEvent.java | 2 +-
.../core/exception/HttpErrorException.java | 4 +-
.../exception/InvalidArgumentException.java | 2 +-
.../MarmottaConfigurationException.java | 2 +-
.../core/exception/MarmottaException.java | 2 +-
.../core/exception/ResolvingException.java | 2 +-
.../core/exception/TemplatingException.java | 2 +-
.../core/exception/UserExistsException.java | 2 +-
.../exception/WritingNotSupportedException.java | 2 +-
.../authentication/LoginFailedException.java | 2 +-
.../exception/io/MarmottaExportException.java | 2 +-
.../exception/io/MarmottaImportException.java | 2 +-
.../io/UnsupportedExporterException.java | 2 +-
.../security/AccessDeniedException.java | 2 +-
.../exception/webservice/NotFoundException.java | 2 +-
.../exception/webservice/ServerException.java | 2 +-
.../core/filters/MarmottaServerNameFilter.java | 2 +-
.../core/filters/ModuleResourceFilter.java | 11 +-
.../platform/core/filters/TemplatingFilter.java | 27 +-
.../platform/core/jaxrs/ErrorMessage.java | 2 +-
.../jaxrs/exceptionmappers/ErrorResponse.java | 2 +-
.../platform/core/jndi/MarmottaContext.java | 15 +-
.../core/jndi/MarmottaContextFactory.java | 5 +-
.../core/jndi/MarmottaInitialContext.java | 2 +-
.../MarmottaInitialContextFactoryBuilder.java | 2 +-
.../core/jndi/MarmottaJndiListener.java | 2 +-
.../platform/core/model/content/Content.java | 2 +-
.../core/model/content/MediaContent.java | 2 +-
.../core/model/content/MediaContentItem.java | 10 +-
.../core/model/filter/MarmottaLocalFilter.java | 2 +-
.../core/model/logging/LoggingOutput.java | 3 +-
.../core/model/module/ModuleConfiguration.java | 2 +-
.../platform/core/model/template/MenuItem.java | 9 +-
.../platform/core/model/user/MarmottaUser.java | 26 +-
.../platform/core/model/user/OnlineAccount.java | 10 +-
.../core/qualifiers/cache/MarmottaCache.java | 4 +-
.../core/qualifiers/event/ContentCreated.java | 2 +-
.../platform/core/qualifiers/event/Created.java | 2 +-
.../platform/core/qualifiers/event/Removed.java | 2 +-
.../platform/core/qualifiers/event/Updated.java | 2 +-
.../event/transaction/AfterCommit.java | 2 +-
.../event/transaction/AfterRollback.java | 2 +-
.../event/transaction/BeforeCommit.java | 2 +-
.../event/transaction/BeforeRollback.java | 2 +-
.../qualifiers/event/transaction/OnAbort.java | 2 +-
.../kspace/ActiveKnowledgeSpaces.java | 2 +-
.../kspace/CurrentKnowledgeSpace.java | 2 +-
.../kspace/DefaultKnowledgeSpace.java | 2 +-
.../kspace/InferredKnowledgeSpace.java | 2 +-
.../qualifiers/kspace/SystemKnowledgeSpace.java | 2 +-
.../core/qualifiers/user/AdminUser.java | 2 +-
.../core/qualifiers/user/AnonymousUser.java | 2 +-
.../core/qualifiers/user/CurrentUser.java | 2 +-
.../platform/core/rio/RDFHtmlFormat.java | 5 +-
.../platform/core/rio/RDFHtmlWriterFactory.java | 2 +-
.../platform/core/rio/RDFHtmlWriterImpl.java | 26 +-
.../core/services/cache/CachingServiceImpl.java | 2 +-
.../config/ConfigurationServiceImpl.java | 61 +-
.../config/DependenciesServiceImpl.java | 16 +-
.../services/content/ContentServiceImpl.java | 35 +-
.../content/FileSystemContentReader.java | 7 +-
.../content/FileSystemContentWriter.java | 2 +-
.../services/content/HTTPContentReader.java | 4 +-
.../services/exporter/ExporterServiceImpl.java | 2 +-
.../services/http/HttpClientServiceImpl.java | 36 +-
.../core/services/http/MonitoredHttpEntity.java | 2 +-
.../response/LastModifiedResponseHandler.java | 4 +-
.../response/StatusCodeResponseHandler.java | 4 +-
.../response/StringBodyResponseHandler.java | 4 +-
.../services/importer/ImportServiceImpl.java | 7 +-
.../services/importer/rdf/RDFImporterImpl.java | 12 +-
.../core/services/io/MarmottaIOServiceImpl.java | 10 +-
.../services/logging/LoggingServiceImpl.java | 4 +-
.../modules/MarmottaResourceServiceImpl.java | 2 +-
.../services/modules/ModuleServiceImpl.java | 34 +-
.../platform/core/services/prefix/PrefixCC.java | 31 +-
.../core/services/prefix/PrefixServiceCC.java | 2 +-
.../core/services/prefix/PrefixServiceImpl.java | 34 +-
.../sesame/ResourceSubjectMetadata.java | 8 +-
.../core/services/ssl/SSLServiceImpl.java | 25 +-
.../statistics/StatisticsServiceImpl.java | 6 +-
.../system/SystemStatisticsModule.java | 6 +-
.../platform/core/services/task/TaskImpl.java | 2 +-
.../services/task/TaskManagerServiceImpl.java | 47 +-
.../templating/AdminTemplatingServiceImpl.java | 29 +-
.../templating/TemplatingServiceImpl.java | 34 +-
.../triplestore/ContextServiceImpl.java | 81 +-
.../services/triplestore/SesameServiceImpl.java | 10 +-
.../core/services/user/UserServiceImpl.java | 4 +-
.../core/servlet/MarmottaH2ConsoleFilter.java | 2 +-
.../core/servlet/MarmottaOptionsFilter.java | 2 +-
.../core/servlet/MarmottaPostStartupFilter.java | 2 +-
.../core/servlet/MarmottaPreStartupFilter.java | 2 +-
.../servlet/MarmottaPreStartupListener.java | 2 +-
.../core/servlet/MarmottaResourceFilter.java | 19 +-
.../core/startup/MarmottaStartupService.java | 2 +-
.../marmotta/platform/core/util/CDIContext.java | 8 +-
.../marmotta/platform/core/util/CDIUtils.java | 2 +-
.../marmotta/platform/core/util/DateUtil.java | 2 +-
.../core/util/FallbackConfiguration.java | 2 +-
.../marmotta/platform/core/util/KiWiIO.java | 2 +-
.../core/util/LinkedHashSetBlockingQueue.java | 6 +-
.../platform/core/util/ReflectionUtils.java | 2 +-
.../platform/core/util/WebServiceUtil.java | 16 +-
.../core/util/http/HttpRequestUtil.java | 2 +-
.../core/webservices/CoreApplication.java | 6 +-
.../config/ConfigurationWebService.java | 47 +-
.../config/DependenciesWebService.java | 2 +-
.../core/webservices/io/ExportWebService.java | 2 +-
.../core/webservices/io/ImportWebService.java | 4 +-
.../webservices/modules/ModuleWebService.java | 19 +-
.../webservices/prefix/PrefixWebService.java | 21 +-
.../resource/AnonResourceWebService.java | 2 +-
.../webservices/resource/ContentWebService.java | 4 +-
.../resource/InspectionWebService.java | 12 +-
.../webservices/resource/MetaWebService.java | 12 +-
.../resource/ResourceWebService.java | 4 +-
.../resource/ResourceWebServiceHelper.java | 4 +-
.../statistics/StatisticsWebService.java | 13 +-
.../webservices/status/StatusWebservice.java | 327 +
.../webservices/system/SystemWebService.java | 2 +-
.../webservices/task/TaskManagerWebService.java | 7 +-
.../triplestore/ContextWebService.java | 6 +-
.../main/resources/config-defaults.properties | 5 +-
.../src/main/resources/kiwi-module.properties | 3 +-
.../src/main/resources/web/admin/export.html | 16 +-
.../resources/web/admin/js/widgets/system.js | 4 +-
.../web/public/img/logo/marmotta-logo.png | Bin 36723 -> 38984 bytes
.../resources/web/public/style/blue/rdfhtml.css | 2 -
.../resources/web/public/style/blue/style.css | 3 +-
.../main/resources/web/public/style/red/404.css | 43 +
.../resources/web/public/style/red/code.css | 51 +
.../resources/web/public/style/red/error.css | 31 +
.../resources/web/public/style/red/javadoc.css | 113 +
.../resources/web/public/style/red/rdfhtml.css | 39 +
.../web/public/style/red/sgvizler.chart.css | 53 +
.../resources/web/public/style/red/style.css | 339 +
.../resources/web/public/style/white/style.css | 2 +-
.../core/test/base/AbstractMarmotta.java | 2 +-
.../core/test/base/EmbeddedMarmotta.java | 2 +-
.../platform/core/test/base/JettyMarmotta.java | 2 +-
.../core/test/base/jetty/TestApplication.java | 2 +-
.../test/base/jetty/TestInjectorFactory.java | 2 +-
.../test/config/ConfigurationServiceTest.java | 2 +-
.../config/ConfigurationWebServiceTest.java | 2 +-
.../test/embedded/EmbeddedMarmottaTest.java | 2 +-
.../modules/MarmottaResourceServiceTest.java | 2 +-
.../platform/core/test/prefix/PrefixCCTest.java | 14 +-
.../core/test/prefix/PrefixServiceTest.java | 2 +-
.../core/test/prefix/PrefixWebServiceTest.java | 2 +-
.../test/triplestore/ContextServiceTest.java | 95 +
.../core/test/user/UserServiceTest.java | 2 +-
.../platform/core/util/http/UriUtilTests.java | 2 +-
platform/marmotta-ldp/pom.xml | 2 +-
.../marmotta/platform/ldp/api/LdpService.java | 8 +-
.../platform/ldp/services/LdpServiceImpl.java | 4 +-
.../marmotta/platform/ldp/util/LdpUtils.java | 4 +-
.../platform/ldp/webservices/LdpWebService.java | 14 +-
.../services/LdpBinaryStoreServiceImplTest.java | 7 +-
.../ldp/webservices/LdpWebServiceTest.java | 7 +-
platform/marmotta-ldpath/pom.xml | 2 +-
.../api/AutoRegisteredLDPathFunction.java | 2 +-
.../platform/ldpath/api/LDPathService.java | 17 +-
.../platform/ldpath/backend/LMFBackend.java | 2 +-
.../ldpath/model/functions/ContentFunction.java | 2 +-
.../ldpath/model/functions/JsoupFunction.java | 2 +-
.../ldpath/services/LDPathServiceImpl.java | 2 +-
.../webservices/LDPathUtilWebService.java | 35 +-
.../ldpath/webservices/LDPathWebService.java | 2 +-
platform/marmotta-reasoner-kiwi/pom.xml | 2 +-
.../services/ReasoningSailProvider.java | 2 +-
.../reasoner/webservices/ProgramWebService.java | 2 +-
.../webservices/ReasonerWebService.java | 2 +-
platform/marmotta-security/pom.xml | 2 +-
.../platform/security/api/SecurityService.java | 10 +-
.../filters/MarmottaAccessControlFilter.java | 2 +-
.../platform/security/model/HTTPMethods.java | 2 +-
.../security/model/SecurityConstraint.java | 4 +-
.../security/services/SecurityServiceImpl.java | 2 +-
.../platform/security/util/IPv4SubnetInfo.java | 2 +-
.../platform/security/util/IPv6SubnetInfo.java | 2 +-
.../platform/security/util/SubnetInfo.java | 2 +-
.../webservices/SecurityWebService.java | 2 +-
platform/marmotta-sparql/pom.xml | 6 +-
.../platform/sparql/api/sparql/QueryType.java | 4 +-
.../sparql/api/sparql/SparqlService.java | 20 +-
.../services/sparql/SparqlServiceImpl.java | 26 +-
.../services/sparql/SparqlWritersHelper.java | 2 +-
.../sparqlio/rdf/SPARQLGraphResultWriter.java | 2 +-
.../sparqlhtml/SPARQLBooleanHTMLFormat.java | 2 +-
.../sparqlhtml/SPARQLBooleanHTMLWriter.java | 2 +-
.../SPARQLBooleanHTMLWriterFactory.java | 2 +-
.../sparqlio/sparqlhtml/SPARQLHTMLSettings.java | 6 +-
.../sparqlhtml/SPARQLResultsHTMLFormat.java | 2 +-
.../sparqlhtml/SPARQLResultsHTMLWriter.java | 25 +-
.../SPARQLResultsHTMLWriterFactory.java | 2 +-
.../sparqlhtml/SPARQLResultsHTMLWriterXSL.java | 17 +-
.../sparql/webservices/SparqlWebService.java | 270 +-
.../main/resources/web/admin/configuration.html | 2 +-
.../main/resources/web/admin/configuration.js | 2 +-
.../src/main/resources/web/admin/sgvizler.html | 4 +-
.../src/main/resources/web/admin/squebi.html | 10 +-
.../webservices/SparqlWebServiceTest.java | 14 +
platform/marmotta-user/pom.xml | 59 +-
.../platform/user/api/AccountService.java | 2 +-
.../user/api/AuthenticationProvider.java | 2 +-
.../user/api/AuthenticationService.java | 14 +-
.../user/api/UserConfigurationService.java | 18 +-
.../filters/MarmottaAuthenticationFilter.java | 8 +-
.../platform/user/model/UserAccount.java | 13 +-
.../user/services/AccountServiceImpl.java | 22 +-
.../services/AuthenticationServiceImpl.java | 6 +-
.../services/UserConfigurationServiceImpl.java | 2 +-
.../user/services/auth/LMFAuthProviderImpl.java | 49 -
.../user/services/auth/LdapAuthProvider.java | 2 +-
.../services/auth/MarmottaAuthProviderImpl.java | 49 +
.../webservices/UserManagementWebService.java | 20 +-
.../user/webservices/UserWebService.java | 53 +-
.../main/resources/config-defaults.properties | 2 +-
.../main/resources/web/admin/widgets/user.js | 33 +-
.../user/services/AccountServiceTest.java | 69 +
.../user/webservices/UserWebServiceTest.java | 55 +
platform/marmotta-versioning-common/pom.xml | 2 +-
platform/marmotta-versioning-kiwi/pom.xml | 2 +-
.../platform/versioning/api/MementoService.java | 6 +-
.../api/VersionSerializerService.java | 4 +-
.../versioning/exception/MementoException.java | 2 +-
.../versioning/filter/MementoFilter.java | 2 +-
.../versioning/io/HtmlVersionSerializer.java | 2 +-
.../versioning/io/LinkVersionSerializer.java | 2 +-
.../versioning/io/VersionSerializer.java | 8 +-
.../versioning/model/MementoVersionSet.java | 2 +-
.../versioning/services/MementoServiceImpl.java | 2 +-
.../services/VersionSerializerServiceImpl.java | 2 +-
.../services/VersioningSailProvider.java | 35 +-
.../platform/versioning/utils/MementoUtils.java | 2 +-
.../webservices/MementoWebService.java | 2 +-
.../webservices/VersioningWebService.java | 2 +-
platform/marmotta-zookeeper/pom.xml | 2 +-
.../zookeeper/api/ZookeeperService.java | 8 +-
.../services/ZookeeperServiceImpl.java | 4 +-
platform/pom.xml | 2 +-
pom.xml | 13 +-
2482 files changed, 247825 insertions(+), 7257 deletions(-)
----------------------------------------------------------------------
[12/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Porto_Velho
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Porto_Velho b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Porto_Velho
new file mode 100644
index 0000000..2423fc1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Porto_Velho differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Puerto_Rico
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Puerto_Rico b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Puerto_Rico
new file mode 100644
index 0000000..d4525a6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Puerto_Rico differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Punta_Arenas
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Punta_Arenas b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Punta_Arenas
new file mode 100644
index 0000000..4d84eed
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Punta_Arenas differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rainy_River
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rainy_River b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rainy_River
new file mode 100644
index 0000000..70dcd2d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rainy_River differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rankin_Inlet
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rankin_Inlet b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rankin_Inlet
new file mode 100644
index 0000000..9f50f36
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rankin_Inlet differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Recife
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Recife b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Recife
new file mode 100644
index 0000000..fe55739
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Recife differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Regina
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Regina b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Regina
new file mode 100644
index 0000000..5fe8d6b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Regina differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Resolute
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Resolute b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Resolute
new file mode 100644
index 0000000..884b1f6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Resolute differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rio_Branco
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rio_Branco b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rio_Branco
new file mode 100644
index 0000000..b612ac2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rio_Branco differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rosario
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rosario b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rosario
new file mode 100644
index 0000000..8c58f8c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Rosario differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santa_Isabel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santa_Isabel b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santa_Isabel
new file mode 100644
index 0000000..29c83e7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santa_Isabel differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santarem
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santarem b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santarem
new file mode 100644
index 0000000..d776a43
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santarem differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santiago
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santiago b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santiago
new file mode 100644
index 0000000..ab766a4
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santiago differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santo_Domingo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santo_Domingo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santo_Domingo
new file mode 100644
index 0000000..cc2cbf2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Santo_Domingo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Sao_Paulo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Sao_Paulo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Sao_Paulo
new file mode 100644
index 0000000..308a545
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Sao_Paulo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Scoresbysund
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Scoresbysund b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Scoresbysund
new file mode 100644
index 0000000..8e1366c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Scoresbysund differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Shiprock
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Shiprock b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Shiprock
new file mode 100644
index 0000000..7fc6691
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Shiprock differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Sitka
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Sitka b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Sitka
new file mode 100644
index 0000000..662b8b6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Sitka differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Barthelemy
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Barthelemy b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Barthelemy
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Barthelemy differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Johns
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Johns b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Johns
new file mode 100644
index 0000000..a1d1485
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Johns differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Kitts
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Kitts b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Kitts
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Kitts differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Lucia
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Lucia b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Lucia
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Lucia differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Thomas
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Thomas b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Thomas
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Thomas differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Vincent
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Vincent b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Vincent
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/St_Vincent differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Swift_Current
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Swift_Current b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Swift_Current
new file mode 100644
index 0000000..4db1300
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Swift_Current differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tegucigalpa
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tegucigalpa b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tegucigalpa
new file mode 100644
index 0000000..7aea8f9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tegucigalpa differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Thule
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Thule b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Thule
new file mode 100644
index 0000000..deefcc8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Thule differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Thunder_Bay
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Thunder_Bay b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Thunder_Bay
new file mode 100644
index 0000000..aa1d486
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Thunder_Bay differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tijuana
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tijuana b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tijuana
new file mode 100644
index 0000000..29c83e7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tijuana differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Toronto
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Toronto b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Toronto
new file mode 100644
index 0000000..7b4682a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Toronto differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tortola
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tortola b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tortola
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Tortola differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Vancouver
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Vancouver b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Vancouver
new file mode 100644
index 0000000..9b5d924
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Vancouver differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Virgin
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Virgin b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Virgin
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Virgin differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Whitehorse
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Whitehorse b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Whitehorse
new file mode 100644
index 0000000..6b62e2d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Whitehorse differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Winnipeg
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Winnipeg b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Winnipeg
new file mode 100644
index 0000000..2ffe3d8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Winnipeg differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Yakutat
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Yakutat b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Yakutat
new file mode 100644
index 0000000..523b0a1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Yakutat differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Yellowknife
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Yellowknife b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Yellowknife
new file mode 100644
index 0000000..d9d6eff
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Yellowknife differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Casey
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Casey b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Casey
new file mode 100644
index 0000000..d0bbacc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Casey differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Davis
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Davis b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Davis
new file mode 100644
index 0000000..40a9926
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Davis differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/DumontDUrville
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/DumontDUrville b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/DumontDUrville
new file mode 100644
index 0000000..0686353
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/DumontDUrville differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Macquarie
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Macquarie b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Macquarie
new file mode 100644
index 0000000..aea2be7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Macquarie differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Mawson
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Mawson b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Mawson
new file mode 100644
index 0000000..5197dd9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Mawson differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/McMurdo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/McMurdo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/McMurdo
new file mode 100644
index 0000000..a5f5b6d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/McMurdo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Palmer
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Palmer b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Palmer
new file mode 100644
index 0000000..43a01d3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Palmer differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Rothera
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Rothera b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Rothera
new file mode 100644
index 0000000..56913f8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Rothera differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/South_Pole
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/South_Pole b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/South_Pole
new file mode 100644
index 0000000..a5f5b6d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/South_Pole differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Syowa
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Syowa b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Syowa
new file mode 100644
index 0000000..94a9d5a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Syowa differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Troll
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Troll b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Troll
new file mode 100644
index 0000000..3757fac
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Troll differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Vostok
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Vostok b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Vostok
new file mode 100644
index 0000000..9fa335c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Antarctica/Vostok differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Arctic/Longyearbyen
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Arctic/Longyearbyen b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Arctic/Longyearbyen
new file mode 100644
index 0000000..239c017
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Arctic/Longyearbyen differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aden
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aden b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aden
new file mode 100644
index 0000000..e71bc4e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aden differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Almaty
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Almaty b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Almaty
new file mode 100644
index 0000000..49a4b4d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Almaty differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Amman
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Amman b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Amman
new file mode 100644
index 0000000..c3f0994
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Amman differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Anadyr
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Anadyr b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Anadyr
new file mode 100644
index 0000000..0e623cf
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Anadyr differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aqtau
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aqtau b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aqtau
new file mode 100644
index 0000000..5803a3d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aqtau differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aqtobe
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aqtobe b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aqtobe
new file mode 100644
index 0000000..808a502
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Aqtobe differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ashgabat
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ashgabat b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ashgabat
new file mode 100644
index 0000000..046c472
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ashgabat differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ashkhabad
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ashkhabad b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ashkhabad
new file mode 100644
index 0000000..046c472
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ashkhabad differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Atyrau
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Atyrau b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Atyrau
new file mode 100644
index 0000000..27072eb
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Atyrau differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Baghdad
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Baghdad b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Baghdad
new file mode 100644
index 0000000..3aacd78
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Baghdad differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bahrain
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bahrain b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bahrain
new file mode 100644
index 0000000..a0c5f66
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bahrain differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Baku
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Baku b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Baku
new file mode 100644
index 0000000..a17d1ad
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Baku differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bangkok
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bangkok b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bangkok
new file mode 100644
index 0000000..8db5e8a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bangkok differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Barnaul
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Barnaul b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Barnaul
new file mode 100644
index 0000000..60efb41
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Barnaul differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Beirut
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Beirut b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Beirut
new file mode 100644
index 0000000..72f0896
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Beirut differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bishkek
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bishkek b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bishkek
new file mode 100644
index 0000000..e3f81ee
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Bishkek differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Brunei
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Brunei b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Brunei
new file mode 100644
index 0000000..cad16b0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Brunei differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Calcutta
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Calcutta b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Calcutta
new file mode 100644
index 0000000..b57972d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Calcutta differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chita
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chita b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chita
new file mode 100644
index 0000000..95f5645
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chita differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Choibalsan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Choibalsan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Choibalsan
new file mode 100644
index 0000000..15b358f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Choibalsan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chongqing
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chongqing b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chongqing
new file mode 100644
index 0000000..dbd132f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chongqing differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chungking
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chungking b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chungking
new file mode 100644
index 0000000..dbd132f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Chungking differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Colombo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Colombo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Colombo
new file mode 100644
index 0000000..28fe430
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Colombo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dacca
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dacca b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dacca
new file mode 100644
index 0000000..98881f0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dacca differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Damascus
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Damascus b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Damascus
new file mode 100644
index 0000000..ac45764
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Damascus differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dhaka
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dhaka b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dhaka
new file mode 100644
index 0000000..98881f0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dhaka differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dili
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dili b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dili
new file mode 100644
index 0000000..c94fa61
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dili differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dubai
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dubai b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dubai
new file mode 100644
index 0000000..c12f31a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dubai differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dushanbe
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dushanbe b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dushanbe
new file mode 100644
index 0000000..67c772b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Dushanbe differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Famagusta
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Famagusta b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Famagusta
new file mode 100644
index 0000000..021f8a2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Famagusta differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Gaza
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Gaza b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Gaza
new file mode 100644
index 0000000..60d0de0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Gaza differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Harbin
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Harbin b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Harbin
new file mode 100644
index 0000000..dbd132f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Harbin differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hebron
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hebron b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hebron
new file mode 100644
index 0000000..a2e1b36
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hebron differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ho_Chi_Minh
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ho_Chi_Minh b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ho_Chi_Minh
new file mode 100644
index 0000000..9264267
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ho_Chi_Minh differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hong_Kong
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hong_Kong b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hong_Kong
new file mode 100644
index 0000000..dc9058e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hong_Kong differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hovd
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hovd b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hovd
new file mode 100644
index 0000000..f367a55
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Hovd differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Irkutsk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Irkutsk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Irkutsk
new file mode 100644
index 0000000..8413636
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Irkutsk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Istanbul
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Istanbul b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Istanbul
new file mode 100644
index 0000000..9a53b3a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Istanbul differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jakarta
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jakarta b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jakarta
new file mode 100644
index 0000000..37b4edd
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jakarta differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jayapura
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jayapura b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jayapura
new file mode 100644
index 0000000..39ddc84
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jayapura differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jerusalem
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jerusalem b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jerusalem
new file mode 100644
index 0000000..df51199
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Jerusalem differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kabul
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kabul b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kabul
new file mode 100644
index 0000000..80429ec
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kabul differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kamchatka
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kamchatka b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kamchatka
new file mode 100644
index 0000000..fab27de
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kamchatka differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Karachi
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Karachi b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Karachi
new file mode 100644
index 0000000..b7dcaab
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Karachi differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kashgar
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kashgar b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kashgar
new file mode 100644
index 0000000..b44a1e1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kashgar differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kathmandu
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kathmandu b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kathmandu
new file mode 100644
index 0000000..0cbd295
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kathmandu differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Katmandu
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Katmandu b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Katmandu
new file mode 100644
index 0000000..0cbd295
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Katmandu differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Khandyga
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Khandyga b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Khandyga
new file mode 100644
index 0000000..9183695
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Khandyga differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kolkata
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kolkata b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kolkata
new file mode 100644
index 0000000..b57972d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kolkata differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Krasnoyarsk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Krasnoyarsk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Krasnoyarsk
new file mode 100644
index 0000000..faec35d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Krasnoyarsk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuala_Lumpur
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuala_Lumpur b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuala_Lumpur
new file mode 100644
index 0000000..5c95ebc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuala_Lumpur differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuching
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuching b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuching
new file mode 100644
index 0000000..62b5389
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuching differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuwait
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuwait b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuwait
new file mode 100644
index 0000000..e71bc4e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Kuwait differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Macao
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Macao b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Macao
new file mode 100644
index 0000000..2c20a32
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Macao differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Macau
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Macau b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Macau
new file mode 100644
index 0000000..2c20a32
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Macau differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Magadan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Magadan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Magadan
new file mode 100644
index 0000000..2db0635
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Magadan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Makassar
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Makassar b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Makassar
new file mode 100644
index 0000000..3a5dcb2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Makassar differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Manila
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Manila b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Manila
new file mode 100644
index 0000000..06859a7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Manila differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Muscat
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Muscat b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Muscat
new file mode 100644
index 0000000..c12f31a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Muscat differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Nicosia
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Nicosia b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Nicosia
new file mode 100644
index 0000000..3e663b2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Nicosia differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Novokuznetsk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Novokuznetsk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Novokuznetsk
new file mode 100644
index 0000000..ed4b248
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Novokuznetsk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Novosibirsk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Novosibirsk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Novosibirsk
new file mode 100644
index 0000000..a5d39df
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Novosibirsk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Omsk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Omsk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Omsk
new file mode 100644
index 0000000..5e0d9b6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Omsk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Oral
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Oral b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Oral
new file mode 100644
index 0000000..b8eb58d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Oral differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Phnom_Penh
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Phnom_Penh b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Phnom_Penh
new file mode 100644
index 0000000..8db5e8a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Phnom_Penh differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Pontianak
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Pontianak b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Pontianak
new file mode 100644
index 0000000..ec98c62
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Pontianak differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Pyongyang
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Pyongyang b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Pyongyang
new file mode 100644
index 0000000..de5c2b1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Pyongyang differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Qatar
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Qatar b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Qatar
new file mode 100644
index 0000000..a0c5f66
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Qatar differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Qyzylorda
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Qyzylorda b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Qyzylorda
new file mode 100644
index 0000000..0fc7fad
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Qyzylorda differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Rangoon
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Rangoon b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Rangoon
new file mode 100644
index 0000000..3cc2aaf
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Rangoon differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Riyadh
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Riyadh b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Riyadh
new file mode 100644
index 0000000..e71bc4e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Riyadh differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Saigon
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Saigon b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Saigon
new file mode 100644
index 0000000..9264267
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Saigon differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Sakhalin
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Sakhalin b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Sakhalin
new file mode 100644
index 0000000..8d6b4df
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Sakhalin differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Samarkand
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Samarkand b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Samarkand
new file mode 100644
index 0000000..10c7af7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Samarkand differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Seoul
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Seoul b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Seoul
new file mode 100644
index 0000000..312ec40
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Seoul differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Shanghai
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Shanghai b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Shanghai
new file mode 100644
index 0000000..dbd132f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Shanghai differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Singapore
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Singapore b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Singapore
new file mode 100644
index 0000000..7858366
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Singapore differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Srednekolymsk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Srednekolymsk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Srednekolymsk
new file mode 100644
index 0000000..16b1cd8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Srednekolymsk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Taipei
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Taipei b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Taipei
new file mode 100644
index 0000000..748873b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Taipei differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tashkent
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tashkent b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tashkent
new file mode 100644
index 0000000..6f7dea4
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tashkent differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tbilisi
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tbilisi b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tbilisi
new file mode 100644
index 0000000..4b2d2e2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tbilisi differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tehran
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tehran b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tehran
new file mode 100644
index 0000000..3157f80
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tehran differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tel_Aviv
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tel_Aviv b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tel_Aviv
new file mode 100644
index 0000000..df51199
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tel_Aviv differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Thimbu
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Thimbu b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Thimbu
new file mode 100644
index 0000000..a8bddb9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Thimbu differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Thimphu
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Thimphu b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Thimphu
new file mode 100644
index 0000000..a8bddb9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Thimphu differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tokyo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tokyo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tokyo
new file mode 100644
index 0000000..8ad44ba
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tokyo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tomsk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tomsk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tomsk
new file mode 100644
index 0000000..919b003
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Tomsk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ujung_Pandang
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ujung_Pandang b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ujung_Pandang
new file mode 100644
index 0000000..3a5dcb2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ujung_Pandang differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ulaanbaatar
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ulaanbaatar b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ulaanbaatar
new file mode 100644
index 0000000..94ddfea
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ulaanbaatar differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ulan_Bator
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ulan_Bator b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ulan_Bator
new file mode 100644
index 0000000..94ddfea
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ulan_Bator differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Urumqi
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Urumqi b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Urumqi
new file mode 100644
index 0000000..b44a1e1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Urumqi differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ust-Nera
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ust-Nera b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ust-Nera
new file mode 100644
index 0000000..7431eb9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Ust-Nera differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Vientiane
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Vientiane b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Vientiane
new file mode 100644
index 0000000..8db5e8a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Vientiane differ
[14/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_lookup_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_lookup_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_lookup_test.cc
new file mode 100644
index 0000000..a5d73d5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_lookup_test.cc
@@ -0,0 +1,1259 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+#include <chrono>
+#include <cstddef>
+#include <future>
+#include <string>
+#include <thread>
+#include <vector>
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "gtest/gtest.h"
+
+using std::chrono::time_point_cast;
+using std::chrono::system_clock;
+using std::chrono::nanoseconds;
+using std::chrono::microseconds;
+using std::chrono::milliseconds;
+using std::chrono::seconds;
+using std::chrono::minutes;
+using std::chrono::hours;
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+namespace {
+
+// A list of known time-zone names.
+const char* const kTimeZoneNames[] = {
+ "Africa/Abidjan",
+ "Africa/Accra",
+ "Africa/Addis_Ababa",
+ "Africa/Algiers",
+ "Africa/Asmara",
+ "Africa/Asmera",
+ "Africa/Bamako",
+ "Africa/Bangui",
+ "Africa/Banjul",
+ "Africa/Bissau",
+ "Africa/Blantyre",
+ "Africa/Brazzaville",
+ "Africa/Bujumbura",
+ "Africa/Cairo",
+ "Africa/Casablanca",
+ "Africa/Ceuta",
+ "Africa/Conakry",
+ "Africa/Dakar",
+ "Africa/Dar_es_Salaam",
+ "Africa/Djibouti",
+ "Africa/Douala",
+ "Africa/El_Aaiun",
+ "Africa/Freetown",
+ "Africa/Gaborone",
+ "Africa/Harare",
+ "Africa/Johannesburg",
+ "Africa/Juba",
+ "Africa/Kampala",
+ "Africa/Khartoum",
+ "Africa/Kigali",
+ "Africa/Kinshasa",
+ "Africa/Lagos",
+ "Africa/Libreville",
+ "Africa/Lome",
+ "Africa/Luanda",
+ "Africa/Lubumbashi",
+ "Africa/Lusaka",
+ "Africa/Malabo",
+ "Africa/Maputo",
+ "Africa/Maseru",
+ "Africa/Mbabane",
+ "Africa/Mogadishu",
+ "Africa/Monrovia",
+ "Africa/Nairobi",
+ "Africa/Ndjamena",
+ "Africa/Niamey",
+ "Africa/Nouakchott",
+ "Africa/Ouagadougou",
+ "Africa/Porto-Novo",
+ "Africa/Sao_Tome",
+ "Africa/Timbuktu",
+ "Africa/Tripoli",
+ "Africa/Tunis",
+ "Africa/Windhoek",
+ "America/Adak",
+ "America/Anchorage",
+ "America/Anguilla",
+ "America/Antigua",
+ "America/Araguaina",
+ "America/Argentina/Buenos_Aires",
+ "America/Argentina/Catamarca",
+ "America/Argentina/ComodRivadavia",
+ "America/Argentina/Cordoba",
+ "America/Argentina/Jujuy",
+ "America/Argentina/La_Rioja",
+ "America/Argentina/Mendoza",
+ "America/Argentina/Rio_Gallegos",
+ "America/Argentina/Salta",
+ "America/Argentina/San_Juan",
+ "America/Argentina/San_Luis",
+ "America/Argentina/Tucuman",
+ "America/Argentina/Ushuaia",
+ "America/Aruba",
+ "America/Asuncion",
+ "America/Atikokan",
+ "America/Atka",
+ "America/Bahia",
+ "America/Bahia_Banderas",
+ "America/Barbados",
+ "America/Belem",
+ "America/Belize",
+ "America/Blanc-Sablon",
+ "America/Boa_Vista",
+ "America/Bogota",
+ "America/Boise",
+ "America/Buenos_Aires",
+ "America/Cambridge_Bay",
+ "America/Campo_Grande",
+ "America/Cancun",
+ "America/Caracas",
+ "America/Catamarca",
+ "America/Cayenne",
+ "America/Cayman",
+ "America/Chicago",
+ "America/Chihuahua",
+ "America/Coral_Harbour",
+ "America/Cordoba",
+ "America/Costa_Rica",
+ "America/Creston",
+ "America/Cuiaba",
+ "America/Curacao",
+ "America/Danmarkshavn",
+ "America/Dawson",
+ "America/Dawson_Creek",
+ "America/Denver",
+ "America/Detroit",
+ "America/Dominica",
+ "America/Edmonton",
+ "America/Eirunepe",
+ "America/El_Salvador",
+ "America/Ensenada",
+ "America/Fort_Nelson",
+ "America/Fort_Wayne",
+ "America/Fortaleza",
+ "America/Glace_Bay",
+ "America/Godthab",
+ "America/Goose_Bay",
+ "America/Grand_Turk",
+ "America/Grenada",
+ "America/Guadeloupe",
+ "America/Guatemala",
+ "America/Guayaquil",
+ "America/Guyana",
+ "America/Halifax",
+ "America/Havana",
+ "America/Hermosillo",
+ "America/Indiana/Indianapolis",
+ "America/Indiana/Knox",
+ "America/Indiana/Marengo",
+ "America/Indiana/Petersburg",
+ "America/Indiana/Tell_City",
+ "America/Indiana/Vevay",
+ "America/Indiana/Vincennes",
+ "America/Indiana/Winamac",
+ "America/Indianapolis",
+ "America/Inuvik",
+ "America/Iqaluit",
+ "America/Jamaica",
+ "America/Jujuy",
+ "America/Juneau",
+ "America/Kentucky/Louisville",
+ "America/Kentucky/Monticello",
+ "America/Knox_IN",
+ "America/Kralendijk",
+ "America/La_Paz",
+ "America/Lima",
+ "America/Los_Angeles",
+ "America/Louisville",
+ "America/Lower_Princes",
+ "America/Maceio",
+ "America/Managua",
+ "America/Manaus",
+ "America/Marigot",
+ "America/Martinique",
+ "America/Matamoros",
+ "America/Mazatlan",
+ "America/Mendoza",
+ "America/Menominee",
+ "America/Merida",
+ "America/Metlakatla",
+ "America/Mexico_City",
+ "America/Miquelon",
+ "America/Moncton",
+ "America/Monterrey",
+ "America/Montevideo",
+ "America/Montreal",
+ "America/Montserrat",
+ "America/Nassau",
+ "America/New_York",
+ "America/Nipigon",
+ "America/Nome",
+ "America/Noronha",
+ "America/North_Dakota/Beulah",
+ "America/North_Dakota/Center",
+ "America/North_Dakota/New_Salem",
+ "America/Ojinaga",
+ "America/Panama",
+ "America/Pangnirtung",
+ "America/Paramaribo",
+ "America/Phoenix",
+ "America/Port-au-Prince",
+ "America/Port_of_Spain",
+ "America/Porto_Acre",
+ "America/Porto_Velho",
+ "America/Puerto_Rico",
+ "America/Punta_Arenas",
+ "America/Rainy_River",
+ "America/Rankin_Inlet",
+ "America/Recife",
+ "America/Regina",
+ "America/Resolute",
+ "America/Rio_Branco",
+ "America/Rosario",
+ "America/Santa_Isabel",
+ "America/Santarem",
+ "America/Santiago",
+ "America/Santo_Domingo",
+ "America/Sao_Paulo",
+ "America/Scoresbysund",
+ "America/Shiprock",
+ "America/Sitka",
+ "America/St_Barthelemy",
+ "America/St_Johns",
+ "America/St_Kitts",
+ "America/St_Lucia",
+ "America/St_Thomas",
+ "America/St_Vincent",
+ "America/Swift_Current",
+ "America/Tegucigalpa",
+ "America/Thule",
+ "America/Thunder_Bay",
+ "America/Tijuana",
+ "America/Toronto",
+ "America/Tortola",
+ "America/Vancouver",
+ "America/Virgin",
+ "America/Whitehorse",
+ "America/Winnipeg",
+ "America/Yakutat",
+ "America/Yellowknife",
+ "Antarctica/Casey",
+ "Antarctica/Davis",
+ "Antarctica/DumontDUrville",
+ "Antarctica/Macquarie",
+ "Antarctica/Mawson",
+ "Antarctica/McMurdo",
+ "Antarctica/Palmer",
+ "Antarctica/Rothera",
+ "Antarctica/South_Pole",
+ "Antarctica/Syowa",
+ "Antarctica/Troll",
+ "Antarctica/Vostok",
+ "Arctic/Longyearbyen",
+ "Asia/Aden",
+ "Asia/Almaty",
+ "Asia/Amman",
+ "Asia/Anadyr",
+ "Asia/Aqtau",
+ "Asia/Aqtobe",
+ "Asia/Ashgabat",
+ "Asia/Ashkhabad",
+ "Asia/Atyrau",
+ "Asia/Baghdad",
+ "Asia/Bahrain",
+ "Asia/Baku",
+ "Asia/Bangkok",
+ "Asia/Barnaul",
+ "Asia/Beirut",
+ "Asia/Bishkek",
+ "Asia/Brunei",
+ "Asia/Calcutta",
+ "Asia/Chita",
+ "Asia/Choibalsan",
+ "Asia/Chongqing",
+ "Asia/Chungking",
+ "Asia/Colombo",
+ "Asia/Dacca",
+ "Asia/Damascus",
+ "Asia/Dhaka",
+ "Asia/Dili",
+ "Asia/Dubai",
+ "Asia/Dushanbe",
+ "Asia/Famagusta",
+ "Asia/Gaza",
+ "Asia/Harbin",
+ "Asia/Hebron",
+ "Asia/Ho_Chi_Minh",
+ "Asia/Hong_Kong",
+ "Asia/Hovd",
+ "Asia/Irkutsk",
+ "Asia/Istanbul",
+ "Asia/Jakarta",
+ "Asia/Jayapura",
+ "Asia/Jerusalem",
+ "Asia/Kabul",
+ "Asia/Kamchatka",
+ "Asia/Karachi",
+ "Asia/Kashgar",
+ "Asia/Kathmandu",
+ "Asia/Katmandu",
+ "Asia/Khandyga",
+ "Asia/Kolkata",
+ "Asia/Krasnoyarsk",
+ "Asia/Kuala_Lumpur",
+ "Asia/Kuching",
+ "Asia/Kuwait",
+ "Asia/Macao",
+ "Asia/Macau",
+ "Asia/Magadan",
+ "Asia/Makassar",
+ "Asia/Manila",
+ "Asia/Muscat",
+ "Asia/Nicosia",
+ "Asia/Novokuznetsk",
+ "Asia/Novosibirsk",
+ "Asia/Omsk",
+ "Asia/Oral",
+ "Asia/Phnom_Penh",
+ "Asia/Pontianak",
+ "Asia/Pyongyang",
+ "Asia/Qatar",
+ "Asia/Qyzylorda",
+ "Asia/Rangoon",
+ "Asia/Riyadh",
+ "Asia/Saigon",
+ "Asia/Sakhalin",
+ "Asia/Samarkand",
+ "Asia/Seoul",
+ "Asia/Shanghai",
+ "Asia/Singapore",
+ "Asia/Srednekolymsk",
+ "Asia/Taipei",
+ "Asia/Tashkent",
+ "Asia/Tbilisi",
+ "Asia/Tehran",
+ "Asia/Tel_Aviv",
+ "Asia/Thimbu",
+ "Asia/Thimphu",
+ "Asia/Tokyo",
+ "Asia/Tomsk",
+ "Asia/Ujung_Pandang",
+ "Asia/Ulaanbaatar",
+ "Asia/Ulan_Bator",
+ "Asia/Urumqi",
+ "Asia/Ust-Nera",
+ "Asia/Vientiane",
+ "Asia/Vladivostok",
+ "Asia/Yakutsk",
+ "Asia/Yangon",
+ "Asia/Yekaterinburg",
+ "Asia/Yerevan",
+ "Atlantic/Azores",
+ "Atlantic/Bermuda",
+ "Atlantic/Canary",
+ "Atlantic/Cape_Verde",
+ "Atlantic/Faeroe",
+ "Atlantic/Faroe",
+ "Atlantic/Jan_Mayen",
+ "Atlantic/Madeira",
+ "Atlantic/Reykjavik",
+ "Atlantic/South_Georgia",
+ "Atlantic/St_Helena",
+ "Atlantic/Stanley",
+ "Australia/ACT",
+ "Australia/Adelaide",
+ "Australia/Brisbane",
+ "Australia/Broken_Hill",
+ "Australia/Canberra",
+ "Australia/Currie",
+ "Australia/Darwin",
+ "Australia/Eucla",
+ "Australia/Hobart",
+ "Australia/LHI",
+ "Australia/Lindeman",
+ "Australia/Lord_Howe",
+ "Australia/Melbourne",
+ "Australia/NSW",
+ "Australia/North",
+ "Australia/Perth",
+ "Australia/Queensland",
+ "Australia/South",
+ "Australia/Sydney",
+ "Australia/Tasmania",
+ "Australia/Victoria",
+ "Australia/West",
+ "Australia/Yancowinna",
+ "Brazil/Acre",
+ "Brazil/DeNoronha",
+ "Brazil/East",
+ "Brazil/West",
+ "CET",
+ "CST6CDT",
+ "Canada/Atlantic",
+ "Canada/Central",
+ "Canada/East-Saskatchewan",
+ "Canada/Eastern",
+ "Canada/Mountain",
+ "Canada/Newfoundland",
+ "Canada/Pacific",
+ "Canada/Saskatchewan",
+ "Canada/Yukon",
+ "Chile/Continental",
+ "Chile/EasterIsland",
+ "Cuba",
+ "EET",
+ "EST",
+ "EST5EDT",
+ "Egypt",
+ "Eire",
+ "Etc/GMT",
+ "Etc/GMT+0",
+ "Etc/GMT+1",
+ "Etc/GMT+10",
+ "Etc/GMT+11",
+ "Etc/GMT+12",
+ "Etc/GMT+2",
+ "Etc/GMT+3",
+ "Etc/GMT+4",
+ "Etc/GMT+5",
+ "Etc/GMT+6",
+ "Etc/GMT+7",
+ "Etc/GMT+8",
+ "Etc/GMT+9",
+ "Etc/GMT-0",
+ "Etc/GMT-1",
+ "Etc/GMT-10",
+ "Etc/GMT-11",
+ "Etc/GMT-12",
+ "Etc/GMT-13",
+ "Etc/GMT-14",
+ "Etc/GMT-2",
+ "Etc/GMT-3",
+ "Etc/GMT-4",
+ "Etc/GMT-5",
+ "Etc/GMT-6",
+ "Etc/GMT-7",
+ "Etc/GMT-8",
+ "Etc/GMT-9",
+ "Etc/GMT0",
+ "Etc/Greenwich",
+ "Etc/UCT",
+ "Etc/UTC",
+ "Etc/Universal",
+ "Etc/Zulu",
+ "Europe/Amsterdam",
+ "Europe/Andorra",
+ "Europe/Astrakhan",
+ "Europe/Athens",
+ "Europe/Belfast",
+ "Europe/Belgrade",
+ "Europe/Berlin",
+ "Europe/Bratislava",
+ "Europe/Brussels",
+ "Europe/Bucharest",
+ "Europe/Budapest",
+ "Europe/Busingen",
+ "Europe/Chisinau",
+ "Europe/Copenhagen",
+ "Europe/Dublin",
+ "Europe/Gibraltar",
+ "Europe/Guernsey",
+ "Europe/Helsinki",
+ "Europe/Isle_of_Man",
+ "Europe/Istanbul",
+ "Europe/Jersey",
+ "Europe/Kaliningrad",
+ "Europe/Kiev",
+ "Europe/Kirov",
+ "Europe/Lisbon",
+ "Europe/Ljubljana",
+ "Europe/London",
+ "Europe/Luxembourg",
+ "Europe/Madrid",
+ "Europe/Malta",
+ "Europe/Mariehamn",
+ "Europe/Minsk",
+ "Europe/Monaco",
+ "Europe/Moscow",
+ "Europe/Nicosia",
+ "Europe/Oslo",
+ "Europe/Paris",
+ "Europe/Podgorica",
+ "Europe/Prague",
+ "Europe/Riga",
+ "Europe/Rome",
+ "Europe/Samara",
+ "Europe/San_Marino",
+ "Europe/Sarajevo",
+ "Europe/Saratov",
+ "Europe/Simferopol",
+ "Europe/Skopje",
+ "Europe/Sofia",
+ "Europe/Stockholm",
+ "Europe/Tallinn",
+ "Europe/Tirane",
+ "Europe/Tiraspol",
+ "Europe/Ulyanovsk",
+ "Europe/Uzhgorod",
+ "Europe/Vaduz",
+ "Europe/Vatican",
+ "Europe/Vienna",
+ "Europe/Vilnius",
+ "Europe/Volgograd",
+ "Europe/Warsaw",
+ "Europe/Zagreb",
+ "Europe/Zaporozhye",
+ "Europe/Zurich",
+ "GB",
+ "GB-Eire",
+ "GMT",
+ "GMT+0",
+ "GMT-0",
+ "GMT0",
+ "Greenwich",
+ "HST",
+ "Hongkong",
+ "Iceland",
+ "Indian/Antananarivo",
+ "Indian/Chagos",
+ "Indian/Christmas",
+ "Indian/Cocos",
+ "Indian/Comoro",
+ "Indian/Kerguelen",
+ "Indian/Mahe",
+ "Indian/Maldives",
+ "Indian/Mauritius",
+ "Indian/Mayotte",
+ "Indian/Reunion",
+ "Iran",
+ "Israel",
+ "Jamaica",
+ "Japan",
+ "Kwajalein",
+ "Libya",
+ "MET",
+ "MST",
+ "MST7MDT",
+ "Mexico/BajaNorte",
+ "Mexico/BajaSur",
+ "Mexico/General",
+ "NZ",
+ "NZ-CHAT",
+ "Navajo",
+ "PRC",
+ "PST8PDT",
+ "Pacific/Apia",
+ "Pacific/Auckland",
+ "Pacific/Bougainville",
+ "Pacific/Chatham",
+ "Pacific/Chuuk",
+ "Pacific/Easter",
+ "Pacific/Efate",
+ "Pacific/Enderbury",
+ "Pacific/Fakaofo",
+ "Pacific/Fiji",
+ "Pacific/Funafuti",
+ "Pacific/Galapagos",
+ "Pacific/Gambier",
+ "Pacific/Guadalcanal",
+ "Pacific/Guam",
+ "Pacific/Honolulu",
+ "Pacific/Johnston",
+ "Pacific/Kiritimati",
+ "Pacific/Kosrae",
+ "Pacific/Kwajalein",
+ "Pacific/Majuro",
+ "Pacific/Marquesas",
+ "Pacific/Midway",
+ "Pacific/Nauru",
+ "Pacific/Niue",
+ "Pacific/Norfolk",
+ "Pacific/Noumea",
+ "Pacific/Pago_Pago",
+ "Pacific/Palau",
+ "Pacific/Pitcairn",
+ "Pacific/Pohnpei",
+ "Pacific/Ponape",
+ "Pacific/Port_Moresby",
+ "Pacific/Rarotonga",
+ "Pacific/Saipan",
+ "Pacific/Samoa",
+ "Pacific/Tahiti",
+ "Pacific/Tarawa",
+ "Pacific/Tongatapu",
+ "Pacific/Truk",
+ "Pacific/Wake",
+ "Pacific/Wallis",
+ "Pacific/Yap",
+ "Poland",
+ "Portugal",
+ "ROC",
+ "ROK",
+ "Singapore",
+ "Turkey",
+ "UCT",
+ "US/Alaska",
+ "US/Aleutian",
+ "US/Arizona",
+ "US/Central",
+ "US/East-Indiana",
+ "US/Eastern",
+ "US/Hawaii",
+ "US/Indiana-Starke",
+ "US/Michigan",
+ "US/Mountain",
+ "US/Pacific",
+ "US/Samoa",
+ "UTC",
+ "Universal",
+ "W-SU",
+ "WET",
+ "Zulu",
+ nullptr
+};
+
+// Helper to return a loaded time zone by value (UTC on error).
+time_zone LoadZone(const std::string& name) {
+ time_zone tz;
+ load_time_zone(name, &tz);
+ return tz;
+}
+
+// This helper is a macro so that failed expectations show up with the
+// correct line numbers.
+#define ExpectTime(tp, tz, y, m, d, hh, mm, ss, off, isdst, zone) \
+ do { \
+ time_zone::absolute_lookup al = tz.lookup(tp); \
+ EXPECT_EQ(y, al.cs.year()); \
+ EXPECT_EQ(m, al.cs.month()); \
+ EXPECT_EQ(d, al.cs.day()); \
+ EXPECT_EQ(hh, al.cs.hour()); \
+ EXPECT_EQ(mm, al.cs.minute()); \
+ EXPECT_EQ(ss, al.cs.second()); \
+ EXPECT_EQ(off, al.offset); \
+ EXPECT_TRUE(isdst == al.is_dst); \
+ /* EXPECT_STREQ(zone, al.abbr); */ \
+ } while (0)
+
+} // namespace
+
+TEST(TimeZones, LoadZonesConcurrently) {
+ std::promise<void> ready_promise;
+ std::shared_future<void> ready_future(ready_promise.get_future());
+ auto load_zones = [ready_future](std::promise<void>* started,
+ std::set<std::string>* failures) {
+ started->set_value();
+ ready_future.wait();
+ for (const char* const* np = kTimeZoneNames; *np != nullptr; ++np) {
+ std::string zone = *np;
+ time_zone tz;
+ if (load_time_zone(zone, &tz)) {
+ EXPECT_EQ(zone, tz.name());
+ } else {
+ failures->insert(zone);
+ }
+ }
+ };
+
+ const std::size_t n_threads = 128;
+ std::vector<std::thread> threads;
+ std::vector<std::set<std::string>> thread_failures(n_threads);
+ for (std::size_t i = 0; i != n_threads; ++i) {
+ std::promise<void> started;
+ threads.emplace_back(load_zones, &started, &thread_failures[i]);
+ started.get_future().wait();
+ }
+ ready_promise.set_value();
+ for (auto& thread : threads) {
+ thread.join();
+ }
+
+ // Allow a small number of failures to account for skew between
+ // the contents of kTimeZoneNames and the zoneinfo data source.
+ const std::size_t max_failures = 3;
+ std::set<std::string> failures;
+ for (const auto& thread_failure : thread_failures) {
+ failures.insert(thread_failure.begin(), thread_failure.end());
+ }
+ EXPECT_LE(failures.size(), max_failures) << testing::PrintToString(failures);
+}
+
+TEST(TimeZone, NamedTimeZones) {
+ const time_zone utc = utc_time_zone();
+ EXPECT_EQ("UTC", utc.name());
+ const time_zone nyc = LoadZone("America/New_York");
+ EXPECT_EQ("America/New_York", nyc.name());
+ const time_zone syd = LoadZone("Australia/Sydney");
+ EXPECT_EQ("Australia/Sydney", syd.name());
+ const time_zone fixed0 = fixed_time_zone(sys_seconds::zero());
+ EXPECT_EQ("UTC", fixed0.name());
+ const time_zone fixed_pos =
+ fixed_time_zone(hours(3) + minutes(25) + seconds(45));
+ EXPECT_EQ("Fixed/UTC+03:25:45", fixed_pos.name());
+ const time_zone fixed_neg =
+ fixed_time_zone(-(hours(12) + minutes(34) + seconds(56)));
+ EXPECT_EQ("Fixed/UTC-12:34:56", fixed_neg.name());
+}
+
+TEST(TimeZone, Failures) {
+ time_zone tz;
+ EXPECT_FALSE(load_time_zone(":America/Los_Angeles", &tz));
+
+ tz = LoadZone("America/Los_Angeles");
+ EXPECT_FALSE(load_time_zone("Invalid/TimeZone", &tz));
+ EXPECT_EQ(system_clock::from_time_t(0),
+ convert(civil_second(1970, 1, 1, 0, 0, 0), tz)); // UTC
+
+ // Ensures that the load still fails on a subsequent attempt.
+ tz = LoadZone("America/Los_Angeles");
+ EXPECT_FALSE(load_time_zone("Invalid/TimeZone", &tz));
+ EXPECT_EQ(system_clock::from_time_t(0),
+ convert(civil_second(1970, 1, 1, 0, 0, 0), tz)); // UTC
+
+ // Loading an empty std::string timezone should fail.
+ tz = LoadZone("America/Los_Angeles");
+ EXPECT_FALSE(load_time_zone("", &tz));
+ EXPECT_EQ(system_clock::from_time_t(0),
+ convert(civil_second(1970, 1, 1, 0, 0, 0), tz)); // UTC
+}
+
+TEST(TimeZone, Equality) {
+ const time_zone a;
+ const time_zone b;
+ EXPECT_EQ(a, b);
+ EXPECT_EQ(a.name(), b.name());
+
+ const time_zone implicit_utc;
+ const time_zone explicit_utc = utc_time_zone();
+ EXPECT_EQ(implicit_utc, explicit_utc);
+ EXPECT_EQ(implicit_utc.name(), explicit_utc.name());
+
+ const time_zone fixed_zero = fixed_time_zone(sys_seconds::zero());
+ EXPECT_EQ(fixed_zero, LoadZone(fixed_zero.name()));
+ EXPECT_EQ(fixed_zero, explicit_utc);
+
+ const time_zone fixed_utc = LoadZone("Fixed/UTC+00:00:00");
+ EXPECT_EQ(fixed_utc, LoadZone(fixed_utc.name()));
+ EXPECT_EQ(fixed_utc, explicit_utc);
+
+ const time_zone fixed_pos =
+ fixed_time_zone(hours(3) + minutes(25) + seconds(45));
+ EXPECT_EQ(fixed_pos, LoadZone(fixed_pos.name()));
+ EXPECT_NE(fixed_pos, explicit_utc);
+ const time_zone fixed_neg =
+ fixed_time_zone(-(hours(12) + minutes(34) + seconds(56)));
+ EXPECT_EQ(fixed_neg, LoadZone(fixed_neg.name()));
+ EXPECT_NE(fixed_neg, explicit_utc);
+
+ const time_zone fixed_lim = fixed_time_zone(hours(24));
+ EXPECT_EQ(fixed_lim, LoadZone(fixed_lim.name()));
+ EXPECT_NE(fixed_lim, explicit_utc);
+ const time_zone fixed_ovfl = fixed_time_zone(hours(24) + seconds(1));
+ EXPECT_EQ(fixed_ovfl, LoadZone(fixed_ovfl.name()));
+ EXPECT_EQ(fixed_ovfl, explicit_utc);
+
+ EXPECT_EQ(fixed_time_zone(seconds(1)), fixed_time_zone(seconds(1)));
+
+ const time_zone local = local_time_zone();
+ EXPECT_EQ(local, LoadZone(local.name()));
+
+ time_zone la = LoadZone("America/Los_Angeles");
+ time_zone nyc = LoadZone("America/New_York");
+ EXPECT_NE(la, nyc);
+}
+
+TEST(StdChronoTimePoint, TimeTAlignment) {
+ // Ensures that the Unix epoch and the system clock epoch are an integral
+ // number of seconds apart. This simplifies conversions to/from time_t.
+ auto diff = system_clock::time_point() - system_clock::from_time_t(0);
+ EXPECT_EQ(system_clock::time_point::duration::zero(), diff % seconds(1));
+}
+
+TEST(BreakTime, TimePointResolution) {
+ const time_zone utc = utc_time_zone();
+ const auto t0 = system_clock::from_time_t(0);
+
+ ExpectTime(time_point_cast<nanoseconds>(t0), utc,
+ 1970, 1, 1, 0, 0, 0, 0, false, "UTC");
+ ExpectTime(time_point_cast<microseconds>(t0), utc,
+ 1970, 1, 1, 0, 0, 0, 0, false, "UTC");
+ ExpectTime(time_point_cast<milliseconds>(t0), utc,
+ 1970, 1, 1, 0, 0, 0, 0, false, "UTC");
+ ExpectTime(time_point_cast<seconds>(t0), utc,
+ 1970, 1, 1, 0, 0, 0, 0, false, "UTC");
+ ExpectTime(time_point_cast<sys_seconds>(t0), utc,
+ 1970, 1, 1, 0, 0, 0, 0, false, "UTC");
+ ExpectTime(time_point_cast<minutes>(t0), utc,
+ 1970, 1, 1, 0, 0, 0, 0, false, "UTC");
+ ExpectTime(time_point_cast<hours>(t0), utc,
+ 1970, 1, 1, 0, 0, 0, 0, false, "UTC");
+}
+
+TEST(BreakTime, LocalTimeInUTC) {
+ const time_zone tz = utc_time_zone();
+ const auto tp = system_clock::from_time_t(0);
+ ExpectTime(tp, tz, 1970, 1, 1, 0, 0, 0, 0, false, "UTC");
+ EXPECT_EQ(weekday::thursday, get_weekday(civil_day(convert(tp, tz))));
+}
+
+TEST(BreakTime, LocalTimeInUTCUnaligned) {
+ const time_zone tz = utc_time_zone();
+ const auto tp = system_clock::from_time_t(0) - milliseconds(500);
+ ExpectTime(tp, tz, 1969, 12, 31, 23, 59, 59, 0, false, "UTC");
+ EXPECT_EQ(weekday::wednesday, get_weekday(civil_day(convert(tp, tz))));
+}
+
+TEST(BreakTime, LocalTimePosix) {
+ // See IEEE Std 1003.1-1988 B.2.3 General Terms, Epoch.
+ const time_zone tz = utc_time_zone();
+ const auto tp = system_clock::from_time_t(536457599);
+ ExpectTime(tp, tz, 1986, 12, 31, 23, 59, 59, 0, false, "UTC");
+ EXPECT_EQ(weekday::wednesday, get_weekday(civil_day(convert(tp, tz))));
+}
+
+TEST(TimeZoneImpl, LocalTimeInFixed) {
+ const sys_seconds offset = -(hours(8) + minutes(33) + seconds(47));
+ const time_zone tz = fixed_time_zone(offset);
+ const auto tp = system_clock::from_time_t(0);
+ ExpectTime(tp, tz, 1969, 12, 31, 15, 26, 13, offset.count(), false,
+ "UTC-083347");
+ EXPECT_EQ(weekday::wednesday, get_weekday(civil_day(convert(tp, tz))));
+}
+
+TEST(BreakTime, LocalTimeInNewYork) {
+ const time_zone tz = LoadZone("America/New_York");
+ const auto tp = system_clock::from_time_t(45);
+ ExpectTime(tp, tz, 1969, 12, 31, 19, 0, 45, -5 * 60 * 60, false, "EST");
+ EXPECT_EQ(weekday::wednesday, get_weekday(civil_day(convert(tp, tz))));
+}
+
+TEST(BreakTime, LocalTimeInMTV) {
+ const time_zone tz = LoadZone("America/Los_Angeles");
+ const auto tp = system_clock::from_time_t(1380855729);
+ ExpectTime(tp, tz, 2013, 10, 3, 20, 2, 9, -7 * 60 * 60, true, "PDT");
+ EXPECT_EQ(weekday::thursday, get_weekday(civil_day(convert(tp, tz))));
+}
+
+TEST(BreakTime, LocalTimeInSydney) {
+ const time_zone tz = LoadZone("Australia/Sydney");
+ const auto tp = system_clock::from_time_t(90);
+ ExpectTime(tp, tz, 1970, 1, 1, 10, 1, 30, 10 * 60 * 60, false, "AEST");
+ EXPECT_EQ(weekday::thursday, get_weekday(civil_day(convert(tp, tz))));
+}
+
+TEST(MakeTime, TimePointResolution) {
+ const time_zone utc = utc_time_zone();
+ const time_point<nanoseconds> tp_ns =
+ convert(civil_second(2015, 1, 2, 3, 4, 5), utc);
+ EXPECT_EQ("04:05", format("%M:%E*S", tp_ns, utc));
+ const time_point<microseconds> tp_us =
+ convert(civil_second(2015, 1, 2, 3, 4, 5), utc);
+ EXPECT_EQ("04:05", format("%M:%E*S", tp_us, utc));
+ const time_point<milliseconds> tp_ms =
+ convert(civil_second(2015, 1, 2, 3, 4, 5), utc);
+ EXPECT_EQ("04:05", format("%M:%E*S", tp_ms, utc));
+ const time_point<seconds> tp_s =
+ convert(civil_second(2015, 1, 2, 3, 4, 5), utc);
+ EXPECT_EQ("04:05", format("%M:%E*S", tp_s, utc));
+ const time_point<sys_seconds> tp_s64 =
+ convert(civil_second(2015, 1, 2, 3, 4, 5), utc);
+ EXPECT_EQ("04:05", format("%M:%E*S", tp_s64, utc));
+
+ // These next two require time_point_cast because the conversion from a
+ // resolution of seconds (the return value of convert()) to a coarser
+ // resolution requires an explicit cast.
+ const time_point<minutes> tp_m =
+ time_point_cast<minutes>(
+ convert(civil_second(2015, 1, 2, 3, 4, 5), utc));
+ EXPECT_EQ("04:00", format("%M:%E*S", tp_m, utc));
+ const time_point<hours> tp_h =
+ time_point_cast<hours>(
+ convert(civil_second(2015, 1, 2, 3, 4, 5), utc));
+ EXPECT_EQ("00:00", format("%M:%E*S", tp_h, utc));
+}
+
+TEST(MakeTime, Normalization) {
+ const time_zone tz = LoadZone("America/New_York");
+ const auto tp = convert(civil_second(2009, 2, 13, 18, 31, 30), tz);
+ EXPECT_EQ(system_clock::from_time_t(1234567890), tp);
+
+ // Now requests for the same time_point but with out-of-range fields.
+ EXPECT_EQ(tp, convert(civil_second(2008, 14, 13, 18, 31, 30), tz)); // month
+ EXPECT_EQ(tp, convert(civil_second(2009, 1, 44, 18, 31, 30), tz)); // day
+ EXPECT_EQ(tp, convert(civil_second(2009, 2, 12, 42, 31, 30), tz)); // hour
+ EXPECT_EQ(tp, convert(civil_second(2009, 2, 13, 17, 91, 30), tz)); // minute
+ EXPECT_EQ(tp, convert(civil_second(2009, 2, 13, 18, 30, 90), tz)); // second
+}
+
+// NOTE: Run this with --copt=-ftrapv to detect overflow problems.
+TEST(MakeTime, SysSecondsLimits) {
+ const char RFC3339[] = "%Y-%m-%dT%H:%M:%S%Ez";
+ const time_zone utc = utc_time_zone();
+ const time_zone east = fixed_time_zone(hours(14));
+ const time_zone west = fixed_time_zone(-hours(14));
+ time_point<sys_seconds> tp;
+
+ // Approach the maximal time_point<sys_seconds> value from below.
+ tp = convert(civil_second(292277026596, 12, 4, 15, 30, 6), utc);
+ EXPECT_EQ("292277026596-12-04T15:30:06+00:00", format(RFC3339, tp, utc));
+ tp = convert(civil_second(292277026596, 12, 4, 15, 30, 7), utc);
+ EXPECT_EQ("292277026596-12-04T15:30:07+00:00", format(RFC3339, tp, utc));
+ EXPECT_EQ(time_point<sys_seconds>::max(), tp);
+ tp = convert(civil_second(292277026596, 12, 4, 15, 30, 8), utc);
+ EXPECT_EQ(time_point<sys_seconds>::max(), tp);
+ tp = convert(civil_second::max(), utc);
+ EXPECT_EQ(time_point<sys_seconds>::max(), tp);
+
+ // Checks that we can also get the maximal value for a far-east zone.
+ tp = convert(civil_second(292277026596, 12, 5, 5, 30, 7), east);
+ EXPECT_EQ("292277026596-12-05T05:30:07+14:00", format(RFC3339, tp, east));
+ EXPECT_EQ(time_point<sys_seconds>::max(), tp);
+ tp = convert(civil_second(292277026596, 12, 5, 5, 30, 8), east);
+ EXPECT_EQ(time_point<sys_seconds>::max(), tp);
+ tp = convert(civil_second::max(), east);
+ EXPECT_EQ(time_point<sys_seconds>::max(), tp);
+
+ // Checks that we can also get the maximal value for a far-west zone.
+ tp = convert(civil_second(292277026596, 12, 4, 1, 30, 7), west);
+ EXPECT_EQ("292277026596-12-04T01:30:07-14:00", format(RFC3339, tp, west));
+ EXPECT_EQ(time_point<sys_seconds>::max(), tp);
+ tp = convert(civil_second(292277026596, 12, 4, 7, 30, 8), west);
+ EXPECT_EQ(time_point<sys_seconds>::max(), tp);
+ tp = convert(civil_second::max(), west);
+ EXPECT_EQ(time_point<sys_seconds>::max(), tp);
+
+ // Approach the minimal time_point<sys_seconds> value from above.
+ tp = convert(civil_second(-292277022657, 1, 27, 8, 29, 53), utc);
+ EXPECT_EQ("-292277022657-01-27T08:29:53+00:00", format(RFC3339, tp, utc));
+ tp = convert(civil_second(-292277022657, 1, 27, 8, 29, 52), utc);
+ EXPECT_EQ("-292277022657-01-27T08:29:52+00:00", format(RFC3339, tp, utc));
+ EXPECT_EQ(time_point<sys_seconds>::min(), tp);
+ tp = convert(civil_second(-292277022657, 1, 27, 8, 29, 51), utc);
+ EXPECT_EQ(time_point<sys_seconds>::min(), tp);
+ tp = convert(civil_second::min(), utc);
+ EXPECT_EQ(time_point<sys_seconds>::min(), tp);
+
+ // Checks that we can also get the minimal value for a far-east zone.
+ tp = convert(civil_second(-292277022657, 1, 27, 22, 29, 52), east);
+ EXPECT_EQ("-292277022657-01-27T22:29:52+14:00", format(RFC3339, tp, east));
+ EXPECT_EQ(time_point<sys_seconds>::min(), tp);
+ tp = convert(civil_second(-292277022657, 1, 27, 22, 29, 51), east);
+ EXPECT_EQ(time_point<sys_seconds>::min(), tp);
+ tp = convert(civil_second::min(), east);
+ EXPECT_EQ(time_point<sys_seconds>::min(), tp);
+
+ // Checks that we can also get the minimal value for a far-west zone.
+ tp = convert(civil_second(-292277022657, 1, 26, 18, 29, 52), west);
+ EXPECT_EQ("-292277022657-01-26T18:29:52-14:00", format(RFC3339, tp, west));
+ EXPECT_EQ(time_point<sys_seconds>::min(), tp);
+ tp = convert(civil_second(-292277022657, 1, 26, 18, 29, 51), west);
+ EXPECT_EQ(time_point<sys_seconds>::min(), tp);
+ tp = convert(civil_second::min(), west);
+ EXPECT_EQ(time_point<sys_seconds>::min(), tp);
+}
+
+TEST(TimeZoneEdgeCase, AmericaNewYork) {
+ const time_zone tz = LoadZone("America/New_York");
+
+ // Spring 1:59:59 -> 3:00:00
+ auto tp = convert(civil_second(2013, 3, 10, 1, 59, 59), tz);
+ ExpectTime(tp, tz, 2013, 3, 10, 1, 59, 59, -5 * 3600, false, "EST");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2013, 3, 10, 3, 0, 0, -4 * 3600, true, "EDT");
+
+ // Fall 1:59:59 -> 1:00:00
+ tp = convert(civil_second(2013, 11, 3, 1, 59, 59), tz);
+ ExpectTime(tp, tz, 2013, 11, 3, 1, 59, 59, -4 * 3600, true, "EDT");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2013, 11, 3, 1, 0, 0, -5 * 3600, false, "EST");
+}
+
+TEST(TimeZoneEdgeCase, AmericaLosAngeles) {
+ const time_zone tz = LoadZone("America/Los_Angeles");
+
+ // Spring 1:59:59 -> 3:00:00
+ auto tp = convert(civil_second(2013, 3, 10, 1, 59, 59), tz);
+ ExpectTime(tp, tz, 2013, 3, 10, 1, 59, 59, -8 * 3600, false, "PST");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2013, 3, 10, 3, 0, 0, -7 * 3600, true, "PDT");
+
+ // Fall 1:59:59 -> 1:00:00
+ tp = convert(civil_second(2013, 11, 3, 1, 59, 59), tz);
+ ExpectTime(tp, tz, 2013, 11, 3, 1, 59, 59, -7 * 3600, true, "PDT");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2013, 11, 3, 1, 0, 0, -8 * 3600, false, "PST");
+}
+
+TEST(TimeZoneEdgeCase, ArizonaNoTransition) {
+ const time_zone tz = LoadZone("America/Phoenix");
+
+ // No transition in Spring.
+ auto tp = convert(civil_second(2013, 3, 10, 1, 59, 59), tz);
+ ExpectTime(tp, tz, 2013, 3, 10, 1, 59, 59, -7 * 3600, false, "MST");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2013, 3, 10, 2, 0, 0, -7 * 3600, false, "MST");
+
+ // No transition in Fall.
+ tp = convert(civil_second(2013, 11, 3, 1, 59, 59), tz);
+ ExpectTime(tp, tz, 2013, 11, 3, 1, 59, 59, -7 * 3600, false, "MST");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2013, 11, 3, 2, 0, 0, -7 * 3600, false, "MST");
+}
+
+TEST(TimeZoneEdgeCase, AsiaKathmandu) {
+ const time_zone tz = LoadZone("Asia/Kathmandu");
+
+ // A non-DST offset change from +0530 to +0545
+ //
+ // 504901799 == Tue, 31 Dec 1985 23:59:59 +0530 (+0530)
+ // 504901800 == Wed, 1 Jan 1986 00:15:00 +0545 (+0545)
+ auto tp = convert(civil_second(1985, 12, 31, 23, 59, 59), tz);
+ ExpectTime(tp, tz, 1985, 12, 31, 23, 59, 59, 5.5 * 3600, false, "+0530");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 1986, 1, 1, 0, 15, 0, 5.75 * 3600, false, "+0545");
+}
+
+TEST(TimeZoneEdgeCase, PacificChatham) {
+ const time_zone tz = LoadZone("Pacific/Chatham");
+
+ // One-hour DST offset changes, but at atypical values
+ //
+ // 1365256799 == Sun, 7 Apr 2013 03:44:59 +1345 (+1345)
+ // 1365256800 == Sun, 7 Apr 2013 02:45:00 +1245 (+1245)
+ auto tp = convert(civil_second(2013, 4, 7, 3, 44, 59), tz);
+ ExpectTime(tp, tz, 2013, 4, 7, 3, 44, 59, 13.75 * 3600, true, "+1345");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2013, 4, 7, 2, 45, 0, 12.75 * 3600, false, "+1245");
+
+ // 1380376799 == Sun, 29 Sep 2013 02:44:59 +1245 (+1245)
+ // 1380376800 == Sun, 29 Sep 2013 03:45:00 +1345 (+1345)
+ tp = convert(civil_second(2013, 9, 29, 2, 44, 59), tz);
+ ExpectTime(tp, tz, 2013, 9, 29, 2, 44, 59, 12.75 * 3600, false, "+1245");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2013, 9, 29, 3, 45, 0, 13.75 * 3600, true, "+1345");
+}
+
+TEST(TimeZoneEdgeCase, AustraliaLordHowe) {
+ const time_zone tz = LoadZone("Australia/Lord_Howe");
+
+ // Half-hour DST offset changes
+ //
+ // 1365260399 == Sun, 7 Apr 2013 01:59:59 +1100 (+11)
+ // 1365260400 == Sun, 7 Apr 2013 01:30:00 +1030 (+1030)
+ auto tp = convert(civil_second(2013, 4, 7, 1, 59, 59), tz);
+ ExpectTime(tp, tz, 2013, 4, 7, 1, 59, 59, 11 * 3600, true, "+11");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2013, 4, 7, 1, 30, 0, 10.5 * 3600, false, "+1030");
+
+ // 1380986999 == Sun, 6 Oct 2013 01:59:59 +1030 (+1030)
+ // 1380987000 == Sun, 6 Oct 2013 02:30:00 +1100 (+11)
+ tp = convert(civil_second(2013, 10, 6, 1, 59, 59), tz);
+ ExpectTime(tp, tz, 2013, 10, 6, 1, 59, 59, 10.5 * 3600, false, "+1030");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2013, 10, 6, 2, 30, 0, 11 * 3600, true, "+11");
+}
+
+TEST(TimeZoneEdgeCase, PacificApia) {
+ const time_zone tz = LoadZone("Pacific/Apia");
+
+ // At the end of December 2011, Samoa jumped forward by one day,
+ // skipping 30 December from the local calendar, when the nation
+ // moved to the west of the International Date Line.
+ //
+ // A one-day, non-DST offset change
+ //
+ // 1325239199 == Thu, 29 Dec 2011 23:59:59 -1000 (-10)
+ // 1325239200 == Sat, 31 Dec 2011 00:00:00 +1400 (+14)
+ auto tp = convert(civil_second(2011, 12, 29, 23, 59, 59), tz);
+ ExpectTime(tp, tz, 2011, 12, 29, 23, 59, 59, -10 * 3600, true, "-10");
+ EXPECT_EQ(363, get_yearday(civil_day(convert(tp, tz))));
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2011, 12, 31, 0, 0, 0, 14 * 3600, true, "+14");
+ EXPECT_EQ(365, get_yearday(civil_day(convert(tp, tz))));
+}
+
+TEST(TimeZoneEdgeCase, AfricaCairo) {
+ const time_zone tz = LoadZone("Africa/Cairo");
+
+ // An interesting case of midnight not existing.
+ //
+ // 1400191199 == Thu, 15 May 2014 23:59:59 +0200 (EET)
+ // 1400191200 == Fri, 16 May 2014 01:00:00 +0300 (EEST)
+ auto tp = convert(civil_second(2014, 5, 15, 23, 59, 59), tz);
+ ExpectTime(tp, tz, 2014, 5, 15, 23, 59, 59, 2 * 3600, false, "EET");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2014, 5, 16, 1, 0, 0, 3 * 3600, true, "EEST");
+}
+
+TEST(TimeZoneEdgeCase, AfricaMonrovia) {
+ const time_zone tz = LoadZone("Africa/Monrovia");
+
+ // Strange offset change -00:44:30 -> +00:00:00 (non-DST)
+ //
+ // 63593069 == Thu, 6 Jan 1972 23:59:59 -0044 (MMT)
+ // 63593070 == Fri, 7 Jan 1972 00:44:30 +0000 (GMT)
+ auto tp = convert(civil_second(1972, 1, 6, 23, 59, 59), tz);
+ ExpectTime(tp, tz, 1972, 1, 6, 23, 59, 59, -44.5 * 60, false, "MMT");
+ tp += seconds(1);
+#ifndef TZDATA_2017B_IS_UBIQUITOUS
+ // The 2017b tzdata release moved the shift from -004430 to +00
+ // from 1972-05-01 to 1972-01-07, so we temporarily accept both
+ // outcomes until 2017b is ubiquitous.
+ if (tz.lookup(tp).offset == -44.5 * 60) {
+ tp = convert(civil_second(1972, 4, 30, 23, 59, 59), tz);
+ ExpectTime(tp, tz, 1972, 4, 30, 23, 59, 59, -44.5 * 60, false, "LRT");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 1972, 5, 1, 0, 44, 30, 0 * 60, false, "GMT");
+ return;
+ }
+#endif
+ ExpectTime(tp, tz, 1972, 1, 7, 0, 44, 30, 0 * 60, false, "GMT");
+}
+
+TEST(TimeZoneEdgeCase, AmericaJamaica) {
+ // Jamaica discontinued DST transitions in 1983, and is now at a
+ // constant -0500. This makes it an interesting edge-case target.
+ // Note that the 32-bit times used in a (tzh_version == 0) zoneinfo
+ // file cannot represent the abbreviation-only transition of 1890,
+ // so we ignore the abbreviation by expecting what we received.
+ const time_zone tz = LoadZone("America/Jamaica");
+
+ // Before the first transition.
+ auto tp = convert(civil_second(1889, 12, 31, 0, 0, 0), tz);
+#if AMERICA_JAMAICA_PRE_1913_OFFSET_FIX
+ // Commit 907241e: Fix off-by-1 error for Jamaica and T&C before 1913.
+ // Until that commit has made its way into a full release we avoid the
+ // expectations on the -18430 offset below. TODO: Uncomment these.
+ ExpectTime(tp, tz, 1889, 12, 31, 0, 0, 0, -18430, false,
+ tz.lookup(tp).abbr);
+
+ // Over the first (abbreviation-change only) transition.
+ // -2524503170 == Tue, 31 Dec 1889 23:59:59 -0507 (LMT)
+ // -2524503169 == Wed, 1 Jan 1890 00:00:00 -0507 (KMT)
+ tp = convert(civil_second(1889, 12, 31, 23, 59, 59), tz);
+ ExpectTime(tp, tz, 1889, 12, 31, 23, 59, 59, -18430, false,
+ tz.lookup(tp).abbr);
+ tp += seconds(1);
+ ExpectTime(tp, tz, 1890, 1, 1, 0, 0, 0, -18430, false, "KMT");
+#endif
+
+ // Over the last (DST) transition.
+ // 436341599 == Sun, 30 Oct 1983 01:59:59 -0400 (EDT)
+ // 436341600 == Sun, 30 Oct 1983 01:00:00 -0500 (EST)
+ tp = convert(civil_second(1983, 10, 30, 1, 59, 59), tz);
+ ExpectTime(tp, tz, 1983, 10, 30, 1, 59, 59, -4 * 3600, true, "EDT");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 1983, 10, 30, 1, 0, 0, -5 * 3600, false, "EST");
+
+ // After the last transition.
+ tp = convert(civil_second(1983, 12, 31, 23, 59, 59), tz);
+ ExpectTime(tp, tz, 1983, 12, 31, 23, 59, 59, -5 * 3600, false, "EST");
+}
+
+TEST(TimeZoneEdgeCase, WET) {
+ // Cover some non-existent times within forward transitions.
+ const time_zone tz = LoadZone("WET");
+
+ // Before the first transition.
+ auto tp = convert(civil_second(1977, 1, 1, 0, 0, 0), tz);
+ ExpectTime(tp, tz, 1977, 1, 1, 0, 0, 0, 0, false, "WET");
+
+ // Over the first transition.
+ // 228877199 == Sun, 3 Apr 1977 00:59:59 +0000 (WET)
+ // 228877200 == Sun, 3 Apr 1977 02:00:00 +0100 (WEST)
+ tp = convert(civil_second(1977, 4, 3, 0, 59, 59), tz);
+ ExpectTime(tp, tz, 1977, 4, 3, 0, 59, 59, 0, false, "WET");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 1977, 4, 3, 2, 0, 0, 1 * 3600, true, "WEST");
+
+ // A non-existent time within the first transition.
+ time_zone::civil_lookup cl1 = tz.lookup(civil_second(1977, 4, 3, 1, 15, 0));
+ EXPECT_EQ(time_zone::civil_lookup::SKIPPED, cl1.kind);
+ ExpectTime(cl1.pre, tz, 1977, 4, 3, 2, 15, 0, 1 * 3600, true, "WEST");
+ ExpectTime(cl1.trans, tz, 1977, 4, 3, 2, 0, 0, 1 * 3600, true, "WEST");
+ ExpectTime(cl1.post, tz, 1977, 4, 3, 0, 15, 0, 0 * 3600, false, "WET");
+
+ // A non-existent time within the second forward transition.
+ time_zone::civil_lookup cl2 = tz.lookup(civil_second(1978, 4, 2, 1, 15, 0));
+ EXPECT_EQ(time_zone::civil_lookup::SKIPPED, cl2.kind);
+ ExpectTime(cl2.pre, tz, 1978, 4, 2, 2, 15, 0, 1 * 3600, true, "WEST");
+ ExpectTime(cl2.trans, tz, 1978, 4, 2, 2, 0, 0, 1 * 3600, true, "WEST");
+ ExpectTime(cl2.post, tz, 1978, 4, 2, 0, 15, 0, 0 * 3600, false, "WET");
+}
+
+TEST(TimeZoneEdgeCase, FixedOffsets) {
+ const time_zone gmtm5 = LoadZone("Etc/GMT+5"); // -0500
+ auto tp = convert(civil_second(1970, 1, 1, 0, 0, 0), gmtm5);
+ ExpectTime(tp, gmtm5, 1970, 1, 1, 0, 0, 0, -5 * 3600, false, "-05");
+ EXPECT_EQ(system_clock::from_time_t(5 * 3600), tp);
+
+ const time_zone gmtp5 = LoadZone("Etc/GMT-5"); // +0500
+ tp = convert(civil_second(1970, 1, 1, 0, 0, 0), gmtp5);
+ ExpectTime(tp, gmtp5, 1970, 1, 1, 0, 0, 0, 5 * 3600, false, "+05");
+ EXPECT_EQ(system_clock::from_time_t(-5 * 3600), tp);
+}
+
+TEST(TimeZoneEdgeCase, NegativeYear) {
+ // Tests transition from year 0 (aka 1BCE) to year -1.
+ const time_zone tz = utc_time_zone();
+ auto tp = convert(civil_second(0, 1, 1, 0, 0, 0), tz);
+ ExpectTime(tp, tz, 0, 1, 1, 0, 0, 0, 0 * 3600, false, "UTC");
+ EXPECT_EQ(weekday::saturday, get_weekday(civil_day(convert(tp, tz))));
+ tp -= seconds(1);
+ ExpectTime(tp, tz, -1, 12, 31, 23, 59, 59, 0 * 3600, false, "UTC");
+ EXPECT_EQ(weekday::friday, get_weekday(civil_day(convert(tp, tz))));
+}
+
+TEST(TimeZoneEdgeCase, UTC32bitLimit) {
+ const time_zone tz = utc_time_zone();
+
+ // Limits of signed 32-bit time_t
+ //
+ // 2147483647 == Tue, 19 Jan 2038 03:14:07 +0000 (UTC)
+ // 2147483648 == Tue, 19 Jan 2038 03:14:08 +0000 (UTC)
+ auto tp = convert(civil_second(2038, 1, 19, 3, 14, 7), tz);
+ ExpectTime(tp, tz, 2038, 1, 19, 3, 14, 7, 0 * 3600, false, "UTC");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 2038, 1, 19, 3, 14, 8, 0 * 3600, false, "UTC");
+}
+
+TEST(TimeZoneEdgeCase, UTC5DigitYear) {
+ const time_zone tz = utc_time_zone();
+
+ // Rollover to 5-digit year
+ //
+ // 253402300799 == Fri, 31 Dec 9999 23:59:59 +0000 (UTC)
+ // 253402300800 == Sat, 1 Jan 1000 00:00:00 +0000 (UTC)
+ auto tp = convert(civil_second(9999, 12, 31, 23, 59, 59), tz);
+ ExpectTime(tp, tz, 9999, 12, 31, 23, 59, 59, 0 * 3600, false, "UTC");
+ tp += seconds(1);
+ ExpectTime(tp, tz, 10000, 1, 1, 0, 0, 0, 0 * 3600, false, "UTC");
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_posix.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_posix.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_posix.cc
new file mode 100644
index 0000000..75ad8bc
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_posix.cc
@@ -0,0 +1,155 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "time_zone_posix.h"
+
+#include <cstddef>
+#include <cstring>
+#include <limits>
+#include <string>
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+namespace {
+
+const char kDigits[] = "0123456789";
+
+const char* ParseInt(const char* p, int min, int max, int* vp) {
+ int value = 0;
+ const char* op = p;
+ const int kMaxInt = std::numeric_limits<int>::max();
+ for (; const char* dp = strchr(kDigits, *p); ++p) {
+ int d = static_cast<int>(dp - kDigits);
+ if (d >= 10) break; // '\0'
+ if (value > kMaxInt / 10) return nullptr;
+ value *= 10;
+ if (value > kMaxInt - d) return nullptr;
+ value += d;
+ }
+ if (p == op || value < min || value > max) return nullptr;
+ *vp = value;
+ return p;
+}
+
+// abbr = <.*?> | [^-+,\d]{3,}
+const char* ParseAbbr(const char* p, std::string* abbr) {
+ const char* op = p;
+ if (*p == '<') { // special zoneinfo <...> form
+ while (*++p != '>') {
+ if (*p == '\0') return nullptr;
+ }
+ abbr->assign(op + 1, static_cast<std::size_t>(p - op) - 1);
+ return ++p;
+ }
+ while (*p != '\0') {
+ if (strchr("-+,", *p)) break;
+ if (strchr(kDigits, *p)) break;
+ ++p;
+ }
+ if (p - op < 3) return nullptr;
+ abbr->assign(op, static_cast<std::size_t>(p - op));
+ return p;
+}
+
+// offset = [+|-]hh[:mm[:ss]] (aggregated into single seconds value)
+const char* ParseOffset(const char* p, int min_hour, int max_hour, int sign,
+ std::int_fast32_t* offset) {
+ if (p == nullptr) return nullptr;
+ if (*p == '+' || *p == '-') {
+ if (*p++ == '-') sign = -sign;
+ }
+ int hours = 0;
+ int minutes = 0;
+ int seconds = 0;
+
+ p = ParseInt(p, min_hour, max_hour, &hours);
+ if (p == nullptr) return nullptr;
+ if (*p == ':') {
+ p = ParseInt(p + 1, 0, 59, &minutes);
+ if (p == nullptr) return nullptr;
+ if (*p == ':') {
+ p = ParseInt(p + 1, 0, 59, &seconds);
+ if (p == nullptr) return nullptr;
+ }
+ }
+ *offset = sign * ((((hours * 60) + minutes) * 60) + seconds);
+ return p;
+}
+
+// datetime = ( Jn | n | Mm.w.d ) [ / offset ]
+const char* ParseDateTime(const char* p, PosixTransition* res) {
+ if (p != nullptr && *p == ',') {
+ if (*++p == 'M') {
+ int month = 0;
+ if ((p = ParseInt(p + 1, 1, 12, &month)) != nullptr && *p == '.') {
+ int week = 0;
+ if ((p = ParseInt(p + 1, 1, 5, &week)) != nullptr && *p == '.') {
+ int weekday = 0;
+ if ((p = ParseInt(p + 1, 0, 6, &weekday)) != nullptr) {
+ res->date.fmt = PosixTransition::M;
+ res->date.m.month = static_cast<int_fast8_t>(month);
+ res->date.m.week = static_cast<int_fast8_t>(week);
+ res->date.m.weekday = static_cast<int_fast8_t>(weekday);
+ }
+ }
+ }
+ } else if (*p == 'J') {
+ int day = 0;
+ if ((p = ParseInt(p + 1, 1, 365, &day)) != nullptr) {
+ res->date.fmt = PosixTransition::J;
+ res->date.j.day = static_cast<int_fast16_t>(day);
+ }
+ } else {
+ int day = 0;
+ if ((p = ParseInt(p, 0, 365, &day)) != nullptr) {
+ res->date.fmt = PosixTransition::N;
+ res->date.j.day = static_cast<int_fast16_t>(day);
+ }
+ }
+ }
+ if (p != nullptr) {
+ res->time.offset = 2 * 60 * 60; // default offset is 02:00:00
+ if (*p == '/') p = ParseOffset(p + 1, -167, 167, 1, &res->time.offset);
+ }
+ return p;
+}
+
+} // namespace
+
+// spec = std offset [ dst [ offset ] , datetime , datetime ]
+bool ParsePosixSpec(const std::string& spec, PosixTimeZone* res) {
+ const char* p = spec.c_str();
+ if (*p == ':') return false;
+
+ p = ParseAbbr(p, &res->std_abbr);
+ p = ParseOffset(p, 0, 24, -1, &res->std_offset);
+ if (p == nullptr) return false;
+ if (*p == '\0') return true;
+
+ p = ParseAbbr(p, &res->dst_abbr);
+ if (p == nullptr) return false;
+ res->dst_offset = res->std_offset + (60 * 60); // default
+ if (*p != ',') p = ParseOffset(p, 0, 24, -1, &res->dst_offset);
+
+ p = ParseDateTime(p, &res->dst_start);
+ p = ParseDateTime(p, &res->dst_end);
+
+ return p != nullptr && *p == '\0';
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_posix.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_posix.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_posix.h
new file mode 100644
index 0000000..6619f27
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_posix.h
@@ -0,0 +1,118 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Parsing of a POSIX zone spec as described in the TZ part of section 8.3 in
+// http://pubs.opengroup.org/onlinepubs/009695399/basedefs/xbd_chap08.html.
+//
+// The current POSIX spec for America/Los_Angeles is "PST8PDT,M3.2.0,M11.1.0",
+// which would be broken down as ...
+//
+// PosixTimeZone {
+// std_abbr = "PST"
+// std_offset = -28800
+// dst_abbr = "PDT"
+// dst_offset = -25200
+// dst_start = PosixTransition {
+// date {
+// m {
+// month = 3
+// week = 2
+// weekday = 0
+// }
+// }
+// time {
+// offset = 7200
+// }
+// }
+// dst_end = PosixTransition {
+// date {
+// m {
+// month = 11
+// week = 1
+// weekday = 0
+// }
+// }
+// time {
+// offset = 7200
+// }
+// }
+// }
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
+
+#include <cstdint>
+#include <string>
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// The date/time of the transition. The date is specified as either:
+// (J) the Nth day of the year (1 <= N <= 365), excluding leap days, or
+// (N) the Nth day of the year (0 <= N <= 365), including leap days, or
+// (M) the Nth weekday of a month (e.g., the 2nd Sunday in March).
+// The time, specified as a day offset, identifies the particular moment
+// of the transition, and may be negative or >= 24h, and in which case
+// it would take us to another day, and perhaps week, or even month.
+struct PosixTransition {
+ enum DateFormat { J, N, M };
+ struct {
+ DateFormat fmt;
+ union {
+ struct {
+ std::int_fast16_t day; // day of non-leap year [1:365]
+ } j;
+ struct {
+ std::int_fast16_t day; // day of year [0:365]
+ } n;
+ struct {
+ std::int_fast8_t month; // month of year [1:12]
+ std::int_fast8_t week; // week of month [1:5] (5==last)
+ std::int_fast8_t weekday; // 0==Sun, ..., 6=Sat
+ } m;
+ };
+ } date;
+ struct {
+ std::int_fast32_t offset; // seconds before/after 00:00:00
+ } time;
+};
+
+// The entirety of a POSIX-std::string specified time-zone rule. The standard
+// abbreviation and offset are always given. If the time zone includes
+// daylight saving, then the daylight abbrevation is non-empty and the
+// remaining fields are also valid. Note that the start/end transitions
+// are not ordered---in the southern hemisphere the transition to end
+// daylight time occurs first in any particular year.
+struct PosixTimeZone {
+ std::string std_abbr;
+ std::int_fast32_t std_offset;
+
+ std::string dst_abbr;
+ std::int_fast32_t dst_offset;
+ PosixTransition dst_start;
+ PosixTransition dst_end;
+};
+
+// Breaks down a POSIX time-zone specification into its constituent pieces,
+// filling in any missing values (DST offset, or start/end transition times)
+// with the standard-defined defaults. Returns false if the specification
+// could not be parsed (although some fields of *res may have been altered).
+bool ParsePosixSpec(const std::string& spec, PosixTimeZone* res);
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+#endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_POSIX_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/tzfile.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/tzfile.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/tzfile.h
new file mode 100644
index 0000000..90cfc0c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/tzfile.h
@@ -0,0 +1,117 @@
+#ifndef TZFILE_H
+
+#define TZFILE_H
+
+/*
+** This file is in the public domain, so clarified as of
+** 1996-06-05 by Arthur David Olson.
+*/
+
+/*
+** This header is for use ONLY with the time conversion code.
+** There is no guarantee that it will remain unchanged,
+** or that it will remain at all.
+** Do NOT copy it to any system include directory.
+** Thank you!
+*/
+
+/*
+** Information about time zone files.
+*/
+
+#ifndef TZDIR
+#define TZDIR "/usr/share/zoneinfo" /* Time zone object file directory */
+#endif /* !defined TZDIR */
+
+#ifndef TZDEFAULT
+#define TZDEFAULT "/etc/localtime"
+#endif /* !defined TZDEFAULT */
+
+#ifndef TZDEFRULES
+#define TZDEFRULES "posixrules"
+#endif /* !defined TZDEFRULES */
+
+/*
+** Each file begins with. . .
+*/
+
+#define TZ_MAGIC "TZif"
+
+struct tzhead {
+ char tzh_magic[4]; /* TZ_MAGIC */
+ char tzh_version[1]; /* '\0' or '2' or '3' as of 2013 */
+ char tzh_reserved[15]; /* reserved; must be zero */
+ char tzh_ttisgmtcnt[4]; /* coded number of trans. time flags */
+ char tzh_ttisstdcnt[4]; /* coded number of trans. time flags */
+ char tzh_leapcnt[4]; /* coded number of leap seconds */
+ char tzh_timecnt[4]; /* coded number of transition times */
+ char tzh_typecnt[4]; /* coded number of local time types */
+ char tzh_charcnt[4]; /* coded number of abbr. chars */
+};
+
+/*
+** . . .followed by. . .
+**
+** tzh_timecnt (char [4])s coded transition times a la time(2)
+** tzh_timecnt (unsigned char)s types of local time starting at above
+** tzh_typecnt repetitions of
+** one (char [4]) coded UT offset in seconds
+** one (unsigned char) used to set tm_isdst
+** one (unsigned char) that's an abbreviation list index
+** tzh_charcnt (char)s '\0'-terminated zone abbreviations
+** tzh_leapcnt repetitions of
+** one (char [4]) coded leap second transition times
+** one (char [4]) total correction after above
+** tzh_ttisstdcnt (char)s indexed by type; if 1, transition
+** time is standard time, if 0,
+** transition time is wall clock time
+** if absent, transition times are
+** assumed to be wall clock time
+** tzh_ttisgmtcnt (char)s indexed by type; if 1, transition
+** time is UT, if 0,
+** transition time is local time
+** if absent, transition times are
+** assumed to be local time
+*/
+
+/*
+** If tzh_version is '2' or greater, the above is followed by a second instance
+** of tzhead and a second instance of the data in which each coded transition
+** time uses 8 rather than 4 chars,
+** then a POSIX-TZ-environment-variable-style std::string for use in handling
+** instants after the last transition time stored in the file
+** (with nothing between the newlines if there is no POSIX representation for
+** such instants).
+**
+** If tz_version is '3' or greater, the above is extended as follows.
+** First, the POSIX TZ std::string's hour offset may range from -167
+** through 167 as compared to the POSIX-required 0 through 24.
+** Second, its DST start time may be January 1 at 00:00 and its stop
+** time December 31 at 24:00 plus the difference between DST and
+** standard time, indicating DST all year.
+*/
+
+/*
+** In the current implementation, "tzset()" refuses to deal with files that
+** exceed any of the limits below.
+*/
+
+#ifndef TZ_MAX_TIMES
+#define TZ_MAX_TIMES 2000
+#endif /* !defined TZ_MAX_TIMES */
+
+#ifndef TZ_MAX_TYPES
+/* This must be at least 17 for Europe/Samara and Europe/Vilnius. */
+#define TZ_MAX_TYPES 256 /* Limited by what (unsigned char)'s can hold */
+#endif /* !defined TZ_MAX_TYPES */
+
+#ifndef TZ_MAX_CHARS
+#define TZ_MAX_CHARS 50 /* Maximum number of abbreviation characters */
+ /* (limited by what unsigned chars can hold) */
+#endif /* !defined TZ_MAX_CHARS */
+
+#ifndef TZ_MAX_LEAPS
+#define TZ_MAX_LEAPS 50 /* Maximum number of leap second corrections */
+#endif /* !defined TZ_MAX_LEAPS */
+
+#endif /* !defined TZFILE_H */
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/zone_info_source.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/zone_info_source.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/zone_info_source.cc
new file mode 100644
index 0000000..b77c0a5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/zone_info_source.cc
@@ -0,0 +1,70 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/internal/cctz/include/cctz/zone_info_source.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// Defined out-of-line to avoid emitting a weak vtable in all TUs.
+ZoneInfoSource::~ZoneInfoSource() {}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+namespace absl {
+namespace time_internal {
+namespace cctz_extension {
+
+namespace {
+
+// A default for cctz_extension::zone_info_source_factory, which simply
+// defers to the fallback factory.
+std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource> DefaultFactory(
+ const std::string& name,
+ const std::function<std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource>(
+ const std::string& name)>& fallback_factory) {
+ return fallback_factory(name);
+}
+
+} // namespace
+
+// A "weak" definition for cctz_extension::zone_info_source_factory.
+// The user may override this with their own "strong" definition (see
+// zone_info_source.h).
+#if defined(_MSC_VER)
+extern ZoneInfoSourceFactory zone_info_source_factory;
+extern ZoneInfoSourceFactory default_factory;
+ZoneInfoSourceFactory default_factory = DefaultFactory;
+#if defined(_M_IX86)
+#pragma comment( \
+ linker, \
+ "/alternatename:?zone_info_source_factory@cctz_extension@time_internal@absl@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@absl@@U?$default_delete@VZoneInfoSource@cctz@time_internal@absl@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@ABV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@absl@@U?$default_delete@VZoneInfoSource@cctz@time_internal@absl@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@5@@ZA=?default_factory@cctz_extension@time_internal@absl@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@absl@@U?$default_delete@VZoneInfoSource@cctz@time_internal@absl@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@ABV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@absl@@U?$default_delete@VZoneInfoSource@cctz@time_internal@absl@@@std@@@std@@ABV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@5@@ZA")
+#elif defined(_M_IA_64) || defined(_M_AMD64)
+#pragma comment( \
+ linker, \
+ "/alternatename:?zone_info_source_factory@cctz_extension@time_internal@absl@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@absl@@U?$default_delete@VZoneInfoSource@cctz@time_internal@absl@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@AEBV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@absl@@U?$default_delete@VZoneInfoSource@cctz@time_internal@absl@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@5@@ZEA=?default_factory@cctz_extension@time_internal@absl@@3P6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@absl@@U?$default_delete@VZoneInfoSource@cctz@time_internal@absl@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@5@AEBV?$function@$$A6A?AV?$unique_ptr@VZoneInfoSource@cctz@time_internal@absl@@U?$default_delete@VZoneInfoSource@cctz@time_internal@absl@@@std@@@std@@AEBV?$basic_string@DU?$char_traits@D@std@@V?$allocator@D@2@@2@@Z@5@@ZEA")
+#else
+#error Unsupported MSVC platform
+#endif
+#else
+ZoneInfoSourceFactory zone_info_source_factory
+ __attribute__((weak)) = DefaultFactory;
+#endif // _MSC_VER
+
+} // namespace cctz_extension
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/README.zoneinfo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/README.zoneinfo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/README.zoneinfo
new file mode 100644
index 0000000..95fb4a9
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/README.zoneinfo
@@ -0,0 +1,37 @@
+testdata/zoneinfo contains time-zone data files that may be used with CCTZ.
+Install them in a location referenced by the ${TZDIR} environment variable.
+Symbolic and hard links have been eliminated for portability.
+
+On Linux systems the distribution's versions of these files can probably
+already be found in the default ${TZDIR} location, /usr/share/zoneinfo.
+
+New versions can be generated using the following shell script.
+
+ #!/bin/sh -
+ set -e
+ DESTDIR=$(mktemp -d)
+ trap "rm -fr ${DESTDIR}" 0 2 15
+ (
+ cd ${DESTDIR}
+ git clone https://github.com/eggert/tz.git
+ make --directory=tz \
+ install DESTDIR=${DESTDIR} \
+ DATAFORM=vanguard \
+ TZDIR=/zoneinfo \
+ REDO=posix_only \
+ LOCALTIME=Factory \
+ TZDATA_TEXT= \
+ ZONETABLES=zone1970.tab
+ tar --create --dereference --hard-dereference --file tzfile.tar \
+ --directory=tz tzfile.h
+ tar --create --dereference --hard-dereference --file zoneinfo.tar \
+ --exclude=zoneinfo/posixrules zoneinfo \
+ --directory=tz version
+ )
+ tar --extract --directory src --file ${DESTDIR}/tzfile.tar
+ tar --extract --directory testdata --file ${DESTDIR}/zoneinfo.tar
+ exit 0
+
+To run the CCTZ tests using the testdata/zoneinfo files, execute:
+
+ bazel test --test_env=TZDIR=${PWD}/testdata/zoneinfo ...
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/version
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/version b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/version
new file mode 100644
index 0000000..05c3ec2
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/version
@@ -0,0 +1 @@
+2018d-2-g8d1dac0
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Abidjan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Abidjan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Abidjan
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Abidjan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Accra
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Accra b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Accra
new file mode 100644
index 0000000..8726e80
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Accra differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Addis_Ababa
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Addis_Ababa b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Addis_Ababa
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Addis_Ababa differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Algiers
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Algiers b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Algiers
new file mode 100644
index 0000000..2a25f3a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Algiers differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Asmara
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Asmara b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Asmara
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Asmara differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Asmera
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Asmera b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Asmera
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Asmera differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bamako
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bamako b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bamako
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bamako differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bangui
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bangui b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bangui
new file mode 100644
index 0000000..b1c97cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bangui differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Banjul
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Banjul b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Banjul
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Banjul differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bissau
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bissau b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bissau
new file mode 100644
index 0000000..8e32be3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bissau differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Blantyre
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Blantyre b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Blantyre
new file mode 100644
index 0000000..5b871db
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Blantyre differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Brazzaville
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Brazzaville b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Brazzaville
new file mode 100644
index 0000000..b1c97cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Brazzaville differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bujumbura
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bujumbura b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bujumbura
new file mode 100644
index 0000000..5b871db
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Bujumbura differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Cairo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Cairo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Cairo
new file mode 100644
index 0000000..ba09750
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Cairo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Casablanca
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Casablanca b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Casablanca
new file mode 100644
index 0000000..65de344
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Casablanca differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ceuta
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ceuta b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ceuta
new file mode 100644
index 0000000..aaa657f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ceuta differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Conakry
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Conakry b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Conakry
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Conakry differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Dakar
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Dakar b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Dakar
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Dakar differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Dar_es_Salaam
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Dar_es_Salaam b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Dar_es_Salaam
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Dar_es_Salaam differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Djibouti
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Djibouti b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Djibouti
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Djibouti differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Douala
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Douala b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Douala
new file mode 100644
index 0000000..b1c97cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Douala differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/El_Aaiun
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/El_Aaiun b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/El_Aaiun
new file mode 100644
index 0000000..f5f8ffb
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/El_Aaiun differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Freetown
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Freetown b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Freetown
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Freetown differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Gaborone
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Gaborone b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Gaborone
new file mode 100644
index 0000000..5b871db
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Gaborone differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Harare
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Harare b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Harare
new file mode 100644
index 0000000..5b871db
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Harare differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Johannesburg
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Johannesburg b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Johannesburg
new file mode 100644
index 0000000..ddf3652
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Johannesburg differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Juba
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Juba b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Juba
new file mode 100644
index 0000000..9fa7119
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Juba differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kampala
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kampala b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kampala
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kampala differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Khartoum
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Khartoum b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Khartoum
new file mode 100644
index 0000000..f2c9e30
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Khartoum differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kigali
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kigali b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kigali
new file mode 100644
index 0000000..5b871db
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kigali differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kinshasa
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kinshasa b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kinshasa
new file mode 100644
index 0000000..b1c97cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Kinshasa differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lagos
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lagos b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lagos
new file mode 100644
index 0000000..b1c97cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lagos differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Libreville
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Libreville b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Libreville
new file mode 100644
index 0000000..b1c97cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Libreville differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lome
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lome b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lome
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lome differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Luanda
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Luanda b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Luanda
new file mode 100644
index 0000000..b1c97cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Luanda differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lubumbashi
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lubumbashi b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lubumbashi
new file mode 100644
index 0000000..5b871db
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lubumbashi differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lusaka
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lusaka b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lusaka
new file mode 100644
index 0000000..5b871db
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Lusaka differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Malabo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Malabo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Malabo
new file mode 100644
index 0000000..b1c97cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Malabo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Maputo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Maputo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Maputo
new file mode 100644
index 0000000..5b871db
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Maputo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Maseru
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Maseru b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Maseru
new file mode 100644
index 0000000..ddf3652
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Maseru differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Mbabane
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Mbabane b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Mbabane
new file mode 100644
index 0000000..ddf3652
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Mbabane differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Mogadishu
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Mogadishu b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Mogadishu
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Mogadishu differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Monrovia
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Monrovia b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Monrovia
new file mode 100644
index 0000000..b434c67
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Monrovia differ
[10/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Sofia
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Sofia b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Sofia
new file mode 100644
index 0000000..763e074
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Sofia differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Stockholm
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Stockholm b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Stockholm
new file mode 100644
index 0000000..43c7f2e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Stockholm differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tallinn
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tallinn b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tallinn
new file mode 100644
index 0000000..18f903f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tallinn differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tirane
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tirane b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tirane
new file mode 100644
index 0000000..52c16a4
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tirane differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tiraspol
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tiraspol b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tiraspol
new file mode 100644
index 0000000..2109b52
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Tiraspol differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Ulyanovsk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Ulyanovsk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Ulyanovsk
new file mode 100644
index 0000000..c280f43
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Ulyanovsk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Uzhgorod
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Uzhgorod b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Uzhgorod
new file mode 100644
index 0000000..8ddba90
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Uzhgorod differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vaduz
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vaduz b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vaduz
new file mode 100644
index 0000000..9c2b600
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vaduz differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vatican
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vatican b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vatican
new file mode 100644
index 0000000..bdd3449
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vatican differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vienna
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vienna b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vienna
new file mode 100644
index 0000000..9c0fac5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vienna differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vilnius
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vilnius b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vilnius
new file mode 100644
index 0000000..da380af
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Vilnius differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Volgograd
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Volgograd b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Volgograd
new file mode 100644
index 0000000..f4cb64f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Volgograd differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Warsaw
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Warsaw b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Warsaw
new file mode 100644
index 0000000..5cbba41
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Warsaw differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zagreb
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zagreb b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zagreb
new file mode 100644
index 0000000..79c25d7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zagreb differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zaporozhye
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zaporozhye b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zaporozhye
new file mode 100644
index 0000000..6f14850
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zaporozhye differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zurich
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zurich b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zurich
new file mode 100644
index 0000000..9c2b600
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Zurich differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Factory
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Factory b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Factory
new file mode 100644
index 0000000..afeeb88
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Factory differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GB
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GB b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GB
new file mode 100644
index 0000000..4527515
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GB differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GB-Eire
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GB-Eire b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GB-Eire
new file mode 100644
index 0000000..4527515
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GB-Eire differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT
new file mode 100644
index 0000000..c05e45f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT+0
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT+0 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT+0
new file mode 100644
index 0000000..c05e45f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT+0 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT-0
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT-0 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT-0
new file mode 100644
index 0000000..c05e45f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT-0 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT0
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT0 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT0
new file mode 100644
index 0000000..c05e45f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/GMT0 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Greenwich
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Greenwich b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Greenwich
new file mode 100644
index 0000000..c05e45f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Greenwich differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/HST
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/HST b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/HST
new file mode 100644
index 0000000..03e4db0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/HST differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Hongkong
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Hongkong b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Hongkong
new file mode 100644
index 0000000..dc9058e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Hongkong differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Iceland
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Iceland b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Iceland
new file mode 100644
index 0000000..dc49c32
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Iceland differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Antananarivo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Antananarivo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Antananarivo
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Antananarivo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Chagos
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Chagos b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Chagos
new file mode 100644
index 0000000..0e5e719
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Chagos differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Christmas
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Christmas b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Christmas
new file mode 100644
index 0000000..066c1e9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Christmas differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Cocos
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Cocos b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Cocos
new file mode 100644
index 0000000..34a2457
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Cocos differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Comoro
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Comoro b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Comoro
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Comoro differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Kerguelen
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Kerguelen b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Kerguelen
new file mode 100644
index 0000000..e7d4d3d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Kerguelen differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mahe
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mahe b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mahe
new file mode 100644
index 0000000..db8ac68
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mahe differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Maldives
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Maldives b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Maldives
new file mode 100644
index 0000000..3f1a76e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Maldives differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mauritius
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mauritius b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mauritius
new file mode 100644
index 0000000..fd8d911
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mauritius differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mayotte
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mayotte b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mayotte
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Mayotte differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Reunion
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Reunion b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Reunion
new file mode 100644
index 0000000..d5f9aa4
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Indian/Reunion differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Iran
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Iran b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Iran
new file mode 100644
index 0000000..3157f80
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Iran differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Israel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Israel b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Israel
new file mode 100644
index 0000000..df51199
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Israel differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Jamaica
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Jamaica b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Jamaica
new file mode 100644
index 0000000..7aedd26
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Jamaica differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Japan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Japan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Japan
new file mode 100644
index 0000000..8ad44ba
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Japan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Kwajalein
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Kwajalein b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Kwajalein
new file mode 100644
index 0000000..1a27122
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Kwajalein differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Libya
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Libya b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Libya
new file mode 100644
index 0000000..b32e220
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Libya differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MET
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MET b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MET
new file mode 100644
index 0000000..71963d5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MET differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MST
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MST b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MST
new file mode 100644
index 0000000..a1bee7c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MST differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MST7MDT
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MST7MDT b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MST7MDT
new file mode 100644
index 0000000..726a7e5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/MST7MDT differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/BajaNorte
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/BajaNorte b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/BajaNorte
new file mode 100644
index 0000000..29c83e7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/BajaNorte differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/BajaSur
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/BajaSur b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/BajaSur
new file mode 100644
index 0000000..afa94c2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/BajaSur differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/General
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/General b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/General
new file mode 100644
index 0000000..f11e3d2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Mexico/General differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/NZ
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/NZ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/NZ
new file mode 100644
index 0000000..a5f5b6d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/NZ differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/NZ-CHAT
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/NZ-CHAT b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/NZ-CHAT
new file mode 100644
index 0000000..957c80b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/NZ-CHAT differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Navajo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Navajo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Navajo
new file mode 100644
index 0000000..7fc6691
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Navajo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/PRC
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/PRC b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/PRC
new file mode 100644
index 0000000..dbd132f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/PRC differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/PST8PDT
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/PST8PDT b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/PST8PDT
new file mode 100644
index 0000000..6242ac0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/PST8PDT differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Apia
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Apia b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Apia
new file mode 100644
index 0000000..4091a85
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Apia differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Auckland
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Auckland b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Auckland
new file mode 100644
index 0000000..a5f5b6d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Auckland differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Bougainville
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Bougainville b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Bougainville
new file mode 100644
index 0000000..dc5a7d7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Bougainville differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Chatham
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Chatham b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Chatham
new file mode 100644
index 0000000..957c80b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Chatham differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Chuuk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Chuuk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Chuuk
new file mode 100644
index 0000000..289b795
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Chuuk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Easter
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Easter b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Easter
new file mode 100644
index 0000000..060bef8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Easter differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Efate
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Efate b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Efate
new file mode 100644
index 0000000..5cee55d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Efate differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Enderbury
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Enderbury b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Enderbury
new file mode 100644
index 0000000..a3f30e5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Enderbury differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Fakaofo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Fakaofo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Fakaofo
new file mode 100644
index 0000000..6e4b8af
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Fakaofo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Fiji
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Fiji b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Fiji
new file mode 100644
index 0000000..912db18
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Fiji differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Funafuti
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Funafuti b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Funafuti
new file mode 100644
index 0000000..3289094
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Funafuti differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Galapagos
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Galapagos b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Galapagos
new file mode 100644
index 0000000..76b2b3a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Galapagos differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Gambier
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Gambier b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Gambier
new file mode 100644
index 0000000..625016d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Gambier differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Guadalcanal
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Guadalcanal b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Guadalcanal
new file mode 100644
index 0000000..0c24095
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Guadalcanal differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Guam
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Guam b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Guam
new file mode 100644
index 0000000..4286e6b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Guam differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Honolulu
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Honolulu b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Honolulu
new file mode 100644
index 0000000..bd85577
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Honolulu differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Johnston
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Johnston b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Johnston
new file mode 100644
index 0000000..bd85577
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Johnston differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kiritimati
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kiritimati b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kiritimati
new file mode 100644
index 0000000..762275d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kiritimati differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kosrae
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kosrae b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kosrae
new file mode 100644
index 0000000..f8222e6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kosrae differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kwajalein
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kwajalein b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kwajalein
new file mode 100644
index 0000000..1a27122
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Kwajalein differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Majuro
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Majuro b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Majuro
new file mode 100644
index 0000000..b3a8c18
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Majuro differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Marquesas
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Marquesas b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Marquesas
new file mode 100644
index 0000000..10c5c9b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Marquesas differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Midway
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Midway b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Midway
new file mode 100644
index 0000000..3e38e97
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Midway differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Nauru
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Nauru b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Nauru
new file mode 100644
index 0000000..6092119
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Nauru differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Niue
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Niue b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Niue
new file mode 100644
index 0000000..df6110d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Niue differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Norfolk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Norfolk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Norfolk
new file mode 100644
index 0000000..d0b9607
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Norfolk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Noumea
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Noumea b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Noumea
new file mode 100644
index 0000000..d9c68f8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Noumea differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pago_Pago
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pago_Pago b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pago_Pago
new file mode 100644
index 0000000..3e38e97
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pago_Pago differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Palau
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Palau b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Palau
new file mode 100644
index 0000000..e1bbea5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Palau differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pitcairn
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pitcairn b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pitcairn
new file mode 100644
index 0000000..54783cf
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pitcairn differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pohnpei
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pohnpei b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pohnpei
new file mode 100644
index 0000000..9743bc3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Pohnpei differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Ponape
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Ponape b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Ponape
new file mode 100644
index 0000000..9743bc3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Ponape differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Port_Moresby
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Port_Moresby b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Port_Moresby
new file mode 100644
index 0000000..3fa1f7f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Port_Moresby differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Rarotonga
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Rarotonga b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Rarotonga
new file mode 100644
index 0000000..ace1ce4
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Rarotonga differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Saipan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Saipan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Saipan
new file mode 100644
index 0000000..4286e6b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Saipan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Samoa
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Samoa b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Samoa
new file mode 100644
index 0000000..3e38e97
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Samoa differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tahiti
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tahiti b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tahiti
new file mode 100644
index 0000000..7867d8b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tahiti differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tarawa
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tarawa b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tarawa
new file mode 100644
index 0000000..3340413
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tarawa differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tongatapu
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tongatapu b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tongatapu
new file mode 100644
index 0000000..b3a5a89
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Tongatapu differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Truk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Truk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Truk
new file mode 100644
index 0000000..289b795
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Truk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Wake
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Wake b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Wake
new file mode 100644
index 0000000..2dc630c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Wake differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Wallis
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Wallis b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Wallis
new file mode 100644
index 0000000..b4f0f9b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Wallis differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Yap
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Yap b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Yap
new file mode 100644
index 0000000..289b795
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Pacific/Yap differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Poland
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Poland b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Poland
new file mode 100644
index 0000000..5cbba41
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Poland differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Portugal
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Portugal b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Portugal
new file mode 100644
index 0000000..a856530
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Portugal differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/ROC
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/ROC b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/ROC
new file mode 100644
index 0000000..748873b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/ROC differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/ROK
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/ROK b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/ROK
new file mode 100644
index 0000000..312ec40
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/ROK differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Singapore
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Singapore b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Singapore
new file mode 100644
index 0000000..7858366
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Singapore differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Turkey
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Turkey b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Turkey
new file mode 100644
index 0000000..9a53b3a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Turkey differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/UCT
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/UCT b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/UCT
new file mode 100644
index 0000000..40147b9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/UCT differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Alaska
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Alaska b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Alaska
new file mode 100644
index 0000000..6c8bdf2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Alaska differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Aleutian
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Aleutian b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Aleutian
new file mode 100644
index 0000000..5696e0f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Aleutian differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Arizona
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Arizona b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Arizona
new file mode 100644
index 0000000..adf2823
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Arizona differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Central
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Central b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Central
new file mode 100644
index 0000000..3dd8f0f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Central differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/East-Indiana
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/East-Indiana b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/East-Indiana
new file mode 100644
index 0000000..4a92c06
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/East-Indiana differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Eastern
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Eastern b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Eastern
new file mode 100644
index 0000000..7553fee
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Eastern differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Hawaii
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Hawaii b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Hawaii
new file mode 100644
index 0000000..bd85577
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Hawaii differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Indiana-Starke
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Indiana-Starke b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Indiana-Starke
new file mode 100644
index 0000000..cc785da
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Indiana-Starke differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Michigan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Michigan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Michigan
new file mode 100644
index 0000000..e3ea5c3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Michigan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Mountain
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Mountain b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Mountain
new file mode 100644
index 0000000..7fc6691
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Mountain differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Pacific
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Pacific b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Pacific
new file mode 100644
index 0000000..c0ce440
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Pacific differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Samoa
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Samoa b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Samoa
new file mode 100644
index 0000000..3e38e97
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/US/Samoa differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/UTC
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/UTC b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/UTC
new file mode 100644
index 0000000..c3b97f1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/UTC differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Universal
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Universal b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Universal
new file mode 100644
index 0000000..c3b97f1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Universal differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/W-SU
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/W-SU b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/W-SU
new file mode 100644
index 0000000..906bd05
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/W-SU differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/WET
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/WET b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/WET
new file mode 100644
index 0000000..444a193
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/WET differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Zulu
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Zulu b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Zulu
new file mode 100644
index 0000000..c3b97f1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Zulu differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/iso3166.tab
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/iso3166.tab b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/iso3166.tab
new file mode 100644
index 0000000..c2e0f8e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/iso3166.tab
@@ -0,0 +1,274 @@
+# ISO 3166 alpha-2 country codes
+#
+# This file is in the public domain, so clarified as of
+# 2009-05-17 by Arthur David Olson.
+#
+# From Paul Eggert (2015-05-02):
+# This file contains a table of two-letter country codes. Columns are
+# separated by a single tab. Lines beginning with '#' are comments.
+# All text uses UTF-8 encoding. The columns of the table are as follows:
+#
+# 1. ISO 3166-1 alpha-2 country code, current as of
+# ISO 3166-1 N905 (2016-11-15). See: Updates on ISO 3166-1
+# http://isotc.iso.org/livelink/livelink/Open/16944257
+# 2. The usual English name for the coded region,
+# chosen so that alphabetic sorting of subsets produces helpful lists.
+# This is not the same as the English name in the ISO 3166 tables.
+#
+# The table is sorted by country code.
+#
+# This table is intended as an aid for users, to help them select time
+# zone data appropriate for their practical needs. It is not intended
+# to take or endorse any position on legal or territorial claims.
+#
+#country-
+#code name of country, territory, area, or subdivision
+AD Andorra
+AE United Arab Emirates
+AF Afghanistan
+AG Antigua & Barbuda
+AI Anguilla
+AL Albania
+AM Armenia
+AO Angola
+AQ Antarctica
+AR Argentina
+AS Samoa (American)
+AT Austria
+AU Australia
+AW Aruba
+AX Åland Islands
+AZ Azerbaijan
+BA Bosnia & Herzegovina
+BB Barbados
+BD Bangladesh
+BE Belgium
+BF Burkina Faso
+BG Bulgaria
+BH Bahrain
+BI Burundi
+BJ Benin
+BL St Barthelemy
+BM Bermuda
+BN Brunei
+BO Bolivia
+BQ Caribbean NL
+BR Brazil
+BS Bahamas
+BT Bhutan
+BV Bouvet Island
+BW Botswana
+BY Belarus
+BZ Belize
+CA Canada
+CC Cocos (Keeling) Islands
+CD Congo (Dem. Rep.)
+CF Central African Rep.
+CG Congo (Rep.)
+CH Switzerland
+CI Côte d'Ivoire
+CK Cook Islands
+CL Chile
+CM Cameroon
+CN China
+CO Colombia
+CR Costa Rica
+CU Cuba
+CV Cape Verde
+CW Curaçao
+CX Christmas Island
+CY Cyprus
+CZ Czech Republic
+DE Germany
+DJ Djibouti
+DK Denmark
+DM Dominica
+DO Dominican Republic
+DZ Algeria
+EC Ecuador
+EE Estonia
+EG Egypt
+EH Western Sahara
+ER Eritrea
+ES Spain
+ET Ethiopia
+FI Finland
+FJ Fiji
+FK Falkland Islands
+FM Micronesia
+FO Faroe Islands
+FR France
+GA Gabon
+GB Britain (UK)
+GD Grenada
+GE Georgia
+GF French Guiana
+GG Guernsey
+GH Ghana
+GI Gibraltar
+GL Greenland
+GM Gambia
+GN Guinea
+GP Guadeloupe
+GQ Equatorial Guinea
+GR Greece
+GS South Georgia & the South Sandwich Islands
+GT Guatemala
+GU Guam
+GW Guinea-Bissau
+GY Guyana
+HK Hong Kong
+HM Heard Island & McDonald Islands
+HN Honduras
+HR Croatia
+HT Haiti
+HU Hungary
+ID Indonesia
+IE Ireland
+IL Israel
+IM Isle of Man
+IN India
+IO British Indian Ocean Territory
+IQ Iraq
+IR Iran
+IS Iceland
+IT Italy
+JE Jersey
+JM Jamaica
+JO Jordan
+JP Japan
+KE Kenya
+KG Kyrgyzstan
+KH Cambodia
+KI Kiribati
+KM Comoros
+KN St Kitts & Nevis
+KP Korea (North)
+KR Korea (South)
+KW Kuwait
+KY Cayman Islands
+KZ Kazakhstan
+LA Laos
+LB Lebanon
+LC St Lucia
+LI Liechtenstein
+LK Sri Lanka
+LR Liberia
+LS Lesotho
+LT Lithuania
+LU Luxembourg
+LV Latvia
+LY Libya
+MA Morocco
+MC Monaco
+MD Moldova
+ME Montenegro
+MF St Martin (French)
+MG Madagascar
+MH Marshall Islands
+MK Macedonia
+ML Mali
+MM Myanmar (Burma)
+MN Mongolia
+MO Macau
+MP Northern Mariana Islands
+MQ Martinique
+MR Mauritania
+MS Montserrat
+MT Malta
+MU Mauritius
+MV Maldives
+MW Malawi
+MX Mexico
+MY Malaysia
+MZ Mozambique
+NA Namibia
+NC New Caledonia
+NE Niger
+NF Norfolk Island
+NG Nigeria
+NI Nicaragua
+NL Netherlands
+NO Norway
+NP Nepal
+NR Nauru
+NU Niue
+NZ New Zealand
+OM Oman
+PA Panama
+PE Peru
+PF French Polynesia
+PG Papua New Guinea
+PH Philippines
+PK Pakistan
+PL Poland
+PM St Pierre & Miquelon
+PN Pitcairn
+PR Puerto Rico
+PS Palestine
+PT Portugal
+PW Palau
+PY Paraguay
+QA Qatar
+RE Réunion
+RO Romania
+RS Serbia
+RU Russia
+RW Rwanda
+SA Saudi Arabia
+SB Solomon Islands
+SC Seychelles
+SD Sudan
+SE Sweden
+SG Singapore
+SH St Helena
+SI Slovenia
+SJ Svalbard & Jan Mayen
+SK Slovakia
+SL Sierra Leone
+SM San Marino
+SN Senegal
+SO Somalia
+SR Suriname
+SS South Sudan
+ST Sao Tome & Principe
+SV El Salvador
+SX St Maarten (Dutch)
+SY Syria
+SZ Swaziland
+TC Turks & Caicos Is
+TD Chad
+TF French Southern & Antarctic Lands
+TG Togo
+TH Thailand
+TJ Tajikistan
+TK Tokelau
+TL East Timor
+TM Turkmenistan
+TN Tunisia
+TO Tonga
+TR Turkey
+TT Trinidad & Tobago
+TV Tuvalu
+TW Taiwan
+TZ Tanzania
+UA Ukraine
+UG Uganda
+UM US minor outlying islands
+US United States
+UY Uruguay
+UZ Uzbekistan
+VA Vatican City
+VC St Vincent
+VE Venezuela
+VG Virgin Islands (UK)
+VI Virgin Islands (US)
+VN Vietnam
+VU Vanuatu
+WF Wallis & Futuna
+WS Samoa (western)
+YE Yemen
+YT Mayotte
+ZA South Africa
+ZM Zambia
+ZW Zimbabwe
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/localtime
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/localtime b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/localtime
new file mode 100644
index 0000000..afeeb88
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/localtime differ
[11/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Vladivostok
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Vladivostok b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Vladivostok
new file mode 100644
index 0000000..80b170b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Vladivostok differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yakutsk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yakutsk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yakutsk
new file mode 100644
index 0000000..220ad3d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yakutsk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yangon
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yangon b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yangon
new file mode 100644
index 0000000..3cc2aaf
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yangon differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yekaterinburg
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yekaterinburg b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yekaterinburg
new file mode 100644
index 0000000..c1abb93
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yekaterinburg differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yerevan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yerevan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yerevan
new file mode 100644
index 0000000..4c4e045
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Asia/Yerevan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Azores
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Azores b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Azores
new file mode 100644
index 0000000..1895e1b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Azores differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Bermuda
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Bermuda b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Bermuda
new file mode 100644
index 0000000..548d979
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Bermuda differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Canary
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Canary b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Canary
new file mode 100644
index 0000000..544f443
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Canary differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Cape_Verde
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Cape_Verde b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Cape_Verde
new file mode 100644
index 0000000..6bda6db
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Cape_Verde differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Faeroe
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Faeroe b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Faeroe
new file mode 100644
index 0000000..c486518
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Faeroe differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Faroe
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Faroe b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Faroe
new file mode 100644
index 0000000..c486518
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Faroe differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Jan_Mayen
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Jan_Mayen b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Jan_Mayen
new file mode 100644
index 0000000..239c017
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Jan_Mayen differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Madeira
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Madeira b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Madeira
new file mode 100644
index 0000000..e25f8a5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Madeira differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Reykjavik
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Reykjavik b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Reykjavik
new file mode 100644
index 0000000..dc49c32
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Reykjavik differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/South_Georgia
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/South_Georgia b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/South_Georgia
new file mode 100644
index 0000000..56b383b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/South_Georgia differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/St_Helena
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/St_Helena b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/St_Helena
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/St_Helena differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Stanley
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Stanley b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Stanley
new file mode 100644
index 0000000..3649415
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Atlantic/Stanley differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/ACT
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/ACT b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/ACT
new file mode 100644
index 0000000..aaed12c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/ACT differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Adelaide
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Adelaide b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Adelaide
new file mode 100644
index 0000000..4f331a8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Adelaide differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Brisbane
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Brisbane b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Brisbane
new file mode 100644
index 0000000..a327d83
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Brisbane differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Broken_Hill
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Broken_Hill b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Broken_Hill
new file mode 100644
index 0000000..768b167
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Broken_Hill differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Canberra
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Canberra b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Canberra
new file mode 100644
index 0000000..aaed12c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Canberra differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Currie
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Currie b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Currie
new file mode 100644
index 0000000..a3f6f29
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Currie differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Darwin
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Darwin b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Darwin
new file mode 100644
index 0000000..c6ae9a7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Darwin differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Eucla
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Eucla b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Eucla
new file mode 100644
index 0000000..99f07a9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Eucla differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Hobart
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Hobart b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Hobart
new file mode 100644
index 0000000..07784ce
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Hobart differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/LHI
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/LHI b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/LHI
new file mode 100644
index 0000000..57597b0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/LHI differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Lindeman
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Lindeman b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Lindeman
new file mode 100644
index 0000000..71ca143
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Lindeman differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Lord_Howe
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Lord_Howe b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Lord_Howe
new file mode 100644
index 0000000..57597b0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Lord_Howe differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Melbourne
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Melbourne b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Melbourne
new file mode 100644
index 0000000..ec8dfe0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Melbourne differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/NSW
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/NSW b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/NSW
new file mode 100644
index 0000000..aaed12c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/NSW differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/North
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/North b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/North
new file mode 100644
index 0000000..c6ae9a7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/North differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Perth
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Perth b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Perth
new file mode 100644
index 0000000..85c26d5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Perth differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Queensland
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Queensland b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Queensland
new file mode 100644
index 0000000..a327d83
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Queensland differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/South
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/South b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/South
new file mode 100644
index 0000000..4f331a8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/South differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Sydney
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Sydney b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Sydney
new file mode 100644
index 0000000..aaed12c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Sydney differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Tasmania
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Tasmania b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Tasmania
new file mode 100644
index 0000000..07784ce
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Tasmania differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Victoria
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Victoria b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Victoria
new file mode 100644
index 0000000..ec8dfe0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Victoria differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/West
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/West b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/West
new file mode 100644
index 0000000..85c26d5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/West differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Yancowinna
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Yancowinna b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Yancowinna
new file mode 100644
index 0000000..768b167
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Australia/Yancowinna differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/Acre
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/Acre b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/Acre
new file mode 100644
index 0000000..b612ac2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/Acre differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/DeNoronha
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/DeNoronha b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/DeNoronha
new file mode 100644
index 0000000..6d91f91
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/DeNoronha differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/East
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/East b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/East
new file mode 100644
index 0000000..308a545
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/East differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/West
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/West b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/West
new file mode 100644
index 0000000..855cb02
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Brazil/West differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/CET
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/CET b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/CET
new file mode 100644
index 0000000..4c4f8ef
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/CET differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/CST6CDT
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/CST6CDT b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/CST6CDT
new file mode 100644
index 0000000..5c8a1d9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/CST6CDT differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Atlantic
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Atlantic b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Atlantic
new file mode 100644
index 0000000..f86ece4
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Atlantic differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Central
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Central b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Central
new file mode 100644
index 0000000..2ffe3d8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Central differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Eastern
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Eastern b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Eastern
new file mode 100644
index 0000000..7b4682a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Eastern differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Mountain
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Mountain b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Mountain
new file mode 100644
index 0000000..d02fbcd
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Mountain differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Newfoundland
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Newfoundland b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Newfoundland
new file mode 100644
index 0000000..a1d1485
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Newfoundland differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Pacific
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Pacific b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Pacific
new file mode 100644
index 0000000..9b5d924
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Pacific differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Saskatchewan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Saskatchewan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Saskatchewan
new file mode 100644
index 0000000..5fe8d6b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Saskatchewan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Yukon
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Yukon b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Yukon
new file mode 100644
index 0000000..6b62e2d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Canada/Yukon differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Chile/Continental
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Chile/Continental b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Chile/Continental
new file mode 100644
index 0000000..ab766a4
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Chile/Continental differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Chile/EasterIsland
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Chile/EasterIsland b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Chile/EasterIsland
new file mode 100644
index 0000000..060bef8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Chile/EasterIsland differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Cuba
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Cuba b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Cuba
new file mode 100644
index 0000000..1a58fcd
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Cuba differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EET
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EET b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EET
new file mode 100644
index 0000000..beb273a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EET differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EST
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EST b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EST
new file mode 100644
index 0000000..ae34663
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EST differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EST5EDT
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EST5EDT b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EST5EDT
new file mode 100644
index 0000000..54541fc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/EST5EDT differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Egypt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Egypt b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Egypt
new file mode 100644
index 0000000..ba09750
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Egypt differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Eire
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Eire b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Eire
new file mode 100644
index 0000000..655daf3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Eire differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT
new file mode 100644
index 0000000..c05e45f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+0
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+0 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+0
new file mode 100644
index 0000000..c05e45f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+0 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+1
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+1 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+1
new file mode 100644
index 0000000..082986e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+1 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+10
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+10 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+10
new file mode 100644
index 0000000..23276cd
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+10 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+11
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+11 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+11
new file mode 100644
index 0000000..28c579d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+11 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+12
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+12 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+12
new file mode 100644
index 0000000..c740603
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+12 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+2
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+2 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+2
new file mode 100644
index 0000000..721cde2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+2 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+3
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+3 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+3
new file mode 100644
index 0000000..ae06bcb
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+3 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+4
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+4 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+4
new file mode 100644
index 0000000..5a7f878
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+4 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+5
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+5 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+5
new file mode 100644
index 0000000..18cbf1f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+5 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+6
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+6 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+6
new file mode 100644
index 0000000..1aa4be8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+6 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+7
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+7 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+7
new file mode 100644
index 0000000..cd8ed49
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+7 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+8
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+8 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+8
new file mode 100644
index 0000000..e0ba6b8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+8 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+9
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+9 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+9
new file mode 100644
index 0000000..eee1bcb
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT+9 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-0
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-0 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-0
new file mode 100644
index 0000000..c05e45f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-0 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-1
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-1 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-1
new file mode 100644
index 0000000..4ff8701
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-1 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-10
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-10 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-10
new file mode 100644
index 0000000..e12e461
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-10 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-11
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-11 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-11
new file mode 100644
index 0000000..37f2739
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-11 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-12
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-12 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-12
new file mode 100644
index 0000000..09297f1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-12 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-13
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-13 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-13
new file mode 100644
index 0000000..97ae1e1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-13 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-14
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-14 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-14
new file mode 100644
index 0000000..58d6d1b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-14 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-2
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-2 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-2
new file mode 100644
index 0000000..f0dc706
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-2 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-3
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-3 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-3
new file mode 100644
index 0000000..a0790fe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-3 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-4
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-4 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-4
new file mode 100644
index 0000000..a75a173
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-4 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-5
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-5 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-5
new file mode 100644
index 0000000..85ebf22
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-5 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-6
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-6 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-6
new file mode 100644
index 0000000..95def1f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-6 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-7
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-7 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-7
new file mode 100644
index 0000000..c6a776e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-7 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-8
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-8 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-8
new file mode 100644
index 0000000..f74a16f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-8 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-9
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-9 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-9
new file mode 100644
index 0000000..9b647c0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT-9 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT0
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT0 b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT0
new file mode 100644
index 0000000..c05e45f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/GMT0 differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Greenwich
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Greenwich b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Greenwich
new file mode 100644
index 0000000..c05e45f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Greenwich differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/UCT
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/UCT b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/UCT
new file mode 100644
index 0000000..40147b9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/UCT differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/UTC
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/UTC b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/UTC
new file mode 100644
index 0000000..c3b97f1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/UTC differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Universal
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Universal b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Universal
new file mode 100644
index 0000000..c3b97f1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Universal differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Zulu
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Zulu b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Zulu
new file mode 100644
index 0000000..c3b97f1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Etc/Zulu differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Amsterdam
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Amsterdam b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Amsterdam
new file mode 100644
index 0000000..6dae5e4
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Amsterdam differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Andorra
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Andorra b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Andorra
new file mode 100644
index 0000000..b06de7a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Andorra differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Astrakhan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Astrakhan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Astrakhan
new file mode 100644
index 0000000..90d7c2a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Astrakhan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Athens
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Athens b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Athens
new file mode 100644
index 0000000..0001602
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Athens differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Belfast
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Belfast b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Belfast
new file mode 100644
index 0000000..4527515
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Belfast differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Belgrade
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Belgrade b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Belgrade
new file mode 100644
index 0000000..79c25d7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Belgrade differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Berlin
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Berlin b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Berlin
new file mode 100644
index 0000000..b4f2a2a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Berlin differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Bratislava
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Bratislava b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Bratislava
new file mode 100644
index 0000000..4eabe5c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Bratislava differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Brussels
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Brussels b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Brussels
new file mode 100644
index 0000000..d8f19a6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Brussels differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Bucharest
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Bucharest b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Bucharest
new file mode 100644
index 0000000..e0eac4c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Bucharest differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Budapest
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Budapest b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Budapest
new file mode 100644
index 0000000..3ddf6a5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Budapest differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Busingen
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Busingen b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Busingen
new file mode 100644
index 0000000..9c2b600
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Busingen differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Chisinau
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Chisinau b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Chisinau
new file mode 100644
index 0000000..2109b52
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Chisinau differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Copenhagen
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Copenhagen b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Copenhagen
new file mode 100644
index 0000000..be87cf1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Copenhagen differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Dublin
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Dublin b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Dublin
new file mode 100644
index 0000000..655daf3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Dublin differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Gibraltar
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Gibraltar b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Gibraltar
new file mode 100644
index 0000000..a7105fa
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Gibraltar differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Guernsey
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Guernsey b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Guernsey
new file mode 100644
index 0000000..4527515
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Guernsey differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Helsinki
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Helsinki b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Helsinki
new file mode 100644
index 0000000..29b3c81
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Helsinki differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Isle_of_Man
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Isle_of_Man b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Isle_of_Man
new file mode 100644
index 0000000..4527515
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Isle_of_Man differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Istanbul
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Istanbul b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Istanbul
new file mode 100644
index 0000000..9a53b3a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Istanbul differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Jersey
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Jersey b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Jersey
new file mode 100644
index 0000000..4527515
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Jersey differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kaliningrad
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kaliningrad b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kaliningrad
new file mode 100644
index 0000000..37280d0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kaliningrad differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kiev
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kiev b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kiev
new file mode 100644
index 0000000..b3e20a7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kiev differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kirov
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kirov b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kirov
new file mode 100644
index 0000000..40b558f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Kirov differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Lisbon
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Lisbon b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Lisbon
new file mode 100644
index 0000000..a856530
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Lisbon differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Ljubljana
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Ljubljana b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Ljubljana
new file mode 100644
index 0000000..79c25d7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Ljubljana differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/London
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/London b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/London
new file mode 100644
index 0000000..4527515
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/London differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Luxembourg
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Luxembourg b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Luxembourg
new file mode 100644
index 0000000..6fae86c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Luxembourg differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Madrid
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Madrid b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Madrid
new file mode 100644
index 0000000..9b51a73
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Madrid differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Malta
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Malta b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Malta
new file mode 100644
index 0000000..c1208e2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Malta differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Mariehamn
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Mariehamn b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Mariehamn
new file mode 100644
index 0000000..29b3c81
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Mariehamn differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Minsk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Minsk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Minsk
new file mode 100644
index 0000000..60041a4
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Minsk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Monaco
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Monaco b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Monaco
new file mode 100644
index 0000000..0b40f1e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Monaco differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Moscow
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Moscow b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Moscow
new file mode 100644
index 0000000..906bd05
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Moscow differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Nicosia
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Nicosia b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Nicosia
new file mode 100644
index 0000000..3e663b2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Nicosia differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Oslo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Oslo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Oslo
new file mode 100644
index 0000000..239c017
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Oslo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Paris
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Paris b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Paris
new file mode 100644
index 0000000..cf6e2e2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Paris differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Podgorica
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Podgorica b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Podgorica
new file mode 100644
index 0000000..79c25d7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Podgorica differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Prague
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Prague b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Prague
new file mode 100644
index 0000000..4eabe5c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Prague differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Riga
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Riga b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Riga
new file mode 100644
index 0000000..b729ee8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Riga differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Rome
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Rome b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Rome
new file mode 100644
index 0000000..bdd3449
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Rome differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Samara
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Samara b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Samara
new file mode 100644
index 0000000..0539acf
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Samara differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/San_Marino
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/San_Marino b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/San_Marino
new file mode 100644
index 0000000..bdd3449
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/San_Marino differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Sarajevo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Sarajevo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Sarajevo
new file mode 100644
index 0000000..79c25d7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Sarajevo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Saratov
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Saratov b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Saratov
new file mode 100644
index 0000000..e8cd6b1
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Saratov differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Simferopol
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Simferopol b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Simferopol
new file mode 100644
index 0000000..f3b42b0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Simferopol differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Skopje
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Skopje b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Skopje
new file mode 100644
index 0000000..79c25d7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Europe/Skopje differ
[51/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
* Replace gtest with upstream version, including LICENSE header.
* Include absl library for faster and safer string operations.
* Update license headers where needed.
* Removed custom code replaced by absl.
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/0eb556da
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/0eb556da
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/0eb556da
Branch: refs/heads/master
Commit: 0eb556da06e0eff2aa08f61fc559bada460a13fb
Parents: 3844ae4
Author: Sebastian Schaffert <ss...@apache.org>
Authored: Sun Apr 29 21:32:50 2018 +0200
Committer: Sebastian Schaffert <ss...@apache.org>
Committed: Sun Apr 29 21:33:09 2018 +0200
----------------------------------------------------------------------
.../backend/3rdparty/abseil/.clang-format | 4 +
.../ostrich/backend/3rdparty/abseil/.gitignore | 2 +
.../3rdparty/abseil/ABSEIL_ISSUE_TEMPLATE.md | 22 +
.../ostrich/backend/3rdparty/abseil/AUTHORS | 6 +
.../3rdparty/abseil/CMake/AbseilHelpers.cmake | 157 +
.../backend/3rdparty/abseil/CMake/README.md | 79 +
.../backend/3rdparty/abseil/CMakeLists.txt | 86 +
.../backend/3rdparty/abseil/CONTRIBUTING.md | 91 +
.../ostrich/backend/3rdparty/abseil/LICENSE | 204 +
.../ostrich/backend/3rdparty/abseil/README.md | 108 +
.../ostrich/backend/3rdparty/abseil/WORKSPACE | 25 +
.../backend/3rdparty/abseil/absl/BUILD.bazel | 52 +
.../backend/3rdparty/abseil/absl/CMakeLists.txt | 30 +
.../3rdparty/abseil/absl/algorithm/BUILD.bazel | 69 +
.../abseil/absl/algorithm/CMakeLists.txt | 63 +
.../3rdparty/abseil/absl/algorithm/algorithm.h | 150 +
.../abseil/absl/algorithm/algorithm_test.cc | 182 +
.../3rdparty/abseil/absl/algorithm/container.h | 1642 ++
.../abseil/absl/algorithm/container_test.cc | 997 +
.../3rdparty/abseil/absl/base/BUILD.bazel | 395 +
.../3rdparty/abseil/absl/base/CMakeLists.txt | 358 +
.../3rdparty/abseil/absl/base/attributes.h | 567 +
.../3rdparty/abseil/absl/base/bit_cast_test.cc | 107 +
.../3rdparty/abseil/absl/base/call_once.h | 216 +
.../3rdparty/abseil/absl/base/call_once_test.cc | 102 +
.../backend/3rdparty/abseil/absl/base/casts.h | 140 +
.../backend/3rdparty/abseil/absl/base/config.h | 427 +
.../3rdparty/abseil/absl/base/config_test.cc | 60 +
.../abseil/absl/base/dynamic_annotations.cc | 129 +
.../abseil/absl/base/dynamic_annotations.h | 409 +
.../absl/base/exception_safety_testing_test.cc | 842 +
.../abseil/absl/base/inline_variable_test.cc | 62 +
.../abseil/absl/base/inline_variable_test_a.cc | 25 +
.../abseil/absl/base/inline_variable_test_b.cc | 25 +
.../abseil/absl/base/internal/atomic_hook.h | 150 +
.../abseil/absl/base/internal/cycleclock.cc | 81 +
.../abseil/absl/base/internal/cycleclock.h | 77 +
.../abseil/absl/base/internal/direct_mmap.h | 151 +
.../3rdparty/abseil/absl/base/internal/endian.h | 269 +
.../abseil/absl/base/internal/endian_test.cc | 279 +
.../base/internal/exception_safety_testing.cc | 41 +
.../base/internal/exception_safety_testing.h | 997 +
.../absl/base/internal/exception_testing.h | 38 +
.../abseil/absl/base/internal/identity.h | 33 +
.../abseil/absl/base/internal/inline_variable.h | 107 +
.../base/internal/inline_variable_testing.h | 44 +
.../3rdparty/abseil/absl/base/internal/invoke.h | 188 +
.../absl/base/internal/low_level_alloc.cc | 604 +
.../abseil/absl/base/internal/low_level_alloc.h | 119 +
.../absl/base/internal/low_level_alloc_test.cc | 157 +
.../absl/base/internal/low_level_scheduling.h | 104 +
.../abseil/absl/base/internal/per_thread_tls.h | 48 +
.../abseil/absl/base/internal/pretty_function.h | 33 +
.../abseil/absl/base/internal/raw_logging.cc | 218 +
.../abseil/absl/base/internal/raw_logging.h | 137 +
.../abseil/absl/base/internal/scheduling_mode.h | 54 +
.../abseil/absl/base/internal/spinlock.cc | 238 +
.../abseil/absl/base/internal/spinlock.h | 239 +
.../absl/base/internal/spinlock_akaros.inc | 35 +
.../absl/base/internal/spinlock_posix.inc | 46 +
.../abseil/absl/base/internal/spinlock_wait.cc | 79 +
.../abseil/absl/base/internal/spinlock_wait.h | 91 +
.../absl/base/internal/spinlock_win32.inc | 37 +
.../abseil/absl/base/internal/sysinfo.cc | 404 +
.../abseil/absl/base/internal/sysinfo.h | 63 +
.../abseil/absl/base/internal/sysinfo_test.cc | 98 +
.../absl/base/internal/thread_identity.cc | 123 +
.../abseil/absl/base/internal/thread_identity.h | 240 +
.../absl/base/internal/thread_identity_test.cc | 126 +
.../abseil/absl/base/internal/throw_delegate.cc | 106 +
.../abseil/absl/base/internal/throw_delegate.h | 71 +
.../absl/base/internal/tsan_mutex_interface.h | 66 +
.../absl/base/internal/unaligned_access.h | 256 +
.../absl/base/internal/unscaledcycleclock.cc | 101 +
.../absl/base/internal/unscaledcycleclock.h | 119 +
.../3rdparty/abseil/absl/base/invoke_test.cc | 200 +
.../3rdparty/abseil/absl/base/log_severity.h | 67 +
.../backend/3rdparty/abseil/absl/base/macros.h | 202 +
.../3rdparty/abseil/absl/base/optimization.h | 165 +
.../3rdparty/abseil/absl/base/policy_checks.h | 121 +
.../backend/3rdparty/abseil/absl/base/port.h | 26 +
.../abseil/absl/base/raw_logging_test.cc | 50 +
.../abseil/absl/base/spinlock_test_common.cc | 266 +
.../abseil/absl/base/thread_annotations.h | 258 +
.../abseil/absl/base/throw_delegate_test.cc | 94 +
.../3rdparty/abseil/absl/container/BUILD.bazel | 128 +
.../abseil/absl/container/CMakeLists.txt | 126 +
.../abseil/absl/container/fixed_array.h | 498 +
.../abseil/absl/container/fixed_array_test.cc | 659 +
.../abseil/absl/container/inlined_vector.h | 1384 ++
.../absl/container/inlined_vector_test.cc | 1766 ++
.../container/internal/test_instance_tracker.cc | 26 +
.../container/internal/test_instance_tracker.h | 220 +
.../internal/test_instance_tracker_test.cc | 160 +
.../backend/3rdparty/abseil/absl/copts.bzl | 155 +
.../3rdparty/abseil/absl/debugging/BUILD.bazel | 305 +
.../abseil/absl/debugging/CMakeLists.txt | 193 +
.../absl/debugging/failure_signal_handler.cc | 351 +
.../absl/debugging/failure_signal_handler.h | 103 +
.../debugging/failure_signal_handler_test.cc | 146 +
.../debugging/internal/address_is_readable.cc | 133 +
.../debugging/internal/address_is_readable.h | 29 +
.../abseil/absl/debugging/internal/demangle.cc | 1862 ++
.../abseil/absl/debugging/internal/demangle.h | 67 +
.../absl/debugging/internal/demangle_test.cc | 191 +
.../absl/debugging/internal/elf_mem_image.cc | 398 +
.../absl/debugging/internal/elf_mem_image.h | 130 +
.../absl/debugging/internal/examine_stack.cc | 147 +
.../absl/debugging/internal/examine_stack.h | 38 +
.../debugging/internal/stack_consumption.cc | 172 +
.../absl/debugging/internal/stack_consumption.h | 45 +
.../internal/stack_consumption_test.cc | 48 +
.../internal/stacktrace_aarch64-inl.inc | 189 +
.../debugging/internal/stacktrace_arm-inl.inc | 123 +
.../absl/debugging/internal/stacktrace_config.h | 74 +
.../internal/stacktrace_generic-inl.inc | 59 +
.../internal/stacktrace_powerpc-inl.inc | 243 +
.../internal/stacktrace_unimplemented-inl.inc | 22 +
.../debugging/internal/stacktrace_win32-inl.inc | 83 +
.../debugging/internal/stacktrace_x86-inl.inc | 337 +
.../abseil/absl/debugging/internal/symbolize.h | 122 +
.../absl/debugging/internal/vdso_support.cc | 192 +
.../absl/debugging/internal/vdso_support.h | 155 +
.../abseil/absl/debugging/leak_check.cc | 48 +
.../3rdparty/abseil/absl/debugging/leak_check.h | 111 +
.../abseil/absl/debugging/leak_check_disable.cc | 20 +
.../absl/debugging/leak_check_fail_test.cc | 41 +
.../abseil/absl/debugging/leak_check_test.cc | 42 +
.../abseil/absl/debugging/stacktrace.cc | 133 +
.../3rdparty/abseil/absl/debugging/stacktrace.h | 167 +
.../3rdparty/abseil/absl/debugging/symbolize.cc | 28 +
.../3rdparty/abseil/absl/debugging/symbolize.h | 35 +
.../abseil/absl/debugging/symbolize_elf.inc | 1473 ++
.../abseil/absl/debugging/symbolize_test.cc | 517 +
.../absl/debugging/symbolize_unimplemented.inc | 35 +
.../abseil/absl/debugging/symbolize_win32.inc | 74 +
.../3rdparty/abseil/absl/memory/BUILD.bazel | 47 +
.../3rdparty/abseil/absl/memory/CMakeLists.txt | 52 +
.../3rdparty/abseil/absl/memory/memory.h | 640 +
.../3rdparty/abseil/absl/memory/memory_test.cc | 614 +
.../3rdparty/abseil/absl/meta/BUILD.bazel | 29 +
.../3rdparty/abseil/absl/meta/CMakeLists.txt | 49 +
.../3rdparty/abseil/absl/meta/type_traits.h | 372 +
.../abseil/absl/meta/type_traits_test.cc | 799 +
.../3rdparty/abseil/absl/numeric/BUILD.bazel | 41 +
.../3rdparty/abseil/absl/numeric/CMakeLists.txt | 62 +
.../3rdparty/abseil/absl/numeric/int128.cc | 225 +
.../3rdparty/abseil/absl/numeric/int128.h | 656 +
.../absl/numeric/int128_have_intrinsic.inc | 18 +
.../abseil/absl/numeric/int128_no_intrinsic.inc | 18 +
.../abseil/absl/numeric/int128_stream_test.cc | 666 +
.../3rdparty/abseil/absl/numeric/int128_test.cc | 431 +
.../3rdparty/abseil/absl/strings/BUILD.bazel | 322 +
.../3rdparty/abseil/absl/strings/CMakeLists.txt | 304 +
.../3rdparty/abseil/absl/strings/ascii.cc | 198 +
.../3rdparty/abseil/absl/strings/ascii.h | 239 +
.../3rdparty/abseil/absl/strings/ascii_test.cc | 354 +
.../3rdparty/abseil/absl/strings/escaping.cc | 1109 +
.../3rdparty/abseil/absl/strings/escaping.h | 161 +
.../abseil/absl/strings/escaping_test.cc | 641 +
.../abseil/absl/strings/internal/char_map.h | 154 +
.../absl/strings/internal/char_map_test.cc | 172 +
.../strings/internal/escaping_test_common.inc | 113 +
.../abseil/absl/strings/internal/memutil.cc | 110 +
.../abseil/absl/strings/internal/memutil.h | 146 +
.../absl/strings/internal/memutil_test.cc | 179 +
.../strings/internal/numbers_test_common.inc | 156 +
.../absl/strings/internal/ostringstream.cc | 34 +
.../absl/strings/internal/ostringstream.h | 87 +
.../absl/strings/internal/ostringstream_test.cc | 102 +
.../strings/internal/resize_uninitialized.h | 69 +
.../internal/resize_uninitialized_test.cc | 68 +
.../absl/strings/internal/stl_type_traits.h | 246 +
.../absl/strings/internal/str_join_internal.h | 309 +
.../absl/strings/internal/str_split_internal.h | 435 +
.../abseil/absl/strings/internal/utf8.cc | 51 +
.../abseil/absl/strings/internal/utf8.h | 47 +
.../abseil/absl/strings/internal/utf8_test.cc | 57 +
.../3rdparty/abseil/absl/strings/match.cc | 40 +
.../3rdparty/abseil/absl/strings/match.h | 84 +
.../3rdparty/abseil/absl/strings/match_test.cc | 99 +
.../3rdparty/abseil/absl/strings/numbers.cc | 919 +
.../3rdparty/abseil/absl/strings/numbers.h | 172 +
.../abseil/absl/strings/numbers_test.cc | 1186 +
.../3rdparty/abseil/absl/strings/str_cat.cc | 239 +
.../3rdparty/abseil/absl/strings/str_cat.h | 385 +
.../abseil/absl/strings/str_cat_test.cc | 539 +
.../3rdparty/abseil/absl/strings/str_join.h | 288 +
.../abseil/absl/strings/str_join_test.cc | 473 +
.../3rdparty/abseil/absl/strings/str_replace.cc | 79 +
.../3rdparty/abseil/absl/strings/str_replace.h | 213 +
.../abseil/absl/strings/str_replace_test.cc | 341 +
.../3rdparty/abseil/absl/strings/str_split.cc | 136 +
.../3rdparty/abseil/absl/strings/str_split.h | 511 +
.../abseil/absl/strings/str_split_test.cc | 907 +
.../3rdparty/abseil/absl/strings/string_view.cc | 247 +
.../3rdparty/abseil/absl/strings/string_view.h | 570 +
.../abseil/absl/strings/string_view_test.cc | 1136 +
.../3rdparty/abseil/absl/strings/strip.h | 89 +
.../3rdparty/abseil/absl/strings/strip_test.cc | 201 +
.../3rdparty/abseil/absl/strings/substitute.cc | 170 +
.../3rdparty/abseil/absl/strings/substitute.h | 668 +
.../abseil/absl/strings/substitute_test.cc | 192 +
.../abseil/absl/strings/testdata/getline-1.txt | 3 +
.../abseil/absl/strings/testdata/getline-2.txt | 1 +
.../abseil/absl/synchronization/BUILD.bazel | 206 +
.../abseil/absl/synchronization/CMakeLists.txt | 154 +
.../abseil/absl/synchronization/barrier.cc | 50 +
.../abseil/absl/synchronization/barrier.h | 77 +
.../abseil/absl/synchronization/barrier_test.cc | 75 +
.../absl/synchronization/blocking_counter.cc | 55 +
.../absl/synchronization/blocking_counter.h | 97 +
.../synchronization/blocking_counter_test.cc | 66 +
.../internal/create_thread_identity.cc | 112 +
.../internal/create_thread_identity.h | 53 +
.../synchronization/internal/graphcycles.cc | 709 +
.../absl/synchronization/internal/graphcycles.h | 136 +
.../internal/graphcycles_test.cc | 462 +
.../synchronization/internal/kernel_timeout.h | 149 +
.../synchronization/internal/mutex_nonprod.cc | 318 +
.../synchronization/internal/mutex_nonprod.inc | 256 +
.../synchronization/internal/per_thread_sem.cc | 99 +
.../synchronization/internal/per_thread_sem.h | 107 +
.../internal/per_thread_sem_test.cc | 172 +
.../absl/synchronization/internal/thread_pool.h | 90 +
.../absl/synchronization/internal/waiter.cc | 412 +
.../absl/synchronization/internal/waiter.h | 139 +
.../absl/synchronization/lifetime_test.cc | 132 +
.../abseil/absl/synchronization/mutex.cc | 2688 +++
.../abseil/absl/synchronization/mutex.h | 1022 +
.../abseil/absl/synchronization/mutex_test.cc | 1539 ++
.../abseil/absl/synchronization/notification.cc | 84 +
.../abseil/absl/synchronization/notification.h | 112 +
.../absl/synchronization/notification_test.cc | 124 +
.../3rdparty/abseil/absl/time/BUILD.bazel | 97 +
.../3rdparty/abseil/absl/time/CMakeLists.txt | 96 +
.../backend/3rdparty/abseil/absl/time/clock.cc | 563 +
.../backend/3rdparty/abseil/absl/time/clock.h | 72 +
.../3rdparty/abseil/absl/time/clock_test.cc | 70 +
.../3rdparty/abseil/absl/time/duration.cc | 908 +
.../3rdparty/abseil/absl/time/duration_test.cc | 1688 ++
.../backend/3rdparty/abseil/absl/time/format.cc | 142 +
.../3rdparty/abseil/absl/time/format_test.cc | 437 +
.../abseil/absl/time/internal/cctz/BUILD.bazel | 105 +
.../internal/cctz/include/cctz/civil_time.h | 329 +
.../cctz/include/cctz/civil_time_detail.h | 564 +
.../time/internal/cctz/include/cctz/time_zone.h | 316 +
.../cctz/include/cctz/zone_info_source.h | 91 +
.../time/internal/cctz/src/civil_time_detail.cc | 90 +
.../time/internal/cctz/src/civil_time_test.cc | 1049 +
.../time/internal/cctz/src/time_zone_fixed.cc | 133 +
.../time/internal/cctz/src/time_zone_fixed.h | 49 +
.../time/internal/cctz/src/time_zone_format.cc | 848 +
.../internal/cctz/src/time_zone_format_test.cc | 1408 ++
.../absl/time/internal/cctz/src/time_zone_if.cc | 41 +
.../absl/time/internal/cctz/src/time_zone_if.h | 70 +
.../time/internal/cctz/src/time_zone_impl.cc | 117 +
.../time/internal/cctz/src/time_zone_impl.h | 97 +
.../time/internal/cctz/src/time_zone_info.cc | 956 +
.../time/internal/cctz/src/time_zone_info.h | 132 +
.../time/internal/cctz/src/time_zone_libc.cc | 156 +
.../time/internal/cctz/src/time_zone_libc.h | 50 +
.../time/internal/cctz/src/time_zone_lookup.cc | 142 +
.../internal/cctz/src/time_zone_lookup_test.cc | 1259 +
.../time/internal/cctz/src/time_zone_posix.cc | 155 +
.../time/internal/cctz/src/time_zone_posix.h | 118 +
.../abseil/absl/time/internal/cctz/src/tzfile.h | 117 +
.../time/internal/cctz/src/zone_info_source.cc | 70 +
.../time/internal/cctz/testdata/README.zoneinfo | 37 +
.../absl/time/internal/cctz/testdata/version | 1 +
.../cctz/testdata/zoneinfo/Africa/Abidjan | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Accra | Bin 0 -> 842 bytes
.../cctz/testdata/zoneinfo/Africa/Addis_Ababa | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Algiers | Bin 0 -> 760 bytes
.../cctz/testdata/zoneinfo/Africa/Asmara | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Asmera | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Bamako | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Bangui | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Banjul | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Bissau | Bin 0 -> 208 bytes
.../cctz/testdata/zoneinfo/Africa/Blantyre | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Brazzaville | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Bujumbura | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Cairo | Bin 0 -> 1972 bytes
.../cctz/testdata/zoneinfo/Africa/Casablanca | Bin 0 -> 1643 bytes
.../cctz/testdata/zoneinfo/Africa/Ceuta | Bin 0 -> 2059 bytes
.../cctz/testdata/zoneinfo/Africa/Conakry | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Dakar | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Dar_es_Salaam | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Djibouti | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Douala | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/El_Aaiun | Bin 0 -> 1473 bytes
.../cctz/testdata/zoneinfo/Africa/Freetown | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Gaborone | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Harare | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Johannesburg | Bin 0 -> 271 bytes
.../internal/cctz/testdata/zoneinfo/Africa/Juba | Bin 0 -> 683 bytes
.../cctz/testdata/zoneinfo/Africa/Kampala | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Khartoum | Bin 0 -> 713 bytes
.../cctz/testdata/zoneinfo/Africa/Kigali | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Kinshasa | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lagos | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Libreville | Bin 0 -> 171 bytes
.../internal/cctz/testdata/zoneinfo/Africa/Lome | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Luanda | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lubumbashi | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lusaka | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Malabo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Maputo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Maseru | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/Africa/Mbabane | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/Africa/Mogadishu | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Monrovia | Bin 0 -> 233 bytes
.../cctz/testdata/zoneinfo/Africa/Nairobi | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Ndjamena | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Africa/Niamey | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Nouakchott | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Ouagadougou | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Porto-Novo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Sao_Tome | Bin 0 -> 234 bytes
.../cctz/testdata/zoneinfo/Africa/Timbuktu | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Tripoli | Bin 0 -> 655 bytes
.../cctz/testdata/zoneinfo/Africa/Tunis | Bin 0 -> 710 bytes
.../cctz/testdata/zoneinfo/Africa/Windhoek | Bin 0 -> 1030 bytes
.../cctz/testdata/zoneinfo/America/Adak | Bin 0 -> 2365 bytes
.../cctz/testdata/zoneinfo/America/Anchorage | Bin 0 -> 2380 bytes
.../cctz/testdata/zoneinfo/America/Anguilla | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Antigua | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Araguaina | Bin 0 -> 910 bytes
.../zoneinfo/America/Argentina/Buenos_Aires | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/Catamarca | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/ComodRivadavia | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Cordoba | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Jujuy | Bin 0 -> 1081 bytes
.../zoneinfo/America/Argentina/La_Rioja | Bin 0 -> 1123 bytes
.../testdata/zoneinfo/America/Argentina/Mendoza | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/Rio_Gallegos | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Salta | Bin 0 -> 1081 bytes
.../zoneinfo/America/Argentina/San_Juan | Bin 0 -> 1123 bytes
.../zoneinfo/America/Argentina/San_Luis | Bin 0 -> 1139 bytes
.../testdata/zoneinfo/America/Argentina/Tucuman | Bin 0 -> 1137 bytes
.../testdata/zoneinfo/America/Argentina/Ushuaia | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Aruba | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Asuncion | Bin 0 -> 2077 bytes
.../cctz/testdata/zoneinfo/America/Atikokan | Bin 0 -> 345 bytes
.../cctz/testdata/zoneinfo/America/Atka | Bin 0 -> 2365 bytes
.../cctz/testdata/zoneinfo/America/Bahia | Bin 0 -> 1050 bytes
.../testdata/zoneinfo/America/Bahia_Banderas | Bin 0 -> 1588 bytes
.../cctz/testdata/zoneinfo/America/Barbados | Bin 0 -> 344 bytes
.../cctz/testdata/zoneinfo/America/Belem | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/America/Belize | Bin 0 -> 978 bytes
.../cctz/testdata/zoneinfo/America/Blanc-Sablon | Bin 0 -> 307 bytes
.../cctz/testdata/zoneinfo/America/Boa_Vista | Bin 0 -> 658 bytes
.../cctz/testdata/zoneinfo/America/Bogota | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/America/Boise | Bin 0 -> 2403 bytes
.../cctz/testdata/zoneinfo/America/Buenos_Aires | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Cambridge_Bay | Bin 0 -> 2098 bytes
.../cctz/testdata/zoneinfo/America/Campo_Grande | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/America/Cancun | Bin 0 -> 816 bytes
.../cctz/testdata/zoneinfo/America/Caracas | Bin 0 -> 289 bytes
.../cctz/testdata/zoneinfo/America/Catamarca | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Cayenne | Bin 0 -> 224 bytes
.../cctz/testdata/zoneinfo/America/Cayman | Bin 0 -> 203 bytes
.../cctz/testdata/zoneinfo/America/Chicago | Bin 0 -> 3585 bytes
.../cctz/testdata/zoneinfo/America/Chihuahua | Bin 0 -> 1522 bytes
.../testdata/zoneinfo/America/Coral_Harbour | Bin 0 -> 345 bytes
.../cctz/testdata/zoneinfo/America/Cordoba | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Costa_Rica | Bin 0 -> 341 bytes
.../cctz/testdata/zoneinfo/America/Creston | Bin 0 -> 233 bytes
.../cctz/testdata/zoneinfo/America/Cuiaba | Bin 0 -> 1988 bytes
.../cctz/testdata/zoneinfo/America/Curacao | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Danmarkshavn | Bin 0 -> 712 bytes
.../cctz/testdata/zoneinfo/America/Dawson | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/America/Dawson_Creek | Bin 0 -> 1059 bytes
.../cctz/testdata/zoneinfo/America/Denver | Bin 0 -> 2453 bytes
.../cctz/testdata/zoneinfo/America/Detroit | Bin 0 -> 2188 bytes
.../cctz/testdata/zoneinfo/America/Dominica | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Edmonton | Bin 0 -> 2402 bytes
.../cctz/testdata/zoneinfo/America/Eirunepe | Bin 0 -> 690 bytes
.../cctz/testdata/zoneinfo/America/El_Salvador | Bin 0 -> 250 bytes
.../cctz/testdata/zoneinfo/America/Ensenada | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Fort_Nelson | Bin 0 -> 2249 bytes
.../cctz/testdata/zoneinfo/America/Fort_Wayne | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Fortaleza | Bin 0 -> 742 bytes
.../cctz/testdata/zoneinfo/America/Glace_Bay | Bin 0 -> 2206 bytes
.../cctz/testdata/zoneinfo/America/Godthab | Bin 0 -> 1892 bytes
.../cctz/testdata/zoneinfo/America/Goose_Bay | Bin 0 -> 3219 bytes
.../cctz/testdata/zoneinfo/America/Grand_Turk | Bin 0 -> 1881 bytes
.../cctz/testdata/zoneinfo/America/Grenada | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Guadeloupe | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Guatemala | Bin 0 -> 306 bytes
.../cctz/testdata/zoneinfo/America/Guayaquil | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/America/Guyana | Bin 0 -> 266 bytes
.../cctz/testdata/zoneinfo/America/Halifax | Bin 0 -> 3438 bytes
.../cctz/testdata/zoneinfo/America/Havana | Bin 0 -> 2437 bytes
.../cctz/testdata/zoneinfo/America/Hermosillo | Bin 0 -> 454 bytes
.../zoneinfo/America/Indiana/Indianapolis | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Indiana/Knox | Bin 0 -> 2437 bytes
.../testdata/zoneinfo/America/Indiana/Marengo | Bin 0 -> 1731 bytes
.../zoneinfo/America/Indiana/Petersburg | Bin 0 -> 1913 bytes
.../testdata/zoneinfo/America/Indiana/Tell_City | Bin 0 -> 1735 bytes
.../testdata/zoneinfo/America/Indiana/Vevay | Bin 0 -> 1423 bytes
.../testdata/zoneinfo/America/Indiana/Vincennes | Bin 0 -> 1703 bytes
.../testdata/zoneinfo/America/Indiana/Winamac | Bin 0 -> 1787 bytes
.../cctz/testdata/zoneinfo/America/Indianapolis | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Inuvik | Bin 0 -> 1928 bytes
.../cctz/testdata/zoneinfo/America/Iqaluit | Bin 0 -> 2046 bytes
.../cctz/testdata/zoneinfo/America/Jamaica | Bin 0 -> 507 bytes
.../cctz/testdata/zoneinfo/America/Jujuy | Bin 0 -> 1081 bytes
.../cctz/testdata/zoneinfo/America/Juneau | Bin 0 -> 2362 bytes
.../zoneinfo/America/Kentucky/Louisville | Bin 0 -> 2781 bytes
.../zoneinfo/America/Kentucky/Monticello | Bin 0 -> 2361 bytes
.../cctz/testdata/zoneinfo/America/Knox_IN | Bin 0 -> 2437 bytes
.../cctz/testdata/zoneinfo/America/Kralendijk | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/La_Paz | Bin 0 -> 257 bytes
.../cctz/testdata/zoneinfo/America/Lima | Bin 0 -> 431 bytes
.../cctz/testdata/zoneinfo/America/Los_Angeles | Bin 0 -> 2845 bytes
.../cctz/testdata/zoneinfo/America/Louisville | Bin 0 -> 2781 bytes
.../testdata/zoneinfo/America/Lower_Princes | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Maceio | Bin 0 -> 770 bytes
.../cctz/testdata/zoneinfo/America/Managua | Bin 0 -> 463 bytes
.../cctz/testdata/zoneinfo/America/Manaus | Bin 0 -> 630 bytes
.../cctz/testdata/zoneinfo/America/Marigot | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Martinique | Bin 0 -> 257 bytes
.../cctz/testdata/zoneinfo/America/Matamoros | Bin 0 -> 1416 bytes
.../cctz/testdata/zoneinfo/America/Mazatlan | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/America/Mendoza | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Menominee | Bin 0 -> 2283 bytes
.../cctz/testdata/zoneinfo/America/Merida | Bin 0 -> 1456 bytes
.../cctz/testdata/zoneinfo/America/Metlakatla | Bin 0 -> 1418 bytes
.../cctz/testdata/zoneinfo/America/Mexico_City | Bin 0 -> 1618 bytes
.../cctz/testdata/zoneinfo/America/Miquelon | Bin 0 -> 1696 bytes
.../cctz/testdata/zoneinfo/America/Moncton | Bin 0 -> 3163 bytes
.../cctz/testdata/zoneinfo/America/Monterrey | Bin 0 -> 1416 bytes
.../cctz/testdata/zoneinfo/America/Montevideo | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/America/Montreal | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/America/Montserrat | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Nassau | Bin 0 -> 2284 bytes
.../cctz/testdata/zoneinfo/America/New_York | Bin 0 -> 3545 bytes
.../cctz/testdata/zoneinfo/America/Nipigon | Bin 0 -> 2131 bytes
.../cctz/testdata/zoneinfo/America/Nome | Bin 0 -> 2376 bytes
.../cctz/testdata/zoneinfo/America/Noronha | Bin 0 -> 742 bytes
.../zoneinfo/America/North_Dakota/Beulah | Bin 0 -> 2389 bytes
.../zoneinfo/America/North_Dakota/Center | Bin 0 -> 2389 bytes
.../zoneinfo/America/North_Dakota/New_Salem | Bin 0 -> 2389 bytes
.../cctz/testdata/zoneinfo/America/Ojinaga | Bin 0 -> 1522 bytes
.../cctz/testdata/zoneinfo/America/Panama | Bin 0 -> 203 bytes
.../cctz/testdata/zoneinfo/America/Pangnirtung | Bin 0 -> 2108 bytes
.../cctz/testdata/zoneinfo/America/Paramaribo | Bin 0 -> 296 bytes
.../cctz/testdata/zoneinfo/America/Phoenix | Bin 0 -> 353 bytes
.../testdata/zoneinfo/America/Port-au-Prince | Bin 0 -> 1455 bytes
.../testdata/zoneinfo/America/Port_of_Spain | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Porto_Acre | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/America/Porto_Velho | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/America/Puerto_Rico | Bin 0 -> 255 bytes
.../cctz/testdata/zoneinfo/America/Punta_Arenas | Bin 0 -> 1911 bytes
.../cctz/testdata/zoneinfo/America/Rainy_River | Bin 0 -> 2131 bytes
.../cctz/testdata/zoneinfo/America/Rankin_Inlet | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Recife | Bin 0 -> 742 bytes
.../cctz/testdata/zoneinfo/America/Regina | Bin 0 -> 994 bytes
.../cctz/testdata/zoneinfo/America/Resolute | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Rio_Branco | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/America/Rosario | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Santa_Isabel | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Santarem | Bin 0 -> 632 bytes
.../cctz/testdata/zoneinfo/America/Santiago | Bin 0 -> 2538 bytes
.../testdata/zoneinfo/America/Santo_Domingo | Bin 0 -> 491 bytes
.../cctz/testdata/zoneinfo/America/Sao_Paulo | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/America/Scoresbysund | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Shiprock | Bin 0 -> 2453 bytes
.../cctz/testdata/zoneinfo/America/Sitka | Bin 0 -> 2350 bytes
.../testdata/zoneinfo/America/St_Barthelemy | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Johns | Bin 0 -> 3664 bytes
.../cctz/testdata/zoneinfo/America/St_Kitts | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Lucia | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Thomas | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Vincent | Bin 0 -> 170 bytes
.../testdata/zoneinfo/America/Swift_Current | Bin 0 -> 574 bytes
.../cctz/testdata/zoneinfo/America/Tegucigalpa | Bin 0 -> 278 bytes
.../cctz/testdata/zoneinfo/America/Thule | Bin 0 -> 1528 bytes
.../cctz/testdata/zoneinfo/America/Thunder_Bay | Bin 0 -> 2211 bytes
.../cctz/testdata/zoneinfo/America/Tijuana | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Toronto | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/America/Tortola | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Vancouver | Bin 0 -> 2901 bytes
.../cctz/testdata/zoneinfo/America/Virgin | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Whitehorse | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/America/Winnipeg | Bin 0 -> 2891 bytes
.../cctz/testdata/zoneinfo/America/Yakutat | Bin 0 -> 2314 bytes
.../cctz/testdata/zoneinfo/America/Yellowknife | Bin 0 -> 1980 bytes
.../cctz/testdata/zoneinfo/Antarctica/Casey | Bin 0 -> 311 bytes
.../cctz/testdata/zoneinfo/Antarctica/Davis | Bin 0 -> 311 bytes
.../testdata/zoneinfo/Antarctica/DumontDUrville | Bin 0 -> 216 bytes
.../cctz/testdata/zoneinfo/Antarctica/Macquarie | Bin 0 -> 1543 bytes
.../cctz/testdata/zoneinfo/Antarctica/Mawson | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Antarctica/McMurdo | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Antarctica/Palmer | Bin 0 -> 1432 bytes
.../cctz/testdata/zoneinfo/Antarctica/Rothera | Bin 0 -> 186 bytes
.../testdata/zoneinfo/Antarctica/South_Pole | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Antarctica/Syowa | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Antarctica/Troll | Bin 0 -> 1176 bytes
.../cctz/testdata/zoneinfo/Antarctica/Vostok | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Arctic/Longyearbyen | Bin 0 -> 2251 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aden | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Almaty | Bin 0 -> 1031 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Amman | Bin 0 -> 1877 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Anadyr | Bin 0 -> 1222 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aqtau | Bin 0 -> 1017 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aqtobe | Bin 0 -> 1047 bytes
.../cctz/testdata/zoneinfo/Asia/Ashgabat | Bin 0 -> 651 bytes
.../cctz/testdata/zoneinfo/Asia/Ashkhabad | Bin 0 -> 651 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Atyrau | Bin 0 -> 1025 bytes
.../cctz/testdata/zoneinfo/Asia/Baghdad | Bin 0 -> 1004 bytes
.../cctz/testdata/zoneinfo/Asia/Bahrain | Bin 0 -> 225 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Baku | Bin 0 -> 1269 bytes
.../cctz/testdata/zoneinfo/Asia/Bangkok | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Barnaul | Bin 0 -> 1255 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Beirut | Bin 0 -> 2175 bytes
.../cctz/testdata/zoneinfo/Asia/Bishkek | Bin 0 -> 1045 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Brunei | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Calcutta | Bin 0 -> 312 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Chita | Bin 0 -> 1257 bytes
.../cctz/testdata/zoneinfo/Asia/Choibalsan | Bin 0 -> 991 bytes
.../cctz/testdata/zoneinfo/Asia/Chongqing | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Chungking | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Colombo | Bin 0 -> 413 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dacca | Bin 0 -> 370 bytes
.../cctz/testdata/zoneinfo/Asia/Damascus | Bin 0 -> 2320 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dhaka | Bin 0 -> 370 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dili | Bin 0 -> 253 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dubai | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Dushanbe | Bin 0 -> 621 bytes
.../cctz/testdata/zoneinfo/Asia/Famagusta | Bin 0 -> 2042 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Gaza | Bin 0 -> 2295 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Harbin | Bin 0 -> 414 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Hebron | Bin 0 -> 2323 bytes
.../cctz/testdata/zoneinfo/Asia/Ho_Chi_Minh | Bin 0 -> 389 bytes
.../cctz/testdata/zoneinfo/Asia/Hong_Kong | Bin 0 -> 1189 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Hovd | Bin 0 -> 921 bytes
.../cctz/testdata/zoneinfo/Asia/Irkutsk | Bin 0 -> 1276 bytes
.../cctz/testdata/zoneinfo/Asia/Istanbul | Bin 0 -> 2166 bytes
.../cctz/testdata/zoneinfo/Asia/Jakarta | Bin 0 -> 392 bytes
.../cctz/testdata/zoneinfo/Asia/Jayapura | Bin 0 -> 251 bytes
.../cctz/testdata/zoneinfo/Asia/Jerusalem | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Kabul | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Kamchatka | Bin 0 -> 1198 bytes
.../cctz/testdata/zoneinfo/Asia/Karachi | Bin 0 -> 417 bytes
.../cctz/testdata/zoneinfo/Asia/Kashgar | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Kathmandu | Bin 0 -> 238 bytes
.../cctz/testdata/zoneinfo/Asia/Katmandu | Bin 0 -> 238 bytes
.../cctz/testdata/zoneinfo/Asia/Khandyga | Bin 0 -> 1311 bytes
.../cctz/testdata/zoneinfo/Asia/Kolkata | Bin 0 -> 312 bytes
.../cctz/testdata/zoneinfo/Asia/Krasnoyarsk | Bin 0 -> 1243 bytes
.../cctz/testdata/zoneinfo/Asia/Kuala_Lumpur | Bin 0 -> 424 bytes
.../cctz/testdata/zoneinfo/Asia/Kuching | Bin 0 -> 521 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Kuwait | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Macao | Bin 0 -> 771 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Macau | Bin 0 -> 771 bytes
.../cctz/testdata/zoneinfo/Asia/Magadan | Bin 0 -> 1258 bytes
.../cctz/testdata/zoneinfo/Asia/Makassar | Bin 0 -> 288 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Manila | Bin 0 -> 367 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Muscat | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Nicosia | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/Asia/Novokuznetsk | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Asia/Novosibirsk | Bin 0 -> 1255 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Omsk | Bin 0 -> 1243 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Oral | Bin 0 -> 1039 bytes
.../cctz/testdata/zoneinfo/Asia/Phnom_Penh | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Pontianak | Bin 0 -> 395 bytes
.../cctz/testdata/zoneinfo/Asia/Pyongyang | Bin 0 -> 272 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Qatar | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Asia/Qyzylorda | Bin 0 -> 1047 bytes
.../cctz/testdata/zoneinfo/Asia/Rangoon | Bin 0 -> 297 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Riyadh | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Saigon | Bin 0 -> 389 bytes
.../cctz/testdata/zoneinfo/Asia/Sakhalin | Bin 0 -> 1234 bytes
.../cctz/testdata/zoneinfo/Asia/Samarkand | Bin 0 -> 619 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Seoul | Bin 0 -> 531 bytes
.../cctz/testdata/zoneinfo/Asia/Shanghai | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Singapore | Bin 0 -> 424 bytes
.../cctz/testdata/zoneinfo/Asia/Srednekolymsk | Bin 0 -> 1244 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Taipei | Bin 0 -> 790 bytes
.../cctz/testdata/zoneinfo/Asia/Tashkent | Bin 0 -> 635 bytes
.../cctz/testdata/zoneinfo/Asia/Tbilisi | Bin 0 -> 1080 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tehran | Bin 0 -> 1718 bytes
.../cctz/testdata/zoneinfo/Asia/Tel_Aviv | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Thimbu | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Thimphu | Bin 0 -> 229 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tokyo | Bin 0 -> 318 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tomsk | Bin 0 -> 1255 bytes
.../cctz/testdata/zoneinfo/Asia/Ujung_Pandang | Bin 0 -> 288 bytes
.../cctz/testdata/zoneinfo/Asia/Ulaanbaatar | Bin 0 -> 921 bytes
.../cctz/testdata/zoneinfo/Asia/Ulan_Bator | Bin 0 -> 921 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Urumqi | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Ust-Nera | Bin 0 -> 1290 bytes
.../cctz/testdata/zoneinfo/Asia/Vientiane | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Vladivostok | Bin 0 -> 1244 bytes
.../cctz/testdata/zoneinfo/Asia/Yakutsk | Bin 0 -> 1243 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Yangon | Bin 0 -> 297 bytes
.../cctz/testdata/zoneinfo/Asia/Yekaterinburg | Bin 0 -> 1281 bytes
.../cctz/testdata/zoneinfo/Asia/Yerevan | Bin 0 -> 1213 bytes
.../cctz/testdata/zoneinfo/Atlantic/Azores | Bin 0 -> 3493 bytes
.../cctz/testdata/zoneinfo/Atlantic/Bermuda | Bin 0 -> 2004 bytes
.../cctz/testdata/zoneinfo/Atlantic/Canary | Bin 0 -> 1911 bytes
.../cctz/testdata/zoneinfo/Atlantic/Cape_Verde | Bin 0 -> 284 bytes
.../cctz/testdata/zoneinfo/Atlantic/Faeroe | Bin 0 -> 1829 bytes
.../cctz/testdata/zoneinfo/Atlantic/Faroe | Bin 0 -> 1829 bytes
.../cctz/testdata/zoneinfo/Atlantic/Jan_Mayen | Bin 0 -> 2251 bytes
.../cctz/testdata/zoneinfo/Atlantic/Madeira | Bin 0 -> 3484 bytes
.../cctz/testdata/zoneinfo/Atlantic/Reykjavik | Bin 0 -> 1188 bytes
.../testdata/zoneinfo/Atlantic/South_Georgia | Bin 0 -> 181 bytes
.../cctz/testdata/zoneinfo/Atlantic/St_Helena | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Atlantic/Stanley | Bin 0 -> 1251 bytes
.../cctz/testdata/zoneinfo/Australia/ACT | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Adelaide | Bin 0 -> 2238 bytes
.../cctz/testdata/zoneinfo/Australia/Brisbane | Bin 0 -> 452 bytes
.../testdata/zoneinfo/Australia/Broken_Hill | Bin 0 -> 2274 bytes
.../cctz/testdata/zoneinfo/Australia/Canberra | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Currie | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Darwin | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Australia/Eucla | Bin 0 -> 503 bytes
.../cctz/testdata/zoneinfo/Australia/Hobart | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Australia/LHI | Bin 0 -> 1889 bytes
.../cctz/testdata/zoneinfo/Australia/Lindeman | Bin 0 -> 522 bytes
.../cctz/testdata/zoneinfo/Australia/Lord_Howe | Bin 0 -> 1889 bytes
.../cctz/testdata/zoneinfo/Australia/Melbourne | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/NSW | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/North | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Australia/Perth | Bin 0 -> 479 bytes
.../cctz/testdata/zoneinfo/Australia/Queensland | Bin 0 -> 452 bytes
.../cctz/testdata/zoneinfo/Australia/South | Bin 0 -> 2238 bytes
.../cctz/testdata/zoneinfo/Australia/Sydney | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Tasmania | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Australia/Victoria | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/West | Bin 0 -> 479 bytes
.../cctz/testdata/zoneinfo/Australia/Yancowinna | Bin 0 -> 2274 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/Acre | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/Brazil/DeNoronha | Bin 0 -> 742 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/East | Bin 0 -> 2016 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/West | Bin 0 -> 630 bytes
.../time/internal/cctz/testdata/zoneinfo/CET | Bin 0 -> 2102 bytes
.../internal/cctz/testdata/zoneinfo/CST6CDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Canada/Atlantic | Bin 0 -> 3438 bytes
.../cctz/testdata/zoneinfo/Canada/Central | Bin 0 -> 2891 bytes
.../cctz/testdata/zoneinfo/Canada/Eastern | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/Canada/Mountain | Bin 0 -> 2402 bytes
.../cctz/testdata/zoneinfo/Canada/Newfoundland | Bin 0 -> 3664 bytes
.../cctz/testdata/zoneinfo/Canada/Pacific | Bin 0 -> 2901 bytes
.../cctz/testdata/zoneinfo/Canada/Saskatchewan | Bin 0 -> 994 bytes
.../cctz/testdata/zoneinfo/Canada/Yukon | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/Chile/Continental | Bin 0 -> 2538 bytes
.../cctz/testdata/zoneinfo/Chile/EasterIsland | Bin 0 -> 2242 bytes
.../time/internal/cctz/testdata/zoneinfo/Cuba | Bin 0 -> 2437 bytes
.../time/internal/cctz/testdata/zoneinfo/EET | Bin 0 -> 1876 bytes
.../time/internal/cctz/testdata/zoneinfo/EST | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/EST5EDT | Bin 0 -> 2294 bytes
.../time/internal/cctz/testdata/zoneinfo/Egypt | Bin 0 -> 1972 bytes
.../time/internal/cctz/testdata/zoneinfo/Eire | Bin 0 -> 3531 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+1 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+10 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+11 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+12 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+2 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+3 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+4 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+5 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+6 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+7 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+8 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+9 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-1 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-10 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-11 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-12 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-13 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-14 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-2 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-3 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-4 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-5 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-6 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-7 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-8 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-9 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT0 | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Etc/Greenwich | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/UCT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/UTC | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Etc/Universal | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/Zulu | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Europe/Amsterdam | Bin 0 -> 2949 bytes
.../cctz/testdata/zoneinfo/Europe/Andorra | Bin 0 -> 1751 bytes
.../cctz/testdata/zoneinfo/Europe/Astrakhan | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Europe/Athens | Bin 0 -> 2271 bytes
.../cctz/testdata/zoneinfo/Europe/Belfast | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Belgrade | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Berlin | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Europe/Bratislava | Bin 0 -> 2272 bytes
.../cctz/testdata/zoneinfo/Europe/Brussels | Bin 0 -> 2970 bytes
.../cctz/testdata/zoneinfo/Europe/Bucharest | Bin 0 -> 2221 bytes
.../cctz/testdata/zoneinfo/Europe/Budapest | Bin 0 -> 2405 bytes
.../cctz/testdata/zoneinfo/Europe/Busingen | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Chisinau | Bin 0 -> 2445 bytes
.../cctz/testdata/zoneinfo/Europe/Copenhagen | Bin 0 -> 2160 bytes
.../cctz/testdata/zoneinfo/Europe/Dublin | Bin 0 -> 3531 bytes
.../cctz/testdata/zoneinfo/Europe/Gibraltar | Bin 0 -> 3061 bytes
.../cctz/testdata/zoneinfo/Europe/Guernsey | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Helsinki | Bin 0 -> 1909 bytes
.../cctz/testdata/zoneinfo/Europe/Isle_of_Man | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Istanbul | Bin 0 -> 2166 bytes
.../cctz/testdata/zoneinfo/Europe/Jersey | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Kaliningrad | Bin 0 -> 1518 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Kiev | Bin 0 -> 2097 bytes
.../cctz/testdata/zoneinfo/Europe/Kirov | Bin 0 -> 1167 bytes
.../cctz/testdata/zoneinfo/Europe/Lisbon | Bin 0 -> 3469 bytes
.../cctz/testdata/zoneinfo/Europe/Ljubljana | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/London | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Luxembourg | Bin 0 -> 2974 bytes
.../cctz/testdata/zoneinfo/Europe/Madrid | Bin 0 -> 2637 bytes
.../cctz/testdata/zoneinfo/Europe/Malta | Bin 0 -> 2629 bytes
.../cctz/testdata/zoneinfo/Europe/Mariehamn | Bin 0 -> 1909 bytes
.../cctz/testdata/zoneinfo/Europe/Minsk | Bin 0 -> 1370 bytes
.../cctz/testdata/zoneinfo/Europe/Monaco | Bin 0 -> 2953 bytes
.../cctz/testdata/zoneinfo/Europe/Moscow | Bin 0 -> 1544 bytes
.../cctz/testdata/zoneinfo/Europe/Nicosia | Bin 0 -> 2016 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Oslo | Bin 0 -> 2251 bytes
.../cctz/testdata/zoneinfo/Europe/Paris | Bin 0 -> 2971 bytes
.../cctz/testdata/zoneinfo/Europe/Podgorica | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Prague | Bin 0 -> 2272 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Riga | Bin 0 -> 2235 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Rome | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Samara | Bin 0 -> 1253 bytes
.../cctz/testdata/zoneinfo/Europe/San_Marino | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Sarajevo | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Saratov | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Europe/Simferopol | Bin 0 -> 1490 bytes
.../cctz/testdata/zoneinfo/Europe/Skopje | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Sofia | Bin 0 -> 2130 bytes
.../cctz/testdata/zoneinfo/Europe/Stockholm | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Tallinn | Bin 0 -> 2187 bytes
.../cctz/testdata/zoneinfo/Europe/Tirane | Bin 0 -> 2098 bytes
.../cctz/testdata/zoneinfo/Europe/Tiraspol | Bin 0 -> 2445 bytes
.../cctz/testdata/zoneinfo/Europe/Ulyanovsk | Bin 0 -> 1281 bytes
.../cctz/testdata/zoneinfo/Europe/Uzhgorod | Bin 0 -> 2103 bytes
.../cctz/testdata/zoneinfo/Europe/Vaduz | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Vatican | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Vienna | Bin 0 -> 2237 bytes
.../cctz/testdata/zoneinfo/Europe/Vilnius | Bin 0 -> 2199 bytes
.../cctz/testdata/zoneinfo/Europe/Volgograd | Bin 0 -> 1167 bytes
.../cctz/testdata/zoneinfo/Europe/Warsaw | Bin 0 -> 2705 bytes
.../cctz/testdata/zoneinfo/Europe/Zagreb | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Zaporozhye | Bin 0 -> 2115 bytes
.../cctz/testdata/zoneinfo/Europe/Zurich | Bin 0 -> 1918 bytes
.../internal/cctz/testdata/zoneinfo/Factory | Bin 0 -> 148 bytes
.../time/internal/cctz/testdata/zoneinfo/GB | Bin 0 -> 3687 bytes
.../internal/cctz/testdata/zoneinfo/GB-Eire | Bin 0 -> 3687 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT+0 | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT-0 | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Greenwich | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/HST | Bin 0 -> 128 bytes
.../internal/cctz/testdata/zoneinfo/Hongkong | Bin 0 -> 1189 bytes
.../internal/cctz/testdata/zoneinfo/Iceland | Bin 0 -> 1188 bytes
.../cctz/testdata/zoneinfo/Indian/Antananarivo | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Chagos | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Indian/Christmas | Bin 0 -> 182 bytes
.../cctz/testdata/zoneinfo/Indian/Cocos | Bin 0 -> 191 bytes
.../cctz/testdata/zoneinfo/Indian/Comoro | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Kerguelen | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Indian/Mahe | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Indian/Maldives | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Indian/Mauritius | Bin 0 -> 267 bytes
.../cctz/testdata/zoneinfo/Indian/Mayotte | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Reunion | Bin 0 -> 187 bytes
.../time/internal/cctz/testdata/zoneinfo/Iran | Bin 0 -> 1718 bytes
.../time/internal/cctz/testdata/zoneinfo/Israel | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Jamaica | Bin 0 -> 507 bytes
.../time/internal/cctz/testdata/zoneinfo/Japan | Bin 0 -> 318 bytes
.../internal/cctz/testdata/zoneinfo/Kwajalein | Bin 0 -> 259 bytes
.../time/internal/cctz/testdata/zoneinfo/Libya | Bin 0 -> 655 bytes
.../time/internal/cctz/testdata/zoneinfo/MET | Bin 0 -> 2102 bytes
.../time/internal/cctz/testdata/zoneinfo/MST | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/MST7MDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Mexico/BajaNorte | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/Mexico/BajaSur | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/Mexico/General | Bin 0 -> 1618 bytes
.../time/internal/cctz/testdata/zoneinfo/NZ | Bin 0 -> 2460 bytes
.../internal/cctz/testdata/zoneinfo/NZ-CHAT | Bin 0 -> 2087 bytes
.../time/internal/cctz/testdata/zoneinfo/Navajo | Bin 0 -> 2453 bytes
.../time/internal/cctz/testdata/zoneinfo/PRC | Bin 0 -> 414 bytes
.../internal/cctz/testdata/zoneinfo/PST8PDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Pacific/Apia | Bin 0 -> 1134 bytes
.../cctz/testdata/zoneinfo/Pacific/Auckland | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Pacific/Bougainville | Bin 0 -> 296 bytes
.../cctz/testdata/zoneinfo/Pacific/Chatham | Bin 0 -> 2087 bytes
.../cctz/testdata/zoneinfo/Pacific/Chuuk | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Easter | Bin 0 -> 2242 bytes
.../cctz/testdata/zoneinfo/Pacific/Efate | Bin 0 -> 492 bytes
.../cctz/testdata/zoneinfo/Pacific/Enderbury | Bin 0 -> 259 bytes
.../cctz/testdata/zoneinfo/Pacific/Fakaofo | Bin 0 -> 221 bytes
.../cctz/testdata/zoneinfo/Pacific/Fiji | Bin 0 -> 1104 bytes
.../cctz/testdata/zoneinfo/Pacific/Funafuti | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Galapagos | Bin 0 -> 268 bytes
.../cctz/testdata/zoneinfo/Pacific/Gambier | Bin 0 -> 186 bytes
.../cctz/testdata/zoneinfo/Pacific/Guadalcanal | Bin 0 -> 188 bytes
.../cctz/testdata/zoneinfo/Pacific/Guam | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Pacific/Honolulu | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/Pacific/Johnston | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/Pacific/Kiritimati | Bin 0 -> 263 bytes
.../cctz/testdata/zoneinfo/Pacific/Kosrae | Bin 0 -> 251 bytes
.../cctz/testdata/zoneinfo/Pacific/Kwajalein | Bin 0 -> 259 bytes
.../cctz/testdata/zoneinfo/Pacific/Majuro | Bin 0 -> 221 bytes
.../cctz/testdata/zoneinfo/Pacific/Marquesas | Bin 0 -> 195 bytes
.../cctz/testdata/zoneinfo/Pacific/Midway | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Nauru | Bin 0 -> 282 bytes
.../cctz/testdata/zoneinfo/Pacific/Niue | Bin 0 -> 266 bytes
.../cctz/testdata/zoneinfo/Pacific/Norfolk | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Pacific/Noumea | Bin 0 -> 328 bytes
.../cctz/testdata/zoneinfo/Pacific/Pago_Pago | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Palau | Bin 0 -> 182 bytes
.../cctz/testdata/zoneinfo/Pacific/Pitcairn | Bin 0 -> 223 bytes
.../cctz/testdata/zoneinfo/Pacific/Pohnpei | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Ponape | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Port_Moresby | Bin 0 -> 206 bytes
.../cctz/testdata/zoneinfo/Pacific/Rarotonga | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/Pacific/Saipan | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Pacific/Samoa | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Tahiti | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Pacific/Tarawa | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Tongatapu | Bin 0 -> 393 bytes
.../cctz/testdata/zoneinfo/Pacific/Truk | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Wake | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Wallis | Bin 0 -> 183 bytes
.../internal/cctz/testdata/zoneinfo/Pacific/Yap | Bin 0 -> 183 bytes
.../time/internal/cctz/testdata/zoneinfo/Poland | Bin 0 -> 2705 bytes
.../internal/cctz/testdata/zoneinfo/Portugal | Bin 0 -> 3469 bytes
.../time/internal/cctz/testdata/zoneinfo/ROC | Bin 0 -> 790 bytes
.../time/internal/cctz/testdata/zoneinfo/ROK | Bin 0 -> 531 bytes
.../internal/cctz/testdata/zoneinfo/Singapore | Bin 0 -> 424 bytes
.../time/internal/cctz/testdata/zoneinfo/Turkey | Bin 0 -> 2166 bytes
.../time/internal/cctz/testdata/zoneinfo/UCT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/US/Alaska | Bin 0 -> 2380 bytes
.../internal/cctz/testdata/zoneinfo/US/Aleutian | Bin 0 -> 2365 bytes
.../internal/cctz/testdata/zoneinfo/US/Arizona | Bin 0 -> 353 bytes
.../internal/cctz/testdata/zoneinfo/US/Central | Bin 0 -> 3585 bytes
.../cctz/testdata/zoneinfo/US/East-Indiana | Bin 0 -> 1675 bytes
.../internal/cctz/testdata/zoneinfo/US/Eastern | Bin 0 -> 3545 bytes
.../internal/cctz/testdata/zoneinfo/US/Hawaii | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/US/Indiana-Starke | Bin 0 -> 2437 bytes
.../internal/cctz/testdata/zoneinfo/US/Michigan | Bin 0 -> 2188 bytes
.../internal/cctz/testdata/zoneinfo/US/Mountain | Bin 0 -> 2453 bytes
.../internal/cctz/testdata/zoneinfo/US/Pacific | Bin 0 -> 2845 bytes
.../internal/cctz/testdata/zoneinfo/US/Samoa | Bin 0 -> 196 bytes
.../time/internal/cctz/testdata/zoneinfo/UTC | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Universal | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/W-SU | Bin 0 -> 1544 bytes
.../time/internal/cctz/testdata/zoneinfo/WET | Bin 0 -> 1873 bytes
.../time/internal/cctz/testdata/zoneinfo/Zulu | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/iso3166.tab | 274 +
.../internal/cctz/testdata/zoneinfo/localtime | Bin 0 -> 148 bytes
.../cctz/testdata/zoneinfo/zone1970.tab | 382 +
.../absl/time/internal/get_current_time_ios.inc | 80 +
.../time/internal/get_current_time_posix.inc | 22 +
.../time/internal/get_current_time_windows.inc | 17 +
.../abseil/absl/time/internal/test_util.cc | 123 +
.../abseil/absl/time/internal/test_util.h | 49 +
.../abseil/absl/time/internal/zoneinfo.inc | 729 +
.../backend/3rdparty/abseil/absl/time/time.cc | 385 +
.../backend/3rdparty/abseil/absl/time/time.h | 1342 ++
.../3rdparty/abseil/absl/time/time_norm_test.cc | 306 +
.../3rdparty/abseil/absl/time/time_test.cc | 1088 +
.../3rdparty/abseil/absl/time/time_zone_test.cc | 97 +
.../3rdparty/abseil/absl/types/BUILD.bazel | 225 +
.../3rdparty/abseil/absl/types/CMakeLists.txt | 201 +
.../backend/3rdparty/abseil/absl/types/any.h | 539 +
.../absl/types/any_exception_safety_test.cc | 166 +
.../3rdparty/abseil/absl/types/any_test.cc | 724 +
.../3rdparty/abseil/absl/types/bad_any_cast.cc | 40 +
.../3rdparty/abseil/absl/types/bad_any_cast.h | 57 +
.../abseil/absl/types/bad_optional_access.cc | 42 +
.../abseil/absl/types/bad_optional_access.h | 60 +
.../abseil/absl/types/bad_variant_access.cc | 58 +
.../abseil/absl/types/bad_variant_access.h | 64 +
.../abseil/absl/types/internal/variant.h | 1387 ++
.../3rdparty/abseil/absl/types/optional.cc | 24 +
.../3rdparty/abseil/absl/types/optional.h | 1131 +
.../3rdparty/abseil/absl/types/optional_test.cc | 1625 ++
.../backend/3rdparty/abseil/absl/types/span.h | 748 +
.../3rdparty/abseil/absl/types/span_test.cc | 781 +
.../3rdparty/abseil/absl/types/variant.h | 838 +
.../3rdparty/abseil/absl/types/variant_test.cc | 2612 ++
.../3rdparty/abseil/absl/utility/BUILD.bazel | 33 +
.../3rdparty/abseil/absl/utility/CMakeLists.txt | 45 +
.../3rdparty/abseil/absl/utility/utility.h | 291 +
.../abseil/absl/utility/utility_test.cc | 345 +
.../ostrich/backend/3rdparty/gtest/.gitignore | 40 +
.../ostrich/backend/3rdparty/gtest/.travis.yml | 78 +
.../ostrich/backend/3rdparty/gtest/BUILD.bazel | 175 +
.../backend/3rdparty/gtest/CMakeLists.txt | 33 +
.../backend/3rdparty/gtest/CONTRIBUTING.md | 160 +
.../ostrich/backend/3rdparty/gtest/LICENSE | 28 +
.../ostrich/backend/3rdparty/gtest/Makefile.am | 14 +
.../ostrich/backend/3rdparty/gtest/README.md | 122 +
.../ostrich/backend/3rdparty/gtest/WORKSPACE | 8 +
.../ostrich/backend/3rdparty/gtest/appveyor.yml | 99 +
.../3rdparty/gtest/ci/build-linux-autotools.sh | 44 +
.../3rdparty/gtest/ci/build-linux-bazel.sh | 36 +
.../backend/3rdparty/gtest/ci/env-linux.sh | 41 +
.../backend/3rdparty/gtest/ci/env-osx.sh | 40 +
.../3rdparty/gtest/ci/get-nprocessors.sh | 48 +
.../backend/3rdparty/gtest/ci/install-linux.sh | 49 +
.../backend/3rdparty/gtest/ci/install-osx.sh | 39 +
.../backend/3rdparty/gtest/ci/log-config.sh | 51 +
.../ostrich/backend/3rdparty/gtest/ci/travis.sh | 36 +
.../ostrich/backend/3rdparty/gtest/configure.ac | 16 +
.../backend/3rdparty/gtest/googlemock/CHANGES | 126 +
.../3rdparty/gtest/googlemock/CMakeLists.txt | 242 +
.../3rdparty/gtest/googlemock/CONTRIBUTORS | 40 +
.../backend/3rdparty/gtest/googlemock/LICENSE | 28 +
.../3rdparty/gtest/googlemock/Makefile.am | 224 +
.../backend/3rdparty/gtest/googlemock/README.md | 344 +
.../3rdparty/gtest/googlemock/cmake/gmock.pc.in | 9 +
.../gtest/googlemock/cmake/gmock_main.pc.in | 9 +
.../3rdparty/gtest/googlemock/configure.ac | 146 +
.../gtest/googlemock/docs/CheatSheet.md | 564 +
.../3rdparty/gtest/googlemock/docs/CookBook.md | 3660 +++
.../3rdparty/gtest/googlemock/docs/DesignDoc.md | 280 +
.../gtest/googlemock/docs/Documentation.md | 15 +
.../gtest/googlemock/docs/ForDummies.md | 447 +
.../googlemock/docs/FrequentlyAskedQuestions.md | 628 +
.../gtest/googlemock/docs/KnownIssues.md | 19 +
.../googlemock/include/gmock/gmock-actions.h | 1262 +
.../include/gmock/gmock-cardinalities.h | 147 +
.../include/gmock/gmock-generated-actions.h | 2571 ++
.../gmock/gmock-generated-actions.h.pump | 833 +
.../gmock/gmock-generated-function-mockers.h | 1379 ++
.../gmock-generated-function-mockers.h.pump | 347 +
.../include/gmock/gmock-generated-matchers.h | 2258 ++
.../gmock/gmock-generated-matchers.h.pump | 675 +
.../include/gmock/gmock-generated-nice-strict.h | 458 +
.../gmock/gmock-generated-nice-strict.h.pump | 178 +
.../googlemock/include/gmock/gmock-matchers.h | 5255 ++++
.../include/gmock/gmock-more-actions.h | 246 +
.../include/gmock/gmock-more-matchers.h | 91 +
.../include/gmock/gmock-spec-builders.h | 1918 ++
.../gtest/googlemock/include/gmock/gmock.h | 95 +
.../internal/custom/gmock-generated-actions.h | 8 +
.../custom/gmock-generated-actions.h.pump | 10 +
.../gmock/internal/custom/gmock-matchers.h | 38 +
.../include/gmock/internal/custom/gmock-port.h | 46 +
.../internal/gmock-generated-internal-utils.h | 286 +
.../gmock-generated-internal-utils.h.pump | 136 +
.../gmock/internal/gmock-internal-utils.h | 574 +
.../include/gmock/internal/gmock-port.h | 87 +
.../3rdparty/gtest/googlemock/make/Makefile | 101 +
.../gtest/googlemock/msvc/2005/gmock.sln | 32 +
.../gtest/googlemock/msvc/2005/gmock.vcproj | 191 +
.../googlemock/msvc/2005/gmock_config.vsprops | 15 +
.../googlemock/msvc/2005/gmock_main.vcproj | 187 +
.../googlemock/msvc/2005/gmock_test.vcproj | 201 +
.../gtest/googlemock/msvc/2010/gmock.sln | 46 +
.../gtest/googlemock/msvc/2010/gmock.vcxproj | 145 +
.../googlemock/msvc/2010/gmock_config.props | 19 +
.../googlemock/msvc/2010/gmock_main.vcxproj | 151 +
.../googlemock/msvc/2010/gmock_test.vcxproj | 176 +
.../gtest/googlemock/msvc/2015/gmock.sln | 46 +
.../gtest/googlemock/msvc/2015/gmock.vcxproj | 145 +
.../googlemock/msvc/2015/gmock_config.props | 19 +
.../googlemock/msvc/2015/gmock_main.vcxproj | 151 +
.../googlemock/msvc/2015/gmock_test.vcxproj | 176 +
.../googlemock/scripts/fuse_gmock_files.py | 240 +
.../gtest/googlemock/scripts/generator/LICENSE | 203 +
.../gtest/googlemock/scripts/generator/README | 35 +
.../scripts/generator/README.cppclean | 115 +
.../scripts/generator/cpp/__init__.py | 0
.../googlemock/scripts/generator/cpp/ast.py | 1733 ++
.../scripts/generator/cpp/gmock_class.py | 227 +
.../scripts/generator/cpp/gmock_class_test.py | 448 +
.../scripts/generator/cpp/keywords.py | 59 +
.../scripts/generator/cpp/tokenize.py | 287 +
.../googlemock/scripts/generator/cpp/utils.py | 41 +
.../googlemock/scripts/generator/gmock_gen.py | 31 +
.../gtest/googlemock/scripts/gmock-config.in | 303 +
.../gtest/googlemock/scripts/gmock_doctor.py | 640 +
.../3rdparty/gtest/googlemock/scripts/upload.py | 1387 ++
.../gtest/googlemock/scripts/upload_gmock.py | 78 +
.../3rdparty/gtest/googlemock/src/gmock-all.cc | 47 +
.../gtest/googlemock/src/gmock-cardinalities.cc | 156 +
.../googlemock/src/gmock-internal-utils.cc | 204 +
.../gtest/googlemock/src/gmock-matchers.cc | 573 +
.../gtest/googlemock/src/gmock-spec-builders.cc | 883 +
.../3rdparty/gtest/googlemock/src/gmock.cc | 205 +
.../3rdparty/gtest/googlemock/src/gmock_main.cc | 54 +
.../3rdparty/gtest/googlemock/test/BUILD.bazel | 123 +
.../gtest/googlemock/test/gmock-actions_test.cc | 1575 ++
.../googlemock/test/gmock-cardinalities_test.cc | 428 +
.../test/gmock-generated-actions_test.cc | 1230 +
.../gmock-generated-function-mockers_test.cc | 647 +
.../test/gmock-generated-internal-utils_test.cc | 129 +
.../test/gmock-generated-matchers_test.cc | 1341 ++
.../test/gmock-internal-utils_test.cc | 718 +
.../googlemock/test/gmock-matchers_test.cc | 6769 ++++++
.../googlemock/test/gmock-more-actions_test.cc | 710 +
.../googlemock/test/gmock-nice-strict_test.cc | 511 +
.../gtest/googlemock/test/gmock-port_test.cc | 43 +
.../googlemock/test/gmock-spec-builders_test.cc | 2771 +++
.../gtest/googlemock/test/gmock_all_test.cc | 51 +
.../gtest/googlemock/test/gmock_ex_test.cc | 81 +
.../gtest/googlemock/test/gmock_leak_test.py | 108 +
.../gtest/googlemock/test/gmock_leak_test_.cc | 100 +
.../gtest/googlemock/test/gmock_link2_test.cc | 40 +
.../gtest/googlemock/test/gmock_link_test.cc | 40 +
.../gtest/googlemock/test/gmock_link_test.h | 691 +
.../gtest/googlemock/test/gmock_output_test.py | 183 +
.../gtest/googlemock/test/gmock_output_test_.cc | 310 +
.../test/gmock_output_test_golden.txt | 317 +
.../gtest/googlemock/test/gmock_stress_test.cc | 323 +
.../gtest/googlemock/test/gmock_test.cc | 262 +
.../gtest/googlemock/test/gmock_test_utils.py | 110 +
.../backend/3rdparty/gtest/googletest/CHANGES | 157 +
.../3rdparty/gtest/googletest/CMakeLists.txt | 312 +
.../3rdparty/gtest/googletest/CONTRIBUTORS | 37 +
.../backend/3rdparty/gtest/googletest/LICENSE | 28 +
.../3rdparty/gtest/googletest/Makefile.am | 339 +
.../backend/3rdparty/gtest/googletest/README.md | 360 +
.../3rdparty/gtest/googletest/cmake/gtest.pc.in | 9 +
.../gtest/googletest/cmake/gtest_main.pc.in | 10 +
.../gtest/googletest/cmake/internal_utils.cmake | 280 +
.../gtest/googletest/codegear/gtest.cbproj | 138 +
.../gtest/googletest/codegear/gtest.groupproj | 54 +
.../gtest/googletest/codegear/gtest_all.cc | 38 +
.../gtest/googletest/codegear/gtest_link.cc | 40 +
.../gtest/googletest/codegear/gtest_main.cbproj | 82 +
.../googletest/codegear/gtest_unittest.cbproj | 88 +
.../3rdparty/gtest/googletest/configure.ac | 68 +
.../gtest/googletest/docs/AdvancedGuide.md | 2416 ++
.../gtest/googletest/docs/Documentation.md | 16 +
.../3rdparty/gtest/googletest/docs/FAQ.md | 1092 +
.../3rdparty/gtest/googletest/docs/Pkgconfig.md | 146 +
.../3rdparty/gtest/googletest/docs/Primer.md | 536 +
.../gtest/googletest/docs/PumpManual.md | 177 +
.../3rdparty/gtest/googletest/docs/Samples.md | 14 +
.../gtest/googletest/docs/XcodeGuide.md | 93 +
.../googletest/include/gtest/gtest-death-test.h | 342 +
.../googletest/include/gtest/gtest-message.h | 249 +
.../googletest/include/gtest/gtest-param-test.h | 1438 ++
.../include/gtest/gtest-param-test.h.pump | 501 +
.../googletest/include/gtest/gtest-printers.h | 1078 +
.../gtest/googletest/include/gtest/gtest-spi.h | 231 +
.../googletest/include/gtest/gtest-test-part.h | 179 +
.../googletest/include/gtest/gtest-typed-test.h | 264 +
.../gtest/googletest/include/gtest/gtest.h | 2330 ++
.../googletest/include/gtest/gtest_pred_impl.h | 357 +
.../gtest/googletest/include/gtest/gtest_prod.h | 61 +
.../include/gtest/internal/custom/gtest-port.h | 75 +
.../gtest/internal/custom/gtest-printers.h | 42 +
.../include/gtest/internal/custom/gtest.h | 45 +
.../gtest/internal/gtest-death-test-internal.h | 275 +
.../include/gtest/internal/gtest-filepath.h | 205 +
.../include/gtest/internal/gtest-internal.h | 1277 +
.../include/gtest/internal/gtest-linked_ptr.h | 243 +
.../gtest/internal/gtest-param-util-generated.h | 5139 ++++
.../internal/gtest-param-util-generated.h.pump | 279 +
.../include/gtest/internal/gtest-param-util.h | 723 +
.../include/gtest/internal/gtest-port-arch.h | 100 +
.../include/gtest/internal/gtest-port.h | 2686 +++
.../include/gtest/internal/gtest-string.h | 167 +
.../include/gtest/internal/gtest-tuple.h | 1020 +
.../include/gtest/internal/gtest-tuple.h.pump | 347 +
.../include/gtest/internal/gtest-type-util.h | 3331 +++
.../gtest/internal/gtest-type-util.h.pump | 297 +
.../3rdparty/gtest/googletest/m4/acx_pthread.m4 | 363 +
.../3rdparty/gtest/googletest/m4/gtest.m4 | 74 +
.../3rdparty/gtest/googletest/make/Makefile | 82 +
.../gtest/googletest/msvc/2010/gtest-md.sln | 55 +
.../gtest/googletest/msvc/2010/gtest-md.vcxproj | 149 +
.../msvc/2010/gtest-md.vcxproj.filters | 18 +
.../gtest/googletest/msvc/2010/gtest.sln | 55 +
.../gtest/googletest/msvc/2010/gtest.vcxproj | 149 +
.../googletest/msvc/2010/gtest.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_main-md.vcxproj | 154 +
.../msvc/2010/gtest_main-md.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_main.vcxproj | 162 +
.../msvc/2010/gtest_main.vcxproj.filters | 18 +
.../msvc/2010/gtest_prod_test-md.vcxproj | 199 +
.../2010/gtest_prod_test-md.vcxproj.filters | 26 +
.../msvc/2010/gtest_prod_test.vcxproj | 191 +
.../msvc/2010/gtest_prod_test.vcxproj.filters | 26 +
.../msvc/2010/gtest_unittest-md.vcxproj | 188 +
.../msvc/2010/gtest_unittest-md.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_unittest.vcxproj | 180 +
.../msvc/2010/gtest_unittest.vcxproj.filters | 18 +
.../gtest/googletest/samples/prime_tables.h | 127 +
.../gtest/googletest/samples/sample1.cc | 68 +
.../3rdparty/gtest/googletest/samples/sample1.h | 43 +
.../googletest/samples/sample10_unittest.cc | 140 +
.../googletest/samples/sample1_unittest.cc | 154 +
.../gtest/googletest/samples/sample2.cc | 56 +
.../3rdparty/gtest/googletest/samples/sample2.h | 85 +
.../googletest/samples/sample2_unittest.cc | 110 +
.../gtest/googletest/samples/sample3-inl.h | 172 +
.../googletest/samples/sample3_unittest.cc | 152 +
.../gtest/googletest/samples/sample4.cc | 46 +
.../3rdparty/gtest/googletest/samples/sample4.h | 53 +
.../googletest/samples/sample4_unittest.cc | 49 +
.../googletest/samples/sample5_unittest.cc | 199 +
.../googletest/samples/sample6_unittest.cc | 225 +
.../googletest/samples/sample7_unittest.cc | 118 +
.../googletest/samples/sample8_unittest.cc | 174 +
.../googletest/samples/sample9_unittest.cc | 157 +
.../3rdparty/gtest/googletest/scripts/common.py | 83 +
.../googletest/scripts/fuse_gtest_files.py | 253 +
.../googletest/scripts/gen_gtest_pred_impl.py | 730 +
.../gtest/googletest/scripts/gtest-config.in | 274 +
.../3rdparty/gtest/googletest/scripts/pump.py | 855 +
.../gtest/googletest/scripts/release_docs.py | 158 +
.../gtest/googletest/scripts/test/Makefile | 59 +
.../3rdparty/gtest/googletest/scripts/upload.py | 1387 ++
.../gtest/googletest/scripts/upload_gtest.py | 78 +
.../3rdparty/gtest/googletest/src/gtest-all.cc | 48 +
.../gtest/googletest/src/gtest-death-test.cc | 1346 ++
.../gtest/googletest/src/gtest-filepath.cc | 385 +
.../gtest/googletest/src/gtest-internal-inl.h | 1175 +
.../3rdparty/gtest/googletest/src/gtest-port.cc | 1253 +
.../gtest/googletest/src/gtest-printers.cc | 458 +
.../gtest/googletest/src/gtest-test-part.cc | 102 +
.../gtest/googletest/src/gtest-typed-test.cc | 119 +
.../3rdparty/gtest/googletest/src/gtest.cc | 5841 +++++
.../3rdparty/gtest/googletest/src/gtest_main.cc | 38 +
.../3rdparty/gtest/googletest/test/BUILD.bazel | 380 +
.../googletest/test/gtest-death-test_ex_test.cc | 93 +
.../googletest/test/gtest-death-test_test.cc | 1423 ++
.../googletest/test/gtest-filepath_test.cc | 652 +
.../googletest/test/gtest-linked_ptr_test.cc | 154 +
.../googletest/test/gtest-listener_test.cc | 311 +
.../gtest/googletest/test/gtest-message_test.cc | 159 +
.../gtest/googletest/test/gtest-options_test.cc | 207 +
.../googletest/test/gtest-param-test2_test.cc | 61 +
.../googletest/test/gtest-param-test_test.cc | 1110 +
.../googletest/test/gtest-param-test_test.h | 53 +
.../gtest/googletest/test/gtest-port_test.cc | 1303 +
.../googletest/test/gtest-printers_test.cc | 1731 ++
.../googletest/test/gtest-test-part_test.cc | 208 +
.../gtest/googletest/test/gtest-tuple_test.cc | 320 +
.../googletest/test/gtest-typed-test2_test.cc | 45 +
.../googletest/test/gtest-typed-test_test.cc | 380 +
.../googletest/test/gtest-typed-test_test.h | 66 +
.../googletest/test/gtest-unittest-api_test.cc | 341 +
.../gtest/googletest/test/gtest_all_test.cc | 47 +
.../test/gtest_assert_by_exception_test.cc | 119 +
.../test/gtest_break_on_failure_unittest.py | 210 +
.../test/gtest_break_on_failure_unittest_.cc | 87 +
.../test/gtest_catch_exceptions_test.py | 235 +
.../test/gtest_catch_exceptions_test_.cc | 311 +
.../gtest/googletest/test/gtest_color_test.py | 129 +
.../gtest/googletest/test/gtest_color_test_.cc | 63 +
.../gtest/googletest/test/gtest_env_var_test.py | 119 +
.../googletest/test/gtest_env_var_test_.cc | 124 +
.../googletest/test/gtest_environment_test.cc | 189 +
.../googletest/test/gtest_filter_unittest.py | 638 +
.../googletest/test/gtest_filter_unittest_.cc | 138 +
.../gtest/googletest/test/gtest_help_test.py | 172 +
.../gtest/googletest/test/gtest_help_test_.cc | 46 +
.../googletest/test/gtest_json_outfiles_test.py | 162 +
.../test/gtest_json_output_unittest.py | 611 +
.../googletest/test/gtest_json_test_utils.py | 60 +
.../test/gtest_list_tests_unittest.py | 207 +
.../test/gtest_list_tests_unittest_.cc | 157 +
.../googletest/test/gtest_main_unittest.cc | 45 +
.../googletest/test/gtest_no_test_unittest.cc | 56 +
.../gtest/googletest/test/gtest_output_test.py | 344 +
.../gtest/googletest/test/gtest_output_test_.cc | 1067 +
.../test/gtest_output_test_golden_lin.txt | 781 +
.../googletest/test/gtest_pred_impl_unittest.cc | 2427 ++
.../test/gtest_premature_exit_test.cc | 127 +
.../gtest/googletest/test/gtest_prod_test.cc | 57 +
.../gtest/googletest/test/gtest_repeat_test.cc | 236 +
.../gtest/googletest/test/gtest_shuffle_test.py | 325 +
.../googletest/test/gtest_shuffle_test_.cc | 103 +
.../googletest/test/gtest_sole_header_test.cc | 57 +
.../gtest/googletest/test/gtest_stress_test.cc | 250 +
.../gtest/googletest/test/gtest_test_utils.py | 318 +
.../test/gtest_throw_on_failure_ex_test.cc | 92 +
.../test/gtest_throw_on_failure_test.py | 171 +
.../test/gtest_throw_on_failure_test_.cc | 72 +
.../googletest/test/gtest_uninitialized_test.py | 69 +
.../test/gtest_uninitialized_test_.cc | 43 +
.../gtest/googletest/test/gtest_unittest.cc | 7750 ++++++
.../googletest/test/gtest_xml_outfile1_test_.cc | 48 +
.../googletest/test/gtest_xml_outfile2_test_.cc | 48 +
.../googletest/test/gtest_xml_outfiles_test.py | 140 +
.../test/gtest_xml_output_unittest.py | 378 +
.../test/gtest_xml_output_unittest_.cc | 179 +
.../googletest/test/gtest_xml_test_utils.py | 196 +
.../gtest/googletest/test/production.cc | 36 +
.../3rdparty/gtest/googletest/test/production.h | 55 +
.../xcode/Config/DebugProject.xcconfig | 30 +
.../xcode/Config/FrameworkTarget.xcconfig | 17 +
.../googletest/xcode/Config/General.xcconfig | 41 +
.../xcode/Config/ReleaseProject.xcconfig | 32 +
.../xcode/Config/StaticLibraryTarget.xcconfig | 18 +
.../googletest/xcode/Config/TestTarget.xcconfig | 8 +
.../gtest/googletest/xcode/Resources/Info.plist | 30 +
.../xcode/Samples/FrameworkSample/Info.plist | 28 +
.../WidgetFramework.xcodeproj/project.pbxproj | 457 +
.../xcode/Samples/FrameworkSample/runtests.sh | 62 +
.../xcode/Samples/FrameworkSample/widget.cc | 63 +
.../xcode/Samples/FrameworkSample/widget.h | 59 +
.../Samples/FrameworkSample/widget_test.cc | 68 +
.../gtest/googletest/xcode/Scripts/runtests.sh | 65 +
.../googletest/xcode/Scripts/versiongenerate.py | 100 +
.../xcode/gtest.xcodeproj/project.pbxproj | 1182 +
libraries/ostrich/backend/CMakeLists.txt | 9 +-
libraries/ostrich/backend/model/CMakeLists.txt | 2 +-
libraries/ostrich/backend/model/rdf_model.cc | 25 +-
.../ostrich/backend/model/rdf_namespaces.cc | 11 +-
.../ostrich/backend/model/rdf_namespaces.h | 76 +-
libraries/ostrich/backend/parser/CMakeLists.txt | 2 +-
libraries/ostrich/backend/parser/rdf_parser.cc | 7 +-
libraries/ostrich/backend/parser/rdf_parser.h | 4 +-
.../backend/persistence/base_persistence.cc | 19 +-
.../backend/persistence/leveldb_server.cc | 1 +
.../ostrich/backend/sharding/CMakeLists.txt | 2 +-
libraries/ostrich/backend/sharding/server.cc | 6 +-
.../ostrich/backend/sparql/rasqal_model.cc | 2 +-
libraries/ostrich/backend/test/CMakeLists.txt | 23 +-
libraries/ostrich/backend/test/LevelDBTest.cc | 20 +-
libraries/ostrich/backend/test/NamespaceTest.cc | 21 +-
.../ostrich/backend/test/PersistenceTest.cc | 20 +-
libraries/ostrich/backend/test/SparqlTest.cc | 20 +-
libraries/ostrich/backend/test/StatementTest.cc | 21 +-
.../ostrich/backend/test/gmock-gtest-all.cc | 12243 ----------
libraries/ostrich/backend/test/gmock/gmock.h | 14978 ------------
libraries/ostrich/backend/test/gtest/gtest.h | 21197 -----------------
libraries/ostrich/backend/test/main.cc | 20 +-
libraries/ostrich/backend/util/CMakeLists.txt | 2 +-
libraries/ostrich/backend/util/raptor_util.cc | 2 +-
libraries/ostrich/backend/util/split.cc | 40 -
libraries/ostrich/backend/util/split.h | 38 -
libraries/ostrich/backend/util/time_logger.cc | 21 +-
libraries/ostrich/backend/util/time_logger.h | 21 +-
1245 files changed, 224954 insertions(+), 48609 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/.clang-format
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/.clang-format b/libraries/ostrich/backend/3rdparty/abseil/.clang-format
new file mode 100644
index 0000000..06ea346
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/.clang-format
@@ -0,0 +1,4 @@
+---
+Language: Cpp
+BasedOnStyle: Google
+...
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/.gitignore
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/.gitignore b/libraries/ostrich/backend/3rdparty/abseil/.gitignore
new file mode 100644
index 0000000..886f443
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/.gitignore
@@ -0,0 +1,2 @@
+# Ignore all bazel-* symlinks.
+/bazel-*
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/ABSEIL_ISSUE_TEMPLATE.md
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/ABSEIL_ISSUE_TEMPLATE.md b/libraries/ostrich/backend/3rdparty/abseil/ABSEIL_ISSUE_TEMPLATE.md
new file mode 100644
index 0000000..ed5461f
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/ABSEIL_ISSUE_TEMPLATE.md
@@ -0,0 +1,22 @@
+Please submit a new Abseil Issue using the template below:
+
+## [Short title of proposed API change(s)]
+
+--------------------------------------------------------------------------------
+--------------------------------------------------------------------------------
+
+## Background
+
+[Provide the background information that is required in order to evaluate the
+proposed API changes. No controversial claims should be made here. If there are
+design constraints that need to be considered, they should be presented here
+**along with justification for those constraints**. Linking to other docs is
+good, but please keep the **pertinent information as self contained** as
+possible in this section.]
+
+## Proposed API Change (s)
+
+[Please clearly describe the API change(s) being proposed. If multiple changes,
+please keep them clearly distinguished. When possible, **use example code
+snippets to illustrate before-after API usages**. List pros-n-cons. Highlight
+the main questions that you want to be answered. Given the Abseil project compatibility requirements, describe why the API change is safe.]
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/AUTHORS
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/AUTHORS b/libraries/ostrich/backend/3rdparty/abseil/AUTHORS
new file mode 100644
index 0000000..976d31d
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/AUTHORS
@@ -0,0 +1,6 @@
+# This is the list of Abseil authors for copyright purposes.
+#
+# This does not necessarily list everyone who has contributed code, since in
+# some cases, their employer may be the copyright holder. To see the full list
+# of contributors, see the revision history in source control.
+Google Inc.
[28/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_join.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_join.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_join.h
new file mode 100644
index 0000000..bd4d0e1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_join.h
@@ -0,0 +1,288 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: str_join.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains functions for joining a range of elements and
+// returning the result as a std::string. StrJoin operations are specified by passing
+// a range, a separator std::string to use between the elements joined, and an
+// optional Formatter responsible for converting each argument in the range to a
+// std::string. If omitted, a default `AlphaNumFormatter()` is called on the elements
+// to be joined, using the same formatting that `absl::StrCat()` uses. This
+// package defines a number of default formatters, and you can define your own
+// implementations.
+//
+// Ranges are specified by passing a container with `std::begin()` and
+// `std::end()` iterators, container-specific `begin()` and `end()` iterators, a
+// brace-initialized `std::initializer_list`, or a `std::tuple` of heterogeneous
+// objects. The separator std::string is specified as an `absl::string_view`.
+//
+// Because the default formatter uses the `absl::AlphaNum` class,
+// `absl::StrJoin()`, like `absl::StrCat()`, will work out-of-the-box on
+// collections of strings, ints, floats, doubles, etc.
+//
+// Example:
+//
+// std::vector<std::string> v = {"foo", "bar", "baz"};
+// std::string s = absl::StrJoin(v, "-");
+// EXPECT_EQ("foo-bar-baz", s);
+//
+// See comments on the `absl::StrJoin()` function for more examples.
+
+#ifndef ABSL_STRINGS_STR_JOIN_H_
+#define ABSL_STRINGS_STR_JOIN_H_
+
+#include <cstdio>
+#include <cstring>
+#include <initializer_list>
+#include <iterator>
+#include <string>
+#include <tuple>
+#include <utility>
+
+#include "absl/base/macros.h"
+#include "absl/strings/internal/str_join_internal.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+
+// -----------------------------------------------------------------------------
+// Concept: Formatter
+// -----------------------------------------------------------------------------
+//
+// A Formatter is a function object that is responsible for formatting its
+// argument as a std::string and appending it to a given output std::string. Formatters
+// may be implemented as function objects, lambdas, or normal functions. You may
+// provide your own Formatter to enable `absl::StrJoin()` to work with arbitrary
+// types.
+//
+// The following is an example of a custom Formatter that simply uses
+// `std::to_string()` to format an integer as a std::string.
+//
+// struct MyFormatter {
+// void operator()(std::string* out, int i) const {
+// out->append(std::to_string(i));
+// }
+// };
+//
+// You would use the above formatter by passing an instance of it as the final
+// argument to `absl::StrJoin()`:
+//
+// std::vector<int> v = {1, 2, 3, 4};
+// std::string s = absl::StrJoin(v, "-", MyFormatter());
+// EXPECT_EQ("1-2-3-4", s);
+//
+// The following standard formatters are provided within this file:
+//
+// - `AlphaNumFormatter()` (the default)
+// - `StreamFormatter()`
+// - `PairFormatter()`
+// - `DereferenceFormatter()`
+
+// AlphaNumFormatter()
+//
+// Default formatter used if none is specified. Uses `absl::AlphaNum` to convert
+// numeric arguments to strings.
+inline strings_internal::AlphaNumFormatterImpl AlphaNumFormatter() {
+ return strings_internal::AlphaNumFormatterImpl();
+}
+
+// StreamFormatter()
+//
+// Formats its argument using the << operator.
+inline strings_internal::StreamFormatterImpl StreamFormatter() {
+ return strings_internal::StreamFormatterImpl();
+}
+
+// Function Template: PairFormatter(Formatter, absl::string_view, Formatter)
+//
+// Formats a `std::pair` by putting a given separator between the pair's
+// `.first` and `.second` members. This formatter allows you to specify
+// custom Formatters for both the first and second member of each pair.
+template <typename FirstFormatter, typename SecondFormatter>
+inline strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>
+PairFormatter(FirstFormatter f1, absl::string_view sep, SecondFormatter f2) {
+ return strings_internal::PairFormatterImpl<FirstFormatter, SecondFormatter>(
+ std::move(f1), sep, std::move(f2));
+}
+
+// Function overload of PairFormatter() for using a default
+// `AlphaNumFormatter()` for each Formatter in the pair.
+inline strings_internal::PairFormatterImpl<
+ strings_internal::AlphaNumFormatterImpl,
+ strings_internal::AlphaNumFormatterImpl>
+PairFormatter(absl::string_view sep) {
+ return PairFormatter(AlphaNumFormatter(), sep, AlphaNumFormatter());
+}
+
+// Function Template: DereferenceFormatter(Formatter)
+//
+// Formats its argument by dereferencing it and then applying the given
+// formatter. This formatter is useful for formatting a container of
+// pointer-to-T. This pattern often shows up when joining repeated fields in
+// protocol buffers.
+template <typename Formatter>
+strings_internal::DereferenceFormatterImpl<Formatter> DereferenceFormatter(
+ Formatter&& f) {
+ return strings_internal::DereferenceFormatterImpl<Formatter>(
+ std::forward<Formatter>(f));
+}
+
+// Function overload of `DererefenceFormatter()` for using a default
+// `AlphaNumFormatter()`.
+inline strings_internal::DereferenceFormatterImpl<
+ strings_internal::AlphaNumFormatterImpl>
+DereferenceFormatter() {
+ return strings_internal::DereferenceFormatterImpl<
+ strings_internal::AlphaNumFormatterImpl>(AlphaNumFormatter());
+}
+
+// -----------------------------------------------------------------------------
+// StrJoin()
+// -----------------------------------------------------------------------------
+//
+// Joins a range of elements and returns the result as a std::string.
+// `absl::StrJoin()` takes a range, a separator std::string to use between the
+// elements joined, and an optional Formatter responsible for converting each
+// argument in the range to a std::string.
+//
+// If omitted, the default `AlphaNumFormatter()` is called on the elements to be
+// joined.
+//
+// Example 1:
+// // Joins a collection of strings. This pattern also works with a collection
+// // of `absl::string_view` or even `const char*`.
+// std::vector<std::string> v = {"foo", "bar", "baz"};
+// std::string s = absl::StrJoin(v, "-");
+// EXPECT_EQ("foo-bar-baz", s);
+//
+// Example 2:
+// // Joins the values in the given `std::initializer_list<>` specified using
+// // brace initialization. This pattern also works with an initializer_list
+// // of ints or `absl::string_view` -- any `AlphaNum`-compatible type.
+// std::string s = absl::StrJoin({"foo", "bar", "baz"}, "-");
+// EXPECT_EQ("foo-bar-baz", s);
+//
+// Example 3:
+// // Joins a collection of ints. This pattern also works with floats,
+// // doubles, int64s -- any `StrCat()`-compatible type.
+// std::vector<int> v = {1, 2, 3, -4};
+// std::string s = absl::StrJoin(v, "-");
+// EXPECT_EQ("1-2-3--4", s);
+//
+// Example 4:
+// // Joins a collection of pointer-to-int. By default, pointers are
+// // dereferenced and the pointee is formatted using the default format for
+// // that type; such dereferencing occurs for all levels of indirection, so
+// // this pattern works just as well for `std::vector<int**>` as for
+// // `std::vector<int*>`.
+// int x = 1, y = 2, z = 3;
+// std::vector<int*> v = {&x, &y, &z};
+// std::string s = absl::StrJoin(v, "-");
+// EXPECT_EQ("1-2-3", s);
+//
+// Example 5:
+// // Dereferencing of `std::unique_ptr<>` is also supported:
+// std::vector<std::unique_ptr<int>> v
+// v.emplace_back(new int(1));
+// v.emplace_back(new int(2));
+// v.emplace_back(new int(3));
+// std::string s = absl::StrJoin(v, "-");
+// EXPECT_EQ("1-2-3", s);
+//
+// Example 6:
+// // Joins a `std::map`, with each key-value pair separated by an equals
+// // sign. This pattern would also work with, say, a
+// // `std::vector<std::pair<>>`.
+// std::map<std::string, int> m = {
+// std::make_pair("a", 1),
+// std::make_pair("b", 2),
+// std::make_pair("c", 3)};
+// std::string s = absl::StrJoin(m, ",", absl::PairFormatter("="));
+// EXPECT_EQ("a=1,b=2,c=3", s);
+//
+// Example 7:
+// // These examples show how `absl::StrJoin()` handles a few common edge
+// // cases:
+// std::vector<std::string> v_empty;
+// EXPECT_EQ("", absl::StrJoin(v_empty, "-"));
+//
+// std::vector<std::string> v_one_item = {"foo"};
+// EXPECT_EQ("foo", absl::StrJoin(v_one_item, "-"));
+//
+// std::vector<std::string> v_empty_string = {""};
+// EXPECT_EQ("", absl::StrJoin(v_empty_string, "-"));
+//
+// std::vector<std::string> v_one_item_empty_string = {"a", ""};
+// EXPECT_EQ("a-", absl::StrJoin(v_one_item_empty_string, "-"));
+//
+// std::vector<std::string> v_two_empty_string = {"", ""};
+// EXPECT_EQ("-", absl::StrJoin(v_two_empty_string, "-"));
+//
+// Example 8:
+// // Joins a `std::tuple<T...>` of heterogeneous types, converting each to
+// // a std::string using the `absl::AlphaNum` class.
+// std::string s = absl::StrJoin(std::make_tuple(123, "abc", 0.456), "-");
+// EXPECT_EQ("123-abc-0.456", s);
+
+template <typename Iterator, typename Formatter>
+std::string StrJoin(Iterator start, Iterator end, absl::string_view sep,
+ Formatter&& fmt) {
+ return strings_internal::JoinAlgorithm(start, end, sep, fmt);
+}
+
+template <typename Range, typename Formatter>
+std::string StrJoin(const Range& range, absl::string_view separator,
+ Formatter&& fmt) {
+ return strings_internal::JoinRange(range, separator, fmt);
+}
+
+template <typename T, typename Formatter>
+std::string StrJoin(std::initializer_list<T> il, absl::string_view separator,
+ Formatter&& fmt) {
+ return strings_internal::JoinRange(il, separator, fmt);
+}
+
+template <typename... T, typename Formatter>
+std::string StrJoin(const std::tuple<T...>& value, absl::string_view separator,
+ Formatter&& fmt) {
+ return strings_internal::JoinAlgorithm(value, separator, fmt);
+}
+
+template <typename Iterator>
+std::string StrJoin(Iterator start, Iterator end, absl::string_view separator) {
+ return strings_internal::JoinRange(start, end, separator);
+}
+
+template <typename Range>
+std::string StrJoin(const Range& range, absl::string_view separator) {
+ return strings_internal::JoinRange(range, separator);
+}
+
+template <typename T>
+std::string StrJoin(std::initializer_list<T> il, absl::string_view separator) {
+ return strings_internal::JoinRange(il, separator);
+}
+
+template <typename... T>
+std::string StrJoin(const std::tuple<T...>& value, absl::string_view separator) {
+ return strings_internal::JoinAlgorithm(value, separator, AlphaNumFormatter());
+}
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_STR_JOIN_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_join_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_join_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_join_test.cc
new file mode 100644
index 0000000..03b60f0
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_join_test.cc
@@ -0,0 +1,473 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Unit tests for all join.h functions
+
+#include "absl/strings/str_join.h"
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <functional>
+#include <initializer_list>
+#include <map>
+#include <memory>
+#include <ostream>
+#include <set>
+#include <tuple>
+#include <type_traits>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/macros.h"
+#include "absl/memory/memory.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
+
+namespace {
+
+TEST(StrJoin, APIExamples) {
+ {
+ // Collection of strings
+ std::vector<std::string> v = {"foo", "bar", "baz"};
+ EXPECT_EQ("foo-bar-baz", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // Collection of absl::string_view
+ std::vector<absl::string_view> v = {"foo", "bar", "baz"};
+ EXPECT_EQ("foo-bar-baz", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // Collection of const char*
+ std::vector<const char*> v = {"foo", "bar", "baz"};
+ EXPECT_EQ("foo-bar-baz", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // Collection of non-const char*
+ std::string a = "foo", b = "bar", c = "baz";
+ std::vector<char*> v = {&a[0], &b[0], &c[0]};
+ EXPECT_EQ("foo-bar-baz", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // Collection of ints
+ std::vector<int> v = {1, 2, 3, -4};
+ EXPECT_EQ("1-2-3--4", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // Literals passed as a std::initializer_list
+ std::string s = absl::StrJoin({"a", "b", "c"}, "-");
+ EXPECT_EQ("a-b-c", s);
+ }
+ {
+ // Join a std::tuple<T...>.
+ std::string s = absl::StrJoin(std::make_tuple(123, "abc", 0.456), "-");
+ EXPECT_EQ("123-abc-0.456", s);
+ }
+
+ {
+ // Collection of unique_ptrs
+ std::vector<std::unique_ptr<int>> v;
+ v.emplace_back(new int(1));
+ v.emplace_back(new int(2));
+ v.emplace_back(new int(3));
+ EXPECT_EQ("1-2-3", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // Array of ints
+ const int a[] = {1, 2, 3, -4};
+ EXPECT_EQ("1-2-3--4", absl::StrJoin(a, a + ABSL_ARRAYSIZE(a), "-"));
+ }
+
+ {
+ // Collection of pointers
+ int x = 1, y = 2, z = 3;
+ std::vector<int*> v = {&x, &y, &z};
+ EXPECT_EQ("1-2-3", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // Collection of pointers to pointers
+ int x = 1, y = 2, z = 3;
+ int *px = &x, *py = &y, *pz = &z;
+ std::vector<int**> v = {&px, &py, &pz};
+ EXPECT_EQ("1-2-3", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // Collection of pointers to std::string
+ std::string a("a"), b("b");
+ std::vector<std::string*> v = {&a, &b};
+ EXPECT_EQ("a-b", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // A std::map, which is a collection of std::pair<>s.
+ std::map<std::string, int> m = { {"a", 1}, {"b", 2}, {"c", 3} };
+ EXPECT_EQ("a=1,b=2,c=3", absl::StrJoin(m, ",", absl::PairFormatter("=")));
+ }
+
+ {
+ // Shows absl::StrSplit and absl::StrJoin working together. This example is
+ // equivalent to s/=/-/g.
+ const std::string s = "a=b=c=d";
+ EXPECT_EQ("a-b-c-d", absl::StrJoin(absl::StrSplit(s, "="), "-"));
+ }
+
+ //
+ // A few examples of edge cases
+ //
+
+ {
+ // Empty range yields an empty std::string.
+ std::vector<std::string> v;
+ EXPECT_EQ("", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // A range of 1 element gives a std::string with that element but no separator.
+ std::vector<std::string> v = {"foo"};
+ EXPECT_EQ("foo", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // A range with a single empty std::string element
+ std::vector<std::string> v = {""};
+ EXPECT_EQ("", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // A range with 2 elements, one of which is an empty std::string
+ std::vector<std::string> v = {"a", ""};
+ EXPECT_EQ("a-", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // A range with 2 empty elements.
+ std::vector<std::string> v = {"", ""};
+ EXPECT_EQ("-", absl::StrJoin(v, "-"));
+ }
+
+ {
+ // A std::vector of bool.
+ std::vector<bool> v = {true, false, true};
+ EXPECT_EQ("1-0-1", absl::StrJoin(v, "-"));
+ }
+}
+
+TEST(StrJoin, CustomFormatter) {
+ std::vector<std::string> v{"One", "Two", "Three"};
+ {
+ std::string joined = absl::StrJoin(v, "", [](std::string* out, const std::string& in) {
+ absl::StrAppend(out, "(", in, ")");
+ });
+ EXPECT_EQ("(One)(Two)(Three)", joined);
+ }
+ {
+ class ImmovableFormatter {
+ public:
+ void operator()(std::string* out, const std::string& in) {
+ absl::StrAppend(out, "(", in, ")");
+ }
+ ImmovableFormatter() {}
+ ImmovableFormatter(const ImmovableFormatter&) = delete;
+ };
+ EXPECT_EQ("(One)(Two)(Three)", absl::StrJoin(v, "", ImmovableFormatter()));
+ }
+ {
+ class OverloadedFormatter {
+ public:
+ void operator()(std::string* out, const std::string& in) {
+ absl::StrAppend(out, "(", in, ")");
+ }
+ void operator()(std::string* out, const std::string& in) const {
+ absl::StrAppend(out, "[", in, "]");
+ }
+ };
+ EXPECT_EQ("(One)(Two)(Three)", absl::StrJoin(v, "", OverloadedFormatter()));
+ const OverloadedFormatter fmt = {};
+ EXPECT_EQ("[One][Two][Three]", absl::StrJoin(v, "", fmt));
+ }
+}
+
+//
+// Tests the Formatters
+//
+
+TEST(AlphaNumFormatter, FormatterAPI) {
+ // Not an exhaustive test. See strings/strcat_test.h for the exhaustive test
+ // of what AlphaNum can convert.
+ auto f = absl::AlphaNumFormatter();
+ std::string s;
+ f(&s, "Testing: ");
+ f(&s, static_cast<int>(1));
+ f(&s, static_cast<int16_t>(2));
+ f(&s, static_cast<int64_t>(3));
+ f(&s, static_cast<float>(4));
+ f(&s, static_cast<double>(5));
+ f(&s, static_cast<unsigned>(6));
+ f(&s, static_cast<size_t>(7));
+ f(&s, absl::string_view(" OK"));
+ EXPECT_EQ("Testing: 1234567 OK", s);
+}
+
+// Make sure people who are mistakenly using std::vector<bool> even though
+// they're not memory-constrained can use absl::AlphaNumFormatter().
+TEST(AlphaNumFormatter, VectorOfBool) {
+ auto f = absl::AlphaNumFormatter();
+ std::string s;
+ std::vector<bool> v = {true, false, true};
+ f(&s, *v.cbegin());
+ f(&s, *v.begin());
+ f(&s, v[1]);
+ EXPECT_EQ("110", s);
+}
+
+TEST(AlphaNumFormatter, AlphaNum) {
+ auto f = absl::AlphaNumFormatter();
+ std::string s;
+ f(&s, absl::AlphaNum("hello"));
+ EXPECT_EQ("hello", s);
+}
+
+struct StreamableType {
+ std::string contents;
+};
+inline std::ostream& operator<<(std::ostream& os, const StreamableType& t) {
+ os << "Streamable:" << t.contents;
+ return os;
+}
+
+TEST(StreamFormatter, FormatterAPI) {
+ auto f = absl::StreamFormatter();
+ std::string s;
+ f(&s, "Testing: ");
+ f(&s, static_cast<int>(1));
+ f(&s, static_cast<int16_t>(2));
+ f(&s, static_cast<int64_t>(3));
+ f(&s, static_cast<float>(4));
+ f(&s, static_cast<double>(5));
+ f(&s, static_cast<unsigned>(6));
+ f(&s, static_cast<size_t>(7));
+ f(&s, absl::string_view(" OK "));
+ StreamableType streamable = {"object"};
+ f(&s, streamable);
+ EXPECT_EQ("Testing: 1234567 OK Streamable:object", s);
+}
+
+// A dummy formatter that wraps each element in parens. Used in some tests
+// below.
+struct TestingParenFormatter {
+ template <typename T>
+ void operator()(std::string* s, const T& t) {
+ absl::StrAppend(s, "(", t, ")");
+ }
+};
+
+TEST(PairFormatter, FormatterAPI) {
+ {
+ // Tests default PairFormatter(sep) that uses AlphaNumFormatter for the
+ // 'first' and 'second' members.
+ const auto f = absl::PairFormatter("=");
+ std::string s;
+ f(&s, std::make_pair("a", "b"));
+ f(&s, std::make_pair(1, 2));
+ EXPECT_EQ("a=b1=2", s);
+ }
+
+ {
+ // Tests using a custom formatter for the 'first' and 'second' members.
+ auto f = absl::PairFormatter(TestingParenFormatter(), "=",
+ TestingParenFormatter());
+ std::string s;
+ f(&s, std::make_pair("a", "b"));
+ f(&s, std::make_pair(1, 2));
+ EXPECT_EQ("(a)=(b)(1)=(2)", s);
+ }
+}
+
+TEST(DereferenceFormatter, FormatterAPI) {
+ {
+ // Tests wrapping the default AlphaNumFormatter.
+ const absl::strings_internal::DereferenceFormatterImpl<
+ absl::strings_internal::AlphaNumFormatterImpl>
+ f;
+ int x = 1, y = 2, z = 3;
+ std::string s;
+ f(&s, &x);
+ f(&s, &y);
+ f(&s, &z);
+ EXPECT_EQ("123", s);
+ }
+
+ {
+ // Tests wrapping std::string's default formatter.
+ absl::strings_internal::DereferenceFormatterImpl<
+ absl::strings_internal::DefaultFormatter<std::string>::Type>
+ f;
+
+ std::string x = "x";
+ std::string y = "y";
+ std::string z = "z";
+ std::string s;
+ f(&s, &x);
+ f(&s, &y);
+ f(&s, &z);
+ EXPECT_EQ(s, "xyz");
+ }
+
+ {
+ // Tests wrapping a custom formatter.
+ auto f = absl::DereferenceFormatter(TestingParenFormatter());
+ int x = 1, y = 2, z = 3;
+ std::string s;
+ f(&s, &x);
+ f(&s, &y);
+ f(&s, &z);
+ EXPECT_EQ("(1)(2)(3)", s);
+ }
+
+ {
+ absl::strings_internal::DereferenceFormatterImpl<
+ absl::strings_internal::AlphaNumFormatterImpl>
+ f;
+ auto x = std::unique_ptr<int>(new int(1));
+ auto y = std::unique_ptr<int>(new int(2));
+ auto z = std::unique_ptr<int>(new int(3));
+ std::string s;
+ f(&s, x);
+ f(&s, y);
+ f(&s, z);
+ EXPECT_EQ("123", s);
+ }
+}
+
+//
+// Tests the interfaces for the 4 public Join function overloads. The semantics
+// of the algorithm is covered in the above APIExamples test.
+//
+TEST(StrJoin, PublicAPIOverloads) {
+ std::vector<std::string> v = {"a", "b", "c"};
+
+ // Iterators + formatter
+ EXPECT_EQ("a-b-c",
+ absl::StrJoin(v.begin(), v.end(), "-", absl::AlphaNumFormatter()));
+ // Range + formatter
+ EXPECT_EQ("a-b-c", absl::StrJoin(v, "-", absl::AlphaNumFormatter()));
+ // Iterators, no formatter
+ EXPECT_EQ("a-b-c", absl::StrJoin(v.begin(), v.end(), "-"));
+ // Range, no formatter
+ EXPECT_EQ("a-b-c", absl::StrJoin(v, "-"));
+}
+
+TEST(StrJoin, Array) {
+ const absl::string_view a[] = {"a", "b", "c"};
+ EXPECT_EQ("a-b-c", absl::StrJoin(a, "-"));
+}
+
+TEST(StrJoin, InitializerList) {
+ { EXPECT_EQ("a-b-c", absl::StrJoin({"a", "b", "c"}, "-")); }
+
+ {
+ auto a = {"a", "b", "c"};
+ EXPECT_EQ("a-b-c", absl::StrJoin(a, "-"));
+ }
+
+ {
+ std::initializer_list<const char*> a = {"a", "b", "c"};
+ EXPECT_EQ("a-b-c", absl::StrJoin(a, "-"));
+ }
+
+ {
+ std::initializer_list<std::string> a = {"a", "b", "c"};
+ EXPECT_EQ("a-b-c", absl::StrJoin(a, "-"));
+ }
+
+ {
+ std::initializer_list<absl::string_view> a = {"a", "b", "c"};
+ EXPECT_EQ("a-b-c", absl::StrJoin(a, "-"));
+ }
+
+ {
+ // Tests initializer_list with a non-default formatter
+ auto a = {"a", "b", "c"};
+ TestingParenFormatter f;
+ EXPECT_EQ("(a)-(b)-(c)", absl::StrJoin(a, "-", f));
+ }
+
+ {
+ // initializer_list of ints
+ EXPECT_EQ("1-2-3", absl::StrJoin({1, 2, 3}, "-"));
+ }
+
+ {
+ // Tests initializer_list of ints with a non-default formatter
+ auto a = {1, 2, 3};
+ TestingParenFormatter f;
+ EXPECT_EQ("(1)-(2)-(3)", absl::StrJoin(a, "-", f));
+ }
+}
+
+TEST(StrJoin, Tuple) {
+ EXPECT_EQ("", absl::StrJoin(std::make_tuple(), "-"));
+ EXPECT_EQ("hello", absl::StrJoin(std::make_tuple("hello"), "-"));
+
+ int x(10);
+ std::string y("hello");
+ double z(3.14);
+ EXPECT_EQ("10-hello-3.14", absl::StrJoin(std::make_tuple(x, y, z), "-"));
+
+ // Faster! Faster!!
+ EXPECT_EQ("10-hello-3.14",
+ absl::StrJoin(std::make_tuple(x, std::cref(y), z), "-"));
+
+ struct TestFormatter {
+ char buffer[128];
+ void operator()(std::string* out, int v) {
+ snprintf(buffer, sizeof(buffer), "%#.8x", v);
+ out->append(buffer);
+ }
+ void operator()(std::string* out, double v) {
+ snprintf(buffer, sizeof(buffer), "%#.0f", v);
+ out->append(buffer);
+ }
+ void operator()(std::string* out, const std::string& v) {
+ snprintf(buffer, sizeof(buffer), "%.4s", v.c_str());
+ out->append(buffer);
+ }
+ };
+ EXPECT_EQ("0x0000000a-hell-3.",
+ absl::StrJoin(std::make_tuple(x, y, z), "-", TestFormatter()));
+ EXPECT_EQ(
+ "0x0000000a-hell-3.",
+ absl::StrJoin(std::make_tuple(x, std::cref(y), z), "-", TestFormatter()));
+ EXPECT_EQ("0x0000000a-hell-3.",
+ absl::StrJoin(std::make_tuple(&x, &y, &z), "-",
+ absl::DereferenceFormatter(TestFormatter())));
+ EXPECT_EQ("0x0000000a-hell-3.",
+ absl::StrJoin(std::make_tuple(absl::make_unique<int>(x),
+ absl::make_unique<std::string>(y),
+ absl::make_unique<double>(z)),
+ "-", absl::DereferenceFormatter(TestFormatter())));
+ EXPECT_EQ("0x0000000a-hell-3.",
+ absl::StrJoin(std::make_tuple(absl::make_unique<int>(x), &y, &z),
+ "-", absl::DereferenceFormatter(TestFormatter())));
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace.cc
new file mode 100644
index 0000000..69efa35
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace.cc
@@ -0,0 +1,79 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/str_replace.h"
+
+#include "absl/strings/str_cat.h"
+
+namespace absl {
+namespace strings_internal {
+
+using FixedMapping =
+ std::initializer_list<std::pair<absl::string_view, absl::string_view>>;
+
+// Applies the ViableSubstitutions in subs_ptr to the absl::string_view s, and
+// stores the result in *result_ptr. Returns the number of substitutions that
+// occurred.
+int ApplySubstitutions(
+ absl::string_view s,
+ std::vector<strings_internal::ViableSubstitution>* subs_ptr,
+ std::string* result_ptr) {
+ auto& subs = *subs_ptr;
+ int substitutions = 0;
+ size_t pos = 0;
+ while (!subs.empty()) {
+ auto& sub = subs.back();
+ if (sub.offset >= pos) {
+ if (pos <= s.size()) {
+ StrAppend(result_ptr, s.substr(pos, sub.offset - pos), sub.replacement);
+ }
+ pos = sub.offset + sub.old.size();
+ substitutions += 1;
+ }
+ sub.offset = s.find(sub.old, pos);
+ if (sub.offset == s.npos) {
+ subs.pop_back();
+ } else {
+ // Insertion sort to ensure the last ViableSubstitution continues to be
+ // before all the others.
+ size_t index = subs.size();
+ while (--index && subs[index - 1].OccursBefore(subs[index])) {
+ std::swap(subs[index], subs[index - 1]);
+ }
+ }
+ }
+ result_ptr->append(s.data() + pos, s.size() - pos);
+ return substitutions;
+}
+
+} // namespace strings_internal
+
+// We can implement this in terms of the generic StrReplaceAll, but
+// we must specify the template overload because C++ cannot deduce the type
+// of an initializer_list parameter to a function, and also if we don't specify
+// the type, we just call ourselves.
+//
+// Note that we implement them here, rather than in the header, so that they
+// aren't inlined.
+
+std::string StrReplaceAll(absl::string_view s,
+ strings_internal::FixedMapping replacements) {
+ return StrReplaceAll<strings_internal::FixedMapping>(s, replacements);
+}
+
+int StrReplaceAll(strings_internal::FixedMapping replacements, std::string* target) {
+ return StrReplaceAll<strings_internal::FixedMapping>(replacements, target);
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace.h
new file mode 100644
index 0000000..f4d9bb9
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace.h
@@ -0,0 +1,213 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: str_replace.h
+// -----------------------------------------------------------------------------
+//
+// This file defines `absl::StrReplaceAll()`, a general-purpose std::string
+// replacement function designed for large, arbitrary text substitutions,
+// especially on strings which you are receiving from some other system for
+// further processing (e.g. processing regular expressions, escaping HTML
+// entities, etc. `StrReplaceAll` is designed to be efficient even when only
+// one substitution is being performed, or when substitution is rare.
+//
+// If the std::string being modified is known at compile-time, and the substitutions
+// vary, `absl::Substitute()` may be a better choice.
+//
+// Example:
+//
+// std::string html_escaped = absl::StrReplaceAll(user_input, {
+// {"&", "&"},
+// {"<", "<"},
+// {">", ">"},
+// {"\"", """},
+// {"'", "'"}});
+#ifndef ABSL_STRINGS_STR_REPLACE_H_
+#define ABSL_STRINGS_STR_REPLACE_H_
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/attributes.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+
+// StrReplaceAll()
+//
+// Replaces character sequences within a given std::string with replacements provided
+// within an initializer list of key/value pairs. Candidate replacements are
+// considered in order as they occur within the std::string, with earlier matches
+// taking precedence, and longer matches taking precedence for candidates
+// starting at the same position in the std::string. Once a substitution is made, the
+// replaced text is not considered for any further substitutions.
+//
+// Example:
+//
+// std::string s = absl::StrReplaceAll("$who bought $count #Noun. Thanks $who!",
+// {{"$count", absl::StrCat(5)},
+// {"$who", "Bob"},
+// {"#Noun", "Apples"}});
+// EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+ABSL_MUST_USE_RESULT std::string StrReplaceAll(
+ absl::string_view s,
+ std::initializer_list<std::pair<absl::string_view, absl::string_view>>
+ replacements);
+
+// Overload of `StrReplaceAll()` to accept a container of key/value replacement
+// pairs (typically either an associative map or a `std::vector` of `std::pair`
+// elements). A vector of pairs is generally more efficient.
+//
+// Examples:
+//
+// std::map<const absl::string_view, const absl::string_view> replacements;
+// replacements["$who"] = "Bob";
+// replacements["$count"] = "5";
+// replacements["#Noun"] = "Apples";
+// std::string s = absl::StrReplaceAll("$who bought $count #Noun. Thanks $who!",
+// replacements);
+// EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+//
+// // A std::vector of std::pair elements can be more efficient.
+// std::vector<std::pair<const absl::string_view, std::string>> replacements;
+// replacements.push_back({"&", "&"});
+// replacements.push_back({"<", "<"});
+// replacements.push_back({">", ">"});
+// std::string s = absl::StrReplaceAll("if (ptr < &foo)",
+// replacements);
+// EXPECT_EQ("if (ptr < &foo)", s);
+template <typename StrToStrMapping>
+std::string StrReplaceAll(absl::string_view s, const StrToStrMapping& replacements);
+
+// Overload of `StrReplaceAll()` to replace character sequences within a given
+// output std::string *in place* with replacements provided within an initializer
+// list of key/value pairs, returning the number of substitutions that occurred.
+//
+// Example:
+//
+// std::string s = std::string("$who bought $count #Noun. Thanks $who!");
+// int count;
+// count = absl::StrReplaceAll({{"$count", absl::StrCat(5)},
+// {"$who", "Bob"},
+// {"#Noun", "Apples"}}, &s);
+// EXPECT_EQ(count, 4);
+// EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+int StrReplaceAll(
+ std::initializer_list<std::pair<absl::string_view, absl::string_view>>
+ replacements,
+ std::string* target);
+
+// Overload of `StrReplaceAll()` to replace patterns within a given output
+// std::string *in place* with replacements provided within a container of key/value
+// pairs.
+//
+// Example:
+//
+// std::string s = std::string("if (ptr < &foo)");
+// int count = absl::StrReplaceAll({{"&", "&"},
+// {"<", "<"},
+// {">", ">"}}, &s);
+// EXPECT_EQ(count, 2);
+// EXPECT_EQ("if (ptr < &foo)", s);
+template <typename StrToStrMapping>
+int StrReplaceAll(const StrToStrMapping& replacements, std::string* target);
+
+// Implementation details only, past this point.
+namespace strings_internal {
+
+struct ViableSubstitution {
+ absl::string_view old;
+ absl::string_view replacement;
+ size_t offset;
+
+ ViableSubstitution(absl::string_view old_str,
+ absl::string_view replacement_str, size_t offset_val)
+ : old(old_str), replacement(replacement_str), offset(offset_val) {}
+
+ // One substitution occurs "before" another (takes priority) if either
+ // it has the lowest offset, or it has the same offset but a larger size.
+ bool OccursBefore(const ViableSubstitution& y) const {
+ if (offset != y.offset) return offset < y.offset;
+ return old.size() > y.old.size();
+ }
+};
+
+// Build a vector of ViableSubstitutions based on the given list of
+// replacements. subs can be implemented as a priority_queue. However, it turns
+// out that most callers have small enough a list of substitutions that the
+// overhead of such a queue isn't worth it.
+template <typename StrToStrMapping>
+std::vector<ViableSubstitution> FindSubstitutions(
+ absl::string_view s, const StrToStrMapping& replacements) {
+ std::vector<ViableSubstitution> subs;
+ subs.reserve(replacements.size());
+
+ for (const auto& rep : replacements) {
+ using std::get;
+ absl::string_view old(get<0>(rep));
+
+ size_t pos = s.find(old);
+ if (pos == s.npos) continue;
+
+ // Ignore attempts to replace "". This condition is almost never true,
+ // but above condition is frequently true. That's why we test for this
+ // now and not before.
+ if (old.empty()) continue;
+
+ subs.emplace_back(old, get<1>(rep), pos);
+
+ // Insertion sort to ensure the last ViableSubstitution comes before
+ // all the others.
+ size_t index = subs.size();
+ while (--index && subs[index - 1].OccursBefore(subs[index])) {
+ std::swap(subs[index], subs[index - 1]);
+ }
+ }
+ return subs;
+}
+
+int ApplySubstitutions(absl::string_view s,
+ std::vector<ViableSubstitution>* subs_ptr,
+ std::string* result_ptr);
+
+} // namespace strings_internal
+
+template <typename StrToStrMapping>
+std::string StrReplaceAll(absl::string_view s, const StrToStrMapping& replacements) {
+ auto subs = strings_internal::FindSubstitutions(s, replacements);
+ std::string result;
+ result.reserve(s.size());
+ strings_internal::ApplySubstitutions(s, &subs, &result);
+ return result;
+}
+
+template <typename StrToStrMapping>
+int StrReplaceAll(const StrToStrMapping& replacements, std::string* target) {
+ auto subs = strings_internal::FindSubstitutions(*target, replacements);
+ if (subs.empty()) return 0;
+
+ std::string result;
+ result.reserve(target->size());
+ int substitutions =
+ strings_internal::ApplySubstitutions(*target, &subs, &result);
+ target->swap(result);
+ return substitutions;
+}
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_STR_REPLACE_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace_test.cc
new file mode 100644
index 0000000..5d003a2
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_replace_test.cc
@@ -0,0 +1,341 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/str_replace.h"
+
+#include <list>
+#include <map>
+#include <tuple>
+
+#include "gtest/gtest.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
+
+TEST(StrReplaceAll, OneReplacement) {
+ std::string s;
+
+ // Empty std::string.
+ s = absl::StrReplaceAll(s, {{"", ""}});
+ EXPECT_EQ(s, "");
+ s = absl::StrReplaceAll(s, {{"x", ""}});
+ EXPECT_EQ(s, "");
+ s = absl::StrReplaceAll(s, {{"", "y"}});
+ EXPECT_EQ(s, "");
+ s = absl::StrReplaceAll(s, {{"x", "y"}});
+ EXPECT_EQ(s, "");
+
+ // Empty substring.
+ s = absl::StrReplaceAll("abc", {{"", ""}});
+ EXPECT_EQ(s, "abc");
+ s = absl::StrReplaceAll("abc", {{"", "y"}});
+ EXPECT_EQ(s, "abc");
+ s = absl::StrReplaceAll("abc", {{"x", ""}});
+ EXPECT_EQ(s, "abc");
+
+ // Substring not found.
+ s = absl::StrReplaceAll("abc", {{"xyz", "123"}});
+ EXPECT_EQ(s, "abc");
+
+ // Replace entire std::string.
+ s = absl::StrReplaceAll("abc", {{"abc", "xyz"}});
+ EXPECT_EQ(s, "xyz");
+
+ // Replace once at the start.
+ s = absl::StrReplaceAll("abc", {{"a", "x"}});
+ EXPECT_EQ(s, "xbc");
+
+ // Replace once in the middle.
+ s = absl::StrReplaceAll("abc", {{"b", "x"}});
+ EXPECT_EQ(s, "axc");
+
+ // Replace once at the end.
+ s = absl::StrReplaceAll("abc", {{"c", "x"}});
+ EXPECT_EQ(s, "abx");
+
+ // Replace multiple times with varying lengths of original/replacement.
+ s = absl::StrReplaceAll("ababa", {{"a", "xxx"}});
+ EXPECT_EQ(s, "xxxbxxxbxxx");
+
+ s = absl::StrReplaceAll("ababa", {{"b", "xxx"}});
+ EXPECT_EQ(s, "axxxaxxxa");
+
+ s = absl::StrReplaceAll("aaabaaabaaa", {{"aaa", "x"}});
+ EXPECT_EQ(s, "xbxbx");
+
+ s = absl::StrReplaceAll("abbbabbba", {{"bbb", "x"}});
+ EXPECT_EQ(s, "axaxa");
+
+ // Overlapping matches are replaced greedily.
+ s = absl::StrReplaceAll("aaa", {{"aa", "x"}});
+ EXPECT_EQ(s, "xa");
+
+ // The replacements are not recursive.
+ s = absl::StrReplaceAll("aaa", {{"aa", "a"}});
+ EXPECT_EQ(s, "aa");
+}
+
+TEST(StrReplaceAll, ManyReplacements) {
+ std::string s;
+
+ // Empty std::string.
+ s = absl::StrReplaceAll("", {{"", ""}, {"x", ""}, {"", "y"}, {"x", "y"}});
+ EXPECT_EQ(s, "");
+
+ // Empty substring.
+ s = absl::StrReplaceAll("abc", {{"", ""}, {"", "y"}, {"x", ""}});
+ EXPECT_EQ(s, "abc");
+
+ // Replace entire std::string, one char at a time
+ s = absl::StrReplaceAll("abc", {{"a", "x"}, {"b", "y"}, {"c", "z"}});
+ EXPECT_EQ(s, "xyz");
+ s = absl::StrReplaceAll("zxy", {{"z", "x"}, {"x", "y"}, {"y", "z"}});
+ EXPECT_EQ(s, "xyz");
+
+ // Replace once at the start (longer matches take precedence)
+ s = absl::StrReplaceAll("abc", {{"a", "x"}, {"ab", "xy"}, {"abc", "xyz"}});
+ EXPECT_EQ(s, "xyz");
+
+ // Replace once in the middle.
+ s = absl::StrReplaceAll(
+ "Abc!", {{"a", "x"}, {"ab", "xy"}, {"b", "y"}, {"bc", "yz"}, {"c", "z"}});
+ EXPECT_EQ(s, "Ayz!");
+
+ // Replace once at the end.
+ s = absl::StrReplaceAll(
+ "Abc!",
+ {{"a", "x"}, {"ab", "xy"}, {"b", "y"}, {"bc!", "yz?"}, {"c!", "z;"}});
+ EXPECT_EQ(s, "Ayz?");
+
+ // Replace multiple times with varying lengths of original/replacement.
+ s = absl::StrReplaceAll("ababa", {{"a", "xxx"}, {"b", "XXXX"}});
+ EXPECT_EQ(s, "xxxXXXXxxxXXXXxxx");
+
+ // Overlapping matches are replaced greedily.
+ s = absl::StrReplaceAll("aaa", {{"aa", "x"}, {"a", "X"}});
+ EXPECT_EQ(s, "xX");
+ s = absl::StrReplaceAll("aaa", {{"a", "X"}, {"aa", "x"}});
+ EXPECT_EQ(s, "xX");
+
+ // Two well-known sentences
+ s = absl::StrReplaceAll("the quick brown fox jumped over the lazy dogs",
+ {
+ {"brown", "box"},
+ {"dogs", "jugs"},
+ {"fox", "with"},
+ {"jumped", "five"},
+ {"over", "dozen"},
+ {"quick", "my"},
+ {"the", "pack"},
+ {"the lazy", "liquor"},
+ });
+ EXPECT_EQ(s, "pack my box with five dozen liquor jugs");
+}
+
+TEST(StrReplaceAll, ManyReplacementsInMap) {
+ std::map<const char *, const char *> replacements;
+ replacements["$who"] = "Bob";
+ replacements["$count"] = "5";
+ replacements["#Noun"] = "Apples";
+ std::string s = absl::StrReplaceAll("$who bought $count #Noun. Thanks $who!",
+ replacements);
+ EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+}
+
+TEST(StrReplaceAll, ReplacementsInPlace) {
+ std::string s = std::string("$who bought $count #Noun. Thanks $who!");
+ int count;
+ count = absl::StrReplaceAll({{"$count", absl::StrCat(5)},
+ {"$who", "Bob"},
+ {"#Noun", "Apples"}}, &s);
+ EXPECT_EQ(count, 4);
+ EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+}
+
+TEST(StrReplaceAll, ReplacementsInPlaceInMap) {
+ std::string s = std::string("$who bought $count #Noun. Thanks $who!");
+ std::map<absl::string_view, absl::string_view> replacements;
+ replacements["$who"] = "Bob";
+ replacements["$count"] = "5";
+ replacements["#Noun"] = "Apples";
+ int count;
+ count = absl::StrReplaceAll(replacements, &s);
+ EXPECT_EQ(count, 4);
+ EXPECT_EQ("Bob bought 5 Apples. Thanks Bob!", s);
+}
+
+struct Cont {
+ Cont() {}
+ explicit Cont(absl::string_view src) : data(src) {}
+
+ absl::string_view data;
+};
+
+template <int index>
+absl::string_view get(const Cont& c) {
+ auto splitter = absl::StrSplit(c.data, ':');
+ auto it = splitter.begin();
+ for (int i = 0; i < index; ++i) ++it;
+
+ return *it;
+}
+
+TEST(StrReplaceAll, VariableNumber) {
+ std::string s;
+ {
+ std::vector<std::pair<std::string, std::string>> replacements;
+
+ s = "abc";
+ EXPECT_EQ(0, absl::StrReplaceAll(replacements, &s));
+ EXPECT_EQ("abc", s);
+
+ s = "abc";
+ replacements.push_back({"a", "A"});
+ EXPECT_EQ(1, absl::StrReplaceAll(replacements, &s));
+ EXPECT_EQ("Abc", s);
+
+ s = "abc";
+ replacements.push_back({"b", "B"});
+ EXPECT_EQ(2, absl::StrReplaceAll(replacements, &s));
+ EXPECT_EQ("ABc", s);
+
+ s = "abc";
+ replacements.push_back({"d", "D"});
+ EXPECT_EQ(2, absl::StrReplaceAll(replacements, &s));
+ EXPECT_EQ("ABc", s);
+
+ EXPECT_EQ("ABcABc", absl::StrReplaceAll("abcabc", replacements));
+ }
+
+ {
+ std::map<const char*, const char*> replacements;
+ replacements["aa"] = "x";
+ replacements["a"] = "X";
+ s = "aaa";
+ EXPECT_EQ(2, absl::StrReplaceAll(replacements, &s));
+ EXPECT_EQ("xX", s);
+
+ EXPECT_EQ("xxX", absl::StrReplaceAll("aaaaa", replacements));
+ }
+
+ {
+ std::list<std::pair<absl::string_view, absl::string_view>> replacements = {
+ {"a", "x"}, {"b", "y"}, {"c", "z"}};
+
+ std::string s = absl::StrReplaceAll("abc", replacements);
+ EXPECT_EQ(s, "xyz");
+ }
+
+ {
+ using X = std::tuple<absl::string_view, std::string, int>;
+ std::vector<X> replacements(3);
+ replacements[0] = X{"a", "x", 1};
+ replacements[1] = X{"b", "y", 0};
+ replacements[2] = X{"c", "z", -1};
+
+ std::string s = absl::StrReplaceAll("abc", replacements);
+ EXPECT_EQ(s, "xyz");
+ }
+
+ {
+ std::vector<Cont> replacements(3);
+ replacements[0] = Cont{"a:x"};
+ replacements[1] = Cont{"b:y"};
+ replacements[2] = Cont{"c:z"};
+
+ std::string s = absl::StrReplaceAll("abc", replacements);
+ EXPECT_EQ(s, "xyz");
+ }
+}
+
+// Same as above, but using the in-place variant of absl::StrReplaceAll,
+// that returns the # of replacements performed.
+TEST(StrReplaceAll, Inplace) {
+ std::string s;
+ int reps;
+
+ // Empty std::string.
+ s = "";
+ reps = absl::StrReplaceAll({{"", ""}, {"x", ""}, {"", "y"}, {"x", "y"}}, &s);
+ EXPECT_EQ(reps, 0);
+ EXPECT_EQ(s, "");
+
+ // Empty substring.
+ s = "abc";
+ reps = absl::StrReplaceAll({{"", ""}, {"", "y"}, {"x", ""}}, &s);
+ EXPECT_EQ(reps, 0);
+ EXPECT_EQ(s, "abc");
+
+ // Replace entire std::string, one char at a time
+ s = "abc";
+ reps = absl::StrReplaceAll({{"a", "x"}, {"b", "y"}, {"c", "z"}}, &s);
+ EXPECT_EQ(reps, 3);
+ EXPECT_EQ(s, "xyz");
+ s = "zxy";
+ reps = absl::StrReplaceAll({{"z", "x"}, {"x", "y"}, {"y", "z"}}, &s);
+ EXPECT_EQ(reps, 3);
+ EXPECT_EQ(s, "xyz");
+
+ // Replace once at the start (longer matches take precedence)
+ s = "abc";
+ reps = absl::StrReplaceAll({{"a", "x"}, {"ab", "xy"}, {"abc", "xyz"}}, &s);
+ EXPECT_EQ(reps, 1);
+ EXPECT_EQ(s, "xyz");
+
+ // Replace once in the middle.
+ s = "Abc!";
+ reps = absl::StrReplaceAll(
+ {{"a", "x"}, {"ab", "xy"}, {"b", "y"}, {"bc", "yz"}, {"c", "z"}}, &s);
+ EXPECT_EQ(reps, 1);
+ EXPECT_EQ(s, "Ayz!");
+
+ // Replace once at the end.
+ s = "Abc!";
+ reps = absl::StrReplaceAll(
+ {{"a", "x"}, {"ab", "xy"}, {"b", "y"}, {"bc!", "yz?"}, {"c!", "z;"}}, &s);
+ EXPECT_EQ(reps, 1);
+ EXPECT_EQ(s, "Ayz?");
+
+ // Replace multiple times with varying lengths of original/replacement.
+ s = "ababa";
+ reps = absl::StrReplaceAll({{"a", "xxx"}, {"b", "XXXX"}}, &s);
+ EXPECT_EQ(reps, 5);
+ EXPECT_EQ(s, "xxxXXXXxxxXXXXxxx");
+
+ // Overlapping matches are replaced greedily.
+ s = "aaa";
+ reps = absl::StrReplaceAll({{"aa", "x"}, {"a", "X"}}, &s);
+ EXPECT_EQ(reps, 2);
+ EXPECT_EQ(s, "xX");
+ s = "aaa";
+ reps = absl::StrReplaceAll({{"a", "X"}, {"aa", "x"}}, &s);
+ EXPECT_EQ(reps, 2);
+ EXPECT_EQ(s, "xX");
+
+ // Two well-known sentences
+ s = "the quick brown fox jumped over the lazy dogs";
+ reps = absl::StrReplaceAll(
+ {
+ {"brown", "box"},
+ {"dogs", "jugs"},
+ {"fox", "with"},
+ {"jumped", "five"},
+ {"over", "dozen"},
+ {"quick", "my"},
+ {"the", "pack"},
+ {"the lazy", "liquor"},
+ },
+ &s);
+ EXPECT_EQ(reps, 8);
+ EXPECT_EQ(s, "pack my box with five dozen liquor jugs");
+}
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split.cc
new file mode 100644
index 0000000..0207213
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split.cc
@@ -0,0 +1,136 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/str_split.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <memory>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/strings/ascii.h"
+
+namespace absl {
+
+namespace {
+
+// This GenericFind() template function encapsulates the finding algorithm
+// shared between the ByString and ByAnyChar delimiters. The FindPolicy
+// template parameter allows each delimiter to customize the actual find
+// function to use and the length of the found delimiter. For example, the
+// Literal delimiter will ultimately use absl::string_view::find(), and the
+// AnyOf delimiter will use absl::string_view::find_first_of().
+template <typename FindPolicy>
+absl::string_view GenericFind(absl::string_view text,
+ absl::string_view delimiter, size_t pos,
+ FindPolicy find_policy) {
+ if (delimiter.empty() && text.length() > 0) {
+ // Special case for empty std::string delimiters: always return a zero-length
+ // absl::string_view referring to the item at position 1 past pos.
+ return absl::string_view(text.begin() + pos + 1, 0);
+ }
+ size_t found_pos = absl::string_view::npos;
+ absl::string_view found(text.end(), 0); // By default, not found
+ found_pos = find_policy.Find(text, delimiter, pos);
+ if (found_pos != absl::string_view::npos) {
+ found = absl::string_view(text.data() + found_pos,
+ find_policy.Length(delimiter));
+ }
+ return found;
+}
+
+// Finds using absl::string_view::find(), therefore the length of the found
+// delimiter is delimiter.length().
+struct LiteralPolicy {
+ size_t Find(absl::string_view text, absl::string_view delimiter, size_t pos) {
+ return text.find(delimiter, pos);
+ }
+ size_t Length(absl::string_view delimiter) { return delimiter.length(); }
+};
+
+// Finds using absl::string_view::find_first_of(), therefore the length of the
+// found delimiter is 1.
+struct AnyOfPolicy {
+ size_t Find(absl::string_view text, absl::string_view delimiter, size_t pos) {
+ return text.find_first_of(delimiter, pos);
+ }
+ size_t Length(absl::string_view /* delimiter */) { return 1; }
+};
+
+} // namespace
+
+//
+// ByString
+//
+
+ByString::ByString(absl::string_view sp) : delimiter_(sp) {}
+
+absl::string_view ByString::Find(absl::string_view text, size_t pos) const {
+ if (delimiter_.length() == 1) {
+ // Much faster to call find on a single character than on an
+ // absl::string_view.
+ size_t found_pos = text.find(delimiter_[0], pos);
+ if (found_pos == absl::string_view::npos)
+ return absl::string_view(text.end(), 0);
+ return text.substr(found_pos, 1);
+ }
+ return GenericFind(text, delimiter_, pos, LiteralPolicy());
+}
+
+//
+// ByChar
+//
+
+absl::string_view ByChar::Find(absl::string_view text, size_t pos) const {
+ size_t found_pos = text.find(c_, pos);
+ if (found_pos == absl::string_view::npos)
+ return absl::string_view(text.end(), 0);
+ return text.substr(found_pos, 1);
+}
+
+//
+// ByAnyChar
+//
+
+ByAnyChar::ByAnyChar(absl::string_view sp) : delimiters_(sp) {}
+
+absl::string_view ByAnyChar::Find(absl::string_view text, size_t pos) const {
+ return GenericFind(text, delimiters_, pos, AnyOfPolicy());
+}
+
+//
+// ByLength
+//
+ByLength::ByLength(ptrdiff_t length) : length_(length) {
+ ABSL_RAW_CHECK(length > 0, "");
+}
+
+absl::string_view ByLength::Find(absl::string_view text,
+ size_t pos) const {
+ pos = std::min(pos, text.size()); // truncate `pos`
+ absl::string_view substr = text.substr(pos);
+ // If the std::string is shorter than the chunk size we say we
+ // "can't find the delimiter" so this will be the last chunk.
+ if (substr.length() <= static_cast<size_t>(length_))
+ return absl::string_view(text.end(), 0);
+
+ return absl::string_view(substr.begin() + length_, 0);
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split.h
new file mode 100644
index 0000000..1f089b9
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split.h
@@ -0,0 +1,511 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: str_split.h
+// -----------------------------------------------------------------------------
+//
+// This file contains functions for splitting strings. It defines the main
+// `StrSplit()` function, several delimiters for determining the boundaries on
+// which to split the std::string, and predicates for filtering delimited results.
+// `StrSplit()` adapts the returned collection to the type specified by the
+// caller.
+//
+// Example:
+//
+// // Splits the given std::string on commas. Returns the results in a
+// // vector of strings.
+// std::vector<std::string> v = absl::StrSplit("a,b,c", ',');
+// // Can also use ","
+// // v[0] == "a", v[1] == "b", v[2] == "c"
+//
+// See StrSplit() below for more information.
+#ifndef ABSL_STRINGS_STR_SPLIT_H_
+#define ABSL_STRINGS_STR_SPLIT_H_
+
+#include <algorithm>
+#include <cstddef>
+#include <map>
+#include <set>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/strings/internal/str_split_internal.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
+
+namespace absl {
+
+//------------------------------------------------------------------------------
+// Delimiters
+//------------------------------------------------------------------------------
+//
+// `StrSplit()` uses delimiters to define the boundaries between elements in the
+// provided input. Several `Delimiter` types are defined below. If a std::string
+// (`const char*`, `std::string`, or `absl::string_view`) is passed in place of
+// an explicit `Delimiter` object, `StrSplit()` treats it the same way as if it
+// were passed a `ByString` delimiter.
+//
+// A `Delimiter` is an object with a `Find()` function that knows how to find
+// the first occurrence of itself in a given `absl::string_view`.
+//
+// The following `Delimiter` types are available for use within `StrSplit()`:
+//
+// - `ByString` (default for std::string arguments)
+// - `ByChar` (default for a char argument)
+// - `ByAnyChar`
+// - `ByLength`
+// - `MaxSplits`
+//
+//
+// A Delimiter's Find() member function will be passed the input text that is to
+// be split and the position to begin searching for the next delimiter in the
+// input text. The returned absl::string_view should refer to the next
+// occurrence (after pos) of the represented delimiter; this returned
+// absl::string_view represents the next location where the input std::string should
+// be broken. The returned absl::string_view may be zero-length if the Delimiter
+// does not represent a part of the std::string (e.g., a fixed-length delimiter). If
+// no delimiter is found in the given text, a zero-length absl::string_view
+// referring to text.end() should be returned (e.g.,
+// absl::string_view(text.end(), 0)). It is important that the returned
+// absl::string_view always be within the bounds of input text given as an
+// argument--it must not refer to a std::string that is physically located outside of
+// the given std::string.
+//
+// The following example is a simple Delimiter object that is created with a
+// single char and will look for that char in the text passed to the Find()
+// function:
+//
+// struct SimpleDelimiter {
+// const char c_;
+// explicit SimpleDelimiter(char c) : c_(c) {}
+// absl::string_view Find(absl::string_view text, size_t pos) {
+// auto found = text.find(c_, pos);
+// if (found == absl::string_view::npos)
+// return absl::string_view(text.end(), 0);
+//
+// return absl::string_view(text, found, 1);
+// }
+// };
+
+// ByString
+//
+// A sub-std::string delimiter. If `StrSplit()` is passed a std::string in place of a
+// `Delimiter` object, the std::string will be implicitly converted into a
+// `ByString` delimiter.
+//
+// Example:
+//
+// // Because a std::string literal is converted to an `absl::ByString`,
+// // the following two splits are equivalent.
+//
+// std::vector<std::string> v1 = absl::StrSplit("a, b, c", ", ");
+//
+// using absl::ByString;
+// std::vector<std::string> v2 = absl::StrSplit("a, b, c",
+// ByString(", "));
+// // v[0] == "a", v[1] == "b", v[2] == "c"
+class ByString {
+ public:
+ explicit ByString(absl::string_view sp);
+ absl::string_view Find(absl::string_view text, size_t pos) const;
+
+ private:
+ const std::string delimiter_;
+};
+
+// ByChar
+//
+// A single character delimiter. `ByChar` is functionally equivalent to a
+// 1-char std::string within a `ByString` delimiter, but slightly more
+// efficient.
+//
+// Example:
+//
+// // Because a char literal is converted to a absl::ByChar,
+// // the following two splits are equivalent.
+// std::vector<std::string> v1 = absl::StrSplit("a,b,c", ',');
+// using absl::ByChar;
+// std::vector<std::string> v2 = absl::StrSplit("a,b,c", ByChar(','));
+// // v[0] == "a", v[1] == "b", v[2] == "c"
+//
+// `ByChar` is also the default delimiter if a single character is given
+// as the delimiter to `StrSplit()`. For example, the following calls are
+// equivalent:
+//
+// std::vector<std::string> v = absl::StrSplit("a-b", '-');
+//
+// using absl::ByChar;
+// std::vector<std::string> v = absl::StrSplit("a-b", ByChar('-'));
+//
+class ByChar {
+ public:
+ explicit ByChar(char c) : c_(c) {}
+ absl::string_view Find(absl::string_view text, size_t pos) const;
+
+ private:
+ char c_;
+};
+
+// ByAnyChar
+//
+// A delimiter that will match any of the given byte-sized characters within
+// its provided std::string.
+//
+// Note: this delimiter works with single-byte std::string data, but does not work
+// with variable-width encodings, such as UTF-8.
+//
+// Example:
+//
+// using absl::ByAnyChar;
+// std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
+// // v[0] == "a", v[1] == "b", v[2] == "c"
+//
+// If `ByAnyChar` is given the empty std::string, it behaves exactly like
+// `ByString` and matches each individual character in the input std::string.
+//
+class ByAnyChar {
+ public:
+ explicit ByAnyChar(absl::string_view sp);
+ absl::string_view Find(absl::string_view text, size_t pos) const;
+
+ private:
+ const std::string delimiters_;
+};
+
+// ByLength
+//
+// A delimiter for splitting into equal-length strings. The length argument to
+// the constructor must be greater than 0.
+//
+// Note: this delimiter works with single-byte std::string data, but does not work
+// with variable-width encodings, such as UTF-8.
+//
+// Example:
+//
+// using absl::ByLength;
+// std::vector<std::string> v = absl::StrSplit("123456789", ByLength(3));
+
+// // v[0] == "123", v[1] == "456", v[2] == "789"
+//
+// Note that the std::string does not have to be a multiple of the fixed split
+// length. In such a case, the last substring will be shorter.
+//
+// using absl::ByLength;
+// std::vector<std::string> v = absl::StrSplit("12345", ByLength(2));
+//
+// // v[0] == "12", v[1] == "34", v[2] == "5"
+class ByLength {
+ public:
+ explicit ByLength(ptrdiff_t length);
+ absl::string_view Find(absl::string_view text, size_t pos) const;
+
+ private:
+ const ptrdiff_t length_;
+};
+
+namespace strings_internal {
+
+// A traits-like metafunction for selecting the default Delimiter object type
+// for a particular Delimiter type. The base case simply exposes type Delimiter
+// itself as the delimiter's Type. However, there are specializations for
+// std::string-like objects that map them to the ByString delimiter object.
+// This allows functions like absl::StrSplit() and absl::MaxSplits() to accept
+// std::string-like objects (e.g., ',') as delimiter arguments but they will be
+// treated as if a ByString delimiter was given.
+template <typename Delimiter>
+struct SelectDelimiter {
+ using type = Delimiter;
+};
+
+template <>
+struct SelectDelimiter<char> {
+ using type = ByChar;
+};
+template <>
+struct SelectDelimiter<char*> {
+ using type = ByString;
+};
+template <>
+struct SelectDelimiter<const char*> {
+ using type = ByString;
+};
+template <>
+struct SelectDelimiter<absl::string_view> {
+ using type = ByString;
+};
+template <>
+struct SelectDelimiter<std::string> {
+ using type = ByString;
+};
+
+// Wraps another delimiter and sets a max number of matches for that delimiter.
+template <typename Delimiter>
+class MaxSplitsImpl {
+ public:
+ MaxSplitsImpl(Delimiter delimiter, int limit)
+ : delimiter_(delimiter), limit_(limit), count_(0) {}
+ absl::string_view Find(absl::string_view text, size_t pos) {
+ if (count_++ == limit_) {
+ return absl::string_view(text.end(), 0); // No more matches.
+ }
+ return delimiter_.Find(text, pos);
+ }
+
+ private:
+ Delimiter delimiter_;
+ const int limit_;
+ int count_;
+};
+
+} // namespace strings_internal
+
+// MaxSplits()
+//
+// A delimiter that limits the number of matches which can occur to the passed
+// `limit`. The last element in the returned collection will contain all
+// remaining unsplit pieces, which may contain instances of the delimiter.
+// The collection will contain at most `limit` + 1 elements.
+// Example:
+//
+// using absl::MaxSplits;
+// std::vector<std::string> v = absl::StrSplit("a,b,c", MaxSplits(',', 1));
+//
+// // v[0] == "a", v[1] == "b,c"
+template <typename Delimiter>
+inline strings_internal::MaxSplitsImpl<
+ typename strings_internal::SelectDelimiter<Delimiter>::type>
+MaxSplits(Delimiter delimiter, int limit) {
+ typedef
+ typename strings_internal::SelectDelimiter<Delimiter>::type DelimiterType;
+ return strings_internal::MaxSplitsImpl<DelimiterType>(
+ DelimiterType(delimiter), limit);
+}
+
+//------------------------------------------------------------------------------
+// Predicates
+//------------------------------------------------------------------------------
+//
+// Predicates filter the results of a `StrSplit()` by determining whether or not
+// a resultant element is included in the result set. A predicate may be passed
+// as an optional third argument to the `StrSplit()` function.
+//
+// Predicates are unary functions (or functors) that take a single
+// `absl::string_view` argument and return a bool indicating whether the
+// argument should be included (`true`) or excluded (`false`).
+//
+// Predicates are useful when filtering out empty substrings. By default, empty
+// substrings may be returned by `StrSplit()`, which is similar to the way split
+// functions work in other programming languages.
+
+// AllowEmpty()
+//
+// Always returns `true`, indicating that all strings--including empty
+// strings--should be included in the split output. This predicate is not
+// strictly needed because this is the default behavior of `StrSplit()`;
+// however, it might be useful at some call sites to make the intent explicit.
+//
+// Example:
+//
+// std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', AllowEmpty());
+//
+// // v[0] == " a ", v[1] == " ", v[2] == "", v[3] = "b", v[4] == ""
+struct AllowEmpty {
+ bool operator()(absl::string_view) const { return true; }
+};
+
+// SkipEmpty()
+//
+// Returns `false` if the given `absl::string_view` is empty, indicating that
+// `StrSplit()` should omit the empty std::string.
+//
+// Example:
+//
+// std::vector<std::string> v = absl::StrSplit(",a,,b,", ',', SkipEmpty());
+//
+// // v[0] == "a", v[1] == "b"
+//
+// Note: `SkipEmpty()` does not consider a std::string containing only whitespace
+// to be empty. To skip such whitespace as well, use the `SkipWhitespace()`
+// predicate.
+struct SkipEmpty {
+ bool operator()(absl::string_view sp) const { return !sp.empty(); }
+};
+
+// SkipWhitespace()
+//
+// Returns `false` if the given `absl::string_view` is empty *or* contains only
+// whitespace, indicating that `StrSplit()` should omit the std::string.
+//
+// Example:
+//
+// std::vector<std::string> v = absl::StrSplit(" a , ,,b,",
+// ',', SkipWhitespace());
+// // v[0] == " a ", v[1] == "b"
+//
+// // SkipEmpty() would return whitespace elements
+// std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', SkipEmpty());
+// // v[0] == " a ", v[1] == " ", v[2] == "b"
+struct SkipWhitespace {
+ bool operator()(absl::string_view sp) const {
+ sp = absl::StripAsciiWhitespace(sp);
+ return !sp.empty();
+ }
+};
+
+//------------------------------------------------------------------------------
+// StrSplit()
+//------------------------------------------------------------------------------
+
+// StrSplit()
+//
+// Splits a given `std::string` based on the provided `Delimiter` object,
+// returning the elements within the type specified by the caller. Optionally,
+// you may also pass a `Predicate` to `StrSplit()` indicating whether to include
+// or exclude the resulting element within the final result set. (See the
+// overviews for Delimiters and Predicates above.)
+//
+// Example:
+//
+// std::vector<std::string> v = absl::StrSplit("a,b,c,d", ',');
+// // v[0] == "a", v[1] == "b", v[2] == "c", v[3] == "d"
+//
+// You can also provide an explicit `Delimiter` object:
+//
+// Example:
+//
+// using absl::ByAnyChar;
+// std::vector<std::string> v = absl::StrSplit("a,b=c", ByAnyChar(",="));
+// // v[0] == "a", v[1] == "b", v[2] == "c"
+//
+// See above for more information on delimiters.
+//
+// By default, empty strings are included in the result set. You can optionally
+// include a third `Predicate` argument to apply a test for whether the
+// resultant element should be included in the result set:
+//
+// Example:
+//
+// std::vector<std::string> v = absl::StrSplit(" a , ,,b,",
+// ',', SkipWhitespace());
+// // v[0] == " a ", v[1] == "b"
+//
+// See above for more information on predicates.
+//
+//------------------------------------------------------------------------------
+// StrSplit() Return Types
+//------------------------------------------------------------------------------
+//
+// The `StrSplit()` function adapts the returned collection to the collection
+// specified by the caller (e.g. `std::vector` above). The returned collections
+// may contain `string`, `absl::string_view` (in which case the original std::string
+// being split must ensure that it outlives the collection), or any object that
+// can be explicitly created from an `absl::string_view`. This behavior works
+// for:
+//
+// 1) All standard STL containers including `std::vector`, `std::list`,
+// `std::deque`, `std::set`,`std::multiset`, 'std::map`, and `std::multimap`
+// 2) `std::pair` (which is not actually a container). See below.
+//
+// Example:
+//
+// // The results are returned as `absl::string_view` objects. Note that we
+// // have to ensure that the input std::string outlives any results.
+// std::vector<absl::string_view> v = absl::StrSplit("a,b,c", ',');
+//
+// // Stores results in a std::set<std::string>, which also performs
+// // de-duplication and orders the elements in ascending order.
+// std::set<std::string> a = absl::StrSplit("b,a,c,a,b", ',');
+// // v[0] == "a", v[1] == "b", v[2] = "c"
+//
+// // `StrSplit()` can be used within a range-based for loop, in which case
+// // each element will be of type `absl::string_view`.
+// std::vector<std::string> v;
+// for (const auto sv : absl::StrSplit("a,b,c", ',')) {
+// if (sv != "b") v.emplace_back(sv);
+// }
+// // v[0] == "a", v[1] == "c"
+//
+// // Stores results in a map. The map implementation assumes that the input
+// // is provided as a series of key/value pairs. For example, the 0th element
+// // resulting from the split will be stored as a key to the 1st element. If
+// // an odd number of elements are resolved, the last element is paired with
+// // a default-constructed value (e.g., empty std::string).
+// std::map<std::string, std::string> m = absl::StrSplit("a,b,c", ',');
+// // m["a"] == "b", m["c"] == "" // last component value equals ""
+//
+// Splitting to `std::pair` is an interesting case because it can hold only two
+// elements and is not a collection type. When splitting to a `std::pair` the
+// first two split strings become the `std::pair` `.first` and `.second`
+// members, respectively. The remaining split substrings are discarded. If there
+// are less than two split substrings, the empty std::string is used for the
+// corresponding
+// `std::pair` member.
+//
+// Example:
+//
+// // Stores first two split strings as the members in a std::pair.
+// std::pair<std::string, std::string> p = absl::StrSplit("a,b,c", ',');
+// // p.first == "a", p.second == "b" // "c" is omitted.
+//
+// The `StrSplit()` function can be used multiple times to perform more
+// complicated splitting logic, such as intelligently parsing key-value pairs.
+//
+// Example:
+//
+// // The input std::string "a=b=c,d=e,f=,g" becomes
+// // { "a" => "b=c", "d" => "e", "f" => "", "g" => "" }
+// std::map<std::string, std::string> m;
+// for (absl::string_view sp : absl::StrSplit("a=b=c,d=e,f=,g", ',')) {
+// m.insert(absl::StrSplit(sp, absl::MaxSplits('=', 1)));
+// }
+// EXPECT_EQ("b=c", m.find("a")->second);
+// EXPECT_EQ("e", m.find("d")->second);
+// EXPECT_EQ("", m.find("f")->second);
+// EXPECT_EQ("", m.find("g")->second);
+//
+// WARNING: Due to a legacy bug that is maintained for backward compatibility,
+// splitting the following empty string_views produces different results:
+//
+// absl::StrSplit(absl::string_view(""), '-'); // {""}
+// absl::StrSplit(absl::string_view(), '-'); // {}, but should be {""}
+//
+// Try not to depend on this distinction because the bug may one day be fixed.
+template <typename Delimiter>
+strings_internal::Splitter<
+ typename strings_internal::SelectDelimiter<Delimiter>::type, AllowEmpty>
+StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d) {
+ using DelimiterType =
+ typename strings_internal::SelectDelimiter<Delimiter>::type;
+ return strings_internal::Splitter<DelimiterType, AllowEmpty>(
+ std::move(text), DelimiterType(d), AllowEmpty());
+}
+
+template <typename Delimiter, typename Predicate>
+strings_internal::Splitter<
+ typename strings_internal::SelectDelimiter<Delimiter>::type, Predicate>
+StrSplit(strings_internal::ConvertibleToStringView text, Delimiter d,
+ Predicate p) {
+ using DelimiterType =
+ typename strings_internal::SelectDelimiter<Delimiter>::type;
+ return strings_internal::Splitter<DelimiterType, Predicate>(
+ std::move(text), DelimiterType(d), std::move(p));
+}
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_STR_SPLIT_H_
[36/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_elf.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_elf.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_elf.inc
new file mode 100644
index 0000000..e21439c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_elf.inc
@@ -0,0 +1,1473 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This library provides Symbolize() function that symbolizes program
+// counters to their corresponding symbol names on linux platforms.
+// This library has a minimal implementation of an ELF symbol table
+// reader (i.e. it doesn't depend on libelf, etc.).
+//
+// The algorithm used in Symbolize() is as follows.
+//
+// 1. Go through a list of maps in /proc/self/maps and find the map
+// containing the program counter.
+//
+// 2. Open the mapped file and find a regular symbol table inside.
+// Iterate over symbols in the symbol table and look for the symbol
+// containing the program counter. If such a symbol is found,
+// obtain the symbol name, and demangle the symbol if possible.
+// If the symbol isn't found in the regular symbol table (binary is
+// stripped), try the same thing with a dynamic symbol table.
+//
+// Note that Symbolize() is originally implemented to be used in
+// signal handlers, hence it doesn't use malloc() and other unsafe
+// operations. It should be both thread-safe and async-signal-safe.
+//
+// Implementation note:
+//
+// We don't use heaps but only use stacks. We want to reduce the
+// stack consumption so that the symbolizer can run on small stacks.
+//
+// Here are some numbers collected with GCC 4.1.0 on x86:
+// - sizeof(Elf32_Sym) = 16
+// - sizeof(Elf32_Shdr) = 40
+// - sizeof(Elf64_Sym) = 24
+// - sizeof(Elf64_Shdr) = 64
+//
+// This implementation is intended to be async-signal-safe but uses some
+// functions which are not guaranteed to be so, such as memchr() and
+// memmove(). We assume they are async-signal-safe.
+
+#include <dlfcn.h>
+#include <elf.h>
+#include <fcntl.h>
+#include <link.h> // For ElfW() macro.
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cerrno>
+#include <cinttypes>
+#include <climits>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include "absl/base/casts.h"
+#include "absl/base/dynamic_annotations.h"
+#include "absl/base/internal/low_level_alloc.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/spinlock.h"
+#include "absl/base/port.h"
+#include "absl/debugging/internal/demangle.h"
+#include "absl/debugging/internal/vdso_support.h"
+
+namespace absl {
+
+// Value of argv[0]. Used by MaybeInitializeObjFile().
+static char *argv0_value = nullptr;
+
+void InitializeSymbolizer(const char *argv0) {
+ if (argv0_value != nullptr) {
+ free(argv0_value);
+ argv0_value = nullptr;
+ }
+ if (argv0 != nullptr && argv0[0] != '\0') {
+ argv0_value = strdup(argv0);
+ }
+}
+
+namespace debugging_internal {
+namespace {
+
+// Re-runs fn until it doesn't cause EINTR.
+#define NO_INTR(fn) \
+ do { \
+ } while ((fn) < 0 && errno == EINTR)
+
+// On Linux, ELF_ST_* are defined in <linux/elf.h>. To make this portable
+// we define our own ELF_ST_BIND and ELF_ST_TYPE if not available.
+#ifndef ELF_ST_BIND
+#define ELF_ST_BIND(info) (((unsigned char)(info)) >> 4)
+#endif
+
+#ifndef ELF_ST_TYPE
+#define ELF_ST_TYPE(info) (((unsigned char)(info)) & 0xF)
+#endif
+
+// Some platforms use a special .opd section to store function pointers.
+const char kOpdSectionName[] = ".opd";
+
+#if (defined(__powerpc__) && !(_CALL_ELF > 1)) || defined(__ia64)
+// Use opd section for function descriptors on these platforms, the function
+// address is the first word of the descriptor.
+enum { kPlatformUsesOPDSections = 1 };
+#else // not PPC or IA64
+enum { kPlatformUsesOPDSections = 0 };
+#endif
+
+// This works for PowerPC & IA64 only. A function descriptor consist of two
+// pointers and the first one is the function's entry.
+const size_t kFunctionDescriptorSize = sizeof(void *) * 2;
+
+const int kMaxDecorators = 10; // Seems like a reasonable upper limit.
+
+struct InstalledSymbolDecorator {
+ SymbolDecorator fn;
+ void *arg;
+ int ticket;
+};
+
+int g_num_decorators;
+InstalledSymbolDecorator g_decorators[kMaxDecorators];
+
+struct FileMappingHint {
+ const void *start;
+ const void *end;
+ uint64_t offset;
+ const char *filename;
+};
+
+// Protects g_decorators.
+// We are using SpinLock and not a Mutex here, because we may be called
+// from inside Mutex::Lock itself, and it prohibits recursive calls.
+// This happens in e.g. base/stacktrace_syscall_unittest.
+// Moreover, we are using only TryLock(), if the decorator list
+// is being modified (is busy), we skip all decorators, and possibly
+// loose some info. Sorry, that's the best we could do.
+base_internal::SpinLock g_decorators_mu(base_internal::kLinkerInitialized);
+
+const int kMaxFileMappingHints = 8;
+int g_num_file_mapping_hints;
+FileMappingHint g_file_mapping_hints[kMaxFileMappingHints];
+// Protects g_file_mapping_hints.
+base_internal::SpinLock g_file_mapping_mu(base_internal::kLinkerInitialized);
+
+// Async-signal-safe function to zero a buffer.
+// memset() is not guaranteed to be async-signal-safe.
+static void SafeMemZero(void* p, size_t size) {
+ unsigned char *c = static_cast<unsigned char *>(p);
+ while (size--) {
+ *c++ = 0;
+ }
+}
+
+struct ObjFile {
+ ObjFile()
+ : filename(nullptr),
+ start_addr(nullptr),
+ end_addr(nullptr),
+ offset(0),
+ fd(-1),
+ elf_type(-1) {
+ SafeMemZero(&elf_header, sizeof(elf_header));
+ }
+
+ char *filename;
+ const void *start_addr;
+ const void *end_addr;
+ uint64_t offset;
+
+ // The following fields are initialized on the first access to the
+ // object file.
+ int fd;
+ int elf_type;
+ ElfW(Ehdr) elf_header;
+};
+
+// Build 4-way associative cache for symbols. Within each cache line, symbols
+// are replaced in LRU order.
+enum {
+ ASSOCIATIVITY = 4,
+};
+struct SymbolCacheLine {
+ const void *pc[ASSOCIATIVITY];
+ char *name[ASSOCIATIVITY];
+
+ // age[i] is incremented when a line is accessed. it's reset to zero if the
+ // i'th entry is read.
+ uint32_t age[ASSOCIATIVITY];
+};
+
+// ---------------------------------------------------------------
+// An async-signal-safe arena for LowLevelAlloc
+static std::atomic<base_internal::LowLevelAlloc::Arena *> g_sig_safe_arena;
+
+static base_internal::LowLevelAlloc::Arena *SigSafeArena() {
+ return g_sig_safe_arena.load(std::memory_order_acquire);
+}
+
+static void InitSigSafeArena() {
+ if (SigSafeArena() == nullptr) {
+ base_internal::LowLevelAlloc::Arena *new_arena =
+ base_internal::LowLevelAlloc::NewArena(
+ base_internal::LowLevelAlloc::kAsyncSignalSafe);
+ base_internal::LowLevelAlloc::Arena *old_value = nullptr;
+ if (!g_sig_safe_arena.compare_exchange_strong(old_value, new_arena,
+ std::memory_order_release,
+ std::memory_order_relaxed)) {
+ // We lost a race to allocate an arena; deallocate.
+ base_internal::LowLevelAlloc::DeleteArena(new_arena);
+ }
+ }
+}
+
+// ---------------------------------------------------------------
+// An AddrMap is a vector of ObjFile, using SigSafeArena() for allocation.
+
+class AddrMap {
+ public:
+ AddrMap() : size_(0), allocated_(0), obj_(nullptr) {}
+ ~AddrMap() { base_internal::LowLevelAlloc::Free(obj_); }
+ int Size() const { return size_; }
+ ObjFile *At(int i) { return &obj_[i]; }
+ ObjFile *Add();
+ void Clear();
+
+ private:
+ int size_; // count of valid elements (<= allocated_)
+ int allocated_; // count of allocated elements
+ ObjFile *obj_; // array of allocated_ elements
+ AddrMap(const AddrMap &) = delete;
+ AddrMap &operator=(const AddrMap &) = delete;
+};
+
+void AddrMap::Clear() {
+ for (int i = 0; i != size_; i++) {
+ At(i)->~ObjFile();
+ }
+ size_ = 0;
+}
+
+ObjFile *AddrMap::Add() {
+ if (size_ == allocated_) {
+ int new_allocated = allocated_ * 2 + 50;
+ ObjFile *new_obj_ =
+ static_cast<ObjFile *>(base_internal::LowLevelAlloc::AllocWithArena(
+ new_allocated * sizeof(*new_obj_), SigSafeArena()));
+ if (obj_) {
+ memcpy(new_obj_, obj_, allocated_ * sizeof(*new_obj_));
+ base_internal::LowLevelAlloc::Free(obj_);
+ }
+ obj_ = new_obj_;
+ allocated_ = new_allocated;
+ }
+ return new (&obj_[size_++]) ObjFile;
+}
+
+// ---------------------------------------------------------------
+
+enum FindSymbolResult { SYMBOL_NOT_FOUND = 1, SYMBOL_TRUNCATED, SYMBOL_FOUND };
+
+class Symbolizer {
+ public:
+ Symbolizer();
+ ~Symbolizer();
+ const char *GetSymbol(const void *const pc);
+
+ private:
+ char *CopyString(const char *s) {
+ int len = strlen(s);
+ char *dst = static_cast<char *>(
+ base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena()));
+ ABSL_RAW_CHECK(dst != nullptr, "out of memory");
+ memcpy(dst, s, len + 1);
+ return dst;
+ }
+ ObjFile *FindObjFile(const void *const start,
+ size_t size) ABSL_ATTRIBUTE_NOINLINE;
+ static bool RegisterObjFile(const char *filename,
+ const void *const start_addr,
+ const void *const end_addr, uint64_t offset,
+ void *arg);
+ SymbolCacheLine *GetCacheLine(const void *const pc);
+ const char *FindSymbolInCache(const void *const pc);
+ const char *InsertSymbolInCache(const void *const pc, const char *name);
+ void AgeSymbols(SymbolCacheLine *line);
+ void ClearAddrMap();
+ FindSymbolResult GetSymbolFromObjectFile(const ObjFile &obj,
+ const void *const pc,
+ const ptrdiff_t relocation,
+ char *out, int out_size,
+ char *tmp_buf, int tmp_buf_size);
+
+ enum {
+ SYMBOL_BUF_SIZE = 2048,
+ TMP_BUF_SIZE = 1024,
+ SYMBOL_CACHE_LINES = 128,
+ };
+
+ AddrMap addr_map_;
+
+ bool ok_;
+ bool addr_map_read_;
+
+ char symbol_buf_[SYMBOL_BUF_SIZE];
+
+ // tmp_buf_ will be used to store arrays of ElfW(Shdr) and ElfW(Sym)
+ // so we ensure that tmp_buf_ is properly aligned to store either.
+ alignas(16) char tmp_buf_[TMP_BUF_SIZE];
+ static_assert(alignof(ElfW(Shdr)) <= 16,
+ "alignment of tmp buf too small for Shdr");
+ static_assert(alignof(ElfW(Sym)) <= 16,
+ "alignment of tmp buf too small for Sym");
+
+ SymbolCacheLine symbol_cache_[SYMBOL_CACHE_LINES];
+};
+
+static std::atomic<Symbolizer *> g_cached_symbolizer;
+
+} // namespace
+
+static int SymbolizerSize() {
+ int pagesize = getpagesize();
+ return ((sizeof(Symbolizer) - 1) / pagesize + 1) * pagesize;
+}
+
+// Return (and set null) g_cached_symbolized_state if it is not null.
+// Otherwise return a new symbolizer.
+static Symbolizer *AllocateSymbolizer() {
+ InitSigSafeArena();
+ Symbolizer *symbolizer =
+ g_cached_symbolizer.exchange(nullptr, std::memory_order_acquire);
+ if (symbolizer != nullptr) {
+ return symbolizer;
+ }
+ return new (base_internal::LowLevelAlloc::AllocWithArena(
+ SymbolizerSize(), SigSafeArena())) Symbolizer();
+}
+
+// Set g_cached_symbolize_state to s if it is null, otherwise
+// delete s.
+static void FreeSymbolizer(Symbolizer *s) {
+ Symbolizer *old_cached_symbolizer = nullptr;
+ if (!g_cached_symbolizer.compare_exchange_strong(old_cached_symbolizer, s,
+ std::memory_order_release,
+ std::memory_order_relaxed)) {
+ s->~Symbolizer();
+ base_internal::LowLevelAlloc::Free(s);
+ }
+}
+
+Symbolizer::Symbolizer() : ok_(true), addr_map_read_(false) {
+ for (SymbolCacheLine &symbol_cache_line : symbol_cache_) {
+ for (size_t j = 0; j < ABSL_ARRAYSIZE(symbol_cache_line.name); ++j) {
+ symbol_cache_line.pc[j] = nullptr;
+ symbol_cache_line.name[j] = nullptr;
+ symbol_cache_line.age[j] = 0;
+ }
+ }
+}
+
+Symbolizer::~Symbolizer() {
+ for (SymbolCacheLine &symbol_cache_line : symbol_cache_) {
+ for (char *s : symbol_cache_line.name) {
+ base_internal::LowLevelAlloc::Free(s);
+ }
+ }
+ ClearAddrMap();
+}
+
+// We don't use assert() since it's not guaranteed to be
+// async-signal-safe. Instead we define a minimal assertion
+// macro. So far, we don't need pretty printing for __FILE__, etc.
+#define SAFE_ASSERT(expr) ((expr) ? static_cast<void>(0) : abort())
+
+// Read up to "count" bytes from file descriptor "fd" into the buffer
+// starting at "buf" while handling short reads and EINTR. On
+// success, return the number of bytes read. Otherwise, return -1.
+static ssize_t ReadPersistent(int fd, void *buf, size_t count) {
+ SAFE_ASSERT(fd >= 0);
+ SAFE_ASSERT(count <= SSIZE_MAX);
+ char *buf0 = reinterpret_cast<char *>(buf);
+ size_t num_bytes = 0;
+ while (num_bytes < count) {
+ ssize_t len;
+ NO_INTR(len = read(fd, buf0 + num_bytes, count - num_bytes));
+ if (len < 0) { // There was an error other than EINTR.
+ ABSL_RAW_LOG(WARNING, "read failed: errno=%d", errno);
+ return -1;
+ }
+ if (len == 0) { // Reached EOF.
+ break;
+ }
+ num_bytes += len;
+ }
+ SAFE_ASSERT(num_bytes <= count);
+ return static_cast<ssize_t>(num_bytes);
+}
+
+// Read up to "count" bytes from "offset" in the file pointed by file
+// descriptor "fd" into the buffer starting at "buf". On success,
+// return the number of bytes read. Otherwise, return -1.
+static ssize_t ReadFromOffset(const int fd, void *buf, const size_t count,
+ const off_t offset) {
+ off_t off = lseek(fd, offset, SEEK_SET);
+ if (off == (off_t)-1) {
+ ABSL_RAW_LOG(WARNING, "lseek(%d, %ju, SEEK_SET) failed: errno=%d", fd,
+ static_cast<uintmax_t>(offset), errno);
+ return -1;
+ }
+ return ReadPersistent(fd, buf, count);
+}
+
+// Try reading exactly "count" bytes from "offset" bytes in a file
+// pointed by "fd" into the buffer starting at "buf" while handling
+// short reads and EINTR. On success, return true. Otherwise, return
+// false.
+static bool ReadFromOffsetExact(const int fd, void *buf, const size_t count,
+ const off_t offset) {
+ ssize_t len = ReadFromOffset(fd, buf, count, offset);
+ return len >= 0 && static_cast<size_t>(len) == count;
+}
+
+// Returns elf_header.e_type if the file pointed by fd is an ELF binary.
+static int FileGetElfType(const int fd) {
+ ElfW(Ehdr) elf_header;
+ if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
+ return -1;
+ }
+ if (memcmp(elf_header.e_ident, ELFMAG, SELFMAG) != 0) {
+ return -1;
+ }
+ return elf_header.e_type;
+}
+
+// Read the section headers in the given ELF binary, and if a section
+// of the specified type is found, set the output to this section header
+// and return true. Otherwise, return false.
+// To keep stack consumption low, we would like this function to not get
+// inlined.
+static ABSL_ATTRIBUTE_NOINLINE bool GetSectionHeaderByType(
+ const int fd, ElfW(Half) sh_num, const off_t sh_offset, ElfW(Word) type,
+ ElfW(Shdr) * out, char *tmp_buf, int tmp_buf_size) {
+ ElfW(Shdr) *buf = reinterpret_cast<ElfW(Shdr) *>(tmp_buf);
+ const int buf_entries = tmp_buf_size / sizeof(buf[0]);
+ const int buf_bytes = buf_entries * sizeof(buf[0]);
+
+ for (int i = 0; i < sh_num;) {
+ const ssize_t num_bytes_left = (sh_num - i) * sizeof(buf[0]);
+ const ssize_t num_bytes_to_read =
+ (buf_bytes > num_bytes_left) ? num_bytes_left : buf_bytes;
+ const off_t offset = sh_offset + i * sizeof(buf[0]);
+ const ssize_t len = ReadFromOffset(fd, buf, num_bytes_to_read, offset);
+ if (len % sizeof(buf[0]) != 0) {
+ ABSL_RAW_LOG(
+ WARNING,
+ "Reading %zd bytes from offset %ju returned %zd which is not a "
+ "multiple of %zu.",
+ num_bytes_to_read, static_cast<uintmax_t>(offset), len,
+ sizeof(buf[0]));
+ return false;
+ }
+ const ssize_t num_headers_in_buf = len / sizeof(buf[0]);
+ SAFE_ASSERT(num_headers_in_buf <= buf_entries);
+ for (int j = 0; j < num_headers_in_buf; ++j) {
+ if (buf[j].sh_type == type) {
+ *out = buf[j];
+ return true;
+ }
+ }
+ i += num_headers_in_buf;
+ }
+ return false;
+}
+
+// There is no particular reason to limit section name to 63 characters,
+// but there has (as yet) been no need for anything longer either.
+const int kMaxSectionNameLen = 64;
+
+bool ForEachSection(int fd,
+ const std::function<bool(const std::string &name,
+ const ElfW(Shdr) &)> &callback) {
+ ElfW(Ehdr) elf_header;
+ if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
+ return false;
+ }
+
+ ElfW(Shdr) shstrtab;
+ off_t shstrtab_offset =
+ (elf_header.e_shoff + elf_header.e_shentsize * elf_header.e_shstrndx);
+ if (!ReadFromOffsetExact(fd, &shstrtab, sizeof(shstrtab), shstrtab_offset)) {
+ return false;
+ }
+
+ for (int i = 0; i < elf_header.e_shnum; ++i) {
+ ElfW(Shdr) out;
+ off_t section_header_offset =
+ (elf_header.e_shoff + elf_header.e_shentsize * i);
+ if (!ReadFromOffsetExact(fd, &out, sizeof(out), section_header_offset)) {
+ return false;
+ }
+ off_t name_offset = shstrtab.sh_offset + out.sh_name;
+ char header_name[kMaxSectionNameLen + 1];
+ ssize_t n_read =
+ ReadFromOffset(fd, &header_name, kMaxSectionNameLen, name_offset);
+ if (n_read == -1) {
+ return false;
+ } else if (n_read > kMaxSectionNameLen) {
+ // Long read?
+ return false;
+ }
+ header_name[n_read] = '\0';
+
+ std::string name(header_name);
+ if (!callback(name, out)) {
+ break;
+ }
+ }
+ return true;
+}
+
+// name_len should include terminating '\0'.
+bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
+ ElfW(Shdr) * out) {
+ char header_name[kMaxSectionNameLen];
+ if (sizeof(header_name) < name_len) {
+ ABSL_RAW_LOG(WARNING,
+ "Section name '%s' is too long (%zu); "
+ "section will not be found (even if present).",
+ name, name_len);
+ // No point in even trying.
+ return false;
+ }
+
+ ElfW(Ehdr) elf_header;
+ if (!ReadFromOffsetExact(fd, &elf_header, sizeof(elf_header), 0)) {
+ return false;
+ }
+
+ ElfW(Shdr) shstrtab;
+ off_t shstrtab_offset =
+ (elf_header.e_shoff + elf_header.e_shentsize * elf_header.e_shstrndx);
+ if (!ReadFromOffsetExact(fd, &shstrtab, sizeof(shstrtab), shstrtab_offset)) {
+ return false;
+ }
+
+ for (int i = 0; i < elf_header.e_shnum; ++i) {
+ off_t section_header_offset =
+ (elf_header.e_shoff + elf_header.e_shentsize * i);
+ if (!ReadFromOffsetExact(fd, out, sizeof(*out), section_header_offset)) {
+ return false;
+ }
+ off_t name_offset = shstrtab.sh_offset + out->sh_name;
+ ssize_t n_read = ReadFromOffset(fd, &header_name, name_len, name_offset);
+ if (n_read < 0) {
+ return false;
+ } else if (static_cast<size_t>(n_read) != name_len) {
+ // Short read -- name could be at end of file.
+ continue;
+ }
+ if (memcmp(header_name, name, name_len) == 0) {
+ return true;
+ }
+ }
+ return false;
+}
+
+// Compare symbols at in the same address.
+// Return true if we should pick symbol1.
+static bool ShouldPickFirstSymbol(const ElfW(Sym) & symbol1,
+ const ElfW(Sym) & symbol2) {
+ // If one of the symbols is weak and the other is not, pick the one
+ // this is not a weak symbol.
+ char bind1 = ELF_ST_BIND(symbol1.st_info);
+ char bind2 = ELF_ST_BIND(symbol1.st_info);
+ if (bind1 == STB_WEAK && bind2 != STB_WEAK) return false;
+ if (bind2 == STB_WEAK && bind1 != STB_WEAK) return true;
+
+ // If one of the symbols has zero size and the other is not, pick the
+ // one that has non-zero size.
+ if (symbol1.st_size != 0 && symbol2.st_size == 0) {
+ return true;
+ }
+ if (symbol1.st_size == 0 && symbol2.st_size != 0) {
+ return false;
+ }
+
+ // If one of the symbols has no type and the other is not, pick the
+ // one that has a type.
+ char type1 = ELF_ST_TYPE(symbol1.st_info);
+ char type2 = ELF_ST_TYPE(symbol1.st_info);
+ if (type1 != STT_NOTYPE && type2 == STT_NOTYPE) {
+ return true;
+ }
+ if (type1 == STT_NOTYPE && type2 != STT_NOTYPE) {
+ return false;
+ }
+
+ // Pick the first one, if we still cannot decide.
+ return true;
+}
+
+// Return true if an address is inside a section.
+static bool InSection(const void *address, const ElfW(Shdr) * section) {
+ const char *start = reinterpret_cast<const char *>(section->sh_addr);
+ size_t size = static_cast<size_t>(section->sh_size);
+ return start <= address && address < (start + size);
+}
+
+// Read a symbol table and look for the symbol containing the
+// pc. Iterate over symbols in a symbol table and look for the symbol
+// containing "pc". If the symbol is found, and its name fits in
+// out_size, the name is written into out and SYMBOL_FOUND is returned.
+// If the name does not fit, truncated name is written into out,
+// and SYMBOL_TRUNCATED is returned. Out is NUL-terminated.
+// If the symbol is not found, SYMBOL_NOT_FOUND is returned;
+// To keep stack consumption low, we would like this function to not get
+// inlined.
+static ABSL_ATTRIBUTE_NOINLINE FindSymbolResult FindSymbol(
+ const void *const pc, const int fd, char *out, int out_size,
+ ptrdiff_t relocation, const ElfW(Shdr) * strtab, const ElfW(Shdr) * symtab,
+ const ElfW(Shdr) * opd, char *tmp_buf, int tmp_buf_size) {
+ if (symtab == nullptr) {
+ return SYMBOL_NOT_FOUND;
+ }
+
+ // Read multiple symbols at once to save read() calls.
+ ElfW(Sym) *buf = reinterpret_cast<ElfW(Sym) *>(tmp_buf);
+ const int buf_entries = tmp_buf_size / sizeof(buf[0]);
+
+ const int num_symbols = symtab->sh_size / symtab->sh_entsize;
+
+ // On platforms using an .opd section (PowerPC & IA64), a function symbol
+ // has the address of a function descriptor, which contains the real
+ // starting address. However, we do not always want to use the real
+ // starting address because we sometimes want to symbolize a function
+ // pointer into the .opd section, e.g. FindSymbol(&foo,...).
+ const bool pc_in_opd =
+ kPlatformUsesOPDSections && opd != nullptr && InSection(pc, opd);
+ const bool deref_function_descriptor_pointer =
+ kPlatformUsesOPDSections && opd != nullptr && !pc_in_opd;
+
+ ElfW(Sym) best_match;
+ SafeMemZero(&best_match, sizeof(best_match));
+ bool found_match = false;
+ for (int i = 0; i < num_symbols;) {
+ off_t offset = symtab->sh_offset + i * symtab->sh_entsize;
+ const int num_remaining_symbols = num_symbols - i;
+ const int entries_in_chunk = std::min(num_remaining_symbols, buf_entries);
+ const int bytes_in_chunk = entries_in_chunk * sizeof(buf[0]);
+ const ssize_t len = ReadFromOffset(fd, buf, bytes_in_chunk, offset);
+ SAFE_ASSERT(len % sizeof(buf[0]) == 0);
+ const ssize_t num_symbols_in_buf = len / sizeof(buf[0]);
+ SAFE_ASSERT(num_symbols_in_buf <= entries_in_chunk);
+ for (int j = 0; j < num_symbols_in_buf; ++j) {
+ const ElfW(Sym) &symbol = buf[j];
+
+ // For a DSO, a symbol address is relocated by the loading address.
+ // We keep the original address for opd redirection below.
+ const char *const original_start_address =
+ reinterpret_cast<const char *>(symbol.st_value);
+ const char *start_address = original_start_address + relocation;
+
+ if (deref_function_descriptor_pointer &&
+ InSection(original_start_address, opd)) {
+ // The opd section is mapped into memory. Just dereference
+ // start_address to get the first double word, which points to the
+ // function entry.
+ start_address = *reinterpret_cast<const char *const *>(start_address);
+ }
+
+ // If pc is inside the .opd section, it points to a function descriptor.
+ const size_t size = pc_in_opd ? kFunctionDescriptorSize : symbol.st_size;
+ const void *const end_address =
+ reinterpret_cast<const char *>(start_address) + size;
+ if (symbol.st_value != 0 && // Skip null value symbols.
+ symbol.st_shndx != 0 && // Skip undefined symbols.
+#ifdef STT_TLS
+ ELF_ST_TYPE(symbol.st_info) != STT_TLS && // Skip thread-local data.
+#endif // STT_TLS
+ ((start_address <= pc && pc < end_address) ||
+ (start_address == pc && pc == end_address))) {
+ if (!found_match || ShouldPickFirstSymbol(symbol, best_match)) {
+ found_match = true;
+ best_match = symbol;
+ }
+ }
+ }
+ i += num_symbols_in_buf;
+ }
+
+ if (found_match) {
+ const size_t off = strtab->sh_offset + best_match.st_name;
+ const ssize_t n_read = ReadFromOffset(fd, out, out_size, off);
+ if (n_read <= 0) {
+ // This should never happen.
+ ABSL_RAW_LOG(WARNING,
+ "Unable to read from fd %d at offset %zu: n_read = %zd", fd,
+ off, n_read);
+ return SYMBOL_NOT_FOUND;
+ }
+ ABSL_RAW_CHECK(n_read <= out_size, "ReadFromOffset read too much data.");
+
+ // strtab->sh_offset points into .strtab-like section that contains
+ // NUL-terminated strings: '\0foo\0barbaz\0...".
+ //
+ // sh_offset+st_name points to the start of symbol name, but we don't know
+ // how long the symbol is, so we try to read as much as we have space for,
+ // and usually over-read (i.e. there is a NUL somewhere before n_read).
+ if (memchr(out, '\0', n_read) == nullptr) {
+ // Either out_size was too small (n_read == out_size and no NUL), or
+ // we tried to read past the EOF (n_read < out_size) and .strtab is
+ // corrupt (missing terminating NUL; should never happen for valid ELF).
+ out[n_read - 1] = '\0';
+ return SYMBOL_TRUNCATED;
+ }
+ return SYMBOL_FOUND;
+ }
+
+ return SYMBOL_NOT_FOUND;
+}
+
+// Get the symbol name of "pc" from the file pointed by "fd". Process
+// both regular and dynamic symbol tables if necessary.
+// See FindSymbol() comment for description of return value.
+FindSymbolResult Symbolizer::GetSymbolFromObjectFile(
+ const ObjFile &obj, const void *const pc, const ptrdiff_t relocation,
+ char *out, int out_size, char *tmp_buf, int tmp_buf_size) {
+ ElfW(Shdr) symtab;
+ ElfW(Shdr) strtab;
+ ElfW(Shdr) opd;
+ ElfW(Shdr) *opd_ptr = nullptr;
+
+ // On platforms using an .opd sections for function descriptor, read
+ // the section header. The .opd section is in data segment and should be
+ // loaded but we check that it is mapped just to be extra careful.
+ if (kPlatformUsesOPDSections) {
+ if (GetSectionHeaderByName(obj.fd, kOpdSectionName,
+ sizeof(kOpdSectionName) - 1, &opd) &&
+ FindObjFile(reinterpret_cast<const char *>(opd.sh_addr) + relocation,
+ opd.sh_size) != nullptr) {
+ opd_ptr = &opd;
+ } else {
+ return SYMBOL_NOT_FOUND;
+ }
+ }
+
+ // Consult a regular symbol table first.
+ if (!GetSectionHeaderByType(obj.fd, obj.elf_header.e_shnum,
+ obj.elf_header.e_shoff, SHT_SYMTAB, &symtab,
+ tmp_buf, tmp_buf_size)) {
+ return SYMBOL_NOT_FOUND;
+ }
+ if (!ReadFromOffsetExact(
+ obj.fd, &strtab, sizeof(strtab),
+ obj.elf_header.e_shoff + symtab.sh_link * sizeof(symtab))) {
+ return SYMBOL_NOT_FOUND;
+ }
+ const FindSymbolResult rc =
+ FindSymbol(pc, obj.fd, out, out_size, relocation, &strtab, &symtab,
+ opd_ptr, tmp_buf, tmp_buf_size);
+ if (rc != SYMBOL_NOT_FOUND) {
+ return rc; // Found the symbol in a regular symbol table.
+ }
+
+ // If the symbol is not found, then consult a dynamic symbol table.
+ if (!GetSectionHeaderByType(obj.fd, obj.elf_header.e_shnum,
+ obj.elf_header.e_shoff, SHT_DYNSYM, &symtab,
+ tmp_buf, tmp_buf_size)) {
+ return SYMBOL_NOT_FOUND;
+ }
+ if (!ReadFromOffsetExact(
+ obj.fd, &strtab, sizeof(strtab),
+ obj.elf_header.e_shoff + symtab.sh_link * sizeof(symtab))) {
+ return SYMBOL_NOT_FOUND;
+ }
+ return FindSymbol(pc, obj.fd, out, out_size, relocation, &strtab, &symtab,
+ opd_ptr, tmp_buf, tmp_buf_size);
+}
+
+namespace {
+// Thin wrapper around a file descriptor so that the file descriptor
+// gets closed for sure.
+class FileDescriptor {
+ public:
+ explicit FileDescriptor(int fd) : fd_(fd) {}
+ FileDescriptor(const FileDescriptor &) = delete;
+ FileDescriptor &operator=(const FileDescriptor &) = delete;
+
+ ~FileDescriptor() {
+ if (fd_ >= 0) {
+ NO_INTR(close(fd_));
+ }
+ }
+
+ int get() const { return fd_; }
+
+ private:
+ const int fd_;
+};
+
+// Helper class for reading lines from file.
+//
+// Note: we don't use ProcMapsIterator since the object is big (it has
+// a 5k array member) and uses async-unsafe functions such as sscanf()
+// and snprintf().
+class LineReader {
+ public:
+ explicit LineReader(int fd, char *buf, int buf_len)
+ : fd_(fd),
+ buf_len_(buf_len),
+ buf_(buf),
+ bol_(buf),
+ eol_(buf),
+ eod_(buf) {}
+
+ LineReader(const LineReader &) = delete;
+ LineReader &operator=(const LineReader &) = delete;
+
+ // Read '\n'-terminated line from file. On success, modify "bol"
+ // and "eol", then return true. Otherwise, return false.
+ //
+ // Note: if the last line doesn't end with '\n', the line will be
+ // dropped. It's an intentional behavior to make the code simple.
+ bool ReadLine(const char **bol, const char **eol) {
+ if (BufferIsEmpty()) { // First time.
+ const ssize_t num_bytes = ReadPersistent(fd_, buf_, buf_len_);
+ if (num_bytes <= 0) { // EOF or error.
+ return false;
+ }
+ eod_ = buf_ + num_bytes;
+ bol_ = buf_;
+ } else {
+ bol_ = eol_ + 1; // Advance to the next line in the buffer.
+ SAFE_ASSERT(bol_ <= eod_); // "bol_" can point to "eod_".
+ if (!HasCompleteLine()) {
+ const int incomplete_line_length = eod_ - bol_;
+ // Move the trailing incomplete line to the beginning.
+ memmove(buf_, bol_, incomplete_line_length);
+ // Read text from file and append it.
+ char *const append_pos = buf_ + incomplete_line_length;
+ const int capacity_left = buf_len_ - incomplete_line_length;
+ const ssize_t num_bytes =
+ ReadPersistent(fd_, append_pos, capacity_left);
+ if (num_bytes <= 0) { // EOF or error.
+ return false;
+ }
+ eod_ = append_pos + num_bytes;
+ bol_ = buf_;
+ }
+ }
+ eol_ = FindLineFeed();
+ if (eol_ == nullptr) { // '\n' not found. Malformed line.
+ return false;
+ }
+ *eol_ = '\0'; // Replace '\n' with '\0'.
+
+ *bol = bol_;
+ *eol = eol_;
+ return true;
+ }
+
+ private:
+ char *FindLineFeed() const {
+ return reinterpret_cast<char *>(memchr(bol_, '\n', eod_ - bol_));
+ }
+
+ bool BufferIsEmpty() const { return buf_ == eod_; }
+
+ bool HasCompleteLine() const {
+ return !BufferIsEmpty() && FindLineFeed() != nullptr;
+ }
+
+ const int fd_;
+ const int buf_len_;
+ char *const buf_;
+ char *bol_;
+ char *eol_;
+ const char *eod_; // End of data in "buf_".
+};
+} // namespace
+
+// Place the hex number read from "start" into "*hex". The pointer to
+// the first non-hex character or "end" is returned.
+static const char *GetHex(const char *start, const char *end,
+ uint64_t *const value) {
+ uint64_t hex = 0;
+ const char *p;
+ for (p = start; p < end; ++p) {
+ int ch = *p;
+ if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'F') ||
+ (ch >= 'a' && ch <= 'f')) {
+ hex = (hex << 4) | (ch < 'A' ? ch - '0' : (ch & 0xF) + 9);
+ } else { // Encountered the first non-hex character.
+ break;
+ }
+ }
+ SAFE_ASSERT(p <= end);
+ *value = hex;
+ return p;
+}
+
+static const char *GetHex(const char *start, const char *end,
+ const void **const addr) {
+ uint64_t hex = 0;
+ const char *p = GetHex(start, end, &hex);
+ *addr = reinterpret_cast<void *>(hex);
+ return p;
+}
+
+// Read /proc/self/maps and run "callback" for each mmapped file found. If
+// "callback" returns false, stop scanning and return true. Else continue
+// scanning /proc/self/maps. Return true if no parse error is found.
+static ABSL_ATTRIBUTE_NOINLINE bool ReadAddrMap(
+ bool (*callback)(const char *filename, const void *const start_addr,
+ const void *const end_addr, uint64_t offset, void *arg),
+ void *arg, void *tmp_buf, int tmp_buf_size) {
+ // Use /proc/self/task/<pid>/maps instead of /proc/self/maps. The latter
+ // requires kernel to stop all threads, and is significantly slower when there
+ // are 1000s of threads.
+ char maps_path[80];
+ snprintf(maps_path, sizeof(maps_path), "/proc/self/task/%d/maps", getpid());
+
+ int maps_fd;
+ NO_INTR(maps_fd = open(maps_path, O_RDONLY));
+ FileDescriptor wrapped_maps_fd(maps_fd);
+ if (wrapped_maps_fd.get() < 0) {
+ ABSL_RAW_LOG(WARNING, "%s: errno=%d", maps_path, errno);
+ return false;
+ }
+
+ // Iterate over maps and look for the map containing the pc. Then
+ // look into the symbol tables inside.
+ LineReader reader(wrapped_maps_fd.get(), static_cast<char *>(tmp_buf),
+ tmp_buf_size);
+ while (true) {
+ const char *cursor;
+ const char *eol;
+ if (!reader.ReadLine(&cursor, &eol)) { // EOF or malformed line.
+ break;
+ }
+
+ const char *line = cursor;
+ const void *start_address;
+ // Start parsing line in /proc/self/maps. Here is an example:
+ //
+ // 08048000-0804c000 r-xp 00000000 08:01 2142121 /bin/cat
+ //
+ // We want start address (08048000), end address (0804c000), flags
+ // (r-xp) and file name (/bin/cat).
+
+ // Read start address.
+ cursor = GetHex(cursor, eol, &start_address);
+ if (cursor == eol || *cursor != '-') {
+ ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line);
+ return false;
+ }
+ ++cursor; // Skip '-'.
+
+ // Read end address.
+ const void *end_address;
+ cursor = GetHex(cursor, eol, &end_address);
+ if (cursor == eol || *cursor != ' ') {
+ ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps line: %s", line);
+ return false;
+ }
+ ++cursor; // Skip ' '.
+
+ // Read flags. Skip flags until we encounter a space or eol.
+ const char *const flags_start = cursor;
+ while (cursor < eol && *cursor != ' ') {
+ ++cursor;
+ }
+ // We expect at least four letters for flags (ex. "r-xp").
+ if (cursor == eol || cursor < flags_start + 4) {
+ ABSL_RAW_LOG(WARNING, "Corrupt /proc/self/maps: %s", line);
+ return false;
+ }
+
+ // Check flags. Normally we are only interested in "r-x" maps. On
+ // the PowerPC, function pointers point to descriptors in the .opd
+ // section. The descriptors themselves are not executable code. So
+ // we need to relax the check below to "r**".
+ if (memcmp(flags_start, "r-x", 3) != 0 && // Not a "r-x" map.
+ !(kPlatformUsesOPDSections && flags_start[0] == 'r')) {
+ continue; // We skip this map.
+ }
+ ++cursor; // Skip ' '.
+
+ // Read file offset.
+ uint64_t offset;
+ cursor = GetHex(cursor, eol, &offset);
+ ++cursor; // Skip ' '.
+
+ // Skip to file name. "cursor" now points to dev. We need to skip at least
+ // two spaces for dev and inode.
+ int num_spaces = 0;
+ while (cursor < eol) {
+ if (*cursor == ' ') {
+ ++num_spaces;
+ } else if (num_spaces >= 2) {
+ // The first non-space character after skipping two spaces
+ // is the beginning of the file name.
+ break;
+ }
+ ++cursor;
+ }
+
+ // Check whether this entry corresponds to our hint table for the true
+ // filename.
+ bool hinted =
+ GetFileMappingHint(&start_address, &end_address, &offset, &cursor);
+ if (!hinted && (cursor == eol || cursor[0] == '[')) {
+ // not an object file, typically [vdso] or [vsyscall]
+ continue;
+ }
+ if (!callback(cursor, start_address, end_address, offset, arg)) break;
+ }
+ return true;
+}
+
+// Find the objfile mapped in address region containing [addr, addr + len).
+ObjFile *Symbolizer::FindObjFile(const void *const addr, size_t len) {
+ for (int i = 0; i < 2; ++i) {
+ if (!ok_) return nullptr;
+
+ // Read /proc/self/maps if necessary
+ if (!addr_map_read_) {
+ addr_map_read_ = true;
+ if (!ReadAddrMap(RegisterObjFile, this, tmp_buf_, TMP_BUF_SIZE)) {
+ ok_ = false;
+ return nullptr;
+ }
+ }
+
+ int lo = 0;
+ int hi = addr_map_.Size();
+ while (lo < hi) {
+ int mid = (lo + hi) / 2;
+ if (addr < addr_map_.At(mid)->end_addr) {
+ hi = mid;
+ } else {
+ lo = mid + 1;
+ }
+ }
+ if (lo != addr_map_.Size()) {
+ ObjFile *obj = addr_map_.At(lo);
+ SAFE_ASSERT(obj->end_addr > addr);
+ if (addr >= obj->start_addr &&
+ reinterpret_cast<const char *>(addr) + len <= obj->end_addr)
+ return obj;
+ }
+
+ // The address mapping may have changed since it was last read. Retry.
+ ClearAddrMap();
+ }
+ return nullptr;
+}
+
+void Symbolizer::ClearAddrMap() {
+ for (int i = 0; i != addr_map_.Size(); i++) {
+ ObjFile *o = addr_map_.At(i);
+ base_internal::LowLevelAlloc::Free(o->filename);
+ if (o->fd >= 0) {
+ NO_INTR(close(o->fd));
+ }
+ }
+ addr_map_.Clear();
+ addr_map_read_ = false;
+}
+
+// Callback for ReadAddrMap to register objfiles in an in-memory table.
+bool Symbolizer::RegisterObjFile(const char *filename,
+ const void *const start_addr,
+ const void *const end_addr, uint64_t offset,
+ void *arg) {
+ Symbolizer *impl = static_cast<Symbolizer *>(arg);
+
+ // Files are supposed to be added in the increasing address order. Make
+ // sure that's the case.
+ int addr_map_size = impl->addr_map_.Size();
+ if (addr_map_size != 0) {
+ ObjFile *old = impl->addr_map_.At(addr_map_size - 1);
+ if (old->end_addr > end_addr) {
+ ABSL_RAW_LOG(ERROR,
+ "Unsorted addr map entry: 0x%" PRIxPTR ": %s <-> 0x%" PRIxPTR
+ ": %s",
+ reinterpret_cast<uintptr_t>(end_addr), filename,
+ reinterpret_cast<uintptr_t>(old->end_addr), old->filename);
+ return true;
+ } else if (old->end_addr == end_addr) {
+ // The same entry appears twice. This sometimes happens for [vdso].
+ if (old->start_addr != start_addr ||
+ strcmp(old->filename, filename) != 0) {
+ ABSL_RAW_LOG(ERROR,
+ "Duplicate addr 0x%" PRIxPTR ": %s <-> 0x%" PRIxPTR ": %s",
+ reinterpret_cast<uintptr_t>(end_addr), filename,
+ reinterpret_cast<uintptr_t>(old->end_addr), old->filename);
+ }
+ return true;
+ }
+ }
+ ObjFile *obj = impl->addr_map_.Add();
+ obj->filename = impl->CopyString(filename);
+ obj->start_addr = start_addr;
+ obj->end_addr = end_addr;
+ obj->offset = offset;
+ obj->elf_type = -1; // filled on demand
+ obj->fd = -1; // opened on demand
+ return true;
+}
+
+// This function wraps the Demangle function to provide an interface
+// where the input symbol is demangled in-place.
+// To keep stack consumption low, we would like this function to not
+// get inlined.
+static ABSL_ATTRIBUTE_NOINLINE void DemangleInplace(char *out, int out_size,
+ char *tmp_buf,
+ int tmp_buf_size) {
+ if (Demangle(out, tmp_buf, tmp_buf_size)) {
+ // Demangling succeeded. Copy to out if the space allows.
+ int len = strlen(tmp_buf);
+ if (len + 1 <= out_size) { // +1 for '\0'.
+ SAFE_ASSERT(len < tmp_buf_size);
+ memmove(out, tmp_buf, len + 1);
+ }
+ }
+}
+
+SymbolCacheLine *Symbolizer::GetCacheLine(const void *const pc) {
+ uintptr_t pc0 = reinterpret_cast<uintptr_t>(pc);
+ pc0 >>= 3; // drop the low 3 bits
+
+ // Shuffle bits.
+ pc0 ^= (pc0 >> 6) ^ (pc0 >> 12) ^ (pc0 >> 18);
+ return &symbol_cache_[pc0 % SYMBOL_CACHE_LINES];
+}
+
+void Symbolizer::AgeSymbols(SymbolCacheLine *line) {
+ for (uint32_t &age : line->age) {
+ ++age;
+ }
+}
+
+const char *Symbolizer::FindSymbolInCache(const void *const pc) {
+ if (pc == nullptr) return nullptr;
+
+ SymbolCacheLine *line = GetCacheLine(pc);
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(line->pc); ++i) {
+ if (line->pc[i] == pc) {
+ AgeSymbols(line);
+ line->age[i] = 0;
+ return line->name[i];
+ }
+ }
+ return nullptr;
+}
+
+const char *Symbolizer::InsertSymbolInCache(const void *const pc,
+ const char *name) {
+ SAFE_ASSERT(pc != nullptr);
+
+ SymbolCacheLine *line = GetCacheLine(pc);
+ uint32_t max_age = 0;
+ int oldest_index = -1;
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(line->pc); ++i) {
+ if (line->pc[i] == nullptr) {
+ AgeSymbols(line);
+ line->pc[i] = pc;
+ line->name[i] = CopyString(name);
+ line->age[i] = 0;
+ return line->name[i];
+ }
+ if (line->age[i] >= max_age) {
+ max_age = line->age[i];
+ oldest_index = i;
+ }
+ }
+
+ AgeSymbols(line);
+ ABSL_RAW_CHECK(oldest_index >= 0, "Corrupt cache");
+ base_internal::LowLevelAlloc::Free(line->name[oldest_index]);
+ line->pc[oldest_index] = pc;
+ line->name[oldest_index] = CopyString(name);
+ line->age[oldest_index] = 0;
+ return line->name[oldest_index];
+}
+
+static void MaybeOpenFdFromSelfExe(ObjFile *obj) {
+ if (memcmp(obj->start_addr, ELFMAG, SELFMAG) != 0) {
+ return;
+ }
+ int fd = open("/proc/self/exe", O_RDONLY);
+ if (fd == -1) {
+ return;
+ }
+ // Verify that contents of /proc/self/exe matches in-memory image of
+ // the binary. This can fail if the "deleted" binary is in fact not
+ // the main executable, or for binaries that have the first PT_LOAD
+ // segment smaller than 4K. We do it in four steps so that the
+ // buffer is smaller and we don't consume too much stack space.
+ const char *mem = reinterpret_cast<const char *>(obj->start_addr);
+ for (int i = 0; i < 4; ++i) {
+ char buf[1024];
+ ssize_t n = read(fd, buf, sizeof(buf));
+ if (n != sizeof(buf) || memcmp(buf, mem, sizeof(buf)) != 0) {
+ close(fd);
+ return;
+ }
+ mem += sizeof(buf);
+ }
+ obj->fd = fd;
+}
+
+static bool MaybeInitializeObjFile(ObjFile *obj) {
+ if (obj->fd < 0) {
+ obj->fd = open(obj->filename, O_RDONLY);
+
+ if (obj->fd < 0) {
+ // Getting /proc/self/exe here means that we were hinted.
+ if (strcmp(obj->filename, "/proc/self/exe") == 0) {
+ // /proc/self/exe may be inaccessible (due to setuid, etc.), so try
+ // accessing the binary via argv0.
+ if (argv0_value != nullptr) {
+ obj->fd = open(argv0_value, O_RDONLY);
+ }
+ } else {
+ MaybeOpenFdFromSelfExe(obj);
+ }
+ }
+
+ if (obj->fd < 0) {
+ ABSL_RAW_LOG(WARNING, "%s: open failed: errno=%d", obj->filename, errno);
+ return false;
+ }
+ obj->elf_type = FileGetElfType(obj->fd);
+ if (obj->elf_type < 0) {
+ ABSL_RAW_LOG(WARNING, "%s: wrong elf type: %d", obj->filename,
+ obj->elf_type);
+ return false;
+ }
+
+ if (!ReadFromOffsetExact(obj->fd, &obj->elf_header, sizeof(obj->elf_header),
+ 0)) {
+ ABSL_RAW_LOG(WARNING, "%s: failed to read elf header", obj->filename);
+ return false;
+ }
+ }
+ return true;
+}
+
+// The implementation of our symbolization routine. If it
+// successfully finds the symbol containing "pc" and obtains the
+// symbol name, returns pointer to that symbol. Otherwise, returns nullptr.
+// If any symbol decorators have been installed via InstallSymbolDecorator(),
+// they are called here as well.
+// To keep stack consumption low, we would like this function to not
+// get inlined.
+const char *Symbolizer::GetSymbol(const void *const pc) {
+ const char *entry = FindSymbolInCache(pc);
+ if (entry != nullptr) {
+ return entry;
+ }
+ symbol_buf_[0] = '\0';
+
+ ObjFile *const obj = FindObjFile(pc, 1);
+ ptrdiff_t relocation = 0;
+ int fd = -1;
+ if (obj != nullptr) {
+ if (MaybeInitializeObjFile(obj)) {
+ if (obj->elf_type == ET_DYN &&
+ reinterpret_cast<uint64_t>(obj->start_addr) >= obj->offset) {
+ // This object was relocated.
+ //
+ // For obj->offset > 0, adjust the relocation since a mapping at offset
+ // X in the file will have a start address of [true relocation]+X.
+ relocation = reinterpret_cast<ptrdiff_t>(obj->start_addr) - obj->offset;
+ }
+
+ fd = obj->fd;
+ }
+ if (GetSymbolFromObjectFile(*obj, pc, relocation, symbol_buf_,
+ sizeof(symbol_buf_), tmp_buf_,
+ sizeof(tmp_buf_)) == SYMBOL_FOUND) {
+ // Only try to demangle the symbol name if it fit into symbol_buf_.
+ DemangleInplace(symbol_buf_, sizeof(symbol_buf_), tmp_buf_,
+ sizeof(tmp_buf_));
+ }
+ } else {
+#if ABSL_HAVE_VDSO_SUPPORT
+ VDSOSupport vdso;
+ if (vdso.IsPresent()) {
+ VDSOSupport::SymbolInfo symbol_info;
+ if (vdso.LookupSymbolByAddress(pc, &symbol_info)) {
+ // All VDSO symbols are known to be short.
+ size_t len = strlen(symbol_info.name);
+ ABSL_RAW_CHECK(len + 1 < sizeof(symbol_buf_),
+ "VDSO symbol unexpectedly long");
+ memcpy(symbol_buf_, symbol_info.name, len + 1);
+ }
+ }
+#endif
+ }
+
+ if (g_decorators_mu.TryLock()) {
+ if (g_num_decorators > 0) {
+ SymbolDecoratorArgs decorator_args = {
+ pc, relocation, fd, symbol_buf_, sizeof(symbol_buf_),
+ tmp_buf_, sizeof(tmp_buf_), nullptr};
+ for (int i = 0; i < g_num_decorators; ++i) {
+ decorator_args.arg = g_decorators[i].arg;
+ g_decorators[i].fn(&decorator_args);
+ }
+ }
+ g_decorators_mu.Unlock();
+ }
+ if (symbol_buf_[0] == '\0') {
+ return nullptr;
+ }
+ symbol_buf_[sizeof(symbol_buf_) - 1] = '\0'; // Paranoia.
+ return InsertSymbolInCache(pc, symbol_buf_);
+}
+
+bool RemoveAllSymbolDecorators(void) {
+ if (!g_decorators_mu.TryLock()) {
+ // Someone else is using decorators. Get out.
+ return false;
+ }
+ g_num_decorators = 0;
+ g_decorators_mu.Unlock();
+ return true;
+}
+
+bool RemoveSymbolDecorator(int ticket) {
+ if (!g_decorators_mu.TryLock()) {
+ // Someone else is using decorators. Get out.
+ return false;
+ }
+ for (int i = 0; i < g_num_decorators; ++i) {
+ if (g_decorators[i].ticket == ticket) {
+ while (i < g_num_decorators - 1) {
+ g_decorators[i] = g_decorators[i + 1];
+ ++i;
+ }
+ g_num_decorators = i;
+ break;
+ }
+ }
+ g_decorators_mu.Unlock();
+ return true; // Decorator is known to be removed.
+}
+
+int InstallSymbolDecorator(SymbolDecorator decorator, void *arg) {
+ static int ticket = 0;
+
+ if (!g_decorators_mu.TryLock()) {
+ // Someone else is using decorators. Get out.
+ return false;
+ }
+ int ret = ticket;
+ if (g_num_decorators >= kMaxDecorators) {
+ ret = -1;
+ } else {
+ g_decorators[g_num_decorators] = {decorator, arg, ticket++};
+ ++g_num_decorators;
+ }
+ g_decorators_mu.Unlock();
+ return ret;
+}
+
+bool RegisterFileMappingHint(const void *start, const void *end, uint64_t offset,
+ const char *filename) {
+ SAFE_ASSERT(start <= end);
+ SAFE_ASSERT(filename != nullptr);
+
+ InitSigSafeArena();
+
+ if (!g_file_mapping_mu.TryLock()) {
+ return false;
+ }
+
+ bool ret = true;
+ if (g_num_file_mapping_hints >= kMaxFileMappingHints) {
+ ret = false;
+ } else {
+ // TODO(ckennelly): Move this into a std::string copy routine.
+ int len = strlen(filename);
+ char *dst = static_cast<char *>(
+ base_internal::LowLevelAlloc::AllocWithArena(len + 1, SigSafeArena()));
+ ABSL_RAW_CHECK(dst != nullptr, "out of memory");
+ memcpy(dst, filename, len + 1);
+
+ auto &hint = g_file_mapping_hints[g_num_file_mapping_hints++];
+ hint.start = start;
+ hint.end = end;
+ hint.offset = offset;
+ hint.filename = dst;
+ }
+
+ g_file_mapping_mu.Unlock();
+ return ret;
+}
+
+bool GetFileMappingHint(const void **start, const void **end, uint64_t *offset,
+ const char **filename) {
+ if (!g_file_mapping_mu.TryLock()) {
+ return false;
+ }
+ bool found = false;
+ for (int i = 0; i < g_num_file_mapping_hints; i++) {
+ if (g_file_mapping_hints[i].start <= *start &&
+ *end <= g_file_mapping_hints[i].end) {
+ // We assume that the start_address for the mapping is the base
+ // address of the ELF section, but when [start_address,end_address) is
+ // not strictly equal to [hint.start, hint.end), that assumption is
+ // invalid.
+ //
+ // This uses the hint's start address (even though hint.start is not
+ // necessarily equal to start_address) to ensure the correct
+ // relocation is computed later.
+ *start = g_file_mapping_hints[i].start;
+ *end = g_file_mapping_hints[i].end;
+ *offset = g_file_mapping_hints[i].offset;
+ *filename = g_file_mapping_hints[i].filename;
+ found = true;
+ break;
+ }
+ }
+ g_file_mapping_mu.Unlock();
+ return found;
+}
+
+} // namespace debugging_internal
+
+bool Symbolize(const void *pc, char *out, int out_size) {
+ // Symbolization is very slow under tsan.
+ ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN();
+ SAFE_ASSERT(out_size >= 0);
+ debugging_internal::Symbolizer *s = debugging_internal::AllocateSymbolizer();
+ const char *name = s->GetSymbol(pc);
+ bool ok = false;
+ if (name != nullptr && out_size > 0) {
+ strncpy(out, name, out_size);
+ ok = true;
+ if (out[out_size - 1] != '\0') {
+ // strncpy() does not '\0' terminate when it truncates. Do so, with
+ // trailing ellipsis.
+ static constexpr char kEllipsis[] = "...";
+ int ellipsis_size =
+ std::min(implicit_cast<int>(strlen(kEllipsis)), out_size - 1);
+ memcpy(out + out_size - ellipsis_size - 1, kEllipsis, ellipsis_size);
+ out[out_size - 1] = '\0';
+ }
+ }
+ debugging_internal::FreeSymbolizer(s);
+ ANNOTATE_IGNORE_READS_AND_WRITES_END();
+ return ok;
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_test.cc
new file mode 100644
index 0000000..c1090b8
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_test.cc
@@ -0,0 +1,517 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/debugging/symbolize.h"
+
+#ifndef _WIN32
+#include <fcntl.h>
+#include <sys/mman.h>
+#endif
+
+#include <cstring>
+#include <iostream>
+#include <memory>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/attributes.h"
+#include "absl/base/casts.h"
+#include "absl/base/internal/per_thread_tls.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/optimization.h"
+#include "absl/debugging/internal/stack_consumption.h"
+#include "absl/memory/memory.h"
+
+using testing::Contains;
+
+// Functions to symbolize. Use C linkage to avoid mangled names.
+extern "C" {
+void nonstatic_func() { ABSL_BLOCK_TAIL_CALL_OPTIMIZATION(); }
+static void static_func() { ABSL_BLOCK_TAIL_CALL_OPTIMIZATION(); }
+} // extern "C"
+
+struct Foo {
+ static void func(int x);
+};
+
+// A C++ method that should have a mangled name.
+void ABSL_ATTRIBUTE_NOINLINE Foo::func(int) {
+ ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+}
+
+// Create functions that will remain in different text sections in the
+// final binary when linker option "-z,keep-text-section-prefix" is used.
+int ABSL_ATTRIBUTE_SECTION_VARIABLE(.text.unlikely) unlikely_func() {
+ return 0;
+}
+
+int ABSL_ATTRIBUTE_SECTION_VARIABLE(.text.hot) hot_func() {
+ return 0;
+}
+
+int ABSL_ATTRIBUTE_SECTION_VARIABLE(.text.startup) startup_func() {
+ return 0;
+}
+
+int ABSL_ATTRIBUTE_SECTION_VARIABLE(.text.exit) exit_func() {
+ return 0;
+}
+
+int ABSL_ATTRIBUTE_SECTION_VARIABLE(.text) regular_func() {
+ return 0;
+}
+
+// Thread-local data may confuse the symbolizer, ensure that it does not.
+// Variable sizes and order are important.
+#if ABSL_PER_THREAD_TLS
+static ABSL_PER_THREAD_TLS_KEYWORD char symbolize_test_thread_small[1];
+static ABSL_PER_THREAD_TLS_KEYWORD char
+ symbolize_test_thread_big[2 * 1024 * 1024];
+#endif
+
+// Used below to hopefully inhibit some compiler/linker optimizations
+// that may remove kHpageTextPadding, kPadding0, and kPadding1 from
+// the binary.
+static volatile bool volatile_bool = false;
+
+// Force the binary to be large enough that a THP .text remap will succeed.
+static constexpr size_t kHpageSize = 1 << 21;
+const char kHpageTextPadding[kHpageSize * 4] ABSL_ATTRIBUTE_SECTION_VARIABLE(
+ ".text") = "";
+
+static char try_symbolize_buffer[4096];
+
+// A wrapper function for absl::Symbolize() to make the unit test simple. The
+// limit must be < sizeof(try_symbolize_buffer). Returns null if
+// absl::Symbolize() returns false, otherwise returns try_symbolize_buffer with
+// the result of absl::Symbolize().
+static const char *TrySymbolizeWithLimit(void *pc, int limit) {
+ ABSL_RAW_CHECK(limit <= sizeof(try_symbolize_buffer),
+ "try_symbolize_buffer is too small");
+
+ // Use the heap to facilitate heap and buffer sanitizer tools.
+ auto heap_buffer = absl::make_unique<char[]>(sizeof(try_symbolize_buffer));
+ bool found = absl::Symbolize(pc, heap_buffer.get(), limit);
+ if (found) {
+ ABSL_RAW_CHECK(strnlen(heap_buffer.get(), limit) < limit,
+ "absl::Symbolize() did not properly terminate the string");
+ strncpy(try_symbolize_buffer, heap_buffer.get(),
+ sizeof(try_symbolize_buffer));
+ }
+
+ return found ? try_symbolize_buffer : nullptr;
+}
+
+// A wrapper for TrySymbolizeWithLimit(), with a large limit.
+static const char *TrySymbolize(void *pc) {
+ return TrySymbolizeWithLimit(pc, sizeof(try_symbolize_buffer));
+}
+
+#ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
+
+TEST(Symbolize, Cached) {
+ // Compilers should give us pointers to them.
+ EXPECT_STREQ("nonstatic_func", TrySymbolize((void *)(&nonstatic_func)));
+
+ // The name of an internal linkage symbol is not specified; allow either a
+ // mangled or an unmangled name here.
+ const char *static_func_symbol = TrySymbolize((void *)(&static_func));
+ EXPECT_TRUE(strcmp("static_func", static_func_symbol) == 0 ||
+ strcmp("static_func()", static_func_symbol) == 0);
+
+ EXPECT_TRUE(nullptr == TrySymbolize(nullptr));
+}
+
+TEST(Symbolize, Truncation) {
+ constexpr char kNonStaticFunc[] = "nonstatic_func";
+ EXPECT_STREQ("nonstatic_func",
+ TrySymbolizeWithLimit((void *)(&nonstatic_func),
+ strlen(kNonStaticFunc) + 1));
+ EXPECT_STREQ("nonstatic_...",
+ TrySymbolizeWithLimit((void *)(&nonstatic_func),
+ strlen(kNonStaticFunc) + 0));
+ EXPECT_STREQ("nonstatic...",
+ TrySymbolizeWithLimit((void *)(&nonstatic_func),
+ strlen(kNonStaticFunc) - 1));
+ EXPECT_STREQ("n...", TrySymbolizeWithLimit((void *)(&nonstatic_func), 5));
+ EXPECT_STREQ("...", TrySymbolizeWithLimit((void *)(&nonstatic_func), 4));
+ EXPECT_STREQ("..", TrySymbolizeWithLimit((void *)(&nonstatic_func), 3));
+ EXPECT_STREQ(".", TrySymbolizeWithLimit((void *)(&nonstatic_func), 2));
+ EXPECT_STREQ("", TrySymbolizeWithLimit((void *)(&nonstatic_func), 1));
+ EXPECT_EQ(nullptr, TrySymbolizeWithLimit((void *)(&nonstatic_func), 0));
+}
+
+TEST(Symbolize, SymbolizeWithDemangling) {
+ Foo::func(100);
+ EXPECT_STREQ("Foo::func()", TrySymbolize((void *)(&Foo::func)));
+}
+
+TEST(Symbolize, SymbolizeSplitTextSections) {
+ EXPECT_STREQ("unlikely_func()", TrySymbolize((void *)(&unlikely_func)));
+ EXPECT_STREQ("hot_func()", TrySymbolize((void *)(&hot_func)));
+ EXPECT_STREQ("startup_func()", TrySymbolize((void *)(&startup_func)));
+ EXPECT_STREQ("exit_func()", TrySymbolize((void *)(&exit_func)));
+ EXPECT_STREQ("regular_func()", TrySymbolize((void *)(®ular_func)));
+}
+
+// Tests that verify that Symbolize stack footprint is within some limit.
+#ifdef ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
+
+static void *g_pc_to_symbolize;
+static char g_symbolize_buffer[4096];
+static char *g_symbolize_result;
+
+static void SymbolizeSignalHandler(int signo) {
+ if (absl::Symbolize(g_pc_to_symbolize, g_symbolize_buffer,
+ sizeof(g_symbolize_buffer))) {
+ g_symbolize_result = g_symbolize_buffer;
+ } else {
+ g_symbolize_result = nullptr;
+ }
+}
+
+// Call Symbolize and figure out the stack footprint of this call.
+static const char *SymbolizeStackConsumption(void *pc, int *stack_consumed) {
+ g_pc_to_symbolize = pc;
+ *stack_consumed = absl::debugging_internal::GetSignalHandlerStackConsumption(
+ SymbolizeSignalHandler);
+ return g_symbolize_result;
+}
+
+static int GetStackConsumptionUpperLimit() {
+ // Symbolize stack consumption should be within 2kB.
+ int stack_consumption_upper_limit = 2048;
+#if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER) || \
+ defined(THREAD_SANITIZER)
+ // Account for sanitizer instrumentation requiring additional stack space.
+ stack_consumption_upper_limit *= 5;
+#endif
+ return stack_consumption_upper_limit;
+}
+
+TEST(Symbolize, SymbolizeStackConsumption) {
+ int stack_consumed = 0;
+
+ const char *symbol =
+ SymbolizeStackConsumption((void *)(&nonstatic_func), &stack_consumed);
+ EXPECT_STREQ("nonstatic_func", symbol);
+ EXPECT_GT(stack_consumed, 0);
+ EXPECT_LT(stack_consumed, GetStackConsumptionUpperLimit());
+
+ // The name of an internal linkage symbol is not specified; allow either a
+ // mangled or an unmangled name here.
+ symbol = SymbolizeStackConsumption((void *)(&static_func), &stack_consumed);
+ EXPECT_TRUE(strcmp("static_func", symbol) == 0 ||
+ strcmp("static_func()", symbol) == 0);
+ EXPECT_GT(stack_consumed, 0);
+ EXPECT_LT(stack_consumed, GetStackConsumptionUpperLimit());
+}
+
+TEST(Symbolize, SymbolizeWithDemanglingStackConsumption) {
+ Foo::func(100);
+ int stack_consumed = 0;
+
+ const char *symbol =
+ SymbolizeStackConsumption((void *)(&Foo::func), &stack_consumed);
+
+ EXPECT_STREQ("Foo::func()", symbol);
+ EXPECT_GT(stack_consumed, 0);
+ EXPECT_LT(stack_consumed, GetStackConsumptionUpperLimit());
+}
+
+#endif // ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
+
+// Use a 64K page size for PPC.
+const size_t kPageSize = 64 << 10;
+// We place a read-only symbols into the .text section and verify that we can
+// symbolize them and other symbols after remapping them.
+const char kPadding0[kPageSize * 4] ABSL_ATTRIBUTE_SECTION_VARIABLE(".text") =
+ "";
+const char kPadding1[kPageSize * 4] ABSL_ATTRIBUTE_SECTION_VARIABLE(".text") =
+ "";
+
+static int FilterElfHeader(struct dl_phdr_info *info, size_t size, void *data) {
+ for (int i = 0; i < info->dlpi_phnum; i++) {
+ if (info->dlpi_phdr[i].p_type == PT_LOAD &&
+ info->dlpi_phdr[i].p_flags == (PF_R | PF_X)) {
+ const void *const vaddr =
+ absl::bit_cast<void *>(info->dlpi_addr + info->dlpi_phdr[i].p_vaddr);
+ const auto segsize = info->dlpi_phdr[i].p_memsz;
+
+ const char *self_exe;
+ if (info->dlpi_name != nullptr && info->dlpi_name[0] != '\0') {
+ self_exe = info->dlpi_name;
+ } else {
+ self_exe = "/proc/self/exe";
+ }
+
+ absl::debugging_internal::RegisterFileMappingHint(
+ vaddr, reinterpret_cast<const char *>(vaddr) + segsize,
+ info->dlpi_phdr[i].p_offset, self_exe);
+
+ return 1;
+ }
+ }
+
+ return 1;
+}
+
+TEST(Symbolize, SymbolizeWithMultipleMaps) {
+ // Force kPadding0 and kPadding1 to be linked in.
+ if (volatile_bool) {
+ ABSL_RAW_LOG(INFO, "%s", kPadding0);
+ ABSL_RAW_LOG(INFO, "%s", kPadding1);
+ }
+
+ // Verify we can symbolize everything.
+ char buf[512];
+ memset(buf, 0, sizeof(buf));
+ absl::Symbolize(kPadding0, buf, sizeof(buf));
+ EXPECT_STREQ("kPadding0", buf);
+
+ memset(buf, 0, sizeof(buf));
+ absl::Symbolize(kPadding1, buf, sizeof(buf));
+ EXPECT_STREQ("kPadding1", buf);
+
+ // Specify a hint for the executable segment.
+ dl_iterate_phdr(FilterElfHeader, nullptr);
+
+ // Reload at least one page out of kPadding0, kPadding1
+ const char *ptrs[] = {kPadding0, kPadding1};
+
+ for (const char *ptr : ptrs) {
+ const int kMapFlags = MAP_ANONYMOUS | MAP_PRIVATE;
+ void *addr = mmap(nullptr, kPageSize, PROT_READ, kMapFlags, 0, 0);
+ ASSERT_NE(addr, MAP_FAILED);
+
+ // kPadding[0-1] is full of zeroes, so we can remap anywhere within it, but
+ // we ensure there is at least a full page of padding.
+ void *remapped = reinterpret_cast<void *>(
+ reinterpret_cast<uintptr_t>(ptr + kPageSize) & ~(kPageSize - 1ULL));
+
+ const int kMremapFlags = (MREMAP_MAYMOVE | MREMAP_FIXED);
+ void *ret = mremap(addr, kPageSize, kPageSize, kMremapFlags, remapped);
+ ASSERT_NE(ret, MAP_FAILED);
+ }
+
+ // Invalidate the symbolization cache so we are forced to rely on the hint.
+ absl::Symbolize(nullptr, buf, sizeof(buf));
+
+ // Verify we can still symbolize.
+ const char *expected[] = {"kPadding0", "kPadding1"};
+ const size_t offsets[] = {0, kPageSize, 2 * kPageSize, 3 * kPageSize};
+
+ for (int i = 0; i < 2; i++) {
+ for (size_t offset : offsets) {
+ memset(buf, 0, sizeof(buf));
+ absl::Symbolize(ptrs[i] + offset, buf, sizeof(buf));
+ EXPECT_STREQ(expected[i], buf);
+ }
+ }
+}
+
+// Appends std::string(*args->arg) to args->symbol_buf.
+static void DummySymbolDecorator(
+ const absl::debugging_internal::SymbolDecoratorArgs *args) {
+ std::string *message = static_cast<std::string *>(args->arg);
+ strncat(args->symbol_buf, message->c_str(),
+ args->symbol_buf_size - strlen(args->symbol_buf) - 1);
+}
+
+TEST(Symbolize, InstallAndRemoveSymbolDecorators) {
+ int ticket_a;
+ std::string a_message("a");
+ EXPECT_GE(ticket_a = absl::debugging_internal::InstallSymbolDecorator(
+ DummySymbolDecorator, &a_message),
+ 0);
+
+ int ticket_b;
+ std::string b_message("b");
+ EXPECT_GE(ticket_b = absl::debugging_internal::InstallSymbolDecorator(
+ DummySymbolDecorator, &b_message),
+ 0);
+
+ int ticket_c;
+ std::string c_message("c");
+ EXPECT_GE(ticket_c = absl::debugging_internal::InstallSymbolDecorator(
+ DummySymbolDecorator, &c_message),
+ 0);
+
+ char *address = reinterpret_cast<char *>(1);
+ EXPECT_STREQ("abc", TrySymbolize(address++));
+
+ EXPECT_TRUE(absl::debugging_internal::RemoveSymbolDecorator(ticket_b));
+
+ EXPECT_STREQ("ac", TrySymbolize(address++));
+
+ // Cleanup: remove all remaining decorators so other stack traces don't
+ // get mystery "ac" decoration.
+ EXPECT_TRUE(absl::debugging_internal::RemoveSymbolDecorator(ticket_a));
+ EXPECT_TRUE(absl::debugging_internal::RemoveSymbolDecorator(ticket_c));
+}
+
+// Some versions of Clang with optimizations enabled seem to be able
+// to optimize away the .data section if no variables live in the
+// section. This variable should get placed in the .data section, and
+// the test below checks for the existence of a .data section.
+static int in_data_section = 1;
+
+TEST(Symbolize, ForEachSection) {
+ int fd = TEMP_FAILURE_RETRY(open("/proc/self/exe", O_RDONLY));
+ ASSERT_NE(fd, -1);
+
+ std::vector<std::string> sections;
+ ASSERT_TRUE(absl::debugging_internal::ForEachSection(
+ fd, [§ions](const std::string &name, const ElfW(Shdr) &) {
+ sections.push_back(name);
+ return true;
+ }));
+
+ // Check for the presence of common section names.
+ EXPECT_THAT(sections, Contains(".text"));
+ EXPECT_THAT(sections, Contains(".rodata"));
+ EXPECT_THAT(sections, Contains(".bss"));
+ ++in_data_section;
+ EXPECT_THAT(sections, Contains(".data"));
+
+ close(fd);
+}
+
+// x86 specific tests. Uses some inline assembler.
+extern "C" {
+inline void *ABSL_ATTRIBUTE_ALWAYS_INLINE inline_func() {
+ void *pc = nullptr;
+#if defined(__i386__) || defined(__x86_64__)
+ __asm__ __volatile__("call 1f; 1: pop %0" : "=r"(pc));
+#endif
+ return pc;
+}
+
+void *ABSL_ATTRIBUTE_NOINLINE non_inline_func() {
+ void *pc = nullptr;
+#if defined(__i386__) || defined(__x86_64__)
+ __asm__ __volatile__("call 1f; 1: pop %0" : "=r"(pc));
+#endif
+ return pc;
+}
+
+void ABSL_ATTRIBUTE_NOINLINE TestWithPCInsideNonInlineFunction() {
+#if defined(ABSL_HAVE_ATTRIBUTE_NOINLINE) && \
+ (defined(__i386__) || defined(__x86_64__))
+ void *pc = non_inline_func();
+ const char *symbol = TrySymbolize(pc);
+ ABSL_RAW_CHECK(symbol != nullptr, "TestWithPCInsideNonInlineFunction failed");
+ ABSL_RAW_CHECK(strcmp(symbol, "non_inline_func") == 0,
+ "TestWithPCInsideNonInlineFunction failed");
+ std::cout << "TestWithPCInsideNonInlineFunction passed" << std::endl;
+#endif
+}
+
+void ABSL_ATTRIBUTE_NOINLINE TestWithPCInsideInlineFunction() {
+#if defined(ABSL_HAVE_ATTRIBUTE_ALWAYS_INLINE) && \
+ (defined(__i386__) || defined(__x86_64__))
+ void *pc = inline_func(); // Must be inlined.
+ const char *symbol = TrySymbolize(pc);
+ ABSL_RAW_CHECK(symbol != nullptr, "TestWithPCInsideInlineFunction failed");
+ ABSL_RAW_CHECK(strcmp(symbol, __FUNCTION__) == 0,
+ "TestWithPCInsideInlineFunction failed");
+ std::cout << "TestWithPCInsideInlineFunction passed" << std::endl;
+#endif
+}
+}
+
+// Test with a return address.
+void ABSL_ATTRIBUTE_NOINLINE TestWithReturnAddress() {
+#if defined(ABSL_HAVE_ATTRIBUTE_NOINLINE)
+ void *return_address = __builtin_return_address(0);
+ const char *symbol = TrySymbolize(return_address);
+ ABSL_RAW_CHECK(symbol != nullptr, "TestWithReturnAddress failed");
+ ABSL_RAW_CHECK(strcmp(symbol, "main") == 0, "TestWithReturnAddress failed");
+ std::cout << "TestWithReturnAddress passed" << std::endl;
+#endif
+}
+
+#elif defined(_WIN32) && defined(_DEBUG)
+
+TEST(Symbolize, Basics) {
+ EXPECT_STREQ("nonstatic_func", TrySymbolize((void *)(&nonstatic_func)));
+
+ // The name of an internal linkage symbol is not specified; allow either a
+ // mangled or an unmangled name here.
+ const char* static_func_symbol = TrySymbolize((void *)(&static_func));
+ ASSERT_TRUE(static_func_symbol != nullptr);
+ EXPECT_TRUE(strstr(static_func_symbol, "static_func") != nullptr);
+
+ EXPECT_TRUE(nullptr == TrySymbolize(nullptr));
+}
+
+TEST(Symbolize, Truncation) {
+ constexpr char kNonStaticFunc[] = "nonstatic_func";
+ EXPECT_STREQ("nonstatic_func",
+ TrySymbolizeWithLimit((void *)(&nonstatic_func),
+ strlen(kNonStaticFunc) + 1));
+ EXPECT_STREQ("nonstatic_...",
+ TrySymbolizeWithLimit((void *)(&nonstatic_func),
+ strlen(kNonStaticFunc) + 0));
+ EXPECT_STREQ("nonstatic...",
+ TrySymbolizeWithLimit((void *)(&nonstatic_func),
+ strlen(kNonStaticFunc) - 1));
+ EXPECT_STREQ("n...", TrySymbolizeWithLimit((void *)(&nonstatic_func), 5));
+ EXPECT_STREQ("...", TrySymbolizeWithLimit((void *)(&nonstatic_func), 4));
+ EXPECT_STREQ("..", TrySymbolizeWithLimit((void *)(&nonstatic_func), 3));
+ EXPECT_STREQ(".", TrySymbolizeWithLimit((void *)(&nonstatic_func), 2));
+ EXPECT_STREQ("", TrySymbolizeWithLimit((void *)(&nonstatic_func), 1));
+ EXPECT_EQ(nullptr, TrySymbolizeWithLimit((void *)(&nonstatic_func), 0));
+}
+
+TEST(Symbolize, SymbolizeWithDemangling) {
+ const char* result = TrySymbolize((void *)(&Foo::func));
+ ASSERT_TRUE(result != nullptr);
+ EXPECT_TRUE(strstr(result, "Foo::func") != nullptr) << result;
+}
+
+#else // Symbolizer unimplemented
+
+TEST(Symbolize, Unimplemented) {
+ char buf[64];
+ EXPECT_FALSE(absl::Symbolize((void *)(&nonstatic_func), buf, sizeof(buf)));
+ EXPECT_FALSE(absl::Symbolize((void *)(&static_func), buf, sizeof(buf)));
+ EXPECT_FALSE(absl::Symbolize((void *)(&Foo::func), buf, sizeof(buf)));
+}
+
+#endif
+
+int main(int argc, char **argv) {
+ // Make sure kHpageTextPadding is linked into the binary.
+ if (volatile_bool) {
+ ABSL_RAW_LOG(INFO, "%s", kHpageTextPadding);
+ }
+
+#if ABSL_PER_THREAD_TLS
+ // Touch the per-thread variables.
+ symbolize_test_thread_small[0] = 0;
+ symbolize_test_thread_big[0] = 0;
+#endif
+
+ absl::InitializeSymbolizer(argv[0]);
+ testing::InitGoogleTest(&argc, argv);
+
+#ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
+ TestWithPCInsideInlineFunction();
+ TestWithPCInsideNonInlineFunction();
+ TestWithReturnAddress();
+#endif
+
+ return RUN_ALL_TESTS();
+}
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_unimplemented.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_unimplemented.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_unimplemented.inc
new file mode 100644
index 0000000..2a3f4ac
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_unimplemented.inc
@@ -0,0 +1,35 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstdint>
+
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+
+namespace debugging_internal {
+
+int InstallSymbolDecorator(SymbolDecorator, void*) { return -1; }
+bool RemoveSymbolDecorator(int) { return false; }
+bool RemoveAllSymbolDecorators(void) { return false; }
+bool RegisterFileMappingHint(const void *, const void *, uint64_t, const char *) {
+ return false;
+}
+
+} // namespace debugging_internal
+
+void InitializeSymbolizer(const char*) {}
+bool Symbolize(const void *, char *, int) { return false; }
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_win32.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_win32.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_win32.inc
new file mode 100644
index 0000000..e3fff74
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize_win32.inc
@@ -0,0 +1,74 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// See "Retrieving Symbol Information by Address":
+// https://msdn.microsoft.com/en-us/library/windows/desktop/ms680578(v=vs.85).aspx
+
+#include <windows.h>
+#include <DbgHelp.h>
+#pragma comment(lib, "DbgHelp")
+
+#include <algorithm>
+#include <cstring>
+
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+
+static HANDLE process = NULL;
+
+void InitializeSymbolizer(const char *argv0) {
+ if (process != nullptr) {
+ return;
+ }
+ process = GetCurrentProcess();
+
+ // Symbols are not loaded until a reference is made requiring the
+ // symbols be loaded. This is the fastest, most efficient way to use
+ // the symbol handler.
+ SymSetOptions(SYMOPT_DEFERRED_LOADS | SYMOPT_UNDNAME);
+ if (!SymInitialize(process, nullptr, true)) {
+ // GetLastError() returns a Win32 DWORD, but we assign to
+ // unsigned long long to simplify the ABSL_RAW_LOG case below. The uniform
+ // initialization guarantees this is not a narrowing conversion.
+ const unsigned long long error{GetLastError()}; // NOLINT(runtime/int)
+ ABSL_RAW_LOG(FATAL, "SymInitialize() failed: %llu", error);
+ }
+}
+
+bool Symbolize(const void *pc, char *out, int out_size) {
+ if (out_size <= 0) {
+ return false;
+ }
+ std::aligned_storage<sizeof(SYMBOL_INFO) + MAX_SYM_NAME,
+ alignof(SYMBOL_INFO)>::type buf;
+ SYMBOL_INFO *symbol = reinterpret_cast<SYMBOL_INFO *>(&buf);
+ symbol->SizeOfStruct = sizeof(SYMBOL_INFO);
+ symbol->MaxNameLen = MAX_SYM_NAME;
+ if (!SymFromAddr(process, reinterpret_cast<DWORD64>(pc), nullptr, symbol)) {
+ return false;
+ }
+ strncpy(out, symbol->Name, out_size);
+ if (out[out_size - 1] != '\0') {
+ // strncpy() does not '\0' terminate when it truncates.
+ static constexpr char kEllipsis[] = "...";
+ int ellipsis_size =
+ std::min<int>(sizeof(kEllipsis) - 1, out_size - 1);
+ memcpy(out + out_size - ellipsis_size - 1, kEllipsis, ellipsis_size);
+ out[out_size - 1] = '\0';
+ }
+ return true;
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/memory/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/memory/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/memory/BUILD.bazel
new file mode 100644
index 0000000..d5c6226
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/memory/BUILD.bazel
@@ -0,0 +1,47 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "memory",
+ hdrs = ["memory.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/base:core_headers",
+ "//absl/meta:type_traits",
+ ],
+)
+
+cc_test(
+ name = "memory_test",
+ srcs = ["memory_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":memory",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/memory/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/memory/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/memory/CMakeLists.txt
new file mode 100644
index 0000000..21bfc87
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/memory/CMakeLists.txt
@@ -0,0 +1,52 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+list(APPEND MEMORY_PUBLIC_HEADERS
+ "memory.h"
+)
+
+
+absl_header_library(
+ TARGET
+ absl_memory
+ EXPORT_NAME
+ memory
+)
+
+#
+## TESTS
+#
+
+# test memory_test
+list(APPEND MEMORY_TEST_SRC
+ "memory_test.cc"
+ ${MEMORY_PUBLIC_HEADERS}
+)
+set(MEMORY_TEST_PUBLIC_LIBRARIES absl::base absl::memory)
+
+
+
+absl_test(
+ TARGET
+ memory_test
+ SOURCES
+ ${MEMORY_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${MEMORY_TEST_PUBLIC_LIBRARIES}
+)
+
+
+
[32/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii_test.cc
new file mode 100644
index 0000000..97f3601
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii_test.cc
@@ -0,0 +1,354 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/ascii.h"
+
+#include <cctype>
+#include <clocale>
+#include <cstring>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+
+namespace {
+
+TEST(AsciiIsFoo, All) {
+ for (int i = 0; i < 256; i++) {
+ if ((i >= 'a' && i <= 'z') || (i >= 'A' && i <= 'Z'))
+ EXPECT_TRUE(absl::ascii_isalpha(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_isalpha(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if ((i >= '0' && i <= '9'))
+ EXPECT_TRUE(absl::ascii_isdigit(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_isdigit(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if (absl::ascii_isalpha(i) || absl::ascii_isdigit(i))
+ EXPECT_TRUE(absl::ascii_isalnum(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_isalnum(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if (i != '\0' && strchr(" \r\n\t\v\f", i))
+ EXPECT_TRUE(absl::ascii_isspace(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_isspace(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if (i >= 32 && i < 127)
+ EXPECT_TRUE(absl::ascii_isprint(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_isprint(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if (absl::ascii_isprint(i) && !absl::ascii_isspace(i) &&
+ !absl::ascii_isalnum(i))
+ EXPECT_TRUE(absl::ascii_ispunct(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_ispunct(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if (i == ' ' || i == '\t')
+ EXPECT_TRUE(absl::ascii_isblank(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_isblank(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if (i < 32 || i == 127)
+ EXPECT_TRUE(absl::ascii_iscntrl(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_iscntrl(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if (absl::ascii_isdigit(i) || (i >= 'A' && i <= 'F') ||
+ (i >= 'a' && i <= 'f'))
+ EXPECT_TRUE(absl::ascii_isxdigit(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_isxdigit(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if (i > 32 && i < 127)
+ EXPECT_TRUE(absl::ascii_isgraph(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_isgraph(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if (i >= 'A' && i <= 'Z')
+ EXPECT_TRUE(absl::ascii_isupper(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_isupper(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 256; i++) {
+ if (i >= 'a' && i <= 'z')
+ EXPECT_TRUE(absl::ascii_islower(i)) << ": failed on " << i;
+ else
+ EXPECT_TRUE(!absl::ascii_islower(i)) << ": failed on " << i;
+ }
+ for (int i = 0; i < 128; i++) {
+ EXPECT_TRUE(absl::ascii_isascii(i)) << ": failed on " << i;
+ }
+ for (int i = 128; i < 256; i++) {
+ EXPECT_TRUE(!absl::ascii_isascii(i)) << ": failed on " << i;
+ }
+
+ // The official is* functions don't accept negative signed chars, but
+ // our absl::ascii_is* functions do.
+ for (int i = 0; i < 256; i++) {
+ signed char sc = static_cast<signed char>(static_cast<unsigned char>(i));
+ EXPECT_EQ(absl::ascii_isalpha(i), absl::ascii_isalpha(sc)) << i;
+ EXPECT_EQ(absl::ascii_isdigit(i), absl::ascii_isdigit(sc)) << i;
+ EXPECT_EQ(absl::ascii_isalnum(i), absl::ascii_isalnum(sc)) << i;
+ EXPECT_EQ(absl::ascii_isspace(i), absl::ascii_isspace(sc)) << i;
+ EXPECT_EQ(absl::ascii_ispunct(i), absl::ascii_ispunct(sc)) << i;
+ EXPECT_EQ(absl::ascii_isblank(i), absl::ascii_isblank(sc)) << i;
+ EXPECT_EQ(absl::ascii_iscntrl(i), absl::ascii_iscntrl(sc)) << i;
+ EXPECT_EQ(absl::ascii_isxdigit(i), absl::ascii_isxdigit(sc)) << i;
+ EXPECT_EQ(absl::ascii_isprint(i), absl::ascii_isprint(sc)) << i;
+ EXPECT_EQ(absl::ascii_isgraph(i), absl::ascii_isgraph(sc)) << i;
+ EXPECT_EQ(absl::ascii_isupper(i), absl::ascii_isupper(sc)) << i;
+ EXPECT_EQ(absl::ascii_islower(i), absl::ascii_islower(sc)) << i;
+ EXPECT_EQ(absl::ascii_isascii(i), absl::ascii_isascii(sc)) << i;
+ }
+}
+
+// Checks that absl::ascii_isfoo returns the same value as isfoo in the C
+// locale.
+TEST(AsciiIsFoo, SameAsIsFoo) {
+ // temporarily change locale to C. It should already be C, but just for safety
+ std::string old_locale = setlocale(LC_CTYPE, nullptr);
+ ASSERT_TRUE(setlocale(LC_CTYPE, "C"));
+
+ for (int i = 0; i < 256; i++) {
+ EXPECT_EQ(isalpha(i) != 0, absl::ascii_isalpha(i)) << i;
+ EXPECT_EQ(isdigit(i) != 0, absl::ascii_isdigit(i)) << i;
+ EXPECT_EQ(isalnum(i) != 0, absl::ascii_isalnum(i)) << i;
+ EXPECT_EQ(isspace(i) != 0, absl::ascii_isspace(i)) << i;
+ EXPECT_EQ(ispunct(i) != 0, absl::ascii_ispunct(i)) << i;
+ EXPECT_EQ(isblank(i) != 0, absl::ascii_isblank(i)) << i;
+ EXPECT_EQ(iscntrl(i) != 0, absl::ascii_iscntrl(i)) << i;
+ EXPECT_EQ(isxdigit(i) != 0, absl::ascii_isxdigit(i)) << i;
+ EXPECT_EQ(isprint(i) != 0, absl::ascii_isprint(i)) << i;
+ EXPECT_EQ(isgraph(i) != 0, absl::ascii_isgraph(i)) << i;
+ EXPECT_EQ(isupper(i) != 0, absl::ascii_isupper(i)) << i;
+ EXPECT_EQ(islower(i) != 0, absl::ascii_islower(i)) << i;
+ EXPECT_EQ(isascii(i) != 0, absl::ascii_isascii(i)) << i;
+ }
+
+ // restore the old locale.
+ ASSERT_TRUE(setlocale(LC_CTYPE, old_locale.c_str()));
+}
+
+TEST(AsciiToFoo, All) {
+ // temporarily change locale to C. It should already be C, but just for safety
+ std::string old_locale = setlocale(LC_CTYPE, nullptr);
+ ASSERT_TRUE(setlocale(LC_CTYPE, "C"));
+
+ for (int i = 0; i < 256; i++) {
+ if (absl::ascii_islower(i))
+ EXPECT_EQ(absl::ascii_toupper(i), 'A' + (i - 'a')) << i;
+ else
+ EXPECT_EQ(absl::ascii_toupper(i), static_cast<char>(i)) << i;
+
+ if (absl::ascii_isupper(i))
+ EXPECT_EQ(absl::ascii_tolower(i), 'a' + (i - 'A')) << i;
+ else
+ EXPECT_EQ(absl::ascii_tolower(i), static_cast<char>(i)) << i;
+
+ // These CHECKs only hold in a C locale.
+ EXPECT_EQ(static_cast<char>(tolower(i)), absl::ascii_tolower(i)) << i;
+ EXPECT_EQ(static_cast<char>(toupper(i)), absl::ascii_toupper(i)) << i;
+
+ // The official to* functions don't accept negative signed chars, but
+ // our absl::ascii_to* functions do.
+ signed char sc = static_cast<signed char>(static_cast<unsigned char>(i));
+ EXPECT_EQ(absl::ascii_tolower(i), absl::ascii_tolower(sc)) << i;
+ EXPECT_EQ(absl::ascii_toupper(i), absl::ascii_toupper(sc)) << i;
+ }
+
+ // restore the old locale.
+ ASSERT_TRUE(setlocale(LC_CTYPE, old_locale.c_str()));
+}
+
+TEST(AsciiStrTo, Lower) {
+ const char buf[] = "ABCDEF";
+ const std::string str("GHIJKL");
+ const std::string str2("MNOPQR");
+ const absl::string_view sp(str2);
+
+ EXPECT_EQ("abcdef", absl::AsciiStrToLower(buf));
+ EXPECT_EQ("ghijkl", absl::AsciiStrToLower(str));
+ EXPECT_EQ("mnopqr", absl::AsciiStrToLower(sp));
+
+ char mutable_buf[] = "Mutable";
+ std::transform(mutable_buf, mutable_buf + strlen(mutable_buf),
+ mutable_buf, absl::ascii_tolower);
+ EXPECT_STREQ("mutable", mutable_buf);
+}
+
+TEST(AsciiStrTo, Upper) {
+ const char buf[] = "abcdef";
+ const std::string str("ghijkl");
+ const std::string str2("mnopqr");
+ const absl::string_view sp(str2);
+
+ EXPECT_EQ("ABCDEF", absl::AsciiStrToUpper(buf));
+ EXPECT_EQ("GHIJKL", absl::AsciiStrToUpper(str));
+ EXPECT_EQ("MNOPQR", absl::AsciiStrToUpper(sp));
+
+ char mutable_buf[] = "Mutable";
+ std::transform(mutable_buf, mutable_buf + strlen(mutable_buf),
+ mutable_buf, absl::ascii_toupper);
+ EXPECT_STREQ("MUTABLE", mutable_buf);
+}
+
+TEST(StripLeadingAsciiWhitespace, FromStringView) {
+ EXPECT_EQ(absl::string_view{},
+ absl::StripLeadingAsciiWhitespace(absl::string_view{}));
+ EXPECT_EQ("foo", absl::StripLeadingAsciiWhitespace({"foo"}));
+ EXPECT_EQ("foo", absl::StripLeadingAsciiWhitespace({"\t \n\f\r\n\vfoo"}));
+ EXPECT_EQ("foo foo\n ",
+ absl::StripLeadingAsciiWhitespace({"\t \n\f\r\n\vfoo foo\n "}));
+ EXPECT_EQ(absl::string_view{}, absl::StripLeadingAsciiWhitespace(
+ {"\t \n\f\r\v\n\t \n\f\r\v\n"}));
+}
+
+TEST(StripLeadingAsciiWhitespace, InPlace) {
+ std::string str;
+
+ absl::StripLeadingAsciiWhitespace(&str);
+ EXPECT_EQ("", str);
+
+ str = "foo";
+ absl::StripLeadingAsciiWhitespace(&str);
+ EXPECT_EQ("foo", str);
+
+ str = "\t \n\f\r\n\vfoo";
+ absl::StripLeadingAsciiWhitespace(&str);
+ EXPECT_EQ("foo", str);
+
+ str = "\t \n\f\r\n\vfoo foo\n ";
+ absl::StripLeadingAsciiWhitespace(&str);
+ EXPECT_EQ("foo foo\n ", str);
+
+ str = "\t \n\f\r\v\n\t \n\f\r\v\n";
+ absl::StripLeadingAsciiWhitespace(&str);
+ EXPECT_EQ(absl::string_view{}, str);
+}
+
+TEST(StripTrailingAsciiWhitespace, FromStringView) {
+ EXPECT_EQ(absl::string_view{},
+ absl::StripTrailingAsciiWhitespace(absl::string_view{}));
+ EXPECT_EQ("foo", absl::StripTrailingAsciiWhitespace({"foo"}));
+ EXPECT_EQ("foo", absl::StripTrailingAsciiWhitespace({"foo\t \n\f\r\n\v"}));
+ EXPECT_EQ(" \nfoo foo",
+ absl::StripTrailingAsciiWhitespace({" \nfoo foo\t \n\f\r\n\v"}));
+ EXPECT_EQ(absl::string_view{}, absl::StripTrailingAsciiWhitespace(
+ {"\t \n\f\r\v\n\t \n\f\r\v\n"}));
+}
+
+TEST(StripTrailingAsciiWhitespace, InPlace) {
+ std::string str;
+
+ absl::StripTrailingAsciiWhitespace(&str);
+ EXPECT_EQ("", str);
+
+ str = "foo";
+ absl::StripTrailingAsciiWhitespace(&str);
+ EXPECT_EQ("foo", str);
+
+ str = "foo\t \n\f\r\n\v";
+ absl::StripTrailingAsciiWhitespace(&str);
+ EXPECT_EQ("foo", str);
+
+ str = " \nfoo foo\t \n\f\r\n\v";
+ absl::StripTrailingAsciiWhitespace(&str);
+ EXPECT_EQ(" \nfoo foo", str);
+
+ str = "\t \n\f\r\v\n\t \n\f\r\v\n";
+ absl::StripTrailingAsciiWhitespace(&str);
+ EXPECT_EQ(absl::string_view{}, str);
+}
+
+TEST(StripAsciiWhitespace, FromStringView) {
+ EXPECT_EQ(absl::string_view{},
+ absl::StripAsciiWhitespace(absl::string_view{}));
+ EXPECT_EQ("foo", absl::StripAsciiWhitespace({"foo"}));
+ EXPECT_EQ("foo",
+ absl::StripAsciiWhitespace({"\t \n\f\r\n\vfoo\t \n\f\r\n\v"}));
+ EXPECT_EQ("foo foo", absl::StripAsciiWhitespace(
+ {"\t \n\f\r\n\vfoo foo\t \n\f\r\n\v"}));
+ EXPECT_EQ(absl::string_view{},
+ absl::StripAsciiWhitespace({"\t \n\f\r\v\n\t \n\f\r\v\n"}));
+}
+
+TEST(StripAsciiWhitespace, InPlace) {
+ std::string str;
+
+ absl::StripAsciiWhitespace(&str);
+ EXPECT_EQ("", str);
+
+ str = "foo";
+ absl::StripAsciiWhitespace(&str);
+ EXPECT_EQ("foo", str);
+
+ str = "\t \n\f\r\n\vfoo\t \n\f\r\n\v";
+ absl::StripAsciiWhitespace(&str);
+ EXPECT_EQ("foo", str);
+
+ str = "\t \n\f\r\n\vfoo foo\t \n\f\r\n\v";
+ absl::StripAsciiWhitespace(&str);
+ EXPECT_EQ("foo foo", str);
+
+ str = "\t \n\f\r\v\n\t \n\f\r\v\n";
+ absl::StripAsciiWhitespace(&str);
+ EXPECT_EQ(absl::string_view{}, str);
+}
+
+TEST(RemoveExtraAsciiWhitespace, InPlace) {
+ const char* inputs[] = {"No extra space",
+ " Leading whitespace",
+ "Trailing whitespace ",
+ " Leading and trailing ",
+ " Whitespace \t in\v middle ",
+ "'Eeeeep! \n Newlines!\n",
+ "nospaces",
+ "",
+ "\n\t a\t\n\nb \t\n"};
+
+ const char* outputs[] = {
+ "No extra space",
+ "Leading whitespace",
+ "Trailing whitespace",
+ "Leading and trailing",
+ "Whitespace in middle",
+ "'Eeeeep! Newlines!",
+ "nospaces",
+ "",
+ "a\nb",
+ };
+ const int NUM_TESTS = ABSL_ARRAYSIZE(inputs);
+
+ for (int i = 0; i < NUM_TESTS; i++) {
+ std::string s(inputs[i]);
+ absl::RemoveExtraAsciiWhitespace(&s);
+ EXPECT_EQ(outputs[i], s);
+ }
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping.cc
new file mode 100644
index 0000000..fbc9f75
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping.cc
@@ -0,0 +1,1109 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/escaping.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cstdint>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <string>
+
+#include "absl/base/internal/endian.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/unaligned_access.h"
+#include "absl/strings/internal/char_map.h"
+#include "absl/strings/internal/resize_uninitialized.h"
+#include "absl/strings/internal/utf8.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+namespace {
+
+// Digit conversion.
+constexpr char kHexChar[] = "0123456789abcdef";
+
+constexpr char kHexTable[513] =
+ "000102030405060708090a0b0c0d0e0f"
+ "101112131415161718191a1b1c1d1e1f"
+ "202122232425262728292a2b2c2d2e2f"
+ "303132333435363738393a3b3c3d3e3f"
+ "404142434445464748494a4b4c4d4e4f"
+ "505152535455565758595a5b5c5d5e5f"
+ "606162636465666768696a6b6c6d6e6f"
+ "707172737475767778797a7b7c7d7e7f"
+ "808182838485868788898a8b8c8d8e8f"
+ "909192939495969798999a9b9c9d9e9f"
+ "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf"
+ "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf"
+ "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf"
+ "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf"
+ "e0e1e2e3e4e5e6e7e8e9eaebecedeeef"
+ "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff";
+
+// These are used for the leave_nulls_escaped argument to CUnescapeInternal().
+constexpr bool kUnescapeNulls = false;
+
+inline bool is_octal_digit(char c) { return ('0' <= c) && (c <= '7'); }
+
+inline int hex_digit_to_int(char c) {
+ static_assert('0' == 0x30 && 'A' == 0x41 && 'a' == 0x61,
+ "Character set must be ASCII.");
+ assert(absl::ascii_isxdigit(c));
+ int x = static_cast<unsigned char>(c);
+ if (x > '9') {
+ x += 9;
+ }
+ return x & 0xf;
+}
+
+inline bool IsSurrogate(char32_t c, absl::string_view src, std::string* error) {
+ if (c >= 0xD800 && c <= 0xDFFF) {
+ if (error) {
+ *error = absl::StrCat("invalid surrogate character (0xD800-DFFF): \\",
+ src);
+ }
+ return true;
+ }
+ return false;
+}
+
+// ----------------------------------------------------------------------
+// CUnescapeInternal()
+// Implements both CUnescape() and CUnescapeForNullTerminatedString().
+//
+// Unescapes C escape sequences and is the reverse of CEscape().
+//
+// If 'source' is valid, stores the unescaped std::string and its size in
+// 'dest' and 'dest_len' respectively, and returns true. Otherwise
+// returns false and optionally stores the error description in
+// 'error'. Set 'error' to nullptr to disable error reporting.
+//
+// 'dest' should point to a buffer that is at least as big as 'source'.
+// 'source' and 'dest' may be the same.
+//
+// NOTE: any changes to this function must also be reflected in the older
+// UnescapeCEscapeSequences().
+// ----------------------------------------------------------------------
+bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
+ char* dest, ptrdiff_t* dest_len, std::string* error) {
+ char* d = dest;
+ const char* p = source.data();
+ const char* end = source.end();
+ const char* last_byte = end - 1;
+
+ // Small optimization for case where source = dest and there's no escaping
+ while (p == d && p < end && *p != '\\') p++, d++;
+
+ while (p < end) {
+ if (*p != '\\') {
+ *d++ = *p++;
+ } else {
+ if (++p > last_byte) { // skip past the '\\'
+ if (error) *error = "String cannot end with \\";
+ return false;
+ }
+ switch (*p) {
+ case 'a': *d++ = '\a'; break;
+ case 'b': *d++ = '\b'; break;
+ case 'f': *d++ = '\f'; break;
+ case 'n': *d++ = '\n'; break;
+ case 'r': *d++ = '\r'; break;
+ case 't': *d++ = '\t'; break;
+ case 'v': *d++ = '\v'; break;
+ case '\\': *d++ = '\\'; break;
+ case '?': *d++ = '\?'; break; // \? Who knew?
+ case '\'': *d++ = '\''; break;
+ case '"': *d++ = '\"'; break;
+ case '0':
+ case '1':
+ case '2':
+ case '3':
+ case '4':
+ case '5':
+ case '6':
+ case '7': {
+ // octal digit: 1 to 3 digits
+ const char* octal_start = p;
+ unsigned int ch = *p - '0';
+ if (p < last_byte && is_octal_digit(p[1])) ch = ch * 8 + *++p - '0';
+ if (p < last_byte && is_octal_digit(p[1]))
+ ch = ch * 8 + *++p - '0'; // now points at last digit
+ if (ch > 0xff) {
+ if (error) {
+ *error = "Value of \\" +
+ std::string(octal_start, p + 1 - octal_start) +
+ " exceeds 0xff";
+ }
+ return false;
+ }
+ if ((ch == 0) && leave_nulls_escaped) {
+ // Copy the escape sequence for the null character
+ const ptrdiff_t octal_size = p + 1 - octal_start;
+ *d++ = '\\';
+ memcpy(d, octal_start, octal_size);
+ d += octal_size;
+ break;
+ }
+ *d++ = ch;
+ break;
+ }
+ case 'x':
+ case 'X': {
+ if (p >= last_byte) {
+ if (error) *error = "String cannot end with \\x";
+ return false;
+ } else if (!absl::ascii_isxdigit(p[1])) {
+ if (error) *error = "\\x cannot be followed by a non-hex digit";
+ return false;
+ }
+ unsigned int ch = 0;
+ const char* hex_start = p;
+ while (p < last_byte && absl::ascii_isxdigit(p[1]))
+ // Arbitrarily many hex digits
+ ch = (ch << 4) + hex_digit_to_int(*++p);
+ if (ch > 0xFF) {
+ if (error) {
+ *error = "Value of \\" + std::string(hex_start, p + 1 - hex_start) +
+ " exceeds 0xff";
+ }
+ return false;
+ }
+ if ((ch == 0) && leave_nulls_escaped) {
+ // Copy the escape sequence for the null character
+ const ptrdiff_t hex_size = p + 1 - hex_start;
+ *d++ = '\\';
+ memcpy(d, hex_start, hex_size);
+ d += hex_size;
+ break;
+ }
+ *d++ = ch;
+ break;
+ }
+ case 'u': {
+ // \uhhhh => convert 4 hex digits to UTF-8
+ char32_t rune = 0;
+ const char* hex_start = p;
+ if (p + 4 >= end) {
+ if (error) {
+ *error = "\\u must be followed by 4 hex digits: \\" +
+ std::string(hex_start, p + 1 - hex_start);
+ }
+ return false;
+ }
+ for (int i = 0; i < 4; ++i) {
+ // Look one char ahead.
+ if (absl::ascii_isxdigit(p[1])) {
+ rune = (rune << 4) + hex_digit_to_int(*++p); // Advance p.
+ } else {
+ if (error) {
+ *error = "\\u must be followed by 4 hex digits: \\" +
+ std::string(hex_start, p + 1 - hex_start);
+ }
+ return false;
+ }
+ }
+ if ((rune == 0) && leave_nulls_escaped) {
+ // Copy the escape sequence for the null character
+ *d++ = '\\';
+ memcpy(d, hex_start, 5); // u0000
+ d += 5;
+ break;
+ }
+ if (IsSurrogate(rune, absl::string_view(hex_start, 5), error)) {
+ return false;
+ }
+ d += strings_internal::EncodeUTF8Char(d, rune);
+ break;
+ }
+ case 'U': {
+ // \Uhhhhhhhh => convert 8 hex digits to UTF-8
+ char32_t rune = 0;
+ const char* hex_start = p;
+ if (p + 8 >= end) {
+ if (error) {
+ *error = "\\U must be followed by 8 hex digits: \\" +
+ std::string(hex_start, p + 1 - hex_start);
+ }
+ return false;
+ }
+ for (int i = 0; i < 8; ++i) {
+ // Look one char ahead.
+ if (absl::ascii_isxdigit(p[1])) {
+ // Don't change rune until we're sure this
+ // is within the Unicode limit, but do advance p.
+ uint32_t newrune = (rune << 4) + hex_digit_to_int(*++p);
+ if (newrune > 0x10FFFF) {
+ if (error) {
+ *error = "Value of \\" +
+ std::string(hex_start, p + 1 - hex_start) +
+ " exceeds Unicode limit (0x10FFFF)";
+ }
+ return false;
+ } else {
+ rune = newrune;
+ }
+ } else {
+ if (error) {
+ *error = "\\U must be followed by 8 hex digits: \\" +
+ std::string(hex_start, p + 1 - hex_start);
+ }
+ return false;
+ }
+ }
+ if ((rune == 0) && leave_nulls_escaped) {
+ // Copy the escape sequence for the null character
+ *d++ = '\\';
+ memcpy(d, hex_start, 9); // U00000000
+ d += 9;
+ break;
+ }
+ if (IsSurrogate(rune, absl::string_view(hex_start, 9), error)) {
+ return false;
+ }
+ d += strings_internal::EncodeUTF8Char(d, rune);
+ break;
+ }
+ default: {
+ if (error) *error = std::string("Unknown escape sequence: \\") + *p;
+ return false;
+ }
+ }
+ p++; // read past letter we escaped
+ }
+ }
+ *dest_len = d - dest;
+ return true;
+}
+
+// ----------------------------------------------------------------------
+// CUnescapeInternal()
+//
+// Same as above but uses a C++ std::string for output. 'source' and 'dest'
+// may be the same.
+// ----------------------------------------------------------------------
+bool CUnescapeInternal(absl::string_view source, bool leave_nulls_escaped,
+ std::string* dest, std::string* error) {
+ strings_internal::STLStringResizeUninitialized(dest, source.size());
+
+ ptrdiff_t dest_size;
+ if (!CUnescapeInternal(source,
+ leave_nulls_escaped,
+ const_cast<char*>(dest->data()),
+ &dest_size,
+ error)) {
+ return false;
+ }
+ dest->erase(dest_size);
+ return true;
+}
+
+// ----------------------------------------------------------------------
+// CEscape()
+// CHexEscape()
+// Utf8SafeCEscape()
+// Utf8SafeCHexEscape()
+// Escapes 'src' using C-style escape sequences. This is useful for
+// preparing query flags. The 'Hex' version uses hexadecimal rather than
+// octal sequences. The 'Utf8Safe' version does not touch UTF-8 bytes.
+//
+// Escaped chars: \n, \r, \t, ", ', \, and !absl::ascii_isprint().
+// ----------------------------------------------------------------------
+std::string CEscapeInternal(absl::string_view src, bool use_hex, bool utf8_safe) {
+ std::string dest;
+ bool last_hex_escape = false; // true if last output char was \xNN.
+
+ for (unsigned char c : src) {
+ bool is_hex_escape = false;
+ switch (c) {
+ case '\n': dest.append("\\" "n"); break;
+ case '\r': dest.append("\\" "r"); break;
+ case '\t': dest.append("\\" "t"); break;
+ case '\"': dest.append("\\" "\""); break;
+ case '\'': dest.append("\\" "'"); break;
+ case '\\': dest.append("\\" "\\"); break;
+ default:
+ // Note that if we emit \xNN and the src character after that is a hex
+ // digit then that digit must be escaped too to prevent it being
+ // interpreted as part of the character code by C.
+ if ((!utf8_safe || c < 0x80) &&
+ (!absl::ascii_isprint(c) ||
+ (last_hex_escape && absl::ascii_isxdigit(c)))) {
+ if (use_hex) {
+ dest.append("\\" "x");
+ dest.push_back(kHexChar[c / 16]);
+ dest.push_back(kHexChar[c % 16]);
+ is_hex_escape = true;
+ } else {
+ dest.append("\\");
+ dest.push_back(kHexChar[c / 64]);
+ dest.push_back(kHexChar[(c % 64) / 8]);
+ dest.push_back(kHexChar[c % 8]);
+ }
+ } else {
+ dest.push_back(c);
+ break;
+ }
+ }
+ last_hex_escape = is_hex_escape;
+ }
+
+ return dest;
+}
+
+/* clang-format off */
+constexpr char c_escaped_len[256] = {
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 4, 4, 2, 4, 4, // \t, \n, \r
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 1, 1, 2, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, // ", '
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // '0'..'9'
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 'A'..'O'
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, // 'P'..'Z', '\'
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 'a'..'o'
+ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4, // 'p'..'z', DEL
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+};
+/* clang-format on */
+
+// Calculates the length of the C-style escaped version of 'src'.
+// Assumes that non-printable characters are escaped using octal sequences, and
+// that UTF-8 bytes are not handled specially.
+inline size_t CEscapedLength(absl::string_view src) {
+ size_t escaped_len = 0;
+ for (unsigned char c : src) escaped_len += c_escaped_len[c];
+ return escaped_len;
+}
+
+void CEscapeAndAppendInternal(absl::string_view src, std::string* dest) {
+ size_t escaped_len = CEscapedLength(src);
+ if (escaped_len == src.size()) {
+ dest->append(src.data(), src.size());
+ return;
+ }
+
+ size_t cur_dest_len = dest->size();
+ strings_internal::STLStringResizeUninitialized(dest,
+ cur_dest_len + escaped_len);
+ char* append_ptr = &(*dest)[cur_dest_len];
+
+ for (unsigned char c : src) {
+ int char_len = c_escaped_len[c];
+ if (char_len == 1) {
+ *append_ptr++ = c;
+ } else if (char_len == 2) {
+ switch (c) {
+ case '\n':
+ *append_ptr++ = '\\';
+ *append_ptr++ = 'n';
+ break;
+ case '\r':
+ *append_ptr++ = '\\';
+ *append_ptr++ = 'r';
+ break;
+ case '\t':
+ *append_ptr++ = '\\';
+ *append_ptr++ = 't';
+ break;
+ case '\"':
+ *append_ptr++ = '\\';
+ *append_ptr++ = '\"';
+ break;
+ case '\'':
+ *append_ptr++ = '\\';
+ *append_ptr++ = '\'';
+ break;
+ case '\\':
+ *append_ptr++ = '\\';
+ *append_ptr++ = '\\';
+ break;
+ }
+ } else {
+ *append_ptr++ = '\\';
+ *append_ptr++ = '0' + c / 64;
+ *append_ptr++ = '0' + (c % 64) / 8;
+ *append_ptr++ = '0' + c % 8;
+ }
+ }
+}
+
+bool Base64UnescapeInternal(const char* src_param, size_t szsrc, char* dest,
+ size_t szdest, const signed char* unbase64,
+ size_t* len) {
+ static const char kPad64Equals = '=';
+ static const char kPad64Dot = '.';
+
+ size_t destidx = 0;
+ int decode = 0;
+ int state = 0;
+ unsigned int ch = 0;
+ unsigned int temp = 0;
+
+ // If "char" is signed by default, using *src as an array index results in
+ // accessing negative array elements. Treat the input as a pointer to
+ // unsigned char to avoid this.
+ const unsigned char* src = reinterpret_cast<const unsigned char*>(src_param);
+
+ // The GET_INPUT macro gets the next input character, skipping
+ // over any whitespace, and stopping when we reach the end of the
+ // std::string or when we read any non-data character. The arguments are
+ // an arbitrary identifier (used as a label for goto) and the number
+ // of data bytes that must remain in the input to avoid aborting the
+ // loop.
+#define GET_INPUT(label, remain) \
+ label: \
+ --szsrc; \
+ ch = *src++; \
+ decode = unbase64[ch]; \
+ if (decode < 0) { \
+ if (absl::ascii_isspace(ch) && szsrc >= remain) goto label; \
+ state = 4 - remain; \
+ break; \
+ }
+
+ // if dest is null, we're just checking to see if it's legal input
+ // rather than producing output. (I suspect this could just be done
+ // with a regexp...). We duplicate the loop so this test can be
+ // outside it instead of in every iteration.
+
+ if (dest) {
+ // This loop consumes 4 input bytes and produces 3 output bytes
+ // per iteration. We can't know at the start that there is enough
+ // data left in the std::string for a full iteration, so the loop may
+ // break out in the middle; if so 'state' will be set to the
+ // number of input bytes read.
+
+ while (szsrc >= 4) {
+ // We'll start by optimistically assuming that the next four
+ // bytes of the std::string (src[0..3]) are four good data bytes
+ // (that is, no nulls, whitespace, padding chars, or illegal
+ // chars). We need to test src[0..2] for nulls individually
+ // before constructing temp to preserve the property that we
+ // never read past a null in the std::string (no matter how long
+ // szsrc claims the std::string is).
+
+ if (!src[0] || !src[1] || !src[2] ||
+ ((temp = ((unsigned(unbase64[src[0]]) << 18) |
+ (unsigned(unbase64[src[1]]) << 12) |
+ (unsigned(unbase64[src[2]]) << 6) |
+ (unsigned(unbase64[src[3]])))) &
+ 0x80000000)) {
+ // Iff any of those four characters was bad (null, illegal,
+ // whitespace, padding), then temp's high bit will be set
+ // (because unbase64[] is -1 for all bad characters).
+ //
+ // We'll back up and resort to the slower decoder, which knows
+ // how to handle those cases.
+
+ GET_INPUT(first, 4);
+ temp = decode;
+ GET_INPUT(second, 3);
+ temp = (temp << 6) | decode;
+ GET_INPUT(third, 2);
+ temp = (temp << 6) | decode;
+ GET_INPUT(fourth, 1);
+ temp = (temp << 6) | decode;
+ } else {
+ // We really did have four good data bytes, so advance four
+ // characters in the std::string.
+
+ szsrc -= 4;
+ src += 4;
+ }
+
+ // temp has 24 bits of input, so write that out as three bytes.
+
+ if (destidx + 3 > szdest) return false;
+ dest[destidx + 2] = temp;
+ temp >>= 8;
+ dest[destidx + 1] = temp;
+ temp >>= 8;
+ dest[destidx] = temp;
+ destidx += 3;
+ }
+ } else {
+ while (szsrc >= 4) {
+ if (!src[0] || !src[1] || !src[2] ||
+ ((temp = ((unsigned(unbase64[src[0]]) << 18) |
+ (unsigned(unbase64[src[1]]) << 12) |
+ (unsigned(unbase64[src[2]]) << 6) |
+ (unsigned(unbase64[src[3]])))) &
+ 0x80000000)) {
+ GET_INPUT(first_no_dest, 4);
+ GET_INPUT(second_no_dest, 3);
+ GET_INPUT(third_no_dest, 2);
+ GET_INPUT(fourth_no_dest, 1);
+ } else {
+ szsrc -= 4;
+ src += 4;
+ }
+ destidx += 3;
+ }
+ }
+
+#undef GET_INPUT
+
+ // if the loop terminated because we read a bad character, return
+ // now.
+ if (decode < 0 && ch != kPad64Equals && ch != kPad64Dot &&
+ !absl::ascii_isspace(ch))
+ return false;
+
+ if (ch == kPad64Equals || ch == kPad64Dot) {
+ // if we stopped by hitting an '=' or '.', un-read that character -- we'll
+ // look at it again when we count to check for the proper number of
+ // equals signs at the end.
+ ++szsrc;
+ --src;
+ } else {
+ // This loop consumes 1 input byte per iteration. It's used to
+ // clean up the 0-3 input bytes remaining when the first, faster
+ // loop finishes. 'temp' contains the data from 'state' input
+ // characters read by the first loop.
+ while (szsrc > 0) {
+ --szsrc;
+ ch = *src++;
+ decode = unbase64[ch];
+ if (decode < 0) {
+ if (absl::ascii_isspace(ch)) {
+ continue;
+ } else if (ch == kPad64Equals || ch == kPad64Dot) {
+ // back up one character; we'll read it again when we check
+ // for the correct number of pad characters at the end.
+ ++szsrc;
+ --src;
+ break;
+ } else {
+ return false;
+ }
+ }
+
+ // Each input character gives us six bits of output.
+ temp = (temp << 6) | decode;
+ ++state;
+ if (state == 4) {
+ // If we've accumulated 24 bits of output, write that out as
+ // three bytes.
+ if (dest) {
+ if (destidx + 3 > szdest) return false;
+ dest[destidx + 2] = temp;
+ temp >>= 8;
+ dest[destidx + 1] = temp;
+ temp >>= 8;
+ dest[destidx] = temp;
+ }
+ destidx += 3;
+ state = 0;
+ temp = 0;
+ }
+ }
+ }
+
+ // Process the leftover data contained in 'temp' at the end of the input.
+ int expected_equals = 0;
+ switch (state) {
+ case 0:
+ // Nothing left over; output is a multiple of 3 bytes.
+ break;
+
+ case 1:
+ // Bad input; we have 6 bits left over.
+ return false;
+
+ case 2:
+ // Produce one more output byte from the 12 input bits we have left.
+ if (dest) {
+ if (destidx + 1 > szdest) return false;
+ temp >>= 4;
+ dest[destidx] = temp;
+ }
+ ++destidx;
+ expected_equals = 2;
+ break;
+
+ case 3:
+ // Produce two more output bytes from the 18 input bits we have left.
+ if (dest) {
+ if (destidx + 2 > szdest) return false;
+ temp >>= 2;
+ dest[destidx + 1] = temp;
+ temp >>= 8;
+ dest[destidx] = temp;
+ }
+ destidx += 2;
+ expected_equals = 1;
+ break;
+
+ default:
+ // state should have no other values at this point.
+ ABSL_RAW_LOG(FATAL, "This can't happen; base64 decoder state = %d",
+ state);
+ }
+
+ // The remainder of the std::string should be all whitespace, mixed with
+ // exactly 0 equals signs, or exactly 'expected_equals' equals
+ // signs. (Always accepting 0 equals signs is an Abseil extension
+ // not covered in the RFC, as is accepting dot as the pad character.)
+
+ int equals = 0;
+ while (szsrc > 0) {
+ if (*src == kPad64Equals || *src == kPad64Dot)
+ ++equals;
+ else if (!absl::ascii_isspace(*src))
+ return false;
+ --szsrc;
+ ++src;
+ }
+
+ const bool ok = (equals == 0 || equals == expected_equals);
+ if (ok) *len = destidx;
+ return ok;
+}
+
+// The arrays below were generated by the following code
+// #include <sys/time.h>
+// #include <stdlib.h>
+// #include <std::string.h>
+// main()
+// {
+// static const char Base64[] =
+// "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+// char* pos;
+// int idx, i, j;
+// printf(" ");
+// for (i = 0; i < 255; i += 8) {
+// for (j = i; j < i + 8; j++) {
+// pos = strchr(Base64, j);
+// if ((pos == nullptr) || (j == 0))
+// idx = -1;
+// else
+// idx = pos - Base64;
+// if (idx == -1)
+// printf(" %2d, ", idx);
+// else
+// printf(" %2d/*%c*/,", idx, j);
+// }
+// printf("\n ");
+// }
+// }
+//
+// where the value of "Base64[]" was replaced by one of the base-64 conversion
+// tables from the functions below.
+/* clang-format off */
+constexpr signed char kUnBase64[] = {
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, 62/*+*/, -1, -1, -1, 63/*/ */,
+ 52/*0*/, 53/*1*/, 54/*2*/, 55/*3*/, 56/*4*/, 57/*5*/, 58/*6*/, 59/*7*/,
+ 60/*8*/, 61/*9*/, -1, -1, -1, -1, -1, -1,
+ -1, 0/*A*/, 1/*B*/, 2/*C*/, 3/*D*/, 4/*E*/, 5/*F*/, 6/*G*/,
+ 07/*H*/, 8/*I*/, 9/*J*/, 10/*K*/, 11/*L*/, 12/*M*/, 13/*N*/, 14/*O*/,
+ 15/*P*/, 16/*Q*/, 17/*R*/, 18/*S*/, 19/*T*/, 20/*U*/, 21/*V*/, 22/*W*/,
+ 23/*X*/, 24/*Y*/, 25/*Z*/, -1, -1, -1, -1, -1,
+ -1, 26/*a*/, 27/*b*/, 28/*c*/, 29/*d*/, 30/*e*/, 31/*f*/, 32/*g*/,
+ 33/*h*/, 34/*i*/, 35/*j*/, 36/*k*/, 37/*l*/, 38/*m*/, 39/*n*/, 40/*o*/,
+ 41/*p*/, 42/*q*/, 43/*r*/, 44/*s*/, 45/*t*/, 46/*u*/, 47/*v*/, 48/*w*/,
+ 49/*x*/, 50/*y*/, 51/*z*/, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1
+};
+
+constexpr signed char kUnWebSafeBase64[] = {
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, 62/*-*/, -1, -1,
+ 52/*0*/, 53/*1*/, 54/*2*/, 55/*3*/, 56/*4*/, 57/*5*/, 58/*6*/, 59/*7*/,
+ 60/*8*/, 61/*9*/, -1, -1, -1, -1, -1, -1,
+ -1, 0/*A*/, 1/*B*/, 2/*C*/, 3/*D*/, 4/*E*/, 5/*F*/, 6/*G*/,
+ 07/*H*/, 8/*I*/, 9/*J*/, 10/*K*/, 11/*L*/, 12/*M*/, 13/*N*/, 14/*O*/,
+ 15/*P*/, 16/*Q*/, 17/*R*/, 18/*S*/, 19/*T*/, 20/*U*/, 21/*V*/, 22/*W*/,
+ 23/*X*/, 24/*Y*/, 25/*Z*/, -1, -1, -1, -1, 63/*_*/,
+ -1, 26/*a*/, 27/*b*/, 28/*c*/, 29/*d*/, 30/*e*/, 31/*f*/, 32/*g*/,
+ 33/*h*/, 34/*i*/, 35/*j*/, 36/*k*/, 37/*l*/, 38/*m*/, 39/*n*/, 40/*o*/,
+ 41/*p*/, 42/*q*/, 43/*r*/, 44/*s*/, 45/*t*/, 46/*u*/, 47/*v*/, 48/*w*/,
+ 49/*x*/, 50/*y*/, 51/*z*/, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1
+};
+/* clang-format on */
+
+size_t CalculateBase64EscapedLenInternal(size_t input_len, bool do_padding) {
+ // Base64 encodes three bytes of input at a time. If the input is not
+ // divisible by three, we pad as appropriate.
+ //
+ // (from http://tools.ietf.org/html/rfc3548)
+ // Special processing is performed if fewer than 24 bits are available
+ // at the end of the data being encoded. A full encoding quantum is
+ // always completed at the end of a quantity. When fewer than 24 input
+ // bits are available in an input group, zero bits are added (on the
+ // right) to form an integral number of 6-bit groups. Padding at the
+ // end of the data is performed using the '=' character. Since all base
+ // 64 input is an integral number of octets, only the following cases
+ // can arise:
+
+ // Base64 encodes each three bytes of input into four bytes of output.
+ size_t len = (input_len / 3) * 4;
+
+ if (input_len % 3 == 0) {
+ // (from http://tools.ietf.org/html/rfc3548)
+ // (1) the final quantum of encoding input is an integral multiple of 24
+ // bits; here, the final unit of encoded output will be an integral
+ // multiple of 4 characters with no "=" padding,
+ } else if (input_len % 3 == 1) {
+ // (from http://tools.ietf.org/html/rfc3548)
+ // (2) the final quantum of encoding input is exactly 8 bits; here, the
+ // final unit of encoded output will be two characters followed by two
+ // "=" padding characters, or
+ len += 2;
+ if (do_padding) {
+ len += 2;
+ }
+ } else { // (input_len % 3 == 2)
+ // (from http://tools.ietf.org/html/rfc3548)
+ // (3) the final quantum of encoding input is exactly 16 bits; here, the
+ // final unit of encoded output will be three characters followed by one
+ // "=" padding character.
+ len += 3;
+ if (do_padding) {
+ len += 1;
+ }
+ }
+
+ assert(len >= input_len); // make sure we didn't overflow
+ return len;
+}
+
+size_t Base64EscapeInternal(const unsigned char* src, size_t szsrc, char* dest,
+ size_t szdest, const char* base64,
+ bool do_padding) {
+ static const char kPad64 = '=';
+
+ if (szsrc * 4 > szdest * 3) return 0;
+
+ char* cur_dest = dest;
+ const unsigned char* cur_src = src;
+
+ char* const limit_dest = dest + szdest;
+ const unsigned char* const limit_src = src + szsrc;
+
+ // Three bytes of data encodes to four characters of cyphertext.
+ // So we can pump through three-byte chunks atomically.
+ if (szsrc >= 3) { // "limit_src - 3" is UB if szsrc < 3
+ while (cur_src < limit_src - 3) { // as long as we have >= 32 bits
+ uint32_t in = absl::big_endian::Load32(cur_src) >> 8;
+
+ cur_dest[0] = base64[in >> 18];
+ in &= 0x3FFFF;
+ cur_dest[1] = base64[in >> 12];
+ in &= 0xFFF;
+ cur_dest[2] = base64[in >> 6];
+ in &= 0x3F;
+ cur_dest[3] = base64[in];
+
+ cur_dest += 4;
+ cur_src += 3;
+ }
+ }
+ // To save time, we didn't update szdest or szsrc in the loop. So do it now.
+ szdest = limit_dest - cur_dest;
+ szsrc = limit_src - cur_src;
+
+ /* now deal with the tail (<=3 bytes) */
+ switch (szsrc) {
+ case 0:
+ // Nothing left; nothing more to do.
+ break;
+ case 1: {
+ // One byte left: this encodes to two characters, and (optionally)
+ // two pad characters to round out the four-character cypherblock.
+ if (szdest < 2) return 0;
+ uint32_t in = cur_src[0];
+ cur_dest[0] = base64[in >> 2];
+ in &= 0x3;
+ cur_dest[1] = base64[in << 4];
+ cur_dest += 2;
+ szdest -= 2;
+ if (do_padding) {
+ if (szdest < 2) return 0;
+ cur_dest[0] = kPad64;
+ cur_dest[1] = kPad64;
+ cur_dest += 2;
+ szdest -= 2;
+ }
+ break;
+ }
+ case 2: {
+ // Two bytes left: this encodes to three characters, and (optionally)
+ // one pad character to round out the four-character cypherblock.
+ if (szdest < 3) return 0;
+ uint32_t in = absl::big_endian::Load16(cur_src);
+ cur_dest[0] = base64[in >> 10];
+ in &= 0x3FF;
+ cur_dest[1] = base64[in >> 4];
+ in &= 0x00F;
+ cur_dest[2] = base64[in << 2];
+ cur_dest += 3;
+ szdest -= 3;
+ if (do_padding) {
+ if (szdest < 1) return 0;
+ cur_dest[0] = kPad64;
+ cur_dest += 1;
+ szdest -= 1;
+ }
+ break;
+ }
+ case 3: {
+ // Three bytes left: same as in the big loop above. We can't do this in
+ // the loop because the loop above always reads 4 bytes, and the fourth
+ // byte is past the end of the input.
+ if (szdest < 4) return 0;
+ uint32_t in = (cur_src[0] << 16) + absl::big_endian::Load16(cur_src + 1);
+ cur_dest[0] = base64[in >> 18];
+ in &= 0x3FFFF;
+ cur_dest[1] = base64[in >> 12];
+ in &= 0xFFF;
+ cur_dest[2] = base64[in >> 6];
+ in &= 0x3F;
+ cur_dest[3] = base64[in];
+ cur_dest += 4;
+ szdest -= 4;
+ break;
+ }
+ default:
+ // Should not be reached: blocks of 4 bytes are handled
+ // in the while loop before this switch statement.
+ ABSL_RAW_LOG(FATAL, "Logic problem? szsrc = %zu", szsrc);
+ break;
+ }
+ return (cur_dest - dest);
+}
+
+constexpr char kBase64Chars[] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+constexpr char kWebSafeBase64Chars[] =
+ "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+void Base64EscapeInternal(const unsigned char* src, size_t szsrc, std::string* dest,
+ bool do_padding, const char* base64_chars) {
+ const size_t calc_escaped_size =
+ CalculateBase64EscapedLenInternal(szsrc, do_padding);
+ strings_internal::STLStringResizeUninitialized(dest, calc_escaped_size);
+
+ const size_t escaped_len = Base64EscapeInternal(
+ src, szsrc, &(*dest)[0], dest->size(), base64_chars, do_padding);
+ assert(calc_escaped_size == escaped_len);
+ dest->erase(escaped_len);
+}
+
+bool Base64UnescapeInternal(const char* src, size_t slen, std::string* dest,
+ const signed char* unbase64) {
+ // Determine the size of the output std::string. Base64 encodes every 3 bytes into
+ // 4 characters. any leftover chars are added directly for good measure.
+ // This is documented in the base64 RFC: http://tools.ietf.org/html/rfc3548
+ const size_t dest_len = 3 * (slen / 4) + (slen % 4);
+
+ strings_internal::STLStringResizeUninitialized(dest, dest_len);
+
+ // We are getting the destination buffer by getting the beginning of the
+ // std::string and converting it into a char *.
+ size_t len;
+ const bool ok =
+ Base64UnescapeInternal(src, slen, &(*dest)[0], dest_len, unbase64, &len);
+ if (!ok) {
+ dest->clear();
+ return false;
+ }
+
+ // could be shorter if there was padding
+ assert(len <= dest_len);
+ dest->erase(len);
+
+ return true;
+}
+
+/* clang-format off */
+constexpr char kHexValue[256] = {
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, // '0'..'9'
+ 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 'A'..'F'
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 'a'..'f'
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+/* clang-format on */
+
+// This is a templated function so that T can be either a char*
+// or a std::string. This works because we use the [] operator to access
+// individual characters at a time.
+template <typename T>
+void HexStringToBytesInternal(const char* from, T to, ptrdiff_t num) {
+ for (int i = 0; i < num; i++) {
+ to[i] = (kHexValue[from[i * 2] & 0xFF] << 4) +
+ (kHexValue[from[i * 2 + 1] & 0xFF]);
+ }
+}
+
+// This is a templated function so that T can be either a char* or a std::string.
+template <typename T>
+void BytesToHexStringInternal(const unsigned char* src, T dest, ptrdiff_t num) {
+ auto dest_ptr = &dest[0];
+ for (auto src_ptr = src; src_ptr != (src + num); ++src_ptr, dest_ptr += 2) {
+ const char* hex_p = &kHexTable[*src_ptr * 2];
+ std::copy(hex_p, hex_p + 2, dest_ptr);
+ }
+}
+
+} // namespace
+
+// ----------------------------------------------------------------------
+// CUnescape()
+//
+// See CUnescapeInternal() for implementation details.
+// ----------------------------------------------------------------------
+bool CUnescape(absl::string_view source, std::string* dest, std::string* error) {
+ return CUnescapeInternal(source, kUnescapeNulls, dest, error);
+}
+
+std::string CEscape(absl::string_view src) {
+ std::string dest;
+ CEscapeAndAppendInternal(src, &dest);
+ return dest;
+}
+
+std::string CHexEscape(absl::string_view src) {
+ return CEscapeInternal(src, true, false);
+}
+
+std::string Utf8SafeCEscape(absl::string_view src) {
+ return CEscapeInternal(src, false, true);
+}
+
+std::string Utf8SafeCHexEscape(absl::string_view src) {
+ return CEscapeInternal(src, true, true);
+}
+
+// ----------------------------------------------------------------------
+// ptrdiff_t Base64Unescape() - base64 decoder
+// ptrdiff_t Base64Escape() - base64 encoder
+// ptrdiff_t WebSafeBase64Unescape() - Google's variation of base64 decoder
+// ptrdiff_t WebSafeBase64Escape() - Google's variation of base64 encoder
+//
+// Check out
+// http://tools.ietf.org/html/rfc2045 for formal description, but what we
+// care about is that...
+// Take the encoded stuff in groups of 4 characters and turn each
+// character into a code 0 to 63 thus:
+// A-Z map to 0 to 25
+// a-z map to 26 to 51
+// 0-9 map to 52 to 61
+// +(- for WebSafe) maps to 62
+// /(_ for WebSafe) maps to 63
+// There will be four numbers, all less than 64 which can be represented
+// by a 6 digit binary number (aaaaaa, bbbbbb, cccccc, dddddd respectively).
+// Arrange the 6 digit binary numbers into three bytes as such:
+// aaaaaabb bbbbcccc ccdddddd
+// Equals signs (one or two) are used at the end of the encoded block to
+// indicate that the text was not an integer multiple of three bytes long.
+// ----------------------------------------------------------------------
+
+bool Base64Unescape(absl::string_view src, std::string* dest) {
+ return Base64UnescapeInternal(src.data(), src.size(), dest, kUnBase64);
+}
+
+bool WebSafeBase64Unescape(absl::string_view src, std::string* dest) {
+ return Base64UnescapeInternal(src.data(), src.size(), dest, kUnWebSafeBase64);
+}
+
+void Base64Escape(absl::string_view src, std::string* dest) {
+ Base64EscapeInternal(reinterpret_cast<const unsigned char*>(src.data()),
+ src.size(), dest, true, kBase64Chars);
+}
+
+void WebSafeBase64Escape(absl::string_view src, std::string* dest) {
+ Base64EscapeInternal(reinterpret_cast<const unsigned char*>(src.data()),
+ src.size(), dest, false, kWebSafeBase64Chars);
+}
+
+std::string HexStringToBytes(absl::string_view from) {
+ std::string result;
+ const auto num = from.size() / 2;
+ strings_internal::STLStringResizeUninitialized(&result, num);
+ absl::HexStringToBytesInternal<std::string&>(from.data(), result, num);
+ return result;
+}
+
+std::string BytesToHexString(absl::string_view from) {
+ std::string result;
+ strings_internal::STLStringResizeUninitialized(&result, 2 * from.size());
+ absl::BytesToHexStringInternal<std::string&>(
+ reinterpret_cast<const unsigned char*>(from.data()), result, from.size());
+ return result;
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping.h
new file mode 100644
index 0000000..1af0afa
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping.h
@@ -0,0 +1,161 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: escaping.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains std::string utilities involved in escaping and
+// unescaping strings in various ways.
+//
+
+#ifndef ABSL_STRINGS_ESCAPING_H_
+#define ABSL_STRINGS_ESCAPING_H_
+
+#include <cstddef>
+#include <string>
+#include <vector>
+
+#include "absl/base/macros.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/str_join.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+
+// CUnescape()
+//
+// Unescapes a `source` std::string and copies it into `dest`, rewriting C-style
+// escape sequences (http://en.cppreference.com/w/cpp/language/escape) into
+// their proper code point equivalents, returning `true` if successful.
+//
+// The following unescape sequences can be handled:
+//
+// * ASCII escape sequences ('\n','\r','\\', etc.) to their ASCII equivalents
+// * Octal escape sequences ('\nnn') to byte nnn. The unescaped value must
+// resolve to a single byte or an error will occur. E.g. values greater than
+// 0xff will produce an error.
+// * Hexadecimal escape sequences ('\xnn') to byte nn. While an arbitrary
+// number of following digits are allowed, the unescaped value must resolve
+// to a single byte or an error will occur. E.g. '\x0045' is equivalent to
+// '\x45', but '\x1234' will produce an error.
+// * Unicode escape sequences ('\unnnn' for exactly four hex digits or
+// '\Unnnnnnnn' for exactly eight hex digits, which will be encoded in
+// UTF-8. (E.g., `\u2019` unescapes to the three bytes 0xE2, 0x80, and
+// 0x99).
+//
+//
+// If any errors are encountered, this function returns `false` and stores the
+// first encountered error in `error`. To disable error reporting, set `error`
+// to `nullptr` or use the overload with no error reporting below.
+//
+// Example:
+//
+// std::string s = "foo\\rbar\\nbaz\\t";
+// std::string unescaped_s;
+// if (!absl::CUnescape(s, &unescaped_s) {
+// ...
+// }
+// EXPECT_EQ(unescaped_s, "foo\rbar\nbaz\t");
+bool CUnescape(absl::string_view source, std::string* dest, std::string* error);
+
+// Overload of `CUnescape()` with no error reporting.
+inline bool CUnescape(absl::string_view source, std::string* dest) {
+ return CUnescape(source, dest, nullptr);
+}
+
+// CEscape()
+//
+// Escapes a 'src' std::string using C-style escapes sequences
+// (http://en.cppreference.com/w/cpp/language/escape), escaping other
+// non-printable/non-whitespace bytes as octal sequences (e.g. "\377").
+//
+// Example:
+//
+// std::string s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n";
+// std::string escaped_s = absl::CEscape(s);
+// EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\010\\t\\n\\013\\014\\r\\n");
+std::string CEscape(absl::string_view src);
+
+// CHexEscape()
+//
+// Escapes a 'src' std::string using C-style escape sequences, escaping
+// other non-printable/non-whitespace bytes as hexadecimal sequences (e.g.
+// "\xFF").
+//
+// Example:
+//
+// std::string s = "foo\rbar\tbaz\010\011\012\013\014\x0d\n";
+// std::string escaped_s = absl::CHexEscape(s);
+// EXPECT_EQ(escaped_s, "foo\\rbar\\tbaz\\x08\\t\\n\\x0b\\x0c\\r\\n");
+std::string CHexEscape(absl::string_view src);
+
+// Utf8SafeCEscape()
+//
+// Escapes a 'src' std::string using C-style escape sequences, escaping bytes as
+// octal sequences, and passing through UTF-8 characters without conversion.
+// I.e., when encountering any bytes with their high bit set, this function
+// will not escape those values, whether or not they are valid UTF-8.
+std::string Utf8SafeCEscape(absl::string_view src);
+
+// Utf8SafeCHexEscape()
+//
+// Escapes a 'src' std::string using C-style escape sequences, escaping bytes as
+// hexadecimal sequences, and passing through UTF-8 characters without
+// conversion.
+std::string Utf8SafeCHexEscape(absl::string_view src);
+
+// Base64Unescape()
+//
+// Converts a `src` std::string encoded in Base64 to its binary equivalent, writing
+// it to a `dest` buffer, returning `true` on success. If `src` contains invalid
+// characters, `dest` is cleared and returns `false`.
+bool Base64Unescape(absl::string_view src, std::string* dest);
+
+// WebSafeBase64Unescape(absl::string_view, std::string*)
+//
+// Converts a `src` std::string encoded in Base64 to its binary equivalent, writing
+// it to a `dest` buffer, but using '-' instead of '+', and '_' instead of '/'.
+// If `src` contains invalid characters, `dest` is cleared and returns `false`.
+bool WebSafeBase64Unescape(absl::string_view src, std::string* dest);
+
+// Base64Escape()
+//
+// Encodes a `src` std::string into a `dest` buffer using base64 encoding, with
+// padding characters. This function conforms with RFC 4648 section 4 (base64).
+void Base64Escape(absl::string_view src, std::string* dest);
+
+// WebSafeBase64Escape()
+//
+// Encodes a `src` std::string into a `dest` buffer using uses '-' instead of '+' and
+// '_' instead of '/', and without padding. This function conforms with RFC 4648
+// section 5 (base64url).
+void WebSafeBase64Escape(absl::string_view src, std::string* dest);
+
+// HexStringToBytes()
+//
+// Converts an ASCII hex std::string into bytes, returning binary data of length
+// `from.size()/2`.
+std::string HexStringToBytes(absl::string_view from);
+
+// BytesToHexString()
+//
+// Converts binary data into an ASCII text std::string, returning a std::string of size
+// `2*from.size()`.
+std::string BytesToHexString(absl::string_view from);
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_ESCAPING_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping_test.cc
new file mode 100644
index 0000000..982989b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/escaping_test.cc
@@ -0,0 +1,641 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/escaping.h"
+
+#include <array>
+#include <cstdio>
+#include <cstring>
+#include <memory>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/container/fixed_array.h"
+#include "absl/strings/str_cat.h"
+
+#include "absl/strings/internal/escaping_test_common.inc"
+
+namespace {
+
+struct epair {
+ std::string escaped;
+ std::string unescaped;
+};
+
+TEST(CEscape, EscapeAndUnescape) {
+ const std::string inputs[] = {
+ std::string("foo\nxx\r\b\0023"),
+ std::string(""),
+ std::string("abc"),
+ std::string("\1chad_rules"),
+ std::string("\1arnar_drools"),
+ std::string("xxxx\r\t'\"\\"),
+ std::string("\0xx\0", 4),
+ std::string("\x01\x31"),
+ std::string("abc\xb\x42\141bc"),
+ std::string("123\1\x31\x32\x33"),
+ std::string("\xc1\xca\x1b\x62\x19o\xcc\x04"),
+ std::string("\\\"\xe8\xb0\xb7\xe6\xad\x8c\\\" is Google\\\'s Chinese name"),
+ };
+ // Do this twice, once for octal escapes and once for hex escapes.
+ for (int kind = 0; kind < 4; kind++) {
+ for (const std::string& original : inputs) {
+ std::string escaped;
+ switch (kind) {
+ case 0:
+ escaped = absl::CEscape(original);
+ break;
+ case 1:
+ escaped = absl::CHexEscape(original);
+ break;
+ case 2:
+ escaped = absl::Utf8SafeCEscape(original);
+ break;
+ case 3:
+ escaped = absl::Utf8SafeCHexEscape(original);
+ break;
+ }
+ std::string unescaped_str;
+ EXPECT_TRUE(absl::CUnescape(escaped, &unescaped_str));
+ EXPECT_EQ(unescaped_str, original);
+
+ // Check in-place unescaping
+ std::string s = escaped;
+ EXPECT_TRUE(absl::CUnescape(s, &s));
+ ASSERT_EQ(s, original);
+ }
+ }
+ // Check that all possible two character strings can be escaped then
+ // unescaped successfully.
+ for (int char0 = 0; char0 < 256; char0++) {
+ for (int char1 = 0; char1 < 256; char1++) {
+ char chars[2];
+ chars[0] = char0;
+ chars[1] = char1;
+ std::string s(chars, 2);
+ std::string escaped = absl::CHexEscape(s);
+ std::string unescaped;
+ EXPECT_TRUE(absl::CUnescape(escaped, &unescaped));
+ EXPECT_EQ(s, unescaped);
+ }
+ }
+}
+
+TEST(CEscape, BasicEscaping) {
+ epair oct_values[] = {
+ {"foo\\rbar\\nbaz\\t", "foo\rbar\nbaz\t"},
+ {"\\'full of \\\"sound\\\" and \\\"fury\\\"\\'",
+ "'full of \"sound\" and \"fury\"'"},
+ {"signi\\\\fying\\\\ nothing\\\\", "signi\\fying\\ nothing\\"},
+ {"\\010\\t\\n\\013\\014\\r", "\010\011\012\013\014\015"}
+ };
+ epair hex_values[] = {
+ {"ubik\\rubik\\nubik\\t", "ubik\rubik\nubik\t"},
+ {"I\\\'ve just seen a \\\"face\\\"",
+ "I've just seen a \"face\""},
+ {"hel\\\\ter\\\\skel\\\\ter\\\\", "hel\\ter\\skel\\ter\\"},
+ {"\\x08\\t\\n\\x0b\\x0c\\r", "\010\011\012\013\014\015"}
+ };
+ epair utf8_oct_values[] = {
+ {"\xe8\xb0\xb7\xe6\xad\x8c\\r\xe8\xb0\xb7\xe6\xad\x8c\\nbaz\\t",
+ "\xe8\xb0\xb7\xe6\xad\x8c\r\xe8\xb0\xb7\xe6\xad\x8c\nbaz\t"},
+ {"\\\"\xe8\xb0\xb7\xe6\xad\x8c\\\" is Google\\\'s Chinese name",
+ "\"\xe8\xb0\xb7\xe6\xad\x8c\" is Google\'s Chinese name"},
+ {"\xe3\x83\xa1\xe3\x83\xbc\xe3\x83\xab\\\\are\\\\Japanese\\\\chars\\\\",
+ "\xe3\x83\xa1\xe3\x83\xbc\xe3\x83\xab\\are\\Japanese\\chars\\"},
+ {"\xed\x81\xac\xeb\xa1\xac\\010\\t\\n\\013\\014\\r",
+ "\xed\x81\xac\xeb\xa1\xac\010\011\012\013\014\015"}
+ };
+ epair utf8_hex_values[] = {
+ {"\x20\xe4\xbd\xa0\\t\xe5\xa5\xbd,\\r!\\n",
+ "\x20\xe4\xbd\xa0\t\xe5\xa5\xbd,\r!\n"},
+ {"\xe8\xa9\xa6\xe9\xa8\x93\\\' means \\\"test\\\"",
+ "\xe8\xa9\xa6\xe9\xa8\x93\' means \"test\""},
+ {"\\\\\xe6\x88\x91\\\\:\\\\\xe6\x9d\xa8\xe6\xac\xa2\\\\",
+ "\\\xe6\x88\x91\\:\\\xe6\x9d\xa8\xe6\xac\xa2\\"},
+ {"\xed\x81\xac\xeb\xa1\xac\\x08\\t\\n\\x0b\\x0c\\r",
+ "\xed\x81\xac\xeb\xa1\xac\010\011\012\013\014\015"}
+ };
+
+ for (const epair& val : oct_values) {
+ std::string escaped = absl::CEscape(val.unescaped);
+ EXPECT_EQ(escaped, val.escaped);
+ }
+ for (const epair& val : hex_values) {
+ std::string escaped = absl::CHexEscape(val.unescaped);
+ EXPECT_EQ(escaped, val.escaped);
+ }
+ for (const epair& val : utf8_oct_values) {
+ std::string escaped = absl::Utf8SafeCEscape(val.unescaped);
+ EXPECT_EQ(escaped, val.escaped);
+ }
+ for (const epair& val : utf8_hex_values) {
+ std::string escaped = absl::Utf8SafeCHexEscape(val.unescaped);
+ EXPECT_EQ(escaped, val.escaped);
+ }
+}
+
+TEST(Unescape, BasicFunction) {
+ epair tests[] =
+ {{"\\u0030", "0"},
+ {"\\u00A3", "\xC2\xA3"},
+ {"\\u22FD", "\xE2\x8B\xBD"},
+ {"\\U00010000", "\xF0\x90\x80\x80"},
+ {"\\U0010FFFD", "\xF4\x8F\xBF\xBD"}};
+ for (const epair& val : tests) {
+ std::string out;
+ EXPECT_TRUE(absl::CUnescape(val.escaped, &out));
+ EXPECT_EQ(out, val.unescaped);
+ }
+ std::string bad[] =
+ {"\\u1", // too short
+ "\\U1", // too short
+ "\\Uffffff", // exceeds 0x10ffff (largest Unicode)
+ "\\U00110000", // exceeds 0x10ffff (largest Unicode)
+ "\\uD835", // surrogate character (D800-DFFF)
+ "\\U0000DD04", // surrogate character (D800-DFFF)
+ "\\777", // exceeds 0xff
+ "\\xABCD"}; // exceeds 0xff
+ for (const std::string& e : bad) {
+ std::string error;
+ std::string out;
+ EXPECT_FALSE(absl::CUnescape(e, &out, &error));
+ EXPECT_FALSE(error.empty());
+ }
+}
+
+class CUnescapeTest : public testing::Test {
+ protected:
+ static const char kStringWithMultipleOctalNulls[];
+ static const char kStringWithMultipleHexNulls[];
+ static const char kStringWithMultipleUnicodeNulls[];
+
+ std::string result_string_;
+};
+
+const char CUnescapeTest::kStringWithMultipleOctalNulls[] =
+ "\\0\\n" // null escape \0 plus newline
+ "0\\n" // just a number 0 (not a null escape) plus newline
+ "\\00\\12" // null escape \00 plus octal newline code
+ "\\000"; // null escape \000
+
+// This has the same ingredients as kStringWithMultipleOctalNulls
+// but with \x hex escapes instead of octal escapes.
+const char CUnescapeTest::kStringWithMultipleHexNulls[] =
+ "\\x0\\n"
+ "0\\n"
+ "\\x00\\xa"
+ "\\x000";
+
+const char CUnescapeTest::kStringWithMultipleUnicodeNulls[] =
+ "\\u0000\\n" // short-form (4-digit) null escape plus newline
+ "0\\n" // just a number 0 (not a null escape) plus newline
+ "\\U00000000"; // long-form (8-digit) null escape
+
+TEST_F(CUnescapeTest, Unescapes1CharOctalNull) {
+ std::string original_string = "\\0";
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ EXPECT_EQ(std::string("\0", 1), result_string_);
+}
+
+TEST_F(CUnescapeTest, Unescapes2CharOctalNull) {
+ std::string original_string = "\\00";
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ EXPECT_EQ(std::string("\0", 1), result_string_);
+}
+
+TEST_F(CUnescapeTest, Unescapes3CharOctalNull) {
+ std::string original_string = "\\000";
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ EXPECT_EQ(std::string("\0", 1), result_string_);
+}
+
+TEST_F(CUnescapeTest, Unescapes1CharHexNull) {
+ std::string original_string = "\\x0";
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ EXPECT_EQ(std::string("\0", 1), result_string_);
+}
+
+TEST_F(CUnescapeTest, Unescapes2CharHexNull) {
+ std::string original_string = "\\x00";
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ EXPECT_EQ(std::string("\0", 1), result_string_);
+}
+
+TEST_F(CUnescapeTest, Unescapes3CharHexNull) {
+ std::string original_string = "\\x000";
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ EXPECT_EQ(std::string("\0", 1), result_string_);
+}
+
+TEST_F(CUnescapeTest, Unescapes4CharUnicodeNull) {
+ std::string original_string = "\\u0000";
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ EXPECT_EQ(std::string("\0", 1), result_string_);
+}
+
+TEST_F(CUnescapeTest, Unescapes8CharUnicodeNull) {
+ std::string original_string = "\\U00000000";
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ EXPECT_EQ(std::string("\0", 1), result_string_);
+}
+
+TEST_F(CUnescapeTest, UnescapesMultipleOctalNulls) {
+ std::string original_string(kStringWithMultipleOctalNulls);
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ // All escapes, including newlines and null escapes, should have been
+ // converted to the equivalent characters.
+ EXPECT_EQ(std::string("\0\n"
+ "0\n"
+ "\0\n"
+ "\0", 7), result_string_);
+}
+
+
+TEST_F(CUnescapeTest, UnescapesMultipleHexNulls) {
+ std::string original_string(kStringWithMultipleHexNulls);
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ EXPECT_EQ(std::string("\0\n"
+ "0\n"
+ "\0\n"
+ "\0", 7), result_string_);
+}
+
+TEST_F(CUnescapeTest, UnescapesMultipleUnicodeNulls) {
+ std::string original_string(kStringWithMultipleUnicodeNulls);
+ EXPECT_TRUE(absl::CUnescape(original_string, &result_string_));
+ EXPECT_EQ(std::string("\0\n"
+ "0\n"
+ "\0", 5), result_string_);
+}
+
+static struct {
+ absl::string_view plaintext;
+ absl::string_view cyphertext;
+} const base64_tests[] = {
+ // Empty std::string.
+ {{"", 0}, {"", 0}},
+ {{nullptr, 0},
+ {"", 0}}, // if length is zero, plaintext ptr must be ignored!
+
+ // Basic bit patterns;
+ // values obtained with "echo -n '...' | uuencode -m test"
+
+ {{"\000", 1}, "AA=="},
+ {{"\001", 1}, "AQ=="},
+ {{"\002", 1}, "Ag=="},
+ {{"\004", 1}, "BA=="},
+ {{"\010", 1}, "CA=="},
+ {{"\020", 1}, "EA=="},
+ {{"\040", 1}, "IA=="},
+ {{"\100", 1}, "QA=="},
+ {{"\200", 1}, "gA=="},
+
+ {{"\377", 1}, "/w=="},
+ {{"\376", 1}, "/g=="},
+ {{"\375", 1}, "/Q=="},
+ {{"\373", 1}, "+w=="},
+ {{"\367", 1}, "9w=="},
+ {{"\357", 1}, "7w=="},
+ {{"\337", 1}, "3w=="},
+ {{"\277", 1}, "vw=="},
+ {{"\177", 1}, "fw=="},
+ {{"\000\000", 2}, "AAA="},
+ {{"\000\001", 2}, "AAE="},
+ {{"\000\002", 2}, "AAI="},
+ {{"\000\004", 2}, "AAQ="},
+ {{"\000\010", 2}, "AAg="},
+ {{"\000\020", 2}, "ABA="},
+ {{"\000\040", 2}, "ACA="},
+ {{"\000\100", 2}, "AEA="},
+ {{"\000\200", 2}, "AIA="},
+ {{"\001\000", 2}, "AQA="},
+ {{"\002\000", 2}, "AgA="},
+ {{"\004\000", 2}, "BAA="},
+ {{"\010\000", 2}, "CAA="},
+ {{"\020\000", 2}, "EAA="},
+ {{"\040\000", 2}, "IAA="},
+ {{"\100\000", 2}, "QAA="},
+ {{"\200\000", 2}, "gAA="},
+
+ {{"\377\377", 2}, "//8="},
+ {{"\377\376", 2}, "//4="},
+ {{"\377\375", 2}, "//0="},
+ {{"\377\373", 2}, "//s="},
+ {{"\377\367", 2}, "//c="},
+ {{"\377\357", 2}, "/+8="},
+ {{"\377\337", 2}, "/98="},
+ {{"\377\277", 2}, "/78="},
+ {{"\377\177", 2}, "/38="},
+ {{"\376\377", 2}, "/v8="},
+ {{"\375\377", 2}, "/f8="},
+ {{"\373\377", 2}, "+/8="},
+ {{"\367\377", 2}, "9/8="},
+ {{"\357\377", 2}, "7/8="},
+ {{"\337\377", 2}, "3/8="},
+ {{"\277\377", 2}, "v/8="},
+ {{"\177\377", 2}, "f/8="},
+
+ {{"\000\000\000", 3}, "AAAA"},
+ {{"\000\000\001", 3}, "AAAB"},
+ {{"\000\000\002", 3}, "AAAC"},
+ {{"\000\000\004", 3}, "AAAE"},
+ {{"\000\000\010", 3}, "AAAI"},
+ {{"\000\000\020", 3}, "AAAQ"},
+ {{"\000\000\040", 3}, "AAAg"},
+ {{"\000\000\100", 3}, "AABA"},
+ {{"\000\000\200", 3}, "AACA"},
+ {{"\000\001\000", 3}, "AAEA"},
+ {{"\000\002\000", 3}, "AAIA"},
+ {{"\000\004\000", 3}, "AAQA"},
+ {{"\000\010\000", 3}, "AAgA"},
+ {{"\000\020\000", 3}, "ABAA"},
+ {{"\000\040\000", 3}, "ACAA"},
+ {{"\000\100\000", 3}, "AEAA"},
+ {{"\000\200\000", 3}, "AIAA"},
+ {{"\001\000\000", 3}, "AQAA"},
+ {{"\002\000\000", 3}, "AgAA"},
+ {{"\004\000\000", 3}, "BAAA"},
+ {{"\010\000\000", 3}, "CAAA"},
+ {{"\020\000\000", 3}, "EAAA"},
+ {{"\040\000\000", 3}, "IAAA"},
+ {{"\100\000\000", 3}, "QAAA"},
+ {{"\200\000\000", 3}, "gAAA"},
+
+ {{"\377\377\377", 3}, "////"},
+ {{"\377\377\376", 3}, "///+"},
+ {{"\377\377\375", 3}, "///9"},
+ {{"\377\377\373", 3}, "///7"},
+ {{"\377\377\367", 3}, "///3"},
+ {{"\377\377\357", 3}, "///v"},
+ {{"\377\377\337", 3}, "///f"},
+ {{"\377\377\277", 3}, "//+/"},
+ {{"\377\377\177", 3}, "//9/"},
+ {{"\377\376\377", 3}, "//7/"},
+ {{"\377\375\377", 3}, "//3/"},
+ {{"\377\373\377", 3}, "//v/"},
+ {{"\377\367\377", 3}, "//f/"},
+ {{"\377\357\377", 3}, "/+//"},
+ {{"\377\337\377", 3}, "/9//"},
+ {{"\377\277\377", 3}, "/7//"},
+ {{"\377\177\377", 3}, "/3//"},
+ {{"\376\377\377", 3}, "/v//"},
+ {{"\375\377\377", 3}, "/f//"},
+ {{"\373\377\377", 3}, "+///"},
+ {{"\367\377\377", 3}, "9///"},
+ {{"\357\377\377", 3}, "7///"},
+ {{"\337\377\377", 3}, "3///"},
+ {{"\277\377\377", 3}, "v///"},
+ {{"\177\377\377", 3}, "f///"},
+
+ // Random numbers: values obtained with
+ //
+ // #! /bin/bash
+ // dd bs=$1 count=1 if=/dev/random of=/tmp/bar.random
+ // od -N $1 -t o1 /tmp/bar.random
+ // uuencode -m test < /tmp/bar.random
+ //
+ // where $1 is the number of bytes (2, 3)
+
+ {{"\243\361", 2}, "o/E="},
+ {{"\024\167", 2}, "FHc="},
+ {{"\313\252", 2}, "y6o="},
+ {{"\046\041", 2}, "JiE="},
+ {{"\145\236", 2}, "ZZ4="},
+ {{"\254\325", 2}, "rNU="},
+ {{"\061\330", 2}, "Mdg="},
+ {{"\245\032", 2}, "pRo="},
+ {{"\006\000", 2}, "BgA="},
+ {{"\375\131", 2}, "/Vk="},
+ {{"\303\210", 2}, "w4g="},
+ {{"\040\037", 2}, "IB8="},
+ {{"\261\372", 2}, "sfo="},
+ {{"\335\014", 2}, "3Qw="},
+ {{"\233\217", 2}, "m48="},
+ {{"\373\056", 2}, "+y4="},
+ {{"\247\232", 2}, "p5o="},
+ {{"\107\053", 2}, "Rys="},
+ {{"\204\077", 2}, "hD8="},
+ {{"\276\211", 2}, "vok="},
+ {{"\313\110", 2}, "y0g="},
+ {{"\363\376", 2}, "8/4="},
+ {{"\251\234", 2}, "qZw="},
+ {{"\103\262", 2}, "Q7I="},
+ {{"\142\312", 2}, "Yso="},
+ {{"\067\211", 2}, "N4k="},
+ {{"\220\001", 2}, "kAE="},
+ {{"\152\240", 2}, "aqA="},
+ {{"\367\061", 2}, "9zE="},
+ {{"\133\255", 2}, "W60="},
+ {{"\176\035", 2}, "fh0="},
+ {{"\032\231", 2}, "Gpk="},
+
+ {{"\013\007\144", 3}, "Cwdk"},
+ {{"\030\112\106", 3}, "GEpG"},
+ {{"\047\325\046", 3}, "J9Um"},
+ {{"\310\160\022", 3}, "yHAS"},
+ {{"\131\100\237", 3}, "WUCf"},
+ {{"\064\342\134", 3}, "NOJc"},
+ {{"\010\177\004", 3}, "CH8E"},
+ {{"\345\147\205", 3}, "5WeF"},
+ {{"\300\343\360", 3}, "wOPw"},
+ {{"\061\240\201", 3}, "MaCB"},
+ {{"\225\333\044", 3}, "ldsk"},
+ {{"\215\137\352", 3}, "jV/q"},
+ {{"\371\147\160", 3}, "+Wdw"},
+ {{"\030\320\051", 3}, "GNAp"},
+ {{"\044\174\241", 3}, "JHyh"},
+ {{"\260\127\037", 3}, "sFcf"},
+ {{"\111\045\033", 3}, "SSUb"},
+ {{"\202\114\107", 3}, "gkxH"},
+ {{"\057\371\042", 3}, "L/ki"},
+ {{"\223\247\244", 3}, "k6ek"},
+ {{"\047\216\144", 3}, "J45k"},
+ {{"\203\070\327", 3}, "gzjX"},
+ {{"\247\140\072", 3}, "p2A6"},
+ {{"\124\115\116", 3}, "VE1O"},
+ {{"\157\162\050", 3}, "b3Io"},
+ {{"\357\223\004", 3}, "75ME"},
+ {{"\052\117\156", 3}, "Kk9u"},
+ {{"\347\154\000", 3}, "52wA"},
+ {{"\303\012\142", 3}, "wwpi"},
+ {{"\060\035\362", 3}, "MB3y"},
+ {{"\130\226\361", 3}, "WJbx"},
+ {{"\173\013\071", 3}, "ews5"},
+ {{"\336\004\027", 3}, "3gQX"},
+ {{"\357\366\234", 3}, "7/ac"},
+ {{"\353\304\111", 3}, "68RJ"},
+ {{"\024\264\131", 3}, "FLRZ"},
+ {{"\075\114\251", 3}, "PUyp"},
+ {{"\315\031\225", 3}, "zRmV"},
+ {{"\154\201\276", 3}, "bIG+"},
+ {{"\200\066\072", 3}, "gDY6"},
+ {{"\142\350\267", 3}, "Yui3"},
+ {{"\033\000\166", 3}, "GwB2"},
+ {{"\210\055\077", 3}, "iC0/"},
+ {{"\341\037\124", 3}, "4R9U"},
+ {{"\161\103\152", 3}, "cUNq"},
+ {{"\270\142\131", 3}, "uGJZ"},
+ {{"\337\076\074", 3}, "3z48"},
+ {{"\375\106\362", 3}, "/Uby"},
+ {{"\227\301\127", 3}, "l8FX"},
+ {{"\340\002\234", 3}, "4AKc"},
+ {{"\121\064\033", 3}, "UTQb"},
+ {{"\157\134\143", 3}, "b1xj"},
+ {{"\247\055\327", 3}, "py3X"},
+ {{"\340\142\005", 3}, "4GIF"},
+ {{"\060\260\143", 3}, "MLBj"},
+ {{"\075\203\170", 3}, "PYN4"},
+ {{"\143\160\016", 3}, "Y3AO"},
+ {{"\313\013\063", 3}, "ywsz"},
+ {{"\174\236\135", 3}, "fJ5d"},
+ {{"\103\047\026", 3}, "QycW"},
+ {{"\365\005\343", 3}, "9QXj"},
+ {{"\271\160\223", 3}, "uXCT"},
+ {{"\362\255\172", 3}, "8q16"},
+ {{"\113\012\015", 3}, "SwoN"},
+
+ // various lengths, generated by this python script:
+ //
+ // from std::string import lowercase as lc
+ // for i in range(27):
+ // print '{ %2d, "%s",%s "%s" },' % (i, lc[:i], ' ' * (26-i),
+ // lc[:i].encode('base64').strip())
+
+ {{"", 0}, {"", 0}},
+ {"a", "YQ=="},
+ {"ab", "YWI="},
+ {"abc", "YWJj"},
+ {"abcd", "YWJjZA=="},
+ {"abcde", "YWJjZGU="},
+ {"abcdef", "YWJjZGVm"},
+ {"abcdefg", "YWJjZGVmZw=="},
+ {"abcdefgh", "YWJjZGVmZ2g="},
+ {"abcdefghi", "YWJjZGVmZ2hp"},
+ {"abcdefghij", "YWJjZGVmZ2hpag=="},
+ {"abcdefghijk", "YWJjZGVmZ2hpams="},
+ {"abcdefghijkl", "YWJjZGVmZ2hpamts"},
+ {"abcdefghijklm", "YWJjZGVmZ2hpamtsbQ=="},
+ {"abcdefghijklmn", "YWJjZGVmZ2hpamtsbW4="},
+ {"abcdefghijklmno", "YWJjZGVmZ2hpamtsbW5v"},
+ {"abcdefghijklmnop", "YWJjZGVmZ2hpamtsbW5vcA=="},
+ {"abcdefghijklmnopq", "YWJjZGVmZ2hpamtsbW5vcHE="},
+ {"abcdefghijklmnopqr", "YWJjZGVmZ2hpamtsbW5vcHFy"},
+ {"abcdefghijklmnopqrs", "YWJjZGVmZ2hpamtsbW5vcHFycw=="},
+ {"abcdefghijklmnopqrst", "YWJjZGVmZ2hpamtsbW5vcHFyc3Q="},
+ {"abcdefghijklmnopqrstu", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1"},
+ {"abcdefghijklmnopqrstuv", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dg=="},
+ {"abcdefghijklmnopqrstuvw", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnc="},
+ {"abcdefghijklmnopqrstuvwx", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4"},
+ {"abcdefghijklmnopqrstuvwxy", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eQ=="},
+ {"abcdefghijklmnopqrstuvwxyz", "YWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXo="},
+};
+
+TEST(Base64, EscapeAndUnescape) {
+ // Check the short strings; this tests the math (and boundaries)
+ for (const auto& tc : base64_tests) {
+ std::string encoded("this junk should be ignored");
+ absl::Base64Escape(tc.plaintext, &encoded);
+ EXPECT_EQ(encoded, tc.cyphertext);
+
+ std::string decoded("this junk should be ignored");
+ EXPECT_TRUE(absl::Base64Unescape(encoded, &decoded));
+ EXPECT_EQ(decoded, tc.plaintext);
+
+ std::string websafe(tc.cyphertext);
+ for (int c = 0; c < websafe.size(); ++c) {
+ if ('+' == websafe[c]) websafe[c] = '-';
+ if ('/' == websafe[c]) websafe[c] = '_';
+ if ('=' == websafe[c]) {
+ websafe.resize(c);
+ break;
+ }
+ }
+
+ encoded = "this junk should be ignored";
+ absl::WebSafeBase64Escape(tc.plaintext, &encoded);
+ EXPECT_EQ(encoded, websafe);
+
+ // Let's try the std::string version of the decoder
+ decoded = "this junk should be ignored";
+ EXPECT_TRUE(absl::WebSafeBase64Unescape(websafe, &decoded));
+ EXPECT_EQ(decoded, tc.plaintext);
+ }
+
+ // Now try the long strings, this tests the streaming
+ for (const auto& tc : base64_strings) {
+ std::string buffer;
+ absl::WebSafeBase64Escape(tc.plaintext, &buffer);
+ EXPECT_EQ(tc.cyphertext, buffer);
+ }
+
+ // Verify the behavior when decoding bad data
+ {
+ absl::string_view data_set[] = {"ab-/", absl::string_view("\0bcd", 4),
+ absl::string_view("abc.\0", 5)};
+ for (absl::string_view bad_data : data_set) {
+ std::string buf;
+ EXPECT_FALSE(absl::Base64Unescape(bad_data, &buf));
+ EXPECT_FALSE(absl::WebSafeBase64Unescape(bad_data, &buf));
+ EXPECT_TRUE(buf.empty());
+ }
+ }
+}
+
+TEST(Base64, DISABLED_HugeData) {
+ const size_t kSize = size_t(3) * 1000 * 1000 * 1000;
+ static_assert(kSize % 3 == 0, "kSize must be divisible by 3");
+ const std::string huge(kSize, 'x');
+
+ std::string escaped;
+ absl::Base64Escape(huge, &escaped);
+
+ // Generates the std::string that should match a base64 encoded "xxx..." std::string.
+ // "xxx" in base64 is "eHh4".
+ std::string expected_encoding;
+ expected_encoding.reserve(kSize / 3 * 4);
+ for (size_t i = 0; i < kSize / 3; ++i) {
+ expected_encoding.append("eHh4");
+ }
+ EXPECT_EQ(expected_encoding, escaped);
+
+ std::string unescaped;
+ EXPECT_TRUE(absl::Base64Unescape(escaped, &unescaped));
+ EXPECT_EQ(huge, unescaped);
+}
+
+TEST(HexAndBack, HexStringToBytes_and_BytesToHexString) {
+ std::string hex_mixed = "0123456789abcdefABCDEF";
+ std::string bytes_expected = "\x01\x23\x45\x67\x89\xab\xcd\xef\xAB\xCD\xEF";
+ std::string hex_only_lower = "0123456789abcdefabcdef";
+
+ std::string bytes_result = absl::HexStringToBytes(hex_mixed);
+ EXPECT_EQ(bytes_expected, bytes_result);
+
+ std::string prefix_valid = hex_mixed + "?";
+ std::string prefix_valid_result = absl::HexStringToBytes(
+ absl::string_view(prefix_valid.data(), prefix_valid.size() - 1));
+ EXPECT_EQ(bytes_expected, prefix_valid_result);
+
+ std::string infix_valid = "?" + hex_mixed + "???";
+ std::string infix_valid_result = absl::HexStringToBytes(
+ absl::string_view(infix_valid.data() + 1, hex_mixed.size()));
+ EXPECT_EQ(bytes_expected, infix_valid_result);
+
+ std::string hex_result = absl::BytesToHexString(bytes_expected);
+ EXPECT_EQ(hex_only_lower, hex_result);
+}
+
+} // namespace
[57/62] [abbrv] marmotta git commit: [maven-release-plugin] prepare
release 3.4.0
Posted by ja...@apache.org.
[maven-release-plugin] prepare release 3.4.0
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/b0e5b937
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/b0e5b937
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/b0e5b937
Branch: refs/heads/master
Commit: b0e5b93772fe16d2cdfc0ed7b444cda160ecdd3a
Parents: b7e0dd4
Author: Jakob Frank <ja...@apache.org>
Authored: Tue Jun 12 13:27:17 2018 +0200
Committer: Jakob Frank <ja...@apache.org>
Committed: Tue Jun 12 13:27:17 2018 +0200
----------------------------------------------------------------------
build/archetypes/marmotta-archetype-module/pom.xml | 2 +-
build/archetypes/marmotta-archetype-webapp/pom.xml | 2 +-
build/archetypes/pom.xml | 2 +-
build/checkstyle-resources/pom.xml | 2 +-
build/dependency-resource-supplement/pom.xml | 2 +-
build/plugins/buildinfo-maven-plugin/pom.xml | 2 +-
build/plugins/marmotta-maven-plugin/pom.xml | 2 +-
build/plugins/pom.xml | 2 +-
build/plugins/refpack-maven-plugin/pom.xml | 2 +-
build/plugins/repocheck-maven-plugin/pom.xml | 2 +-
build/pom.xml | 2 +-
client/marmotta-client-java/pom.xml | 2 +-
client/marmotta-client-js-sample-webapp/pom.xml | 2 +-
client/marmotta-client-js/pom.xml | 2 +-
client/pom.xml | 2 +-
commons/marmotta-commons/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml | 2 +-
.../marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml | 2 +-
.../marmotta-sesame-tools/marmotta-sail-transactions/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml | 2 +-
.../marmotta-sesame-tools/marmotta-util-tripletable/pom.xml | 2 +-
commons/marmotta-sesame-tools/pom.xml | 2 +-
commons/pom.xml | 2 +-
extras/pom.xml | 2 +-
extras/webjars/codemirror/pom.xml | 2 +-
extras/webjars/pom.xml | 2 +-
extras/webjars/strftime/pom.xml | 2 +-
launchers/marmotta-installer/pom.xml | 2 +-
launchers/marmotta-splash/pom.xml | 2 +-
launchers/marmotta-webapp/pom.xml | 2 +-
launchers/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-ehcache/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-hazelcast/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-infinispan/pom.xml | 2 +-
libraries/kiwi/kiwi-loader/pom.xml | 2 +-
libraries/kiwi/kiwi-reasoner/pom.xml | 2 +-
libraries/kiwi/kiwi-sparql/pom.xml | 2 +-
libraries/kiwi/kiwi-triplestore/pom.xml | 2 +-
libraries/kiwi/kiwi-versioning/pom.xml | 2 +-
libraries/kiwi/pom.xml | 2 +-
libraries/ldcache/ldcache-api/pom.xml | 2 +-
libraries/ldcache/ldcache-backend-file/pom.xml | 2 +-
libraries/ldcache/ldcache-backend-infinispan/pom.xml | 2 +-
libraries/ldcache/ldcache-backend-kiwi/pom.xml | 2 +-
libraries/ldcache/ldcache-core/pom.xml | 2 +-
libraries/ldcache/ldcache-sail-generic/pom.xml | 2 +-
libraries/ldcache/ldcache-sail-kiwi/pom.xml | 2 +-
libraries/ldcache/pom.xml | 2 +-
libraries/ldclient/ldclient-api/pom.xml | 2 +-
libraries/ldclient/ldclient-core/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-facebook/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-html/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-ldap/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-mediawiki/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-phpbb/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-rdf/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-rdfa/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-vimeo/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-xml/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-youtube/pom.xml | 2 +-
libraries/ldclient/pom.xml | 2 +-
libraries/ldpath/ldpath-api/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-file/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-jena/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-linkeddata/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-sesame/pom.xml | 2 +-
libraries/ldpath/ldpath-core-bundle/pom.xml | 2 +-
libraries/ldpath/ldpath-core/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-collections/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-date/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-html/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-json/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-math/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-text/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-xml/pom.xml | 2 +-
libraries/ldpath/ldpath-ldquery-cli/pom.xml | 2 +-
libraries/ldpath/ldpath-template-linkeddata/pom.xml | 2 +-
libraries/ldpath/ldpath-template/pom.xml | 2 +-
libraries/ldpath/pom.xml | 2 +-
libraries/pom.xml | 2 +-
loader/marmotta-loader-berkeley/pom.xml | 2 +-
loader/marmotta-loader-core/pom.xml | 2 +-
loader/marmotta-loader-hbase/pom.xml | 2 +-
loader/marmotta-loader-kiwi/pom.xml | 2 +-
loader/marmotta-loader-titan/pom.xml | 2 +-
loader/pom.xml | 2 +-
parent/pom.xml | 6 +++++-
platform/backends/marmotta-backend-accumulograph/pom.xml | 6 ++----
platform/backends/marmotta-backend-kiwi/pom.xml | 2 +-
platform/backends/marmotta-backend-memory/pom.xml | 2 +-
platform/backends/marmotta-backend-native/pom.xml | 2 +-
platform/backends/marmotta-backend-titan/pom.xml | 2 +-
platform/backends/pom.xml | 2 +-
platform/ldcache/marmotta-ldcache-common/pom.xml | 2 +-
platform/ldcache/marmotta-ldcache-file/pom.xml | 2 +-
platform/ldcache/marmotta-ldcache-kiwi/pom.xml | 2 +-
platform/ldcache/pom.xml | 2 +-
platform/marmotta-core/pom.xml | 2 +-
platform/marmotta-ldp/pom.xml | 2 +-
platform/marmotta-ldpath/pom.xml | 2 +-
platform/marmotta-reasoner-kiwi/pom.xml | 2 +-
platform/marmotta-security/pom.xml | 2 +-
platform/marmotta-sparql/pom.xml | 2 +-
platform/marmotta-user/pom.xml | 2 +-
platform/marmotta-versioning-common/pom.xml | 2 +-
platform/marmotta-versioning-kiwi/pom.xml | 2 +-
platform/marmotta-zookeeper/pom.xml | 2 +-
platform/pom.xml | 2 +-
pom.xml | 4 ++--
116 files changed, 122 insertions(+), 120 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/archetypes/marmotta-archetype-module/pom.xml
----------------------------------------------------------------------
diff --git a/build/archetypes/marmotta-archetype-module/pom.xml b/build/archetypes/marmotta-archetype-module/pom.xml
index ce2c1d6..2a00be0 100644
--- a/build/archetypes/marmotta-archetype-module/pom.xml
+++ b/build/archetypes/marmotta-archetype-module/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/archetypes/marmotta-archetype-webapp/pom.xml
----------------------------------------------------------------------
diff --git a/build/archetypes/marmotta-archetype-webapp/pom.xml b/build/archetypes/marmotta-archetype-webapp/pom.xml
index fea0092..087135f 100644
--- a/build/archetypes/marmotta-archetype-webapp/pom.xml
+++ b/build/archetypes/marmotta-archetype-webapp/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/archetypes/pom.xml
----------------------------------------------------------------------
diff --git a/build/archetypes/pom.xml b/build/archetypes/pom.xml
index ffb3cc3..2338f04 100644
--- a/build/archetypes/pom.xml
+++ b/build/archetypes/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
<artifactId>archetypes-reactor</artifactId>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/checkstyle-resources/pom.xml
----------------------------------------------------------------------
diff --git a/build/checkstyle-resources/pom.xml b/build/checkstyle-resources/pom.xml
index 1a1a314..e1ccbb7 100644
--- a/build/checkstyle-resources/pom.xml
+++ b/build/checkstyle-resources/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/dependency-resource-supplement/pom.xml
----------------------------------------------------------------------
diff --git a/build/dependency-resource-supplement/pom.xml b/build/dependency-resource-supplement/pom.xml
index d9b87ac..7e0ec1b 100644
--- a/build/dependency-resource-supplement/pom.xml
+++ b/build/dependency-resource-supplement/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/plugins/buildinfo-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/buildinfo-maven-plugin/pom.xml b/build/plugins/buildinfo-maven-plugin/pom.xml
index 39e2c68..eee29df 100644
--- a/build/plugins/buildinfo-maven-plugin/pom.xml
+++ b/build/plugins/buildinfo-maven-plugin/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/plugins/marmotta-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/marmotta-maven-plugin/pom.xml b/build/plugins/marmotta-maven-plugin/pom.xml
index e87f3c9..c0ce8e9 100644
--- a/build/plugins/marmotta-maven-plugin/pom.xml
+++ b/build/plugins/marmotta-maven-plugin/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
<artifactId>plugins-reactor</artifactId>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/plugins/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/pom.xml b/build/plugins/pom.xml
index b680532..ba775ac 100644
--- a/build/plugins/pom.xml
+++ b/build/plugins/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/plugins/refpack-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/refpack-maven-plugin/pom.xml b/build/plugins/refpack-maven-plugin/pom.xml
index 9433d98..f1fe33c 100644
--- a/build/plugins/refpack-maven-plugin/pom.xml
+++ b/build/plugins/refpack-maven-plugin/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<artifactId>plugins-reactor</artifactId>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/plugins/repocheck-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/repocheck-maven-plugin/pom.xml b/build/plugins/repocheck-maven-plugin/pom.xml
index b755ab7..c1beb9e 100644
--- a/build/plugins/repocheck-maven-plugin/pom.xml
+++ b/build/plugins/repocheck-maven-plugin/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>plugins-reactor</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
<!-- <artifactId>maven-plugins</artifactId> <groupId>org.apache.maven.plugins</groupId>
<version>23</version> <relativePath /> -->
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/pom.xml
----------------------------------------------------------------------
diff --git a/build/pom.xml b/build/pom.xml
index e27ab3b..0bebd2e 100644
--- a/build/pom.xml
+++ b/build/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/client/marmotta-client-java/pom.xml
----------------------------------------------------------------------
diff --git a/client/marmotta-client-java/pom.xml b/client/marmotta-client-java/pom.xml
index eb88957..6a38fb2 100644
--- a/client/marmotta-client-java/pom.xml
+++ b/client/marmotta-client-java/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/client/marmotta-client-js-sample-webapp/pom.xml
----------------------------------------------------------------------
diff --git a/client/marmotta-client-js-sample-webapp/pom.xml b/client/marmotta-client-js-sample-webapp/pom.xml
index 9de908b..584251d 100644
--- a/client/marmotta-client-js-sample-webapp/pom.xml
+++ b/client/marmotta-client-js-sample-webapp/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent/pom.xml</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/client/marmotta-client-js/pom.xml
----------------------------------------------------------------------
diff --git a/client/marmotta-client-js/pom.xml b/client/marmotta-client-js/pom.xml
index e724481..8245b8c 100644
--- a/client/marmotta-client-js/pom.xml
+++ b/client/marmotta-client-js/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent/pom.xml</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/client/pom.xml
----------------------------------------------------------------------
diff --git a/client/pom.xml b/client/pom.xml
index 6ba9da1..9dc1dd7 100644
--- a/client/pom.xml
+++ b/client/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-commons/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-commons/pom.xml b/commons/marmotta-commons/pom.xml
index cb4a754..39c0de3 100644
--- a/commons/marmotta-commons/pom.xml
+++ b/commons/marmotta-commons/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml b/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
index 94b60af..c0a38bb 100644
--- a/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
index 5611307..be494cc 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
index 6ec8c52..f10b42b 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
index e1ab020..ebdb353 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
index 6518e36..b6cc99f 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml b/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
index 277ee42..1aa196d 100644
--- a/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml b/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
index 85d98cb..85e0071 100644
--- a/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml b/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
index 36314c0..f9ec969 100644
--- a/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
index d9b3225..9a41a0d 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
index 34eee31..f840141 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
index 4ae2133..01c6c85 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
index 39fcf7f..e556426 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/pom.xml b/commons/marmotta-sesame-tools/pom.xml
index 56213d1..f0a1af9 100644
--- a/commons/marmotta-sesame-tools/pom.xml
+++ b/commons/marmotta-sesame-tools/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/pom.xml
----------------------------------------------------------------------
diff --git a/commons/pom.xml b/commons/pom.xml
index e79b480..3697ca3 100644
--- a/commons/pom.xml
+++ b/commons/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/extras/pom.xml
----------------------------------------------------------------------
diff --git a/extras/pom.xml b/extras/pom.xml
index a234cb4..50aafd5 100644
--- a/extras/pom.xml
+++ b/extras/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/extras/webjars/codemirror/pom.xml
----------------------------------------------------------------------
diff --git a/extras/webjars/codemirror/pom.xml b/extras/webjars/codemirror/pom.xml
index c5242ab..24057c6 100644
--- a/extras/webjars/codemirror/pom.xml
+++ b/extras/webjars/codemirror/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/extras/webjars/pom.xml
----------------------------------------------------------------------
diff --git a/extras/webjars/pom.xml b/extras/webjars/pom.xml
index b0a4290..1407c83 100644
--- a/extras/webjars/pom.xml
+++ b/extras/webjars/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/extras/webjars/strftime/pom.xml
----------------------------------------------------------------------
diff --git a/extras/webjars/strftime/pom.xml b/extras/webjars/strftime/pom.xml
index 83c48fc..2ebb335 100644
--- a/extras/webjars/strftime/pom.xml
+++ b/extras/webjars/strftime/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/launchers/marmotta-installer/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/marmotta-installer/pom.xml b/launchers/marmotta-installer/pom.xml
index df03f8e..045adb8 100644
--- a/launchers/marmotta-installer/pom.xml
+++ b/launchers/marmotta-installer/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/launchers/marmotta-splash/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/marmotta-splash/pom.xml b/launchers/marmotta-splash/pom.xml
index 8e37731..e464ee3 100644
--- a/launchers/marmotta-splash/pom.xml
+++ b/launchers/marmotta-splash/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/launchers/marmotta-webapp/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/marmotta-webapp/pom.xml b/launchers/marmotta-webapp/pom.xml
index 6636410..3718b17 100644
--- a/launchers/marmotta-webapp/pom.xml
+++ b/launchers/marmotta-webapp/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/launchers/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/pom.xml b/launchers/pom.xml
index e138762..0df37e6 100644
--- a/launchers/pom.xml
+++ b/launchers/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-caching-ehcache/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-caching-ehcache/pom.xml b/libraries/kiwi/kiwi-caching-ehcache/pom.xml
index d6c7cdf..8e0dbf2 100644
--- a/libraries/kiwi/kiwi-caching-ehcache/pom.xml
+++ b/libraries/kiwi/kiwi-caching-ehcache/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-caching-hazelcast/pom.xml b/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
index bdbda65..8b19a26 100644
--- a/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
+++ b/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-caching-infinispan/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-caching-infinispan/pom.xml b/libraries/kiwi/kiwi-caching-infinispan/pom.xml
index bb7a7f4..833c4a9 100644
--- a/libraries/kiwi/kiwi-caching-infinispan/pom.xml
+++ b/libraries/kiwi/kiwi-caching-infinispan/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-loader/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-loader/pom.xml b/libraries/kiwi/kiwi-loader/pom.xml
index 7823e49..c0df08e 100644
--- a/libraries/kiwi/kiwi-loader/pom.xml
+++ b/libraries/kiwi/kiwi-loader/pom.xml
@@ -14,7 +14,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
</parent>
<artifactId>kiwi-loader</artifactId>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-reasoner/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-reasoner/pom.xml b/libraries/kiwi/kiwi-reasoner/pom.xml
index f2322ee..7432004 100644
--- a/libraries/kiwi/kiwi-reasoner/pom.xml
+++ b/libraries/kiwi/kiwi-reasoner/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-sparql/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-sparql/pom.xml b/libraries/kiwi/kiwi-sparql/pom.xml
index 3860d7a..782277c 100644
--- a/libraries/kiwi/kiwi-sparql/pom.xml
+++ b/libraries/kiwi/kiwi-sparql/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-triplestore/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-triplestore/pom.xml b/libraries/kiwi/kiwi-triplestore/pom.xml
index 77263ac..9c98c20 100644
--- a/libraries/kiwi/kiwi-triplestore/pom.xml
+++ b/libraries/kiwi/kiwi-triplestore/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-versioning/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-versioning/pom.xml b/libraries/kiwi/kiwi-versioning/pom.xml
index 3f73fa0..6ce814c 100644
--- a/libraries/kiwi/kiwi-versioning/pom.xml
+++ b/libraries/kiwi/kiwi-versioning/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/pom.xml b/libraries/kiwi/pom.xml
index 37b1e2c..a6a7a58 100644
--- a/libraries/kiwi/pom.xml
+++ b/libraries/kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-api/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-api/pom.xml b/libraries/ldcache/ldcache-api/pom.xml
index 63db71a..cf1634b 100644
--- a/libraries/ldcache/ldcache-api/pom.xml
+++ b/libraries/ldcache/ldcache-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-backend-file/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-backend-file/pom.xml b/libraries/ldcache/ldcache-backend-file/pom.xml
index 461ecfe..ba8b274 100644
--- a/libraries/ldcache/ldcache-backend-file/pom.xml
+++ b/libraries/ldcache/ldcache-backend-file/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-backend-infinispan/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-backend-infinispan/pom.xml b/libraries/ldcache/ldcache-backend-infinispan/pom.xml
index ad0cae2..41aaf9f 100644
--- a/libraries/ldcache/ldcache-backend-infinispan/pom.xml
+++ b/libraries/ldcache/ldcache-backend-infinispan/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-backend-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-backend-kiwi/pom.xml b/libraries/ldcache/ldcache-backend-kiwi/pom.xml
index 71c105d..b227eab 100644
--- a/libraries/ldcache/ldcache-backend-kiwi/pom.xml
+++ b/libraries/ldcache/ldcache-backend-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-core/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-core/pom.xml b/libraries/ldcache/ldcache-core/pom.xml
index e8ed25f..21997b9 100644
--- a/libraries/ldcache/ldcache-core/pom.xml
+++ b/libraries/ldcache/ldcache-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-sail-generic/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-sail-generic/pom.xml b/libraries/ldcache/ldcache-sail-generic/pom.xml
index d70a3f4..4a0e6f4 100644
--- a/libraries/ldcache/ldcache-sail-generic/pom.xml
+++ b/libraries/ldcache/ldcache-sail-generic/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-sail-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-sail-kiwi/pom.xml b/libraries/ldcache/ldcache-sail-kiwi/pom.xml
index 65c5adf..a844934 100644
--- a/libraries/ldcache/ldcache-sail-kiwi/pom.xml
+++ b/libraries/ldcache/ldcache-sail-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/pom.xml b/libraries/ldcache/pom.xml
index b5d13c0..2874143 100644
--- a/libraries/ldcache/pom.xml
+++ b/libraries/ldcache/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-api/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-api/pom.xml b/libraries/ldclient/ldclient-api/pom.xml
index fe9949d..1634c79 100644
--- a/libraries/ldclient/ldclient-api/pom.xml
+++ b/libraries/ldclient/ldclient-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-core/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-core/pom.xml b/libraries/ldclient/ldclient-core/pom.xml
index 2c353f1..d350020 100644
--- a/libraries/ldclient/ldclient-core/pom.xml
+++ b/libraries/ldclient/ldclient-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-facebook/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-facebook/pom.xml b/libraries/ldclient/ldclient-provider-facebook/pom.xml
index af07251..7ab6d44 100644
--- a/libraries/ldclient/ldclient-provider-facebook/pom.xml
+++ b/libraries/ldclient/ldclient-provider-facebook/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-html/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-html/pom.xml b/libraries/ldclient/ldclient-provider-html/pom.xml
index 7a92db8..3c7c6a3 100644
--- a/libraries/ldclient/ldclient-provider-html/pom.xml
+++ b/libraries/ldclient/ldclient-provider-html/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-ldap/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-ldap/pom.xml b/libraries/ldclient/ldclient-provider-ldap/pom.xml
index c30d427..5697646 100644
--- a/libraries/ldclient/ldclient-provider-ldap/pom.xml
+++ b/libraries/ldclient/ldclient-provider-ldap/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-mediawiki/pom.xml b/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
index 23b90c0..636c533 100644
--- a/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
+++ b/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-phpbb/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-phpbb/pom.xml b/libraries/ldclient/ldclient-provider-phpbb/pom.xml
index 7db5a25..b73f601 100644
--- a/libraries/ldclient/ldclient-provider-phpbb/pom.xml
+++ b/libraries/ldclient/ldclient-provider-phpbb/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-rdf/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-rdf/pom.xml b/libraries/ldclient/ldclient-provider-rdf/pom.xml
index ba90ead..fbbd3be 100644
--- a/libraries/ldclient/ldclient-provider-rdf/pom.xml
+++ b/libraries/ldclient/ldclient-provider-rdf/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-rdfa/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-rdfa/pom.xml b/libraries/ldclient/ldclient-provider-rdfa/pom.xml
index 312f345..e3c4020 100644
--- a/libraries/ldclient/ldclient-provider-rdfa/pom.xml
+++ b/libraries/ldclient/ldclient-provider-rdfa/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-vimeo/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-vimeo/pom.xml b/libraries/ldclient/ldclient-provider-vimeo/pom.xml
index 5d2648e..dd6eb6b 100644
--- a/libraries/ldclient/ldclient-provider-vimeo/pom.xml
+++ b/libraries/ldclient/ldclient-provider-vimeo/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-xml/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-xml/pom.xml b/libraries/ldclient/ldclient-provider-xml/pom.xml
index 8de6ea3..1146025 100644
--- a/libraries/ldclient/ldclient-provider-xml/pom.xml
+++ b/libraries/ldclient/ldclient-provider-xml/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-youtube/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-youtube/pom.xml b/libraries/ldclient/ldclient-provider-youtube/pom.xml
index 01a5de8..d49b755 100644
--- a/libraries/ldclient/ldclient-provider-youtube/pom.xml
+++ b/libraries/ldclient/ldclient-provider-youtube/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/pom.xml b/libraries/ldclient/pom.xml
index 79f1c33..c66058b 100644
--- a/libraries/ldclient/pom.xml
+++ b/libraries/ldclient/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-api/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-api/pom.xml b/libraries/ldpath/ldpath-api/pom.xml
index 6e20f23..8bacad0 100644
--- a/libraries/ldpath/ldpath-api/pom.xml
+++ b/libraries/ldpath/ldpath-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-backend-file/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-file/pom.xml b/libraries/ldpath/ldpath-backend-file/pom.xml
index 69fa596..0584f0d 100644
--- a/libraries/ldpath/ldpath-backend-file/pom.xml
+++ b/libraries/ldpath/ldpath-backend-file/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-backend-jena/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-jena/pom.xml b/libraries/ldpath/ldpath-backend-jena/pom.xml
index ed0edd6..1b83d2f 100644
--- a/libraries/ldpath/ldpath-backend-jena/pom.xml
+++ b/libraries/ldpath/ldpath-backend-jena/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-linkeddata/pom.xml b/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
index 0a76197..fbb5388 100644
--- a/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
+++ b/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-backend-sesame/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-sesame/pom.xml b/libraries/ldpath/ldpath-backend-sesame/pom.xml
index 47b7312..4de5163 100644
--- a/libraries/ldpath/ldpath-backend-sesame/pom.xml
+++ b/libraries/ldpath/ldpath-backend-sesame/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-core-bundle/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-core-bundle/pom.xml b/libraries/ldpath/ldpath-core-bundle/pom.xml
index 03bbdca..0797860 100644
--- a/libraries/ldpath/ldpath-core-bundle/pom.xml
+++ b/libraries/ldpath/ldpath-core-bundle/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-core/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-core/pom.xml b/libraries/ldpath/ldpath-core/pom.xml
index 15c16a0..085d86c 100644
--- a/libraries/ldpath/ldpath-core/pom.xml
+++ b/libraries/ldpath/ldpath-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-collections/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-collections/pom.xml b/libraries/ldpath/ldpath-functions-collections/pom.xml
index cc2b348..3644308 100644
--- a/libraries/ldpath/ldpath-functions-collections/pom.xml
+++ b/libraries/ldpath/ldpath-functions-collections/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-date/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-date/pom.xml b/libraries/ldpath/ldpath-functions-date/pom.xml
index 097d59e..bdbd631 100644
--- a/libraries/ldpath/ldpath-functions-date/pom.xml
+++ b/libraries/ldpath/ldpath-functions-date/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-html/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-html/pom.xml b/libraries/ldpath/ldpath-functions-html/pom.xml
index 3b29cb2..d2c2de9 100644
--- a/libraries/ldpath/ldpath-functions-html/pom.xml
+++ b/libraries/ldpath/ldpath-functions-html/pom.xml
@@ -19,7 +19,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-json/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-json/pom.xml b/libraries/ldpath/ldpath-functions-json/pom.xml
index d3ef877..89569c6 100644
--- a/libraries/ldpath/ldpath-functions-json/pom.xml
+++ b/libraries/ldpath/ldpath-functions-json/pom.xml
@@ -19,7 +19,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-math/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-math/pom.xml b/libraries/ldpath/ldpath-functions-math/pom.xml
index a014708..b726355 100644
--- a/libraries/ldpath/ldpath-functions-math/pom.xml
+++ b/libraries/ldpath/ldpath-functions-math/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-text/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-text/pom.xml b/libraries/ldpath/ldpath-functions-text/pom.xml
index 3419d40..962035f 100644
--- a/libraries/ldpath/ldpath-functions-text/pom.xml
+++ b/libraries/ldpath/ldpath-functions-text/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-xml/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-xml/pom.xml b/libraries/ldpath/ldpath-functions-xml/pom.xml
index a353ce9..859ab99 100644
--- a/libraries/ldpath/ldpath-functions-xml/pom.xml
+++ b/libraries/ldpath/ldpath-functions-xml/pom.xml
@@ -19,7 +19,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-ldquery-cli/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-ldquery-cli/pom.xml b/libraries/ldpath/ldpath-ldquery-cli/pom.xml
index f5f98fa..4237db3 100644
--- a/libraries/ldpath/ldpath-ldquery-cli/pom.xml
+++ b/libraries/ldpath/ldpath-ldquery-cli/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-template-linkeddata/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-template-linkeddata/pom.xml b/libraries/ldpath/ldpath-template-linkeddata/pom.xml
index 1bb9c13..29e3d42 100644
--- a/libraries/ldpath/ldpath-template-linkeddata/pom.xml
+++ b/libraries/ldpath/ldpath-template-linkeddata/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-template/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-template/pom.xml b/libraries/ldpath/ldpath-template/pom.xml
index 74cabaa..5ba307b 100644
--- a/libraries/ldpath/ldpath-template/pom.xml
+++ b/libraries/ldpath/ldpath-template/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/pom.xml b/libraries/ldpath/pom.xml
index c1fdae1..b2a4f48 100644
--- a/libraries/ldpath/pom.xml
+++ b/libraries/ldpath/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/pom.xml b/libraries/pom.xml
index 7dbcf41..e130fe8 100644
--- a/libraries/pom.xml
+++ b/libraries/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/marmotta-loader-berkeley/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-berkeley/pom.xml b/loader/marmotta-loader-berkeley/pom.xml
index 9a40202..b684f49 100644
--- a/loader/marmotta-loader-berkeley/pom.xml
+++ b/loader/marmotta-loader-berkeley/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/marmotta-loader-core/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-core/pom.xml b/loader/marmotta-loader-core/pom.xml
index a2168d9..4a903a9 100644
--- a/loader/marmotta-loader-core/pom.xml
+++ b/loader/marmotta-loader-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/marmotta-loader-hbase/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-hbase/pom.xml b/loader/marmotta-loader-hbase/pom.xml
index 9bdc437..0a8b525 100644
--- a/loader/marmotta-loader-hbase/pom.xml
+++ b/loader/marmotta-loader-hbase/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/marmotta-loader-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-kiwi/pom.xml b/loader/marmotta-loader-kiwi/pom.xml
index 4d80693..f2bf1bc 100644
--- a/loader/marmotta-loader-kiwi/pom.xml
+++ b/loader/marmotta-loader-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/marmotta-loader-titan/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-titan/pom.xml b/loader/marmotta-loader-titan/pom.xml
index 6d4a7bc..dc60e45 100644
--- a/loader/marmotta-loader-titan/pom.xml
+++ b/loader/marmotta-loader-titan/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/pom.xml
----------------------------------------------------------------------
diff --git a/loader/pom.xml b/loader/pom.xml
index 4771f28..78ebc16 100644
--- a/loader/pom.xml
+++ b/loader/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/parent/pom.xml
----------------------------------------------------------------------
diff --git a/parent/pom.xml b/parent/pom.xml
index 073455f..62dafff 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -29,7 +29,7 @@
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
<packaging>pom</packaging>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<name>Apache Marmotta Parent</name>
<description>Parent POM for the Apache Marmotta project</description>
@@ -1841,4 +1841,8 @@
</properties>
</profile>
</profiles>
+
+ <scm>
+ <tag>3.4.0</tag>
+ </scm>
</project>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/marmotta-backend-accumulograph/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-accumulograph/pom.xml b/platform/backends/marmotta-backend-accumulograph/pom.xml
index 40bb6c2..ede3aa9 100644
--- a/platform/backends/marmotta-backend-accumulograph/pom.xml
+++ b/platform/backends/marmotta-backend-accumulograph/pom.xml
@@ -16,13 +16,11 @@
~ limitations under the License.
-->
-<project xmlns="http://maven.apache.org/POM/4.0.0"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/marmotta-backend-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-kiwi/pom.xml b/platform/backends/marmotta-backend-kiwi/pom.xml
index 2b64595..9a28ed6 100644
--- a/platform/backends/marmotta-backend-kiwi/pom.xml
+++ b/platform/backends/marmotta-backend-kiwi/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/marmotta-backend-memory/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-memory/pom.xml b/platform/backends/marmotta-backend-memory/pom.xml
index 516cb1d..c29b8c0 100644
--- a/platform/backends/marmotta-backend-memory/pom.xml
+++ b/platform/backends/marmotta-backend-memory/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/marmotta-backend-native/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-native/pom.xml b/platform/backends/marmotta-backend-native/pom.xml
index f4e49d4..7c4657c 100644
--- a/platform/backends/marmotta-backend-native/pom.xml
+++ b/platform/backends/marmotta-backend-native/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/marmotta-backend-titan/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-titan/pom.xml b/platform/backends/marmotta-backend-titan/pom.xml
index ea2d48f..e726410 100644
--- a/platform/backends/marmotta-backend-titan/pom.xml
+++ b/platform/backends/marmotta-backend-titan/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/pom.xml</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/pom.xml b/platform/backends/pom.xml
index ecc5375..519bf64 100644
--- a/platform/backends/pom.xml
+++ b/platform/backends/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/ldcache/marmotta-ldcache-common/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/marmotta-ldcache-common/pom.xml b/platform/ldcache/marmotta-ldcache-common/pom.xml
index 2f6763f..784db15 100644
--- a/platform/ldcache/marmotta-ldcache-common/pom.xml
+++ b/platform/ldcache/marmotta-ldcache-common/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/ldcache/marmotta-ldcache-file/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/marmotta-ldcache-file/pom.xml b/platform/ldcache/marmotta-ldcache-file/pom.xml
index 5373af4..48b185b 100644
--- a/platform/ldcache/marmotta-ldcache-file/pom.xml
+++ b/platform/ldcache/marmotta-ldcache-file/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/marmotta-ldcache-kiwi/pom.xml b/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
index 5d6b079..c6bf7b2 100644
--- a/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
+++ b/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/ldcache/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/pom.xml b/platform/ldcache/pom.xml
index 5a0327b..484097a 100644
--- a/platform/ldcache/pom.xml
+++ b/platform/ldcache/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-core/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-core/pom.xml b/platform/marmotta-core/pom.xml
index 671a51a..6e85133 100644
--- a/platform/marmotta-core/pom.xml
+++ b/platform/marmotta-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-ldp/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-ldp/pom.xml b/platform/marmotta-ldp/pom.xml
index d2053de..c0ed328 100644
--- a/platform/marmotta-ldp/pom.xml
+++ b/platform/marmotta-ldp/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-ldpath/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-ldpath/pom.xml b/platform/marmotta-ldpath/pom.xml
index 4260c6e..9d5c986 100644
--- a/platform/marmotta-ldpath/pom.xml
+++ b/platform/marmotta-ldpath/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-reasoner-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-reasoner-kiwi/pom.xml b/platform/marmotta-reasoner-kiwi/pom.xml
index 84d54c0..c253b67 100644
--- a/platform/marmotta-reasoner-kiwi/pom.xml
+++ b/platform/marmotta-reasoner-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-security/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-security/pom.xml b/platform/marmotta-security/pom.xml
index 4993a73..845721e 100644
--- a/platform/marmotta-security/pom.xml
+++ b/platform/marmotta-security/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-sparql/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-sparql/pom.xml b/platform/marmotta-sparql/pom.xml
index 732c47d..1123ab8 100644
--- a/platform/marmotta-sparql/pom.xml
+++ b/platform/marmotta-sparql/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-user/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-user/pom.xml b/platform/marmotta-user/pom.xml
index 573cd61..4ee022f 100644
--- a/platform/marmotta-user/pom.xml
+++ b/platform/marmotta-user/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-versioning-common/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-versioning-common/pom.xml b/platform/marmotta-versioning-common/pom.xml
index 51ff785..6da4aa0 100644
--- a/platform/marmotta-versioning-common/pom.xml
+++ b/platform/marmotta-versioning-common/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-versioning-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-versioning-kiwi/pom.xml b/platform/marmotta-versioning-kiwi/pom.xml
index f49926d..f979e58 100644
--- a/platform/marmotta-versioning-kiwi/pom.xml
+++ b/platform/marmotta-versioning-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-zookeeper/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-zookeeper/pom.xml b/platform/marmotta-zookeeper/pom.xml
index f02374e..53513f7 100644
--- a/platform/marmotta-zookeeper/pom.xml
+++ b/platform/marmotta-zookeeper/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/pom.xml
----------------------------------------------------------------------
diff --git a/platform/pom.xml b/platform/pom.xml
index 6d9d9ea..2adc9b6 100644
--- a/platform/pom.xml
+++ b/platform/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 360fdf5..089c6eb 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>parent</relativePath>
</parent>
@@ -145,7 +145,7 @@
<url>https://git-wip-us.apache.org/repos/asf/marmotta.git</url>
<connection>scm:git:https://git-wip-us.apache.org/repos/asf/marmotta.git</connection>
<developerConnection>scm:git:https://git-wip-us.apache.org/repos/asf/marmotta.git</developerConnection>
- <tag>HEAD</tag>
+ <tag>3.4.0</tag>
</scm>
<issueManagement>
[42/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/container/fixed_array_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/container/fixed_array_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/container/fixed_array_test.cc
new file mode 100644
index 0000000..2142132
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/container/fixed_array_test.cc
@@ -0,0 +1,659 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/container/fixed_array.h"
+
+#include <stdio.h>
+#include <list>
+#include <memory>
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/internal/exception_testing.h"
+#include "absl/memory/memory.h"
+
+using ::testing::ElementsAreArray;
+
+namespace {
+
+// Helper routine to determine if a absl::FixedArray used stack allocation.
+template <typename ArrayType>
+static bool IsOnStack(const ArrayType& a) {
+ return a.size() <= ArrayType::inline_elements;
+}
+
+class ConstructionTester {
+ public:
+ ConstructionTester()
+ : self_ptr_(this),
+ value_(0) {
+ constructions++;
+ }
+ ~ConstructionTester() {
+ assert(self_ptr_ == this);
+ self_ptr_ = nullptr;
+ destructions++;
+ }
+
+ // These are incremented as elements are constructed and destructed so we can
+ // be sure all elements are properly cleaned up.
+ static int constructions;
+ static int destructions;
+
+ void CheckConstructed() {
+ assert(self_ptr_ == this);
+ }
+
+ void set(int value) { value_ = value; }
+ int get() { return value_; }
+
+ private:
+ // self_ptr_ should always point to 'this' -- that's how we can be sure the
+ // constructor has been called.
+ ConstructionTester* self_ptr_;
+ int value_;
+};
+
+int ConstructionTester::constructions = 0;
+int ConstructionTester::destructions = 0;
+
+// ThreeInts will initialize its three ints to the value stored in
+// ThreeInts::counter. The constructor increments counter so that each object
+// in an array of ThreeInts will have different values.
+class ThreeInts {
+ public:
+ ThreeInts() {
+ x_ = counter;
+ y_ = counter;
+ z_ = counter;
+ ++counter;
+ }
+
+ static int counter;
+
+ int x_, y_, z_;
+};
+
+int ThreeInts::counter = 0;
+
+TEST(FixedArrayTest, CopyCtor) {
+ absl::FixedArray<int, 10> on_stack(5);
+ std::iota(on_stack.begin(), on_stack.end(), 0);
+ absl::FixedArray<int, 10> stack_copy = on_stack;
+ EXPECT_THAT(stack_copy, ElementsAreArray(on_stack));
+ EXPECT_TRUE(IsOnStack(stack_copy));
+
+ absl::FixedArray<int, 10> allocated(15);
+ std::iota(allocated.begin(), allocated.end(), 0);
+ absl::FixedArray<int, 10> alloced_copy = allocated;
+ EXPECT_THAT(alloced_copy, ElementsAreArray(allocated));
+ EXPECT_FALSE(IsOnStack(alloced_copy));
+}
+
+TEST(FixedArrayTest, MoveCtor) {
+ absl::FixedArray<std::unique_ptr<int>, 10> on_stack(5);
+ for (int i = 0; i < 5; ++i) {
+ on_stack[i] = absl::make_unique<int>(i);
+ }
+
+ absl::FixedArray<std::unique_ptr<int>, 10> stack_copy = std::move(on_stack);
+ for (int i = 0; i < 5; ++i) EXPECT_EQ(*(stack_copy[i]), i);
+ EXPECT_EQ(stack_copy.size(), on_stack.size());
+
+ absl::FixedArray<std::unique_ptr<int>, 10> allocated(15);
+ for (int i = 0; i < 15; ++i) {
+ allocated[i] = absl::make_unique<int>(i);
+ }
+
+ absl::FixedArray<std::unique_ptr<int>, 10> alloced_copy =
+ std::move(allocated);
+ for (int i = 0; i < 15; ++i) EXPECT_EQ(*(alloced_copy[i]), i);
+ EXPECT_EQ(allocated.size(), alloced_copy.size());
+}
+
+TEST(FixedArrayTest, SmallObjects) {
+ // Small object arrays
+ {
+ // Short arrays should be on the stack
+ absl::FixedArray<int> array(4);
+ EXPECT_TRUE(IsOnStack(array));
+ }
+
+ {
+ // Large arrays should be on the heap
+ absl::FixedArray<int> array(1048576);
+ EXPECT_FALSE(IsOnStack(array));
+ }
+
+ {
+ // Arrays of <= default size should be on the stack
+ absl::FixedArray<int, 100> array(100);
+ EXPECT_TRUE(IsOnStack(array));
+ }
+
+ {
+ // Arrays of > default size should be on the stack
+ absl::FixedArray<int, 100> array(101);
+ EXPECT_FALSE(IsOnStack(array));
+ }
+
+ {
+ // Arrays with different size elements should use approximately
+ // same amount of stack space
+ absl::FixedArray<int> array1(0);
+ absl::FixedArray<char> array2(0);
+ EXPECT_LE(sizeof(array1), sizeof(array2)+100);
+ EXPECT_LE(sizeof(array2), sizeof(array1)+100);
+ }
+
+ {
+ // Ensure that vectors are properly constructed inside a fixed array.
+ absl::FixedArray<std::vector<int> > array(2);
+ EXPECT_EQ(0, array[0].size());
+ EXPECT_EQ(0, array[1].size());
+ }
+
+ {
+ // Regardless of absl::FixedArray implementation, check that a type with a
+ // low alignment requirement and a non power-of-two size is initialized
+ // correctly.
+ ThreeInts::counter = 1;
+ absl::FixedArray<ThreeInts> array(2);
+ EXPECT_EQ(1, array[0].x_);
+ EXPECT_EQ(1, array[0].y_);
+ EXPECT_EQ(1, array[0].z_);
+ EXPECT_EQ(2, array[1].x_);
+ EXPECT_EQ(2, array[1].y_);
+ EXPECT_EQ(2, array[1].z_);
+ }
+}
+
+TEST(FixedArrayTest, AtThrows) {
+ absl::FixedArray<int> a = {1, 2, 3};
+ EXPECT_EQ(a.at(2), 3);
+ ABSL_BASE_INTERNAL_EXPECT_FAIL(a.at(3), std::out_of_range,
+ "failed bounds check");
+}
+
+TEST(FixedArrayRelationalsTest, EqualArrays) {
+ for (int i = 0; i < 10; ++i) {
+ absl::FixedArray<int, 5> a1(i);
+ std::iota(a1.begin(), a1.end(), 0);
+ absl::FixedArray<int, 5> a2(a1.begin(), a1.end());
+
+ EXPECT_TRUE(a1 == a2);
+ EXPECT_FALSE(a1 != a2);
+ EXPECT_TRUE(a2 == a1);
+ EXPECT_FALSE(a2 != a1);
+ EXPECT_FALSE(a1 < a2);
+ EXPECT_FALSE(a1 > a2);
+ EXPECT_FALSE(a2 < a1);
+ EXPECT_FALSE(a2 > a1);
+ EXPECT_TRUE(a1 <= a2);
+ EXPECT_TRUE(a1 >= a2);
+ EXPECT_TRUE(a2 <= a1);
+ EXPECT_TRUE(a2 >= a1);
+ }
+}
+
+TEST(FixedArrayRelationalsTest, UnequalArrays) {
+ for (int i = 1; i < 10; ++i) {
+ absl::FixedArray<int, 5> a1(i);
+ std::iota(a1.begin(), a1.end(), 0);
+ absl::FixedArray<int, 5> a2(a1.begin(), a1.end());
+ --a2[i / 2];
+
+ EXPECT_FALSE(a1 == a2);
+ EXPECT_TRUE(a1 != a2);
+ EXPECT_FALSE(a2 == a1);
+ EXPECT_TRUE(a2 != a1);
+ EXPECT_FALSE(a1 < a2);
+ EXPECT_TRUE(a1 > a2);
+ EXPECT_TRUE(a2 < a1);
+ EXPECT_FALSE(a2 > a1);
+ EXPECT_FALSE(a1 <= a2);
+ EXPECT_TRUE(a1 >= a2);
+ EXPECT_TRUE(a2 <= a1);
+ EXPECT_FALSE(a2 >= a1);
+ }
+}
+
+template <int stack_elements>
+static void TestArray(int n) {
+ SCOPED_TRACE(n);
+ SCOPED_TRACE(stack_elements);
+ ConstructionTester::constructions = 0;
+ ConstructionTester::destructions = 0;
+ {
+ absl::FixedArray<ConstructionTester, stack_elements> array(n);
+
+ EXPECT_THAT(array.size(), n);
+ EXPECT_THAT(array.memsize(), sizeof(ConstructionTester) * n);
+ EXPECT_THAT(array.begin() + n, array.end());
+
+ // Check that all elements were constructed
+ for (int i = 0; i < n; i++) {
+ array[i].CheckConstructed();
+ }
+ // Check that no other elements were constructed
+ EXPECT_THAT(ConstructionTester::constructions, n);
+
+ // Test operator[]
+ for (int i = 0; i < n; i++) {
+ array[i].set(i);
+ }
+ for (int i = 0; i < n; i++) {
+ EXPECT_THAT(array[i].get(), i);
+ EXPECT_THAT(array.data()[i].get(), i);
+ }
+
+ // Test data()
+ for (int i = 0; i < n; i++) {
+ array.data()[i].set(i + 1);
+ }
+ for (int i = 0; i < n; i++) {
+ EXPECT_THAT(array[i].get(), i+1);
+ EXPECT_THAT(array.data()[i].get(), i+1);
+ }
+ } // Close scope containing 'array'.
+
+ // Check that all constructed elements were destructed.
+ EXPECT_EQ(ConstructionTester::constructions,
+ ConstructionTester::destructions);
+}
+
+template <int elements_per_inner_array, int inline_elements>
+static void TestArrayOfArrays(int n) {
+ SCOPED_TRACE(n);
+ SCOPED_TRACE(inline_elements);
+ SCOPED_TRACE(elements_per_inner_array);
+ ConstructionTester::constructions = 0;
+ ConstructionTester::destructions = 0;
+ {
+ using InnerArray = ConstructionTester[elements_per_inner_array];
+ // Heap-allocate the FixedArray to avoid blowing the stack frame.
+ auto array_ptr =
+ absl::make_unique<absl::FixedArray<InnerArray, inline_elements>>(n);
+ auto& array = *array_ptr;
+
+ ASSERT_EQ(array.size(), n);
+ ASSERT_EQ(array.memsize(),
+ sizeof(ConstructionTester) * elements_per_inner_array * n);
+ ASSERT_EQ(array.begin() + n, array.end());
+
+ // Check that all elements were constructed
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < elements_per_inner_array; j++) {
+ (array[i])[j].CheckConstructed();
+ }
+ }
+ // Check that no other elements were constructed
+ ASSERT_EQ(ConstructionTester::constructions, n * elements_per_inner_array);
+
+ // Test operator[]
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < elements_per_inner_array; j++) {
+ (array[i])[j].set(i * elements_per_inner_array + j);
+ }
+ }
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < elements_per_inner_array; j++) {
+ ASSERT_EQ((array[i])[j].get(), i * elements_per_inner_array + j);
+ ASSERT_EQ((array.data()[i])[j].get(), i * elements_per_inner_array + j);
+ }
+ }
+
+ // Test data()
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < elements_per_inner_array; j++) {
+ (array.data()[i])[j].set((i + 1) * elements_per_inner_array + j);
+ }
+ }
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < elements_per_inner_array; j++) {
+ ASSERT_EQ((array[i])[j].get(),
+ (i + 1) * elements_per_inner_array + j);
+ ASSERT_EQ((array.data()[i])[j].get(),
+ (i + 1) * elements_per_inner_array + j);
+ }
+ }
+ } // Close scope containing 'array'.
+
+ // Check that all constructed elements were destructed.
+ EXPECT_EQ(ConstructionTester::constructions,
+ ConstructionTester::destructions);
+}
+
+TEST(IteratorConstructorTest, NonInline) {
+ int const kInput[] = { 2, 3, 5, 7, 11, 13, 17 };
+ absl::FixedArray<int, ABSL_ARRAYSIZE(kInput) - 1> const fixed(
+ kInput, kInput + ABSL_ARRAYSIZE(kInput));
+ ASSERT_EQ(ABSL_ARRAYSIZE(kInput), fixed.size());
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(kInput); ++i) {
+ ASSERT_EQ(kInput[i], fixed[i]);
+ }
+}
+
+TEST(IteratorConstructorTest, Inline) {
+ int const kInput[] = { 2, 3, 5, 7, 11, 13, 17 };
+ absl::FixedArray<int, ABSL_ARRAYSIZE(kInput)> const fixed(
+ kInput, kInput + ABSL_ARRAYSIZE(kInput));
+ ASSERT_EQ(ABSL_ARRAYSIZE(kInput), fixed.size());
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(kInput); ++i) {
+ ASSERT_EQ(kInput[i], fixed[i]);
+ }
+}
+
+TEST(IteratorConstructorTest, NonPod) {
+ char const* kInput[] =
+ { "red", "orange", "yellow", "green", "blue", "indigo", "violet" };
+ absl::FixedArray<std::string> const fixed(kInput, kInput + ABSL_ARRAYSIZE(kInput));
+ ASSERT_EQ(ABSL_ARRAYSIZE(kInput), fixed.size());
+ for (size_t i = 0; i < ABSL_ARRAYSIZE(kInput); ++i) {
+ ASSERT_EQ(kInput[i], fixed[i]);
+ }
+}
+
+TEST(IteratorConstructorTest, FromEmptyVector) {
+ std::vector<int> const empty;
+ absl::FixedArray<int> const fixed(empty.begin(), empty.end());
+ EXPECT_EQ(0, fixed.size());
+ EXPECT_EQ(empty.size(), fixed.size());
+}
+
+TEST(IteratorConstructorTest, FromNonEmptyVector) {
+ int const kInput[] = { 2, 3, 5, 7, 11, 13, 17 };
+ std::vector<int> const items(kInput, kInput + ABSL_ARRAYSIZE(kInput));
+ absl::FixedArray<int> const fixed(items.begin(), items.end());
+ ASSERT_EQ(items.size(), fixed.size());
+ for (size_t i = 0; i < items.size(); ++i) {
+ ASSERT_EQ(items[i], fixed[i]);
+ }
+}
+
+TEST(IteratorConstructorTest, FromBidirectionalIteratorRange) {
+ int const kInput[] = { 2, 3, 5, 7, 11, 13, 17 };
+ std::list<int> const items(kInput, kInput + ABSL_ARRAYSIZE(kInput));
+ absl::FixedArray<int> const fixed(items.begin(), items.end());
+ EXPECT_THAT(fixed, testing::ElementsAreArray(kInput));
+}
+
+TEST(InitListConstructorTest, InitListConstruction) {
+ absl::FixedArray<int> fixed = {1, 2, 3};
+ EXPECT_THAT(fixed, testing::ElementsAreArray({1, 2, 3}));
+}
+
+TEST(FillConstructorTest, NonEmptyArrays) {
+ absl::FixedArray<int> stack_array(4, 1);
+ EXPECT_THAT(stack_array, testing::ElementsAreArray({1, 1, 1, 1}));
+
+ absl::FixedArray<int, 0> heap_array(4, 1);
+ EXPECT_THAT(stack_array, testing::ElementsAreArray({1, 1, 1, 1}));
+}
+
+TEST(FillConstructorTest, EmptyArray) {
+ absl::FixedArray<int> empty_fill(0, 1);
+ absl::FixedArray<int> empty_size(0);
+ EXPECT_EQ(empty_fill, empty_size);
+}
+
+TEST(FillConstructorTest, NotTriviallyCopyable) {
+ std::string str = "abcd";
+ absl::FixedArray<std::string> strings = {str, str, str, str};
+
+ absl::FixedArray<std::string> array(4, str);
+ EXPECT_EQ(array, strings);
+}
+
+TEST(FillConstructorTest, Disambiguation) {
+ absl::FixedArray<size_t> a(1, 2);
+ EXPECT_THAT(a, testing::ElementsAre(2));
+}
+
+TEST(FixedArrayTest, ManySizedArrays) {
+ std::vector<int> sizes;
+ for (int i = 1; i < 100; i++) sizes.push_back(i);
+ for (int i = 100; i <= 1000; i += 100) sizes.push_back(i);
+ for (int n : sizes) {
+ TestArray<0>(n);
+ TestArray<1>(n);
+ TestArray<64>(n);
+ TestArray<1000>(n);
+ }
+}
+
+TEST(FixedArrayTest, ManySizedArraysOfArraysOf1) {
+ for (int n = 1; n < 1000; n++) {
+ ASSERT_NO_FATAL_FAILURE((TestArrayOfArrays<1, 0>(n)));
+ ASSERT_NO_FATAL_FAILURE((TestArrayOfArrays<1, 1>(n)));
+ ASSERT_NO_FATAL_FAILURE((TestArrayOfArrays<1, 64>(n)));
+ ASSERT_NO_FATAL_FAILURE((TestArrayOfArrays<1, 1000>(n)));
+ }
+}
+
+TEST(FixedArrayTest, ManySizedArraysOfArraysOf2) {
+ for (int n = 1; n < 1000; n++) {
+ TestArrayOfArrays<2, 0>(n);
+ TestArrayOfArrays<2, 1>(n);
+ TestArrayOfArrays<2, 64>(n);
+ TestArrayOfArrays<2, 1000>(n);
+ }
+}
+
+// If value_type is put inside of a struct container,
+// we might evoke this error in a hardened build unless data() is carefully
+// written, so check on that.
+// error: call to int __builtin___sprintf_chk(etc...)
+// will always overflow destination buffer [-Werror]
+TEST(FixedArrayTest, AvoidParanoidDiagnostics) {
+ absl::FixedArray<char, 32> buf(32);
+ sprintf(buf.data(), "foo"); // NOLINT(runtime/printf)
+}
+
+TEST(FixedArrayTest, TooBigInlinedSpace) {
+ struct TooBig {
+ char c[1 << 20];
+ }; // too big for even one on the stack
+
+ // Simulate the data members of absl::FixedArray, a pointer and a size_t.
+ struct Data {
+ TooBig* p;
+ size_t size;
+ };
+
+ // Make sure TooBig objects are not inlined for 0 or default size.
+ static_assert(sizeof(absl::FixedArray<TooBig, 0>) == sizeof(Data),
+ "0-sized absl::FixedArray should have same size as Data.");
+ static_assert(alignof(absl::FixedArray<TooBig, 0>) == alignof(Data),
+ "0-sized absl::FixedArray should have same alignment as Data.");
+ static_assert(sizeof(absl::FixedArray<TooBig>) == sizeof(Data),
+ "default-sized absl::FixedArray should have same size as Data");
+ static_assert(
+ alignof(absl::FixedArray<TooBig>) == alignof(Data),
+ "default-sized absl::FixedArray should have same alignment as Data.");
+}
+
+// PickyDelete EXPECTs its class-scope deallocation funcs are unused.
+struct PickyDelete {
+ PickyDelete() {}
+ ~PickyDelete() {}
+ void operator delete(void* p) {
+ EXPECT_TRUE(false) << __FUNCTION__;
+ ::operator delete(p);
+ }
+ void operator delete[](void* p) {
+ EXPECT_TRUE(false) << __FUNCTION__;
+ ::operator delete[](p);
+ }
+};
+
+TEST(FixedArrayTest, UsesGlobalAlloc) { absl::FixedArray<PickyDelete, 0> a(5); }
+
+
+TEST(FixedArrayTest, Data) {
+ static const int kInput[] = { 2, 3, 5, 7, 11, 13, 17 };
+ absl::FixedArray<int> fa(std::begin(kInput), std::end(kInput));
+ EXPECT_EQ(fa.data(), &*fa.begin());
+ EXPECT_EQ(fa.data(), &fa[0]);
+
+ const absl::FixedArray<int>& cfa = fa;
+ EXPECT_EQ(cfa.data(), &*cfa.begin());
+ EXPECT_EQ(cfa.data(), &cfa[0]);
+}
+
+TEST(FixedArrayTest, Empty) {
+ absl::FixedArray<int> empty(0);
+ absl::FixedArray<int> inline_filled(1);
+ absl::FixedArray<int, 0> heap_filled(1);
+ EXPECT_TRUE(empty.empty());
+ EXPECT_FALSE(inline_filled.empty());
+ EXPECT_FALSE(heap_filled.empty());
+}
+
+TEST(FixedArrayTest, FrontAndBack) {
+ absl::FixedArray<int, 3 * sizeof(int)> inlined = {1, 2, 3};
+ EXPECT_EQ(inlined.front(), 1);
+ EXPECT_EQ(inlined.back(), 3);
+
+ absl::FixedArray<int, 0> allocated = {1, 2, 3};
+ EXPECT_EQ(allocated.front(), 1);
+ EXPECT_EQ(allocated.back(), 3);
+
+ absl::FixedArray<int> one_element = {1};
+ EXPECT_EQ(one_element.front(), one_element.back());
+}
+
+TEST(FixedArrayTest, ReverseIteratorInlined) {
+ absl::FixedArray<int, 5 * sizeof(int)> a = {0, 1, 2, 3, 4};
+
+ int counter = 5;
+ for (absl::FixedArray<int>::reverse_iterator iter = a.rbegin();
+ iter != a.rend(); ++iter) {
+ counter--;
+ EXPECT_EQ(counter, *iter);
+ }
+ EXPECT_EQ(counter, 0);
+
+ counter = 5;
+ for (absl::FixedArray<int>::const_reverse_iterator iter = a.rbegin();
+ iter != a.rend(); ++iter) {
+ counter--;
+ EXPECT_EQ(counter, *iter);
+ }
+ EXPECT_EQ(counter, 0);
+
+ counter = 5;
+ for (auto iter = a.crbegin(); iter != a.crend(); ++iter) {
+ counter--;
+ EXPECT_EQ(counter, *iter);
+ }
+ EXPECT_EQ(counter, 0);
+}
+
+TEST(FixedArrayTest, ReverseIteratorAllocated) {
+ absl::FixedArray<int, 0> a = {0, 1, 2, 3, 4};
+
+ int counter = 5;
+ for (absl::FixedArray<int>::reverse_iterator iter = a.rbegin();
+ iter != a.rend(); ++iter) {
+ counter--;
+ EXPECT_EQ(counter, *iter);
+ }
+ EXPECT_EQ(counter, 0);
+
+ counter = 5;
+ for (absl::FixedArray<int>::const_reverse_iterator iter = a.rbegin();
+ iter != a.rend(); ++iter) {
+ counter--;
+ EXPECT_EQ(counter, *iter);
+ }
+ EXPECT_EQ(counter, 0);
+
+ counter = 5;
+ for (auto iter = a.crbegin(); iter != a.crend(); ++iter) {
+ counter--;
+ EXPECT_EQ(counter, *iter);
+ }
+ EXPECT_EQ(counter, 0);
+}
+
+TEST(FixedArrayTest, Fill) {
+ absl::FixedArray<int, 5 * sizeof(int)> inlined(5);
+ int fill_val = 42;
+ inlined.fill(fill_val);
+ for (int i : inlined) EXPECT_EQ(i, fill_val);
+
+ absl::FixedArray<int, 0> allocated(5);
+ allocated.fill(fill_val);
+ for (int i : allocated) EXPECT_EQ(i, fill_val);
+
+ // It doesn't do anything, just make sure this compiles.
+ absl::FixedArray<int> empty(0);
+ empty.fill(fill_val);
+}
+
+#ifdef ADDRESS_SANITIZER
+TEST(FixedArrayTest, AddressSanitizerAnnotations1) {
+ absl::FixedArray<int, 32> a(10);
+ int *raw = a.data();
+ raw[0] = 0;
+ raw[9] = 0;
+ EXPECT_DEATH(raw[-2] = 0, "container-overflow");
+ EXPECT_DEATH(raw[-1] = 0, "container-overflow");
+ EXPECT_DEATH(raw[10] = 0, "container-overflow");
+ EXPECT_DEATH(raw[31] = 0, "container-overflow");
+}
+
+TEST(FixedArrayTest, AddressSanitizerAnnotations2) {
+ absl::FixedArray<char, 17> a(12);
+ char *raw = a.data();
+ raw[0] = 0;
+ raw[11] = 0;
+ EXPECT_DEATH(raw[-7] = 0, "container-overflow");
+ EXPECT_DEATH(raw[-1] = 0, "container-overflow");
+ EXPECT_DEATH(raw[12] = 0, "container-overflow");
+ EXPECT_DEATH(raw[17] = 0, "container-overflow");
+}
+
+TEST(FixedArrayTest, AddressSanitizerAnnotations3) {
+ absl::FixedArray<uint64_t, 20> a(20);
+ uint64_t *raw = a.data();
+ raw[0] = 0;
+ raw[19] = 0;
+ EXPECT_DEATH(raw[-1] = 0, "container-overflow");
+ EXPECT_DEATH(raw[20] = 0, "container-overflow");
+}
+
+TEST(FixedArrayTest, AddressSanitizerAnnotations4) {
+ absl::FixedArray<ThreeInts> a(10);
+ ThreeInts *raw = a.data();
+ raw[0] = ThreeInts();
+ raw[9] = ThreeInts();
+ // Note: raw[-1] is pointing to 12 bytes before the container range. However,
+ // there is only a 8-byte red zone before the container range, so we only
+ // access the last 4 bytes of the struct to make sure it stays within the red
+ // zone.
+ EXPECT_DEATH(raw[-1].z_ = 0, "container-overflow");
+ EXPECT_DEATH(raw[10] = ThreeInts(), "container-overflow");
+ // The actual size of storage is kDefaultBytes=256, 21*12 = 252,
+ // so reading raw[21] should still trigger the correct warning.
+ EXPECT_DEATH(raw[21] = ThreeInts(), "container-overflow");
+}
+#endif // ADDRESS_SANITIZER
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/container/inlined_vector.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/container/inlined_vector.h b/libraries/ostrich/backend/3rdparty/abseil/absl/container/inlined_vector.h
new file mode 100644
index 0000000..78f78ea
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/container/inlined_vector.h
@@ -0,0 +1,1384 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: inlined_vector.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains the declaration and definition of an "inlined
+// vector" which behaves in an equivalent fashion to a `std::vector`, except
+// that storage for small sequences of the vector are provided inline without
+// requiring any heap allocation.
+
+// An `absl::InlinedVector<T,N>` specifies the size N at which to inline as one
+// of its template parameters. Vectors of length <= N are provided inline.
+// Typically N is very small (e.g., 4) so that sequences that are expected to be
+// short do not require allocations.
+
+// An `absl::InlinedVector` does not usually require a specific allocator; if
+// the inlined vector grows beyond its initial constraints, it will need to
+// allocate (as any normal `std::vector` would) and it will generally use the
+// default allocator in that case; optionally, a custom allocator may be
+// specified using an `absl::InlinedVector<T,N,A>` construction.
+
+#ifndef ABSL_CONTAINER_INLINED_VECTOR_H_
+#define ABSL_CONTAINER_INLINED_VECTOR_H_
+
+#include <algorithm>
+#include <cassert>
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <initializer_list>
+#include <iterator>
+#include <memory>
+#include <type_traits>
+#include <utility>
+
+#include "absl/algorithm/algorithm.h"
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+#include "absl/memory/memory.h"
+
+namespace absl {
+
+// -----------------------------------------------------------------------------
+// InlinedVector
+// -----------------------------------------------------------------------------
+//
+// An `absl::InlinedVector` is designed to be a drop-in replacement for
+// `std::vector` for use cases where the vector's size is sufficiently small
+// that it can be inlined. If the inlined vector does grow beyond its estimated
+// size, it will trigger an initial allocation on the heap, and will behave as a
+// `std:vector`. The API of the `absl::InlinedVector` within this file is
+// designed to cover the same API footprint as covered by `std::vector`.
+template <typename T, size_t N, typename A = std::allocator<T> >
+class InlinedVector {
+ using AllocatorTraits = std::allocator_traits<A>;
+
+ public:
+ using allocator_type = A;
+ using value_type = typename allocator_type::value_type;
+ using pointer = typename allocator_type::pointer;
+ using const_pointer = typename allocator_type::const_pointer;
+ using reference = typename allocator_type::reference;
+ using const_reference = typename allocator_type::const_reference;
+ using size_type = typename allocator_type::size_type;
+ using difference_type = typename allocator_type::difference_type;
+ using iterator = pointer;
+ using const_iterator = const_pointer;
+ using reverse_iterator = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+
+ InlinedVector() noexcept(noexcept(allocator_type()))
+ : allocator_and_tag_(allocator_type()) {}
+
+ explicit InlinedVector(const allocator_type& alloc) noexcept
+ : allocator_and_tag_(alloc) {}
+
+ // Create a vector with n copies of value_type().
+ explicit InlinedVector(size_type n) : allocator_and_tag_(allocator_type()) {
+ InitAssign(n);
+ }
+
+ // Create a vector with n copies of elem
+ InlinedVector(size_type n, const value_type& elem,
+ const allocator_type& alloc = allocator_type())
+ : allocator_and_tag_(alloc) {
+ InitAssign(n, elem);
+ }
+
+ // Create and initialize with the elements [first .. last).
+ // The unused enable_if argument restricts this constructor so that it is
+ // elided when value_type is an integral type. This prevents ambiguous
+ // interpretation between a call to this constructor with two integral
+ // arguments and a call to the preceding (n, elem) constructor.
+ template <typename InputIterator>
+ InlinedVector(
+ InputIterator first, InputIterator last,
+ const allocator_type& alloc = allocator_type(),
+ typename std::enable_if<!std::is_integral<InputIterator>::value>::type* =
+ nullptr)
+ : allocator_and_tag_(alloc) {
+ AppendRange(first, last);
+ }
+
+ InlinedVector(std::initializer_list<value_type> init,
+ const allocator_type& alloc = allocator_type())
+ : allocator_and_tag_(alloc) {
+ AppendRange(init.begin(), init.end());
+ }
+
+ InlinedVector(const InlinedVector& v);
+ InlinedVector(const InlinedVector& v, const allocator_type& alloc);
+
+ // This move constructor does not allocate and only moves the underlying
+ // objects, so its `noexcept` specification depends on whether moving the
+ // underlying objects can throw or not. We assume
+ // a) move constructors should only throw due to allocation failure and
+ // b) if `value_type`'s move constructor allocates, it uses the same
+ // allocation function as the `InlinedVector`'s allocator, so the move
+ // constructor is non-throwing if the allocator is non-throwing or
+ // `value_type`'s move constructor is specified as `noexcept`.
+ InlinedVector(InlinedVector&& v) noexcept(
+ absl::allocator_is_nothrow<allocator_type>::value ||
+ std::is_nothrow_move_constructible<value_type>::value);
+
+ // This move constructor allocates and also moves the underlying objects, so
+ // its `noexcept` specification depends on whether the allocation can throw
+ // and whether moving the underlying objects can throw. Based on the same
+ // assumptions above, the `noexcept` specification is dominated by whether the
+ // allocation can throw regardless of whether `value_type`'s move constructor
+ // is specified as `noexcept`.
+ InlinedVector(InlinedVector&& v, const allocator_type& alloc) noexcept(
+ absl::allocator_is_nothrow<allocator_type>::value);
+
+ ~InlinedVector() { clear(); }
+
+ InlinedVector& operator=(const InlinedVector& v) {
+ if (this == &v) {
+ return *this;
+ }
+ // Optimized to avoid reallocation.
+ // Prefer reassignment to copy construction for elements.
+ if (size() < v.size()) { // grow
+ reserve(v.size());
+ std::copy(v.begin(), v.begin() + size(), begin());
+ std::copy(v.begin() + size(), v.end(), std::back_inserter(*this));
+ } else { // maybe shrink
+ erase(begin() + v.size(), end());
+ std::copy(v.begin(), v.end(), begin());
+ }
+ return *this;
+ }
+
+ InlinedVector& operator=(InlinedVector&& v) {
+ if (this == &v) {
+ return *this;
+ }
+ if (v.allocated()) {
+ clear();
+ tag().set_allocated_size(v.size());
+ init_allocation(v.allocation());
+ v.tag() = Tag();
+ } else {
+ if (allocated()) clear();
+ // Both are inlined now.
+ if (size() < v.size()) {
+ auto mid = std::make_move_iterator(v.begin() + size());
+ std::copy(std::make_move_iterator(v.begin()), mid, begin());
+ UninitializedCopy(mid, std::make_move_iterator(v.end()), end());
+ } else {
+ auto new_end = std::copy(std::make_move_iterator(v.begin()),
+ std::make_move_iterator(v.end()), begin());
+ Destroy(new_end, end());
+ }
+ tag().set_inline_size(v.size());
+ }
+ return *this;
+ }
+
+ InlinedVector& operator=(std::initializer_list<value_type> init) {
+ AssignRange(init.begin(), init.end());
+ return *this;
+ }
+
+ // InlinedVector::assign()
+ //
+ // Replaces the contents of the inlined vector with copies of those in the
+ // iterator range [first, last).
+ template <typename InputIterator>
+ void assign(
+ InputIterator first, InputIterator last,
+ typename std::enable_if<!std::is_integral<InputIterator>::value>::type* =
+ nullptr) {
+ AssignRange(first, last);
+ }
+
+ // Overload of `InlinedVector::assign()` to take values from elements of an
+ // initializer list
+ void assign(std::initializer_list<value_type> init) {
+ AssignRange(init.begin(), init.end());
+ }
+
+ // Overload of `InlinedVector::assign()` to replace the first `n` elements of
+ // the inlined vector with `elem` values.
+ void assign(size_type n, const value_type& elem) {
+ if (n <= size()) { // Possibly shrink
+ std::fill_n(begin(), n, elem);
+ erase(begin() + n, end());
+ return;
+ }
+ // Grow
+ reserve(n);
+ std::fill_n(begin(), size(), elem);
+ if (allocated()) {
+ UninitializedFill(allocated_space() + size(), allocated_space() + n,
+ elem);
+ tag().set_allocated_size(n);
+ } else {
+ UninitializedFill(inlined_space() + size(), inlined_space() + n, elem);
+ tag().set_inline_size(n);
+ }
+ }
+
+ // InlinedVector::size()
+ //
+ // Returns the number of elements in the inlined vector.
+ size_type size() const noexcept { return tag().size(); }
+
+ // InlinedVector::empty()
+ //
+ // Checks if the inlined vector has no elements.
+ bool empty() const noexcept { return (size() == 0); }
+
+ // InlinedVector::capacity()
+ //
+ // Returns the number of elements that can be stored in an inlined vector
+ // without requiring a reallocation of underlying memory. Note that for
+ // most inlined vectors, `capacity()` should equal its initial size `N`; for
+ // inlined vectors which exceed this capacity, they will no longer be inlined,
+ // and `capacity()` will equal its capacity on the allocated heap.
+ size_type capacity() const noexcept {
+ return allocated() ? allocation().capacity() : N;
+ }
+
+ // InlinedVector::max_size()
+ //
+ // Returns the maximum number of elements the vector can hold.
+ size_type max_size() const noexcept {
+ // One bit of the size storage is used to indicate whether the inlined
+ // vector is allocated; as a result, the maximum size of the container that
+ // we can express is half of the max for our size type.
+ return std::numeric_limits<size_type>::max() / 2;
+ }
+
+ // InlinedVector::data()
+ //
+ // Returns a const T* pointer to elements of the inlined vector. This pointer
+ // can be used to access (but not modify) the contained elements.
+ // Only results within the range `[0,size())` are defined.
+ const_pointer data() const noexcept {
+ return allocated() ? allocated_space() : inlined_space();
+ }
+
+ // Overload of InlinedVector::data() to return a T* pointer to elements of the
+ // inlined vector. This pointer can be used to access and modify the contained
+ // elements.
+ pointer data() noexcept {
+ return allocated() ? allocated_space() : inlined_space();
+ }
+
+ // InlinedVector::clear()
+ //
+ // Removes all elements from the inlined vector.
+ void clear() noexcept {
+ size_type s = size();
+ if (allocated()) {
+ Destroy(allocated_space(), allocated_space() + s);
+ allocation().Dealloc(allocator());
+ } else if (s != 0) { // do nothing for empty vectors
+ Destroy(inlined_space(), inlined_space() + s);
+ }
+ tag() = Tag();
+ }
+
+ // InlinedVector::at()
+ //
+ // Returns the ith element of an inlined vector.
+ const value_type& at(size_type i) const {
+ if (ABSL_PREDICT_FALSE(i >= size())) {
+ base_internal::ThrowStdOutOfRange(
+ "InlinedVector::at failed bounds check");
+ }
+ return data()[i];
+ }
+
+ // InlinedVector::operator[]
+ //
+ // Returns the ith element of an inlined vector using the array operator.
+ const value_type& operator[](size_type i) const {
+ assert(i < size());
+ return data()[i];
+ }
+
+ // Overload of InlinedVector::at() to return the ith element of an inlined
+ // vector.
+ value_type& at(size_type i) {
+ if (i >= size()) {
+ base_internal::ThrowStdOutOfRange(
+ "InlinedVector::at failed bounds check");
+ }
+ return data()[i];
+ }
+
+ // Overload of InlinedVector::operator[] to return the ith element of an
+ // inlined vector.
+ value_type& operator[](size_type i) {
+ assert(i < size());
+ return data()[i];
+ }
+
+ // InlinedVector::back()
+ //
+ // Returns a reference to the last element of an inlined vector.
+ value_type& back() {
+ assert(!empty());
+ return at(size() - 1);
+ }
+
+ // Overload of InlinedVector::back() returns a reference to the last element
+ // of an inlined vector of const values.
+ const value_type& back() const {
+ assert(!empty());
+ return at(size() - 1);
+ }
+
+ // InlinedVector::front()
+ //
+ // Returns a reference to the first element of an inlined vector.
+ value_type& front() {
+ assert(!empty());
+ return at(0);
+ }
+
+ // Overload of InlinedVector::front() returns a reference to the first element
+ // of an inlined vector of const values.
+ const value_type& front() const {
+ assert(!empty());
+ return at(0);
+ }
+
+ // InlinedVector::emplace_back()
+ //
+ // Constructs and appends an object to the inlined vector.
+ //
+ // Returns a reference to the inserted element.
+ template <typename... Args>
+ value_type& emplace_back(Args&&... args) {
+ size_type s = size();
+ assert(s <= capacity());
+ if (ABSL_PREDICT_FALSE(s == capacity())) {
+ return GrowAndEmplaceBack(std::forward<Args>(args)...);
+ }
+ assert(s < capacity());
+
+ value_type* space;
+ if (allocated()) {
+ tag().set_allocated_size(s + 1);
+ space = allocated_space();
+ } else {
+ tag().set_inline_size(s + 1);
+ space = inlined_space();
+ }
+ return Construct(space + s, std::forward<Args>(args)...);
+ }
+
+ // InlinedVector::push_back()
+ //
+ // Appends a const element to the inlined vector.
+ void push_back(const value_type& t) { emplace_back(t); }
+
+ // Overload of InlinedVector::push_back() to append a move-only element to the
+ // inlined vector.
+ void push_back(value_type&& t) { emplace_back(std::move(t)); }
+
+ // InlinedVector::pop_back()
+ //
+ // Removes the last element (which is destroyed) in the inlined vector.
+ void pop_back() {
+ assert(!empty());
+ size_type s = size();
+ if (allocated()) {
+ Destroy(allocated_space() + s - 1, allocated_space() + s);
+ tag().set_allocated_size(s - 1);
+ } else {
+ Destroy(inlined_space() + s - 1, inlined_space() + s);
+ tag().set_inline_size(s - 1);
+ }
+ }
+
+ // InlinedVector::resize()
+ //
+ // Resizes the inlined vector to contain `n` elements. If `n` is smaller than
+ // the inlined vector's current size, extra elements are destroyed. If `n` is
+ // larger than the initial size, new elements are value-initialized.
+ void resize(size_type n);
+
+ // Overload of InlinedVector::resize() to resize the inlined vector to contain
+ // `n` elements. If `n` is larger than the current size, enough copies of
+ // `elem` are appended to increase its size to `n`.
+ void resize(size_type n, const value_type& elem);
+
+ // InlinedVector::begin()
+ //
+ // Returns an iterator to the beginning of the inlined vector.
+ iterator begin() noexcept { return data(); }
+
+ // Overload of InlinedVector::begin() for returning a const iterator to the
+ // beginning of the inlined vector.
+ const_iterator begin() const noexcept { return data(); }
+
+ // InlinedVector::cbegin()
+ //
+ // Returns a const iterator to the beginning of the inlined vector.
+ const_iterator cbegin() const noexcept { return begin(); }
+
+ // InlinedVector::end()
+ //
+ // Returns an iterator to the end of the inlined vector.
+ iterator end() noexcept { return data() + size(); }
+
+ // Overload of InlinedVector::end() for returning a const iterator to the end
+ // of the inlined vector.
+ const_iterator end() const noexcept { return data() + size(); }
+
+ // InlinedVector::cend()
+ //
+ // Returns a const iterator to the end of the inlined vector.
+ const_iterator cend() const noexcept { return end(); }
+
+ // InlinedVector::rbegin()
+ //
+ // Returns a reverse iterator from the end of the inlined vector.
+ reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+
+ // Overload of InlinedVector::rbegin() for returning a const reverse iterator
+ // from the end of the inlined vector.
+ const_reverse_iterator rbegin() const noexcept {
+ return const_reverse_iterator(end());
+ }
+
+ // InlinedVector::crbegin()
+ //
+ // Returns a const reverse iterator from the end of the inlined vector.
+ const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+
+ // InlinedVector::rend()
+ //
+ // Returns a reverse iterator from the beginning of the inlined vector.
+ reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
+
+ // Overload of InlinedVector::rend() for returning a const reverse iterator
+ // from the beginning of the inlined vector.
+ const_reverse_iterator rend() const noexcept {
+ return const_reverse_iterator(begin());
+ }
+
+ // InlinedVector::crend()
+ //
+ // Returns a reverse iterator from the beginning of the inlined vector.
+ const_reverse_iterator crend() const noexcept { return rend(); }
+
+ // InlinedVector::emplace()
+ //
+ // Constructs and inserts an object to the inlined vector at the given
+ // `position`, returning an iterator pointing to the newly emplaced element.
+ template <typename... Args>
+ iterator emplace(const_iterator position, Args&&... args);
+
+ // InlinedVector::insert()
+ //
+ // Inserts an element of the specified value at `position`, returning an
+ // iterator pointing to the newly inserted element.
+ iterator insert(const_iterator position, const value_type& v) {
+ return emplace(position, v);
+ }
+
+ // Overload of InlinedVector::insert() for inserting an element of the
+ // specified rvalue, returning an iterator pointing to the newly inserted
+ // element.
+ iterator insert(const_iterator position, value_type&& v) {
+ return emplace(position, std::move(v));
+ }
+
+ // Overload of InlinedVector::insert() for inserting `n` elements of the
+ // specified value at `position`, returning an iterator pointing to the first
+ // of the newly inserted elements.
+ iterator insert(const_iterator position, size_type n, const value_type& v) {
+ return InsertWithCount(position, n, v);
+ }
+
+ // Overload of `InlinedVector::insert()` to disambiguate the two
+ // three-argument overloads of `insert()`, returning an iterator pointing to
+ // the first of the newly inserted elements.
+ template <typename InputIterator,
+ typename = typename std::enable_if<std::is_convertible<
+ typename std::iterator_traits<InputIterator>::iterator_category,
+ std::input_iterator_tag>::value>::type>
+ iterator insert(const_iterator position, InputIterator first,
+ InputIterator last) {
+ using IterType =
+ typename std::iterator_traits<InputIterator>::iterator_category;
+ return InsertWithRange(position, first, last, IterType());
+ }
+
+ // Overload of InlinedVector::insert() for inserting a list of elements at
+ // `position`, returning an iterator pointing to the first of the newly
+ // inserted elements.
+ iterator insert(const_iterator position,
+ std::initializer_list<value_type> init) {
+ return insert(position, init.begin(), init.end());
+ }
+
+ // InlinedVector::erase()
+ //
+ // Erases the element at `position` of the inlined vector, returning an
+ // iterator pointing to the following element or the container's end if the
+ // last element was erased.
+ iterator erase(const_iterator position) {
+ assert(position >= begin());
+ assert(position < end());
+
+ iterator pos = const_cast<iterator>(position);
+ std::move(pos + 1, end(), pos);
+ pop_back();
+ return pos;
+ }
+
+ // Overload of InlinedVector::erase() for erasing all elements in the
+ // iterator range [first, last) in the inlined vector, returning an iterator
+ // pointing to the first element following the range erased, or the
+ // container's end if range included the container's last element.
+ iterator erase(const_iterator first, const_iterator last);
+
+ // InlinedVector::reserve()
+ //
+ // Enlarges the underlying representation of the inlined vector so it can hold
+ // at least `n` elements. This method does not change `size()` or the actual
+ // contents of the vector.
+ //
+ // Note that if `n` does not exceed the inlined vector's initial size `N`,
+ // `reserve()` will have no effect; if it does exceed its initial size,
+ // `reserve()` will trigger an initial allocation and move the inlined vector
+ // onto the heap. If the vector already exists on the heap and the requested
+ // size exceeds it, a reallocation will be performed.
+ void reserve(size_type n) {
+ if (n > capacity()) {
+ // Make room for new elements
+ EnlargeBy(n - size());
+ }
+ }
+
+ // InlinedVector::shrink_to_fit()
+ //
+ // Reduces memory usage by freeing unused memory.
+ // After this call `capacity()` will be equal to `max(N, size())`.
+ //
+ // If `size() <= N` and the elements are currently stored on the heap, they
+ // will be moved to the inlined storage and the heap memory deallocated.
+ // If `size() > N` and `size() < capacity()` the elements will be moved to
+ // a reallocated storage on heap.
+ void shrink_to_fit() {
+ const auto s = size();
+ if (!allocated() || s == capacity()) {
+ // There's nothing to deallocate.
+ return;
+ }
+
+ if (s <= N) {
+ // Move the elements to the inlined storage.
+ // We have to do this using a temporary, because inlined_storage and
+ // allocation_storage are in a union field.
+ auto temp = std::move(*this);
+ assign(std::make_move_iterator(temp.begin()),
+ std::make_move_iterator(temp.end()));
+ return;
+ }
+
+ // Reallocate storage and move elements.
+ // We can't simply use the same approach as above, because assign() would
+ // call into reserve() internally and reserve larger capacity than we need.
+ Allocation new_allocation(allocator(), s);
+ UninitializedCopy(std::make_move_iterator(allocated_space()),
+ std::make_move_iterator(allocated_space() + s),
+ new_allocation.buffer());
+ ResetAllocation(new_allocation, s);
+ }
+
+ // InlinedVector::swap()
+ //
+ // Swaps the contents of this inlined vector with the contents of `other`.
+ void swap(InlinedVector& other);
+
+ // InlinedVector::get_allocator()
+ //
+ // Returns the allocator of this inlined vector.
+ allocator_type get_allocator() const { return allocator(); }
+
+ private:
+ static_assert(N > 0, "inlined vector with nonpositive size");
+
+ // It holds whether the vector is allocated or not in the lowest bit.
+ // The size is held in the high bits:
+ // size_ = (size << 1) | is_allocated;
+ class Tag {
+ public:
+ Tag() : size_(0) {}
+ size_type size() const { return size_ >> 1; }
+ void add_size(size_type n) { size_ += n << 1; }
+ void set_inline_size(size_type n) { size_ = n << 1; }
+ void set_allocated_size(size_type n) { size_ = (n << 1) | 1; }
+ bool allocated() const { return size_ & 1; }
+
+ private:
+ size_type size_;
+ };
+
+ // Derives from allocator_type to use the empty base class optimization.
+ // If the allocator_type is stateless, we can 'store'
+ // our instance of it for free.
+ class AllocatorAndTag : private allocator_type {
+ public:
+ explicit AllocatorAndTag(const allocator_type& a, Tag t = Tag())
+ : allocator_type(a), tag_(t) {
+ }
+ Tag& tag() { return tag_; }
+ const Tag& tag() const { return tag_; }
+ allocator_type& allocator() { return *this; }
+ const allocator_type& allocator() const { return *this; }
+ private:
+ Tag tag_;
+ };
+
+ class Allocation {
+ public:
+ Allocation(allocator_type& a, // NOLINT(runtime/references)
+ size_type capacity)
+ : capacity_(capacity),
+ buffer_(AllocatorTraits::allocate(a, capacity_)) {}
+
+ void Dealloc(allocator_type& a) { // NOLINT(runtime/references)
+ AllocatorTraits::deallocate(a, buffer(), capacity());
+ }
+
+ size_type capacity() const { return capacity_; }
+ const value_type* buffer() const { return buffer_; }
+ value_type* buffer() { return buffer_; }
+
+ private:
+ size_type capacity_;
+ value_type* buffer_;
+ };
+
+ const Tag& tag() const { return allocator_and_tag_.tag(); }
+ Tag& tag() { return allocator_and_tag_.tag(); }
+
+ Allocation& allocation() {
+ return reinterpret_cast<Allocation&>(rep_.allocation_storage.allocation);
+ }
+ const Allocation& allocation() const {
+ return reinterpret_cast<const Allocation&>(
+ rep_.allocation_storage.allocation);
+ }
+ void init_allocation(const Allocation& allocation) {
+ new (&rep_.allocation_storage.allocation) Allocation(allocation);
+ }
+
+ value_type* inlined_space() {
+ return reinterpret_cast<value_type*>(&rep_.inlined_storage.inlined);
+ }
+ const value_type* inlined_space() const {
+ return reinterpret_cast<const value_type*>(&rep_.inlined_storage.inlined);
+ }
+
+ value_type* allocated_space() {
+ return allocation().buffer();
+ }
+ const value_type* allocated_space() const {
+ return allocation().buffer();
+ }
+
+ const allocator_type& allocator() const {
+ return allocator_and_tag_.allocator();
+ }
+ allocator_type& allocator() {
+ return allocator_and_tag_.allocator();
+ }
+
+ bool allocated() const { return tag().allocated(); }
+
+ // Enlarge the underlying representation so we can store size_ + delta elems.
+ // The size is not changed, and any newly added memory is not initialized.
+ void EnlargeBy(size_type delta);
+
+ // Shift all elements from position to end() n places to the right.
+ // If the vector needs to be enlarged, memory will be allocated.
+ // Returns iterators pointing to the start of the previously-initialized
+ // portion and the start of the uninitialized portion of the created gap.
+ // The number of initialized spots is pair.second - pair.first;
+ // the number of raw spots is n - (pair.second - pair.first).
+ //
+ // Updates the size of the InlinedVector internally.
+ std::pair<iterator, iterator> ShiftRight(const_iterator position,
+ size_type n);
+
+ void ResetAllocation(Allocation new_allocation, size_type new_size) {
+ if (allocated()) {
+ Destroy(allocated_space(), allocated_space() + size());
+ assert(begin() == allocated_space());
+ allocation().Dealloc(allocator());
+ allocation() = new_allocation;
+ } else {
+ Destroy(inlined_space(), inlined_space() + size());
+ init_allocation(new_allocation); // bug: only init once
+ }
+ tag().set_allocated_size(new_size);
+ }
+
+ template <typename... Args>
+ value_type& GrowAndEmplaceBack(Args&&... args) {
+ assert(size() == capacity());
+ const size_type s = size();
+
+ Allocation new_allocation(allocator(), 2 * capacity());
+
+ value_type& new_element =
+ Construct(new_allocation.buffer() + s, std::forward<Args>(args)...);
+ UninitializedCopy(std::make_move_iterator(data()),
+ std::make_move_iterator(data() + s),
+ new_allocation.buffer());
+
+ ResetAllocation(new_allocation, s + 1);
+
+ return new_element;
+ }
+
+ void InitAssign(size_type n);
+ void InitAssign(size_type n, const value_type& t);
+
+ template <typename... Args>
+ value_type& Construct(pointer p, Args&&... args) {
+ AllocatorTraits::construct(allocator(), p, std::forward<Args>(args)...);
+ return *p;
+ }
+
+ template <typename Iter>
+ void UninitializedCopy(Iter src, Iter src_last, value_type* dst) {
+ for (; src != src_last; ++dst, ++src) Construct(dst, *src);
+ }
+
+ template <typename... Args>
+ void UninitializedFill(value_type* dst, value_type* dst_last,
+ const Args&... args) {
+ for (; dst != dst_last; ++dst) Construct(dst, args...);
+ }
+
+ // Destroy [ptr, ptr_last) in place.
+ void Destroy(value_type* ptr, value_type* ptr_last);
+
+ template <typename Iter>
+ void AppendRange(Iter first, Iter last, std::input_iterator_tag) {
+ std::copy(first, last, std::back_inserter(*this));
+ }
+
+ // Faster path for forward iterators.
+ template <typename Iter>
+ void AppendRange(Iter first, Iter last, std::forward_iterator_tag);
+
+ template <typename Iter>
+ void AppendRange(Iter first, Iter last) {
+ using IterTag = typename std::iterator_traits<Iter>::iterator_category;
+ AppendRange(first, last, IterTag());
+ }
+
+ template <typename Iter>
+ void AssignRange(Iter first, Iter last, std::input_iterator_tag);
+
+ // Faster path for forward iterators.
+ template <typename Iter>
+ void AssignRange(Iter first, Iter last, std::forward_iterator_tag);
+
+ template <typename Iter>
+ void AssignRange(Iter first, Iter last) {
+ using IterTag = typename std::iterator_traits<Iter>::iterator_category;
+ AssignRange(first, last, IterTag());
+ }
+
+ iterator InsertWithCount(const_iterator position, size_type n,
+ const value_type& v);
+
+ template <typename InputIter>
+ iterator InsertWithRange(const_iterator position, InputIter first,
+ InputIter last, std::input_iterator_tag);
+ template <typename ForwardIter>
+ iterator InsertWithRange(const_iterator position, ForwardIter first,
+ ForwardIter last, std::forward_iterator_tag);
+
+ AllocatorAndTag allocator_and_tag_;
+
+ // Either the inlined or allocated representation
+ union Rep {
+ // Use struct to perform indirection that solves a bizarre compilation
+ // error on Visual Studio (all known versions).
+ struct {
+ typename std::aligned_storage<sizeof(value_type),
+ alignof(value_type)>::type inlined[N];
+ } inlined_storage;
+ struct {
+ typename std::aligned_storage<sizeof(Allocation),
+ alignof(Allocation)>::type allocation;
+ } allocation_storage;
+ } rep_;
+};
+
+// -----------------------------------------------------------------------------
+// InlinedVector Non-Member Functions
+// -----------------------------------------------------------------------------
+
+// swap()
+//
+// Swaps the contents of two inlined vectors. This convenience function
+// simply calls InlinedVector::swap(other_inlined_vector).
+template <typename T, size_t N, typename A>
+void swap(InlinedVector<T, N, A>& a,
+ InlinedVector<T, N, A>& b) noexcept(noexcept(a.swap(b))) {
+ a.swap(b);
+}
+
+// operator==()
+//
+// Tests the equivalency of the contents of two inlined vectors.
+template <typename T, size_t N, typename A>
+bool operator==(const InlinedVector<T, N, A>& a,
+ const InlinedVector<T, N, A>& b) {
+ return absl::equal(a.begin(), a.end(), b.begin(), b.end());
+}
+
+// operator!=()
+//
+// Tests the inequality of the contents of two inlined vectors.
+template <typename T, size_t N, typename A>
+bool operator!=(const InlinedVector<T, N, A>& a,
+ const InlinedVector<T, N, A>& b) {
+ return !(a == b);
+}
+
+// operator<()
+//
+// Tests whether the contents of one inlined vector are less than the contents
+// of another through a lexicographical comparison operation.
+template <typename T, size_t N, typename A>
+bool operator<(const InlinedVector<T, N, A>& a,
+ const InlinedVector<T, N, A>& b) {
+ return std::lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
+}
+
+// operator>()
+//
+// Tests whether the contents of one inlined vector are greater than the
+// contents of another through a lexicographical comparison operation.
+template <typename T, size_t N, typename A>
+bool operator>(const InlinedVector<T, N, A>& a,
+ const InlinedVector<T, N, A>& b) {
+ return b < a;
+}
+
+// operator<=()
+//
+// Tests whether the contents of one inlined vector are less than or equal to
+// the contents of another through a lexicographical comparison operation.
+template <typename T, size_t N, typename A>
+bool operator<=(const InlinedVector<T, N, A>& a,
+ const InlinedVector<T, N, A>& b) {
+ return !(b < a);
+}
+
+// operator>=()
+//
+// Tests whether the contents of one inlined vector are greater than or equal to
+// the contents of another through a lexicographical comparison operation.
+template <typename T, size_t N, typename A>
+bool operator>=(const InlinedVector<T, N, A>& a,
+ const InlinedVector<T, N, A>& b) {
+ return !(a < b);
+}
+
+// -----------------------------------------------------------------------------
+// Implementation of InlinedVector
+// -----------------------------------------------------------------------------
+//
+// Do not depend on any implementation details below this line.
+
+template <typename T, size_t N, typename A>
+InlinedVector<T, N, A>::InlinedVector(const InlinedVector& v)
+ : allocator_and_tag_(v.allocator()) {
+ reserve(v.size());
+ if (allocated()) {
+ UninitializedCopy(v.begin(), v.end(), allocated_space());
+ tag().set_allocated_size(v.size());
+ } else {
+ UninitializedCopy(v.begin(), v.end(), inlined_space());
+ tag().set_inline_size(v.size());
+ }
+}
+
+template <typename T, size_t N, typename A>
+InlinedVector<T, N, A>::InlinedVector(const InlinedVector& v,
+ const allocator_type& alloc)
+ : allocator_and_tag_(alloc) {
+ reserve(v.size());
+ if (allocated()) {
+ UninitializedCopy(v.begin(), v.end(), allocated_space());
+ tag().set_allocated_size(v.size());
+ } else {
+ UninitializedCopy(v.begin(), v.end(), inlined_space());
+ tag().set_inline_size(v.size());
+ }
+}
+
+template <typename T, size_t N, typename A>
+InlinedVector<T, N, A>::InlinedVector(InlinedVector&& v) noexcept(
+ absl::allocator_is_nothrow<allocator_type>::value ||
+ std::is_nothrow_move_constructible<value_type>::value)
+ : allocator_and_tag_(v.allocator_and_tag_) {
+ if (v.allocated()) {
+ // We can just steal the underlying buffer from the source.
+ // That leaves the source empty, so we clear its size.
+ init_allocation(v.allocation());
+ v.tag() = Tag();
+ } else {
+ UninitializedCopy(std::make_move_iterator(v.inlined_space()),
+ std::make_move_iterator(v.inlined_space() + v.size()),
+ inlined_space());
+ }
+}
+
+template <typename T, size_t N, typename A>
+InlinedVector<T, N, A>::InlinedVector(
+ InlinedVector&& v,
+ const allocator_type&
+ alloc) noexcept(absl::allocator_is_nothrow<allocator_type>::value)
+ : allocator_and_tag_(alloc) {
+ if (v.allocated()) {
+ if (alloc == v.allocator()) {
+ // We can just steal the allocation from the source.
+ tag() = v.tag();
+ init_allocation(v.allocation());
+ v.tag() = Tag();
+ } else {
+ // We need to use our own allocator
+ reserve(v.size());
+ UninitializedCopy(std::make_move_iterator(v.begin()),
+ std::make_move_iterator(v.end()), allocated_space());
+ tag().set_allocated_size(v.size());
+ }
+ } else {
+ UninitializedCopy(std::make_move_iterator(v.inlined_space()),
+ std::make_move_iterator(v.inlined_space() + v.size()),
+ inlined_space());
+ tag().set_inline_size(v.size());
+ }
+}
+
+template <typename T, size_t N, typename A>
+void InlinedVector<T, N, A>::InitAssign(size_type n, const value_type& t) {
+ if (n > static_cast<size_type>(N)) {
+ Allocation new_allocation(allocator(), n);
+ init_allocation(new_allocation);
+ UninitializedFill(allocated_space(), allocated_space() + n, t);
+ tag().set_allocated_size(n);
+ } else {
+ UninitializedFill(inlined_space(), inlined_space() + n, t);
+ tag().set_inline_size(n);
+ }
+}
+
+template <typename T, size_t N, typename A>
+void InlinedVector<T, N, A>::InitAssign(size_type n) {
+ if (n > static_cast<size_type>(N)) {
+ Allocation new_allocation(allocator(), n);
+ init_allocation(new_allocation);
+ UninitializedFill(allocated_space(), allocated_space() + n);
+ tag().set_allocated_size(n);
+ } else {
+ UninitializedFill(inlined_space(), inlined_space() + n);
+ tag().set_inline_size(n);
+ }
+}
+
+template <typename T, size_t N, typename A>
+void InlinedVector<T, N, A>::resize(size_type n) {
+ size_type s = size();
+ if (n < s) {
+ erase(begin() + n, end());
+ return;
+ }
+ reserve(n);
+ assert(capacity() >= n);
+
+ // Fill new space with elements constructed in-place.
+ if (allocated()) {
+ UninitializedFill(allocated_space() + s, allocated_space() + n);
+ tag().set_allocated_size(n);
+ } else {
+ UninitializedFill(inlined_space() + s, inlined_space() + n);
+ tag().set_inline_size(n);
+ }
+}
+
+template <typename T, size_t N, typename A>
+void InlinedVector<T, N, A>::resize(size_type n, const value_type& elem) {
+ size_type s = size();
+ if (n < s) {
+ erase(begin() + n, end());
+ return;
+ }
+ reserve(n);
+ assert(capacity() >= n);
+
+ // Fill new space with copies of 'elem'.
+ if (allocated()) {
+ UninitializedFill(allocated_space() + s, allocated_space() + n, elem);
+ tag().set_allocated_size(n);
+ } else {
+ UninitializedFill(inlined_space() + s, inlined_space() + n, elem);
+ tag().set_inline_size(n);
+ }
+}
+
+template <typename T, size_t N, typename A>
+template <typename... Args>
+typename InlinedVector<T, N, A>::iterator InlinedVector<T, N, A>::emplace(
+ const_iterator position, Args&&... args) {
+ assert(position >= begin());
+ assert(position <= end());
+ if (position == end()) {
+ emplace_back(std::forward<Args>(args)...);
+ return end() - 1;
+ }
+
+ T new_t = T(std::forward<Args>(args)...);
+
+ auto range = ShiftRight(position, 1);
+ if (range.first == range.second) {
+ // constructing into uninitialized memory
+ Construct(range.first, std::move(new_t));
+ } else {
+ // assigning into moved-from object
+ *range.first = T(std::move(new_t));
+ }
+
+ return range.first;
+}
+
+template <typename T, size_t N, typename A>
+typename InlinedVector<T, N, A>::iterator InlinedVector<T, N, A>::erase(
+ const_iterator first, const_iterator last) {
+ assert(begin() <= first);
+ assert(first <= last);
+ assert(last <= end());
+
+ iterator range_start = const_cast<iterator>(first);
+ iterator range_end = const_cast<iterator>(last);
+
+ size_type s = size();
+ ptrdiff_t erase_gap = std::distance(range_start, range_end);
+ if (erase_gap > 0) {
+ pointer space;
+ if (allocated()) {
+ space = allocated_space();
+ tag().set_allocated_size(s - erase_gap);
+ } else {
+ space = inlined_space();
+ tag().set_inline_size(s - erase_gap);
+ }
+ std::move(range_end, space + s, range_start);
+ Destroy(space + s - erase_gap, space + s);
+ }
+ return range_start;
+}
+
+template <typename T, size_t N, typename A>
+void InlinedVector<T, N, A>::swap(InlinedVector& other) {
+ using std::swap; // Augment ADL with std::swap.
+ if (&other == this) {
+ return;
+ }
+ if (allocated() && other.allocated()) {
+ // Both out of line, so just swap the tag, allocation, and allocator.
+ swap(tag(), other.tag());
+ swap(allocation(), other.allocation());
+ swap(allocator(), other.allocator());
+ return;
+ }
+ if (!allocated() && !other.allocated()) {
+ // Both inlined: swap up to smaller size, then move remaining elements.
+ InlinedVector* a = this;
+ InlinedVector* b = &other;
+ if (size() < other.size()) {
+ swap(a, b);
+ }
+
+ const size_type a_size = a->size();
+ const size_type b_size = b->size();
+ assert(a_size >= b_size);
+ // 'a' is larger. Swap the elements up to the smaller array size.
+ std::swap_ranges(a->inlined_space(),
+ a->inlined_space() + b_size,
+ b->inlined_space());
+
+ // Move the remaining elements: A[b_size,a_size) -> B[b_size,a_size)
+ b->UninitializedCopy(a->inlined_space() + b_size,
+ a->inlined_space() + a_size,
+ b->inlined_space() + b_size);
+ a->Destroy(a->inlined_space() + b_size, a->inlined_space() + a_size);
+
+ swap(a->tag(), b->tag());
+ swap(a->allocator(), b->allocator());
+ assert(b->size() == a_size);
+ assert(a->size() == b_size);
+ return;
+ }
+ // One is out of line, one is inline.
+ // We first move the elements from the inlined vector into the
+ // inlined space in the other vector. We then put the other vector's
+ // pointer/capacity into the originally inlined vector and swap
+ // the tags.
+ InlinedVector* a = this;
+ InlinedVector* b = &other;
+ if (a->allocated()) {
+ swap(a, b);
+ }
+ assert(!a->allocated());
+ assert(b->allocated());
+ const size_type a_size = a->size();
+ const size_type b_size = b->size();
+ // In an optimized build, b_size would be unused.
+ (void)b_size;
+
+ // Made Local copies of size(), don't need tag() accurate anymore
+ swap(a->tag(), b->tag());
+
+ // Copy b_allocation out before b's union gets clobbered by inline_space.
+ Allocation b_allocation = b->allocation();
+
+ b->UninitializedCopy(a->inlined_space(), a->inlined_space() + a_size,
+ b->inlined_space());
+ a->Destroy(a->inlined_space(), a->inlined_space() + a_size);
+
+ a->allocation() = b_allocation;
+
+ if (a->allocator() != b->allocator()) {
+ swap(a->allocator(), b->allocator());
+ }
+
+ assert(b->size() == a_size);
+ assert(a->size() == b_size);
+}
+
+template <typename T, size_t N, typename A>
+void InlinedVector<T, N, A>::EnlargeBy(size_type delta) {
+ const size_type s = size();
+ assert(s <= capacity());
+
+ size_type target = std::max(static_cast<size_type>(N), s + delta);
+
+ // Compute new capacity by repeatedly doubling current capacity
+ // TODO(psrc): Check and avoid overflow?
+ size_type new_capacity = capacity();
+ while (new_capacity < target) {
+ new_capacity <<= 1;
+ }
+
+ Allocation new_allocation(allocator(), new_capacity);
+
+ UninitializedCopy(std::make_move_iterator(data()),
+ std::make_move_iterator(data() + s),
+ new_allocation.buffer());
+
+ ResetAllocation(new_allocation, s);
+}
+
+template <typename T, size_t N, typename A>
+auto InlinedVector<T, N, A>::ShiftRight(const_iterator position, size_type n)
+ -> std::pair<iterator, iterator> {
+ iterator start_used = const_cast<iterator>(position);
+ iterator start_raw = const_cast<iterator>(position);
+ size_type s = size();
+ size_type required_size = s + n;
+
+ if (required_size > capacity()) {
+ // Compute new capacity by repeatedly doubling current capacity
+ size_type new_capacity = capacity();
+ while (new_capacity < required_size) {
+ new_capacity <<= 1;
+ }
+ // Move everyone into the new allocation, leaving a gap of n for the
+ // requested shift.
+ Allocation new_allocation(allocator(), new_capacity);
+ size_type index = position - begin();
+ UninitializedCopy(std::make_move_iterator(data()),
+ std::make_move_iterator(data() + index),
+ new_allocation.buffer());
+ UninitializedCopy(std::make_move_iterator(data() + index),
+ std::make_move_iterator(data() + s),
+ new_allocation.buffer() + index + n);
+ ResetAllocation(new_allocation, s);
+
+ // New allocation means our iterator is invalid, so we'll recalculate.
+ // Since the entire gap is in new space, there's no used space to reuse.
+ start_raw = begin() + index;
+ start_used = start_raw;
+ } else {
+ // If we had enough space, it's a two-part move. Elements going into
+ // previously-unoccupied space need an UninitializedCopy. Elements
+ // going into a previously-occupied space are just a move.
+ iterator pos = const_cast<iterator>(position);
+ iterator raw_space = end();
+ size_type slots_in_used_space = raw_space - pos;
+ size_type new_elements_in_used_space = std::min(n, slots_in_used_space);
+ size_type new_elements_in_raw_space = n - new_elements_in_used_space;
+ size_type old_elements_in_used_space =
+ slots_in_used_space - new_elements_in_used_space;
+
+ UninitializedCopy(std::make_move_iterator(pos + old_elements_in_used_space),
+ std::make_move_iterator(raw_space),
+ raw_space + new_elements_in_raw_space);
+ std::move_backward(pos, pos + old_elements_in_used_space, raw_space);
+
+ // If the gap is entirely in raw space, the used space starts where the raw
+ // space starts, leaving no elements in used space. If the gap is entirely
+ // in used space, the raw space starts at the end of the gap, leaving all
+ // elements accounted for within the used space.
+ start_used = pos;
+ start_raw = pos + new_elements_in_used_space;
+ }
+ tag().add_size(n);
+ return std::make_pair(start_used, start_raw);
+}
+
+template <typename T, size_t N, typename A>
+void InlinedVector<T, N, A>::Destroy(value_type* ptr, value_type* ptr_last) {
+ for (value_type* p = ptr; p != ptr_last; ++p) {
+ AllocatorTraits::destroy(allocator(), p);
+ }
+
+ // Overwrite unused memory with 0xab so we can catch uninitialized usage.
+ // Cast to void* to tell the compiler that we don't care that we might be
+ // scribbling on a vtable pointer.
+#ifndef NDEBUG
+ if (ptr != ptr_last) {
+ memset(reinterpret_cast<void*>(ptr), 0xab,
+ sizeof(*ptr) * (ptr_last - ptr));
+ }
+#endif
+}
+
+template <typename T, size_t N, typename A>
+template <typename Iter>
+void InlinedVector<T, N, A>::AppendRange(Iter first, Iter last,
+ std::forward_iterator_tag) {
+ using Length = typename std::iterator_traits<Iter>::difference_type;
+ Length length = std::distance(first, last);
+ reserve(size() + length);
+ if (allocated()) {
+ UninitializedCopy(first, last, allocated_space() + size());
+ tag().set_allocated_size(size() + length);
+ } else {
+ UninitializedCopy(first, last, inlined_space() + size());
+ tag().set_inline_size(size() + length);
+ }
+}
+
+template <typename T, size_t N, typename A>
+template <typename Iter>
+void InlinedVector<T, N, A>::AssignRange(Iter first, Iter last,
+ std::input_iterator_tag) {
+ // Optimized to avoid reallocation.
+ // Prefer reassignment to copy construction for elements.
+ iterator out = begin();
+ for ( ; first != last && out != end(); ++first, ++out)
+ *out = *first;
+ erase(out, end());
+ std::copy(first, last, std::back_inserter(*this));
+}
+
+template <typename T, size_t N, typename A>
+template <typename Iter>
+void InlinedVector<T, N, A>::AssignRange(Iter first, Iter last,
+ std::forward_iterator_tag) {
+ using Length = typename std::iterator_traits<Iter>::difference_type;
+ Length length = std::distance(first, last);
+ // Prefer reassignment to copy construction for elements.
+ if (static_cast<size_type>(length) <= size()) {
+ erase(std::copy(first, last, begin()), end());
+ return;
+ }
+ reserve(length);
+ iterator out = begin();
+ for (; out != end(); ++first, ++out) *out = *first;
+ if (allocated()) {
+ UninitializedCopy(first, last, out);
+ tag().set_allocated_size(length);
+ } else {
+ UninitializedCopy(first, last, out);
+ tag().set_inline_size(length);
+ }
+}
+
+template <typename T, size_t N, typename A>
+auto InlinedVector<T, N, A>::InsertWithCount(const_iterator position,
+ size_type n, const value_type& v)
+ -> iterator {
+ assert(position >= begin() && position <= end());
+ if (n == 0) return const_cast<iterator>(position);
+
+ value_type copy = v;
+ std::pair<iterator, iterator> it_pair = ShiftRight(position, n);
+ std::fill(it_pair.first, it_pair.second, copy);
+ UninitializedFill(it_pair.second, it_pair.first + n, copy);
+
+ return it_pair.first;
+}
+
+template <typename T, size_t N, typename A>
+template <typename InputIter>
+auto InlinedVector<T, N, A>::InsertWithRange(const_iterator position,
+ InputIter first, InputIter last,
+ std::input_iterator_tag)
+ -> iterator {
+ assert(position >= begin() && position <= end());
+ size_type index = position - cbegin();
+ size_type i = index;
+ while (first != last) insert(begin() + i++, *first++);
+ return begin() + index;
+}
+
+// Overload of InlinedVector::InsertWithRange()
+template <typename T, size_t N, typename A>
+template <typename ForwardIter>
+auto InlinedVector<T, N, A>::InsertWithRange(const_iterator position,
+ ForwardIter first,
+ ForwardIter last,
+ std::forward_iterator_tag)
+ -> iterator {
+ assert(position >= begin() && position <= end());
+ if (first == last) {
+ return const_cast<iterator>(position);
+ }
+ using Length = typename std::iterator_traits<ForwardIter>::difference_type;
+ Length n = std::distance(first, last);
+ std::pair<iterator, iterator> it_pair = ShiftRight(position, n);
+ size_type used_spots = it_pair.second - it_pair.first;
+ ForwardIter open_spot = std::next(first, used_spots);
+ std::copy(first, open_spot, it_pair.first);
+ UninitializedCopy(open_spot, last, it_pair.second);
+ return it_pair.first;
+}
+
+} // namespace absl
+
+#endif // ABSL_CONTAINER_INLINED_VECTOR_H_
[56/62] [abbrv] marmotta git commit: Fix duplicate plugin-version in
marmotta-installer
Posted by ja...@apache.org.
Fix duplicate plugin-version in marmotta-installer
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/b7e0dd4d
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/b7e0dd4d
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/b7e0dd4d
Branch: refs/heads/master
Commit: b7e0dd4d304fdbfb014500ee7c42fca4c70bffb4
Parents: 04fbf29
Author: Jakob Frank <ja...@apache.org>
Authored: Tue Jun 12 12:27:44 2018 +0200
Committer: Jakob Frank <ja...@apache.org>
Committed: Tue Jun 12 12:27:44 2018 +0200
----------------------------------------------------------------------
launchers/marmotta-installer/pom.xml | 2 --
1 file changed, 2 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b7e0dd4d/launchers/marmotta-installer/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/marmotta-installer/pom.xml b/launchers/marmotta-installer/pom.xml
index 5eca819..df03f8e 100644
--- a/launchers/marmotta-installer/pom.xml
+++ b/launchers/marmotta-installer/pom.xml
@@ -159,7 +159,6 @@
</plugin>
<plugin>
<artifactId>maven-dependency-plugin</artifactId>
- <version>2.8</version>
</plugin>
<plugin>
<groupId>org.apache.marmotta</groupId>
@@ -209,7 +208,6 @@
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
- <version>2.6</version>
<executions>
<execution>
<phase>compile</phase>
[13/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Nairobi
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Nairobi b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Nairobi
new file mode 100644
index 0000000..39631f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Nairobi differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ndjamena
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ndjamena b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ndjamena
new file mode 100644
index 0000000..bbfe19d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ndjamena differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Niamey
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Niamey b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Niamey
new file mode 100644
index 0000000..b1c97cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Niamey differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Nouakchott
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Nouakchott b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Nouakchott
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Nouakchott differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ouagadougou
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ouagadougou b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ouagadougou
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Ouagadougou differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Porto-Novo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Porto-Novo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Porto-Novo
new file mode 100644
index 0000000..b1c97cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Porto-Novo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Sao_Tome
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Sao_Tome b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Sao_Tome
new file mode 100644
index 0000000..a4ece7f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Sao_Tome differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Timbuktu
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Timbuktu b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Timbuktu
new file mode 100644
index 0000000..6fd1af3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Timbuktu differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Tripoli
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Tripoli b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Tripoli
new file mode 100644
index 0000000..b32e220
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Tripoli differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Tunis
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Tunis b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Tunis
new file mode 100644
index 0000000..4bd3885
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Tunis differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Windhoek
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Windhoek b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Windhoek
new file mode 100644
index 0000000..358f11e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/Africa/Windhoek differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Adak
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Adak b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Adak
new file mode 100644
index 0000000..5696e0f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Adak differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Anchorage
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Anchorage b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Anchorage
new file mode 100644
index 0000000..6c8bdf2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Anchorage differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Anguilla
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Anguilla b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Anguilla
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Anguilla differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Antigua
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Antigua b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Antigua
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Antigua differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Araguaina
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Araguaina b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Araguaina
new file mode 100644
index 0000000..8b295a9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Araguaina differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Buenos_Aires
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Buenos_Aires b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Buenos_Aires
new file mode 100644
index 0000000..e4866ce
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Buenos_Aires differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Catamarca
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Catamarca b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Catamarca
new file mode 100644
index 0000000..9fe9ad6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Catamarca differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/ComodRivadavia
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/ComodRivadavia b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/ComodRivadavia
new file mode 100644
index 0000000..9fe9ad6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/ComodRivadavia differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Cordoba
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Cordoba b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Cordoba
new file mode 100644
index 0000000..8c58f8c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Cordoba differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Jujuy
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Jujuy b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Jujuy
new file mode 100644
index 0000000..a74ba04
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Jujuy differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/La_Rioja
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/La_Rioja b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/La_Rioja
new file mode 100644
index 0000000..cb184d6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/La_Rioja differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Mendoza
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Mendoza b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Mendoza
new file mode 100644
index 0000000..5e8c44c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Mendoza differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Rio_Gallegos
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Rio_Gallegos b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Rio_Gallegos
new file mode 100644
index 0000000..966a529
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Rio_Gallegos differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Salta
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Salta b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Salta
new file mode 100644
index 0000000..b19aa22
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Salta differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/San_Juan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/San_Juan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/San_Juan
new file mode 100644
index 0000000..9e5ade6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/San_Juan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/San_Luis
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/San_Luis b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/San_Luis
new file mode 100644
index 0000000..af8aa99
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/San_Luis differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Tucuman
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Tucuman b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Tucuman
new file mode 100644
index 0000000..bbb03a0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Tucuman differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Ushuaia
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Ushuaia b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Ushuaia
new file mode 100644
index 0000000..07e4e9f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Argentina/Ushuaia differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Aruba
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Aruba b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Aruba
new file mode 100644
index 0000000..d308336
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Aruba differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Asuncion
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Asuncion b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Asuncion
new file mode 100644
index 0000000..3c61ddb
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Asuncion differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Atikokan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Atikokan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Atikokan
new file mode 100644
index 0000000..5708b55
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Atikokan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Atka
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Atka b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Atka
new file mode 100644
index 0000000..5696e0f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Atka differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bahia
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bahia b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bahia
new file mode 100644
index 0000000..6008a57
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bahia differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bahia_Banderas
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bahia_Banderas b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bahia_Banderas
new file mode 100644
index 0000000..21e2b71
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bahia_Banderas differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Barbados
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Barbados b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Barbados
new file mode 100644
index 0000000..6339936
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Barbados differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Belem
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Belem b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Belem
new file mode 100644
index 0000000..b8e13b0
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Belem differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Belize
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Belize b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Belize
new file mode 100644
index 0000000..7dcc4fc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Belize differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Blanc-Sablon
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Blanc-Sablon b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Blanc-Sablon
new file mode 100644
index 0000000..abcde7d
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Blanc-Sablon differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Boa_Vista
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Boa_Vista b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Boa_Vista
new file mode 100644
index 0000000..f776904
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Boa_Vista differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bogota
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bogota b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bogota
new file mode 100644
index 0000000..d893446
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Bogota differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Boise
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Boise b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Boise
new file mode 100644
index 0000000..ada6d64
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Boise differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Buenos_Aires
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Buenos_Aires b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Buenos_Aires
new file mode 100644
index 0000000..e4866ce
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Buenos_Aires differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cambridge_Bay
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cambridge_Bay b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cambridge_Bay
new file mode 100644
index 0000000..d322f01
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cambridge_Bay differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Campo_Grande
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Campo_Grande b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Campo_Grande
new file mode 100644
index 0000000..de52bb6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Campo_Grande differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cancun
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cancun b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cancun
new file mode 100644
index 0000000..7e69f73
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cancun differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Caracas
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Caracas b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Caracas
new file mode 100644
index 0000000..c8cab1a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Caracas differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Catamarca
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Catamarca b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Catamarca
new file mode 100644
index 0000000..9fe9ad6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Catamarca differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cayenne
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cayenne b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cayenne
new file mode 100644
index 0000000..6db6409
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cayenne differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cayman
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cayman b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cayman
new file mode 100644
index 0000000..5c1c063
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cayman differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Chicago
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Chicago b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Chicago
new file mode 100644
index 0000000..3dd8f0f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Chicago differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Chihuahua
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Chihuahua b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Chihuahua
new file mode 100644
index 0000000..e3adbdb
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Chihuahua differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Coral_Harbour
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Coral_Harbour b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Coral_Harbour
new file mode 100644
index 0000000..5708b55
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Coral_Harbour differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cordoba
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cordoba b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cordoba
new file mode 100644
index 0000000..8c58f8c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cordoba differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Costa_Rica
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Costa_Rica b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Costa_Rica
new file mode 100644
index 0000000..c247133
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Costa_Rica differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Creston
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Creston b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Creston
new file mode 100644
index 0000000..798f627
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Creston differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cuiaba
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cuiaba b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cuiaba
new file mode 100644
index 0000000..145c89e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Cuiaba differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Curacao
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Curacao b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Curacao
new file mode 100644
index 0000000..d308336
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Curacao differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Danmarkshavn
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Danmarkshavn b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Danmarkshavn
new file mode 100644
index 0000000..ad68c72
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Danmarkshavn differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dawson
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dawson b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dawson
new file mode 100644
index 0000000..61c9688
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dawson differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dawson_Creek
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dawson_Creek b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dawson_Creek
new file mode 100644
index 0000000..78f9076
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dawson_Creek differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Denver
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Denver b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Denver
new file mode 100644
index 0000000..7fc6691
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Denver differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Detroit
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Detroit b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Detroit
new file mode 100644
index 0000000..e3ea5c3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Detroit differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dominica
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dominica b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dominica
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Dominica differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Edmonton
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Edmonton b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Edmonton
new file mode 100644
index 0000000..d02fbcd
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Edmonton differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Eirunepe
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Eirunepe b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Eirunepe
new file mode 100644
index 0000000..41047f2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Eirunepe differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/El_Salvador
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/El_Salvador b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/El_Salvador
new file mode 100644
index 0000000..9b8bc7a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/El_Salvador differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Ensenada
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Ensenada b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Ensenada
new file mode 100644
index 0000000..29c83e7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Ensenada differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fort_Nelson
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fort_Nelson b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fort_Nelson
new file mode 100644
index 0000000..5923cc6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fort_Nelson differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fort_Wayne
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fort_Wayne b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fort_Wayne
new file mode 100644
index 0000000..4a92c06
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fort_Wayne differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fortaleza
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fortaleza b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fortaleza
new file mode 100644
index 0000000..22396bb
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Fortaleza differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Glace_Bay
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Glace_Bay b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Glace_Bay
new file mode 100644
index 0000000..f58522b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Glace_Bay differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Godthab
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Godthab b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Godthab
new file mode 100644
index 0000000..ea293cc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Godthab differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Goose_Bay
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Goose_Bay b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Goose_Bay
new file mode 100644
index 0000000..b4b945e
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Goose_Bay differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Grand_Turk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Grand_Turk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Grand_Turk
new file mode 100644
index 0000000..4c8ca6f
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Grand_Turk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Grenada
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Grenada b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Grenada
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Grenada differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guadeloupe
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guadeloupe b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guadeloupe
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guadeloupe differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guatemala
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guatemala b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guatemala
new file mode 100644
index 0000000..abf943b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guatemala differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guayaquil
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guayaquil b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guayaquil
new file mode 100644
index 0000000..92de38b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guayaquil differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guyana
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guyana b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guyana
new file mode 100644
index 0000000..7d29876
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Guyana differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Halifax
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Halifax b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Halifax
new file mode 100644
index 0000000..f86ece4
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Halifax differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Havana
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Havana b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Havana
new file mode 100644
index 0000000..1a58fcd
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Havana differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Hermosillo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Hermosillo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Hermosillo
new file mode 100644
index 0000000..ec435c2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Hermosillo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Indianapolis
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Indianapolis b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Indianapolis
new file mode 100644
index 0000000..4a92c06
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Indianapolis differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Knox
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Knox b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Knox
new file mode 100644
index 0000000..cc785da
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Knox differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Marengo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Marengo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Marengo
new file mode 100644
index 0000000..a23d7b7
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Marengo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Petersburg
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Petersburg b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Petersburg
new file mode 100644
index 0000000..f16cb30
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Petersburg differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Tell_City
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Tell_City b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Tell_City
new file mode 100644
index 0000000..0250bf9
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Tell_City differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Vevay
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Vevay b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Vevay
new file mode 100644
index 0000000..e934de6
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Vevay differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Vincennes
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Vincennes b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Vincennes
new file mode 100644
index 0000000..adbdbee
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Vincennes differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Winamac
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Winamac b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Winamac
new file mode 100644
index 0000000..b34f7b2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indiana/Winamac differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indianapolis
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indianapolis b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indianapolis
new file mode 100644
index 0000000..4a92c06
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Indianapolis differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Inuvik
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Inuvik b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Inuvik
new file mode 100644
index 0000000..1388e8a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Inuvik differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Iqaluit
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Iqaluit b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Iqaluit
new file mode 100644
index 0000000..0785ac5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Iqaluit differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Jamaica
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Jamaica b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Jamaica
new file mode 100644
index 0000000..7aedd26
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Jamaica differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Jujuy
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Jujuy b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Jujuy
new file mode 100644
index 0000000..a74ba04
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Jujuy differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Juneau
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Juneau b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Juneau
new file mode 100644
index 0000000..d00668a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Juneau differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kentucky/Louisville
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kentucky/Louisville b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kentucky/Louisville
new file mode 100644
index 0000000..fdf2e88
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kentucky/Louisville differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kentucky/Monticello
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kentucky/Monticello b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kentucky/Monticello
new file mode 100644
index 0000000..60991aa
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kentucky/Monticello differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Knox_IN
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Knox_IN b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Knox_IN
new file mode 100644
index 0000000..cc785da
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Knox_IN differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kralendijk
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kralendijk b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kralendijk
new file mode 100644
index 0000000..d308336
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Kralendijk differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/La_Paz
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/La_Paz b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/La_Paz
new file mode 100644
index 0000000..bc3df52
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/La_Paz differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Lima
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Lima b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Lima
new file mode 100644
index 0000000..44280a5
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Lima differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Los_Angeles
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Los_Angeles b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Los_Angeles
new file mode 100644
index 0000000..c0ce440
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Los_Angeles differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Louisville
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Louisville b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Louisville
new file mode 100644
index 0000000..fdf2e88
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Louisville differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Lower_Princes
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Lower_Princes b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Lower_Princes
new file mode 100644
index 0000000..d308336
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Lower_Princes differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Maceio
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Maceio b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Maceio
new file mode 100644
index 0000000..54442dc
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Maceio differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Managua
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Managua b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Managua
new file mode 100644
index 0000000..c543ffd
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Managua differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Manaus
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Manaus b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Manaus
new file mode 100644
index 0000000..855cb02
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Manaus differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Marigot
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Marigot b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Marigot
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Marigot differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Martinique
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Martinique b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Martinique
new file mode 100644
index 0000000..f9e2399
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Martinique differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Matamoros
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Matamoros b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Matamoros
new file mode 100644
index 0000000..5671d25
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Matamoros differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mazatlan
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mazatlan b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mazatlan
new file mode 100644
index 0000000..afa94c2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mazatlan differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mendoza
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mendoza b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mendoza
new file mode 100644
index 0000000..5e8c44c
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mendoza differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Menominee
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Menominee b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Menominee
new file mode 100644
index 0000000..55d6e32
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Menominee differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Merida
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Merida b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Merida
new file mode 100644
index 0000000..ecc1856
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Merida differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Metlakatla
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Metlakatla b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Metlakatla
new file mode 100644
index 0000000..c033597
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Metlakatla differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mexico_City
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mexico_City b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mexico_City
new file mode 100644
index 0000000..f11e3d2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Mexico_City differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Miquelon
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Miquelon b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Miquelon
new file mode 100644
index 0000000..75bbcf2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Miquelon differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Moncton
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Moncton b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Moncton
new file mode 100644
index 0000000..51cb1ba
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Moncton differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Monterrey
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Monterrey b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Monterrey
new file mode 100644
index 0000000..dcac92b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Monterrey differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montevideo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montevideo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montevideo
new file mode 100644
index 0000000..f524fd2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montevideo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montreal
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montreal b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montreal
new file mode 100644
index 0000000..7b4682a
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montreal differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montserrat
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montserrat b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montserrat
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Montserrat differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nassau
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nassau b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nassau
new file mode 100644
index 0000000..e5d0289
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nassau differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/New_York
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/New_York b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/New_York
new file mode 100644
index 0000000..7553fee
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/New_York differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nipigon
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nipigon b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nipigon
new file mode 100644
index 0000000..f8a0292
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nipigon differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nome
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nome b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nome
new file mode 100644
index 0000000..c886c9b
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Nome differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Noronha
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Noronha b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Noronha
new file mode 100644
index 0000000..6d91f91
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Noronha differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/Beulah
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/Beulah b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/Beulah
new file mode 100644
index 0000000..8174c88
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/Beulah differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/Center
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/Center b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/Center
new file mode 100644
index 0000000..8035b24
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/Center differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/New_Salem
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/New_Salem b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/New_Salem
new file mode 100644
index 0000000..5b630ee
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/North_Dakota/New_Salem differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Ojinaga
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Ojinaga b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Ojinaga
new file mode 100644
index 0000000..190c5c8
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Ojinaga differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Panama
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Panama b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Panama
new file mode 100644
index 0000000..5c1c063
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Panama differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Pangnirtung
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Pangnirtung b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Pangnirtung
new file mode 100644
index 0000000..df78b62
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Pangnirtung differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Paramaribo
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Paramaribo b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Paramaribo
new file mode 100644
index 0000000..1b608b3
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Paramaribo differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Phoenix
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Phoenix b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Phoenix
new file mode 100644
index 0000000..adf2823
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Phoenix differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Port-au-Prince
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Port-au-Prince b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Port-au-Prince
new file mode 100644
index 0000000..7306cae
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Port-au-Prince differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Port_of_Spain
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Port_of_Spain b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Port_of_Spain
new file mode 100644
index 0000000..447efbe
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Port_of_Spain differ
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Porto_Acre
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Porto_Acre b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Porto_Acre
new file mode 100644
index 0000000..b612ac2
Binary files /dev/null and b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/America/Porto_Acre differ
[18/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/format_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/format_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/format_test.cc
new file mode 100644
index 0000000..09d1fe6
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/format_test.cc
@@ -0,0 +1,437 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstdint>
+#include <limits>
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/time/internal/test_util.h"
+#include "absl/time/time.h"
+
+using testing::HasSubstr;
+
+namespace {
+
+// A helper that tests the given format specifier by itself, and with leading
+// and trailing characters. For example: TestFormatSpecifier(t, "%a", "Thu").
+void TestFormatSpecifier(absl::Time t, absl::TimeZone tz, const std::string& fmt,
+ const std::string& ans) {
+ EXPECT_EQ(ans, absl::FormatTime(fmt, t, tz));
+ EXPECT_EQ("xxx " + ans, absl::FormatTime("xxx " + fmt, t, tz));
+ EXPECT_EQ(ans + " yyy", absl::FormatTime(fmt + " yyy", t, tz));
+ EXPECT_EQ("xxx " + ans + " yyy",
+ absl::FormatTime("xxx " + fmt + " yyy", t, tz));
+}
+
+//
+// Testing FormatTime()
+//
+
+TEST(FormatTime, Basics) {
+ absl::TimeZone tz = absl::UTCTimeZone();
+ absl::Time t = absl::FromTimeT(0);
+
+ // Starts with a couple basic edge cases.
+ EXPECT_EQ("", absl::FormatTime("", t, tz));
+ EXPECT_EQ(" ", absl::FormatTime(" ", t, tz));
+ EXPECT_EQ(" ", absl::FormatTime(" ", t, tz));
+ EXPECT_EQ("xxx", absl::FormatTime("xxx", t, tz));
+ std::string big(128, 'x');
+ EXPECT_EQ(big, absl::FormatTime(big, t, tz));
+ // Cause the 1024-byte buffer to grow.
+ std::string bigger(100000, 'x');
+ EXPECT_EQ(bigger, absl::FormatTime(bigger, t, tz));
+
+ t += absl::Hours(13) + absl::Minutes(4) + absl::Seconds(5);
+ t += absl::Milliseconds(6) + absl::Microseconds(7) + absl::Nanoseconds(8);
+ EXPECT_EQ("1970-01-01", absl::FormatTime("%Y-%m-%d", t, tz));
+ EXPECT_EQ("13:04:05", absl::FormatTime("%H:%M:%S", t, tz));
+ EXPECT_EQ("13:04:05.006", absl::FormatTime("%H:%M:%E3S", t, tz));
+ EXPECT_EQ("13:04:05.006007", absl::FormatTime("%H:%M:%E6S", t, tz));
+ EXPECT_EQ("13:04:05.006007008", absl::FormatTime("%H:%M:%E9S", t, tz));
+}
+
+TEST(FormatTime, LocaleSpecific) {
+ const absl::TimeZone tz = absl::UTCTimeZone();
+ absl::Time t = absl::FromTimeT(0);
+
+ TestFormatSpecifier(t, tz, "%a", "Thu");
+ TestFormatSpecifier(t, tz, "%A", "Thursday");
+ TestFormatSpecifier(t, tz, "%b", "Jan");
+ TestFormatSpecifier(t, tz, "%B", "January");
+
+ // %c should at least produce the numeric year and time-of-day.
+ const std::string s =
+ absl::FormatTime("%c", absl::FromTimeT(0), absl::UTCTimeZone());
+ EXPECT_THAT(s, HasSubstr("1970"));
+ EXPECT_THAT(s, HasSubstr("00:00:00"));
+
+ TestFormatSpecifier(t, tz, "%p", "AM");
+ TestFormatSpecifier(t, tz, "%x", "01/01/70");
+ TestFormatSpecifier(t, tz, "%X", "00:00:00");
+}
+
+TEST(FormatTime, ExtendedSeconds) {
+ const absl::TimeZone tz = absl::UTCTimeZone();
+
+ // No subseconds.
+ absl::Time t = absl::FromTimeT(0) + absl::Seconds(5);
+ EXPECT_EQ("05", absl::FormatTime("%E*S", t, tz));
+ EXPECT_EQ("05.000000000000000", absl::FormatTime("%E15S", t, tz));
+
+ // With subseconds.
+ t += absl::Milliseconds(6) + absl::Microseconds(7) + absl::Nanoseconds(8);
+ EXPECT_EQ("05.006007008", absl::FormatTime("%E*S", t, tz));
+ EXPECT_EQ("05", absl::FormatTime("%E0S", t, tz));
+ EXPECT_EQ("05.006007008000000", absl::FormatTime("%E15S", t, tz));
+
+ // Times before the Unix epoch.
+ t = absl::FromUnixMicros(-1);
+ EXPECT_EQ("1969-12-31 23:59:59.999999",
+ absl::FormatTime("%Y-%m-%d %H:%M:%E*S", t, tz));
+
+ // Here is a "%E*S" case we got wrong for a while. While the first
+ // instant below is correctly rendered as "...:07.333304", the second
+ // one used to appear as "...:07.33330499999999999".
+ t = absl::FromUnixMicros(1395024427333304);
+ EXPECT_EQ("2014-03-17 02:47:07.333304",
+ absl::FormatTime("%Y-%m-%d %H:%M:%E*S", t, tz));
+ t += absl::Microseconds(1);
+ EXPECT_EQ("2014-03-17 02:47:07.333305",
+ absl::FormatTime("%Y-%m-%d %H:%M:%E*S", t, tz));
+}
+
+TEST(FormatTime, RFC1123FormatPadsYear) { // locale specific
+ absl::TimeZone tz = absl::UTCTimeZone();
+
+ // A year of 77 should be padded to 0077.
+ absl::Time t = absl::FromDateTime(77, 6, 28, 9, 8, 7, tz);
+ EXPECT_EQ("Mon, 28 Jun 0077 09:08:07 +0000",
+ absl::FormatTime(absl::RFC1123_full, t, tz));
+ EXPECT_EQ("28 Jun 0077 09:08:07 +0000",
+ absl::FormatTime(absl::RFC1123_no_wday, t, tz));
+}
+
+TEST(FormatTime, InfiniteTime) {
+ absl::TimeZone tz = absl::time_internal::LoadTimeZone("America/Los_Angeles");
+
+ // The format and timezone are ignored.
+ EXPECT_EQ("infinite-future",
+ absl::FormatTime("%H:%M blah", absl::InfiniteFuture(), tz));
+ EXPECT_EQ("infinite-past",
+ absl::FormatTime("%H:%M blah", absl::InfinitePast(), tz));
+}
+
+//
+// Testing ParseTime()
+//
+
+TEST(ParseTime, Basics) {
+ absl::Time t = absl::FromTimeT(1234567890);
+ std::string err;
+
+ // Simple edge cases.
+ EXPECT_TRUE(absl::ParseTime("", "", &t, &err)) << err;
+ EXPECT_EQ(absl::UnixEpoch(), t); // everything defaulted
+ EXPECT_TRUE(absl::ParseTime(" ", " ", &t, &err)) << err;
+ EXPECT_TRUE(absl::ParseTime(" ", " ", &t, &err)) << err;
+ EXPECT_TRUE(absl::ParseTime("x", "x", &t, &err)) << err;
+ EXPECT_TRUE(absl::ParseTime("xxx", "xxx", &t, &err)) << err;
+
+ EXPECT_TRUE(absl::ParseTime("%Y-%m-%d %H:%M:%S %z",
+ "2013-06-28 19:08:09 -0800", &t, &err))
+ << err;
+ absl::Time::Breakdown bd = t.In(absl::FixedTimeZone(-8 * 60 * 60));
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 6, 28, 19, 8, 9, -8 * 60 * 60, false,
+ "UTC-8");
+ EXPECT_EQ(absl::ZeroDuration(), bd.subsecond);
+}
+
+TEST(ParseTime, NullErrorString) {
+ absl::Time t;
+ EXPECT_FALSE(absl::ParseTime("%Q", "invalid format", &t, nullptr));
+ EXPECT_FALSE(absl::ParseTime("%H", "12 trailing data", &t, nullptr));
+ EXPECT_FALSE(
+ absl::ParseTime("%H out of range", "42 out of range", &t, nullptr));
+}
+
+TEST(ParseTime, WithTimeZone) {
+ const absl::TimeZone tz =
+ absl::time_internal::LoadTimeZone("America/Los_Angeles");
+ absl::Time t;
+ std::string e;
+
+ // We can parse a std::string without a UTC offset if we supply a timezone.
+ EXPECT_TRUE(
+ absl::ParseTime("%Y-%m-%d %H:%M:%S", "2013-06-28 19:08:09", tz, &t, &e))
+ << e;
+ absl::Time::Breakdown bd = t.In(tz);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 6, 28, 19, 8, 9, -7 * 60 * 60, true,
+ "PDT");
+ EXPECT_EQ(absl::ZeroDuration(), bd.subsecond);
+
+ // But the timezone is ignored when a UTC offset is present.
+ EXPECT_TRUE(absl::ParseTime("%Y-%m-%d %H:%M:%S %z",
+ "2013-06-28 19:08:09 +0800", tz, &t, &e))
+ << e;
+ bd = t.In(absl::FixedTimeZone(8 * 60 * 60));
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 6, 28, 19, 8, 9, 8 * 60 * 60, false,
+ "UTC+8");
+ EXPECT_EQ(absl::ZeroDuration(), bd.subsecond);
+}
+
+TEST(ParseTime, ErrorCases) {
+ absl::Time t = absl::FromTimeT(0);
+ std::string err;
+
+ EXPECT_FALSE(absl::ParseTime("%S", "123", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Illegal trailing data"));
+
+ // Can't parse an illegal format specifier.
+ err.clear();
+ EXPECT_FALSE(absl::ParseTime("%Q", "x", &t, &err)) << err;
+ // Exact contents of "err" are platform-dependent because of
+ // differences in the strptime implementation between OSX and Linux.
+ EXPECT_FALSE(err.empty());
+
+ // Fails because of trailing, unparsed data "blah".
+ EXPECT_FALSE(absl::ParseTime("%m-%d", "2-3 blah", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Illegal trailing data"));
+
+ // Feb 31 requires normalization.
+ EXPECT_FALSE(absl::ParseTime("%m-%d", "2-31", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Out-of-range"));
+
+ // Check that we cannot have spaces in UTC offsets.
+ EXPECT_TRUE(absl::ParseTime("%z", "-0203", &t, &err)) << err;
+ EXPECT_FALSE(absl::ParseTime("%z", "- 2 3", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+ EXPECT_TRUE(absl::ParseTime("%Ez", "-02:03", &t, &err)) << err;
+ EXPECT_FALSE(absl::ParseTime("%Ez", "- 2: 3", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+
+ // Check that we reject other malformed UTC offsets.
+ EXPECT_FALSE(absl::ParseTime("%Ez", "+-08:00", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+ EXPECT_FALSE(absl::ParseTime("%Ez", "-+08:00", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+
+ // Check that we do not accept "-0" in fields that allow zero.
+ EXPECT_FALSE(absl::ParseTime("%Y", "-0", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+ EXPECT_FALSE(absl::ParseTime("%E4Y", "-0", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+ EXPECT_FALSE(absl::ParseTime("%H", "-0", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+ EXPECT_FALSE(absl::ParseTime("%M", "-0", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+ EXPECT_FALSE(absl::ParseTime("%S", "-0", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+ EXPECT_FALSE(absl::ParseTime("%z", "+-000", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+ EXPECT_FALSE(absl::ParseTime("%Ez", "+-0:00", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+ EXPECT_FALSE(absl::ParseTime("%z", "-00-0", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Illegal trailing data"));
+ EXPECT_FALSE(absl::ParseTime("%Ez", "-00:-0", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Illegal trailing data"));
+}
+
+TEST(ParseTime, ExtendedSeconds) {
+ std::string err;
+ absl::Time t;
+
+ // Here is a "%E*S" case we got wrong for a while. The fractional
+ // part of the first instant is less than 2^31 and was correctly
+ // parsed, while the second (and any subsecond field >=2^31) failed.
+ t = absl::UnixEpoch();
+ EXPECT_TRUE(absl::ParseTime("%E*S", "0.2147483647", &t, &err)) << err;
+ EXPECT_EQ(absl::UnixEpoch() + absl::Nanoseconds(214748364) +
+ absl::Nanoseconds(1) / 2,
+ t);
+ t = absl::UnixEpoch();
+ EXPECT_TRUE(absl::ParseTime("%E*S", "0.2147483648", &t, &err)) << err;
+ EXPECT_EQ(absl::UnixEpoch() + absl::Nanoseconds(214748364) +
+ absl::Nanoseconds(3) / 4,
+ t);
+
+ // We should also be able to specify long strings of digits far
+ // beyond the current resolution and have them convert the same way.
+ t = absl::UnixEpoch();
+ EXPECT_TRUE(absl::ParseTime(
+ "%E*S", "0.214748364801234567890123456789012345678901234567890123456789",
+ &t, &err))
+ << err;
+ EXPECT_EQ(absl::UnixEpoch() + absl::Nanoseconds(214748364) +
+ absl::Nanoseconds(3) / 4,
+ t);
+}
+
+TEST(ParseTime, ExtendedOffsetErrors) {
+ std::string err;
+ absl::Time t;
+
+ // %z against +-HHMM.
+ EXPECT_FALSE(absl::ParseTime("%z", "-123", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Illegal trailing data"));
+
+ // %z against +-HH.
+ EXPECT_FALSE(absl::ParseTime("%z", "-1", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+
+ // %Ez against +-HH:MM.
+ EXPECT_FALSE(absl::ParseTime("%Ez", "-12:3", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Illegal trailing data"));
+
+ // %Ez against +-HHMM.
+ EXPECT_FALSE(absl::ParseTime("%Ez", "-123", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Illegal trailing data"));
+
+ // %Ez against +-HH.
+ EXPECT_FALSE(absl::ParseTime("%Ez", "-1", &t, &err)) << err;
+ EXPECT_THAT(err, HasSubstr("Failed to parse"));
+}
+
+TEST(ParseTime, InfiniteTime) {
+ absl::Time t;
+ std::string err;
+ EXPECT_TRUE(absl::ParseTime("%H:%M blah", "infinite-future", &t, &err));
+ EXPECT_EQ(absl::InfiniteFuture(), t);
+
+ // Surrounding whitespace.
+ EXPECT_TRUE(absl::ParseTime("%H:%M blah", " infinite-future", &t, &err));
+ EXPECT_EQ(absl::InfiniteFuture(), t);
+ EXPECT_TRUE(absl::ParseTime("%H:%M blah", "infinite-future ", &t, &err));
+ EXPECT_EQ(absl::InfiniteFuture(), t);
+ EXPECT_TRUE(absl::ParseTime("%H:%M blah", " infinite-future ", &t, &err));
+ EXPECT_EQ(absl::InfiniteFuture(), t);
+
+ EXPECT_TRUE(absl::ParseTime("%H:%M blah", "infinite-past", &t, &err));
+ EXPECT_EQ(absl::InfinitePast(), t);
+
+ // Surrounding whitespace.
+ EXPECT_TRUE(absl::ParseTime("%H:%M blah", " infinite-past", &t, &err));
+ EXPECT_EQ(absl::InfinitePast(), t);
+ EXPECT_TRUE(absl::ParseTime("%H:%M blah", "infinite-past ", &t, &err));
+ EXPECT_EQ(absl::InfinitePast(), t);
+ EXPECT_TRUE(absl::ParseTime("%H:%M blah", " infinite-past ", &t, &err));
+ EXPECT_EQ(absl::InfinitePast(), t);
+
+ // "infinite-future" as literal std::string
+ absl::TimeZone tz = absl::UTCTimeZone();
+ EXPECT_TRUE(absl::ParseTime("infinite-future %H:%M", "infinite-future 03:04",
+ &t, &err));
+ EXPECT_NE(absl::InfiniteFuture(), t);
+ EXPECT_EQ(3, t.In(tz).hour);
+ EXPECT_EQ(4, t.In(tz).minute);
+
+ // "infinite-past" as literal std::string
+ EXPECT_TRUE(
+ absl::ParseTime("infinite-past %H:%M", "infinite-past 03:04", &t, &err));
+ EXPECT_NE(absl::InfinitePast(), t);
+ EXPECT_EQ(3, t.In(tz).hour);
+ EXPECT_EQ(4, t.In(tz).minute);
+
+ // The input doesn't match the format.
+ EXPECT_FALSE(absl::ParseTime("infinite-future %H:%M", "03:04", &t, &err));
+ EXPECT_FALSE(absl::ParseTime("infinite-past %H:%M", "03:04", &t, &err));
+}
+
+TEST(ParseTime, FailsOnUnrepresentableTime) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+ absl::Time t;
+ EXPECT_FALSE(
+ absl::ParseTime("%Y-%m-%d", "-292277022657-01-27", utc, &t, nullptr));
+ EXPECT_TRUE(
+ absl::ParseTime("%Y-%m-%d", "-292277022657-01-28", utc, &t, nullptr));
+ EXPECT_TRUE(
+ absl::ParseTime("%Y-%m-%d", "292277026596-12-04", utc, &t, nullptr));
+ EXPECT_FALSE(
+ absl::ParseTime("%Y-%m-%d", "292277026596-12-05", utc, &t, nullptr));
+}
+
+//
+// Roundtrip test for FormatTime()/ParseTime().
+//
+
+TEST(FormatParse, RoundTrip) {
+ const absl::TimeZone gst =
+ absl::time_internal::LoadTimeZone("America/Los_Angeles");
+ const absl::Time in = absl::FromDateTime(1977, 6, 28, 9, 8, 7, gst);
+ const absl::Duration subseconds = absl::Nanoseconds(654321);
+ std::string err;
+
+ // RFC3339, which renders subseconds.
+ {
+ absl::Time out;
+ const std::string s = absl::FormatTime(absl::RFC3339_full, in + subseconds, gst);
+ EXPECT_TRUE(absl::ParseTime(absl::RFC3339_full, s, &out, &err))
+ << s << ": " << err;
+ EXPECT_EQ(in + subseconds, out); // RFC3339_full includes %Ez
+ }
+
+ // RFC1123, which only does whole seconds.
+ {
+ absl::Time out;
+ const std::string s = absl::FormatTime(absl::RFC1123_full, in, gst);
+ EXPECT_TRUE(absl::ParseTime(absl::RFC1123_full, s, &out, &err))
+ << s << ": " << err;
+ EXPECT_EQ(in, out); // RFC1123_full includes %z
+ }
+
+ // `absl::FormatTime()` falls back to strftime() for "%c", which appears to
+ // work. On Windows, `absl::ParseTime()` falls back to std::get_time() which
+ // appears to fail on "%c" (or at least on the "%c" text produced by
+ // `strftime()`). This makes it fail the round-trip test.
+#ifndef _MSC_VER
+ // Even though we don't know what %c will produce, it should roundtrip,
+ // but only in the 0-offset timezone.
+ {
+ absl::Time out;
+ const std::string s = absl::FormatTime("%c", in, absl::UTCTimeZone());
+ EXPECT_TRUE(absl::ParseTime("%c", s, &out, &err)) << s << ": " << err;
+ EXPECT_EQ(in, out);
+ }
+#endif // _MSC_VER
+}
+
+TEST(FormatParse, RoundTripDistantFuture) {
+ const absl::TimeZone tz = absl::UTCTimeZone();
+ const absl::Time in =
+ absl::FromUnixSeconds(std::numeric_limits<int64_t>::max());
+ std::string err;
+
+ absl::Time out;
+ const std::string s = absl::FormatTime(absl::RFC3339_full, in, tz);
+ EXPECT_TRUE(absl::ParseTime(absl::RFC3339_full, s, &out, &err))
+ << s << ": " << err;
+ EXPECT_EQ(in, out);
+}
+
+TEST(FormatParse, RoundTripDistantPast) {
+ const absl::TimeZone tz = absl::UTCTimeZone();
+ const absl::Time in =
+ absl::FromUnixSeconds(std::numeric_limits<int64_t>::min());
+ std::string err;
+
+ absl::Time out;
+ const std::string s = absl::FormatTime(absl::RFC3339_full, in, tz);
+ EXPECT_TRUE(absl::ParseTime(absl::RFC3339_full, s, &out, &err))
+ << s << ": " << err;
+ EXPECT_EQ(in, out);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/BUILD.bazel
new file mode 100644
index 0000000..fe17b3e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/BUILD.bazel
@@ -0,0 +1,105 @@
+# Copyright 2016 Google Inc. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+licenses(["notice"]) # Apache License
+
+### libraries
+
+cc_library(
+ name = "includes",
+ textual_hdrs = [
+ "include/cctz/civil_time.h",
+ "include/cctz/civil_time_detail.h",
+ "include/cctz/time_zone.h",
+ ],
+ visibility = ["//absl/time:__pkg__"],
+)
+
+cc_library(
+ name = "civil_time",
+ srcs = ["src/civil_time_detail.cc"],
+ hdrs = [
+ "include/cctz/civil_time.h",
+ ],
+ textual_hdrs = ["include/cctz/civil_time_detail.h"],
+ visibility = ["//visibility:public"],
+)
+
+cc_library(
+ name = "time_zone",
+ srcs = [
+ "src/time_zone_fixed.cc",
+ "src/time_zone_fixed.h",
+ "src/time_zone_format.cc",
+ "src/time_zone_if.cc",
+ "src/time_zone_if.h",
+ "src/time_zone_impl.cc",
+ "src/time_zone_impl.h",
+ "src/time_zone_info.cc",
+ "src/time_zone_info.h",
+ "src/time_zone_libc.cc",
+ "src/time_zone_libc.h",
+ "src/time_zone_lookup.cc",
+ "src/time_zone_posix.cc",
+ "src/time_zone_posix.h",
+ "src/tzfile.h",
+ "src/zone_info_source.cc",
+ ],
+ hdrs = [
+ "include/cctz/time_zone.h",
+ "include/cctz/zone_info_source.h",
+ ],
+ visibility = ["//visibility:public"],
+ deps = [":civil_time"],
+)
+
+### tests
+
+cc_test(
+ name = "civil_time_test",
+ size = "small",
+ srcs = ["src/civil_time_test.cc"],
+ deps = [
+ ":civil_time",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "time_zone_format_test",
+ size = "small",
+ srcs = ["src/time_zone_format_test.cc"],
+ deps = [
+ ":civil_time",
+ ":time_zone",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "time_zone_lookup_test",
+ size = "small",
+ srcs = ["src/time_zone_lookup_test.cc"],
+ deps = [
+ ":civil_time",
+ ":time_zone",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+### benchmarks
+
+### examples
+
+### binaries
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/civil_time.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/civil_time.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/civil_time.h
new file mode 100644
index 0000000..898222b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/civil_time.h
@@ -0,0 +1,329 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
+#define ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
+
+#include "absl/time/internal/cctz/include/cctz/civil_time_detail.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// The term "civil time" refers to the legally recognized human-scale time
+// that is represented by the six fields YYYY-MM-DD hh:mm:ss. Modern-day civil
+// time follows the Gregorian Calendar and is a time-zone-independent concept.
+// A "date" is perhaps the most common example of a civil time (represented in
+// this library as cctz::civil_day). This library provides six classes and a
+// handful of functions that help with rounding, iterating, and arithmetic on
+// civil times while avoiding complications like daylight-saving time (DST).
+//
+// The following six classes form the core of this civil-time library:
+//
+// * civil_second
+// * civil_minute
+// * civil_hour
+// * civil_day
+// * civil_month
+// * civil_year
+//
+// Each class is a simple value type with the same interface for construction
+// and the same six accessors for each of the civil fields (year, month, day,
+// hour, minute, and second, aka YMDHMS). These classes differ only in their
+// alignment, which is indicated by the type name and specifies the field on
+// which arithmetic operates.
+//
+// Each class can be constructed by passing up to six optional integer
+// arguments representing the YMDHMS fields (in that order) to the
+// constructor. Omitted fields are assigned their minimum valid value. Hours,
+// minutes, and seconds will be set to 0, month and day will be set to 1, and
+// since there is no minimum valid year, it will be set to 1970. So, a
+// default-constructed civil-time object will have YMDHMS fields representing
+// "1970-01-01 00:00:00". Fields that are out-of-range are normalized (e.g.,
+// October 32 -> November 1) so that all civil-time objects represent valid
+// values.
+//
+// Each civil-time class is aligned to the civil-time field indicated in the
+// class's name after normalization. Alignment is performed by setting all the
+// inferior fields to their minimum valid value (as described above). The
+// following are examples of how each of the six types would align the fields
+// representing November 22, 2015 at 12:34:56 in the afternoon. (Note: the
+// std::string format used here is not important; it's just a shorthand way of
+// showing the six YMDHMS fields.)
+//
+// civil_second 2015-11-22 12:34:56
+// civil_minute 2015-11-22 12:34:00
+// civil_hour 2015-11-22 12:00:00
+// civil_day 2015-11-22 00:00:00
+// civil_month 2015-11-01 00:00:00
+// civil_year 2015-01-01 00:00:00
+//
+// Each civil-time type performs arithmetic on the field to which it is
+// aligned. This means that adding 1 to a civil_day increments the day field
+// (normalizing as necessary), and subtracting 7 from a civil_month operates
+// on the month field (normalizing as necessary). All arithmetic produces a
+// valid civil time. Difference requires two similarly aligned civil-time
+// objects and returns the scalar answer in units of the objects' alignment.
+// For example, the difference between two civil_hour objects will give an
+// answer in units of civil hours.
+//
+// In addition to the six civil-time types just described, there are
+// a handful of helper functions and algorithms for performing common
+// calculations. These are described below.
+//
+// Note: In C++14 and later, this library is usable in a constexpr context.
+//
+// CONSTRUCTION:
+//
+// Each of the civil-time types can be constructed in two ways: by directly
+// passing to the constructor up to six (optional) integers representing the
+// YMDHMS fields, or by copying the YMDHMS fields from a differently aligned
+// civil-time type.
+//
+// civil_day default_value; // 1970-01-01 00:00:00
+//
+// civil_day a(2015, 2, 3); // 2015-02-03 00:00:00
+// civil_day b(2015, 2, 3, 4, 5, 6); // 2015-02-03 00:00:00
+// civil_day c(2015); // 2015-01-01 00:00:00
+//
+// civil_second ss(2015, 2, 3, 4, 5, 6); // 2015-02-03 04:05:06
+// civil_minute mm(ss); // 2015-02-03 04:05:00
+// civil_hour hh(mm); // 2015-02-03 04:00:00
+// civil_day d(hh); // 2015-02-03 00:00:00
+// civil_month m(d); // 2015-02-01 00:00:00
+// civil_year y(m); // 2015-01-01 00:00:00
+//
+// m = civil_month(y); // 2015-01-01 00:00:00
+// d = civil_day(m); // 2015-01-01 00:00:00
+// hh = civil_hour(d); // 2015-01-01 00:00:00
+// mm = civil_minute(hh); // 2015-01-01 00:00:00
+// ss = civil_second(mm); // 2015-01-01 00:00:00
+//
+// ALIGNMENT CONVERSION:
+//
+// The alignment of a civil-time object cannot change, but the object may be
+// used to construct a new object with a different alignment. This is referred
+// to as "realigning". When realigning to a type with the same or more
+// precision (e.g., civil_day -> civil_second), the conversion may be
+// performed implicitly since no information is lost. However, if information
+// could be discarded (e.g., civil_second -> civil_day), the conversion must
+// be explicit at the call site.
+//
+// void fun(const civil_day& day);
+//
+// civil_second cs;
+// fun(cs); // Won't compile because data may be discarded
+// fun(civil_day(cs)); // OK: explicit conversion
+//
+// civil_day cd;
+// fun(cd); // OK: no conversion needed
+//
+// civil_month cm;
+// fun(cm); // OK: implicit conversion to civil_day
+//
+// NORMALIZATION:
+//
+// Integer arguments passed to the constructor may be out-of-range, in which
+// case they are normalized to produce a valid civil-time object. This enables
+// natural arithmetic on constructor arguments without worrying about the
+// field's range. Normalization guarantees that there are no invalid
+// civil-time objects.
+//
+// civil_day d(2016, 10, 32); // Out-of-range day; normalized to 2016-11-01
+//
+// Note: If normalization is undesired, you can signal an error by comparing
+// the constructor arguments to the normalized values returned by the YMDHMS
+// properties.
+//
+// PROPERTIES:
+//
+// All civil-time types have accessors for all six of the civil-time fields:
+// year, month, day, hour, minute, and second. Recall that fields inferior to
+// the type's aligment will be set to their minimum valid value.
+//
+// civil_day d(2015, 6, 28);
+// // d.year() == 2015
+// // d.month() == 6
+// // d.day() == 28
+// // d.hour() == 0
+// // d.minute() == 0
+// // d.second() == 0
+//
+// COMPARISON:
+//
+// Comparison always considers all six YMDHMS fields, regardless of the type's
+// alignment. Comparison between differently aligned civil-time types is
+// allowed.
+//
+// civil_day feb_3(2015, 2, 3); // 2015-02-03 00:00:00
+// civil_day mar_4(2015, 3, 4); // 2015-03-04 00:00:00
+// // feb_3 < mar_4
+// // civil_year(feb_3) == civil_year(mar_4)
+//
+// civil_second feb_3_noon(2015, 2, 3, 12, 0, 0); // 2015-02-03 12:00:00
+// // feb_3 < feb_3_noon
+// // feb_3 == civil_day(feb_3_noon)
+//
+// // Iterates all the days of February 2015.
+// for (civil_day d(2015, 2, 1); d < civil_month(2015, 3); ++d) {
+// // ...
+// }
+//
+// STREAMING:
+//
+// Each civil-time type may be sent to an output stream using operator<<().
+// The output format follows the pattern "YYYY-MM-DDThh:mm:ss" where fields
+// inferior to the type's alignment are omitted.
+//
+// civil_second cs(2015, 2, 3, 4, 5, 6);
+// std::cout << cs << "\n"; // Outputs: 2015-02-03T04:05:06
+//
+// civil_day cd(cs);
+// std::cout << cd << "\n"; // Outputs: 2015-02-03
+//
+// civil_year cy(cs);
+// std::cout << cy << "\n"; // Outputs: 2015
+//
+// ARITHMETIC:
+//
+// Civil-time types support natural arithmetic operators such as addition,
+// subtraction, and difference. Arithmetic operates on the civil-time field
+// indicated in the type's name. Difference requires arguments with the same
+// alignment and returns the answer in units of the alignment.
+//
+// civil_day a(2015, 2, 3);
+// ++a; // 2015-02-04 00:00:00
+// --a; // 2015-02-03 00:00:00
+// civil_day b = a + 1; // 2015-02-04 00:00:00
+// civil_day c = 1 + b; // 2015-02-05 00:00:00
+// int n = c - a; // n = 2 (civil days)
+// int m = c - civil_month(c); // Won't compile: different types.
+//
+// EXAMPLE: Adding a month to January 31.
+//
+// One of the classic questions that arises when considering a civil-time
+// library (or a date library or a date/time library) is this: "What happens
+// when you add a month to January 31?" This is an interesting question
+// because there could be a number of possible answers:
+//
+// 1. March 3 (or 2 if a leap year). This may make sense if the operation
+// wants the equivalent of February 31.
+// 2. February 28 (or 29 if a leap year). This may make sense if the operation
+// wants the last day of January to go to the last day of February.
+// 3. Error. The caller may get some error, an exception, an invalid date
+// object, or maybe false is returned. This may make sense because there is
+// no single unambiguously correct answer to the question.
+//
+// Practically speaking, any answer that is not what the programmer intended
+// is the wrong answer.
+//
+// This civil-time library avoids the problem by making it impossible to ask
+// ambiguous questions. All civil-time objects are aligned to a particular
+// civil-field boundary (such as aligned to a year, month, day, hour, minute,
+// or second), and arithmetic operates on the field to which the object is
+// aligned. This means that in order to "add a month" the object must first be
+// aligned to a month boundary, which is equivalent to the first day of that
+// month.
+//
+// Of course, there are ways to compute an answer the question at hand using
+// this civil-time library, but they require the programmer to be explicit
+// about the answer they expect. To illustrate, let's see how to compute all
+// three of the above possible answers to the question of "Jan 31 plus 1
+// month":
+//
+// const civil_day d(2015, 1, 31);
+//
+// // Answer 1:
+// // Add 1 to the month field in the constructor, and rely on normalization.
+// const auto ans_normalized = civil_day(d.year(), d.month() + 1, d.day());
+// // ans_normalized == 2015-03-03 (aka Feb 31)
+//
+// // Answer 2:
+// // Add 1 to month field, capping to the end of next month.
+// const auto next_month = civil_month(d) + 1;
+// const auto last_day_of_next_month = civil_day(next_month + 1) - 1;
+// const auto ans_capped = std::min(ans_normalized, last_day_of_next_month);
+// // ans_capped == 2015-02-28
+//
+// // Answer 3:
+// // Signal an error if the normalized answer is not in next month.
+// if (civil_month(ans_normalized) != next_month) {
+// // error, month overflow
+// }
+//
+using civil_year = detail::civil_year;
+using civil_month = detail::civil_month;
+using civil_day = detail::civil_day;
+using civil_hour = detail::civil_hour;
+using civil_minute = detail::civil_minute;
+using civil_second = detail::civil_second;
+
+// An enum class with members monday, tuesday, wednesday, thursday, friday,
+// saturday, and sunday. These enum values may be sent to an output stream
+// using operator<<(). The result is the full weekday name in English with a
+// leading capital letter.
+//
+// weekday wd = weekday::thursday;
+// std::cout << wd << "\n"; // Outputs: Thursday
+//
+using detail::weekday;
+
+// Returns the weekday for the given civil_day.
+//
+// civil_day a(2015, 8, 13);
+// weekday wd = get_weekday(a); // wd == weekday::thursday
+//
+using detail::get_weekday;
+
+// Returns the civil_day that strictly follows or precedes the given
+// civil_day, and that falls on the given weekday.
+//
+// For example, given:
+//
+// August 2015
+// Su Mo Tu We Th Fr Sa
+// 1
+// 2 3 4 5 6 7 8
+// 9 10 11 12 13 14 15
+// 16 17 18 19 20 21 22
+// 23 24 25 26 27 28 29
+// 30 31
+//
+// civil_day a(2015, 8, 13); // get_weekday(a) == weekday::thursday
+// civil_day b = next_weekday(a, weekday::thursday); // b = 2015-08-20
+// civil_day c = prev_weekday(a, weekday::thursday); // c = 2015-08-06
+//
+// civil_day d = ...
+// // Gets the following Thursday if d is not already Thursday
+// civil_day thurs1 = prev_weekday(d, weekday::thursday) + 7;
+// // Gets the previous Thursday if d is not already Thursday
+// civil_day thurs2 = next_weekday(d, weekday::thursday) - 7;
+//
+using detail::next_weekday;
+using detail::prev_weekday;
+
+// Returns the day-of-year for the given civil_day.
+//
+// civil_day a(2015, 1, 1);
+// int yd_jan_1 = get_yearday(a); // yd_jan_1 = 1
+// civil_day b(2015, 12, 31);
+// int yd_dec_31 = get_yearday(b); // yd_dec_31 = 365
+//
+using detail::get_yearday;
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+#endif // ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/civil_time_detail.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/civil_time_detail.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/civil_time_detail.h
new file mode 100644
index 0000000..4c39c7d
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/civil_time_detail.h
@@ -0,0 +1,564 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
+#define ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
+
+#include <cstdint>
+#include <limits>
+#include <ostream>
+#include <type_traits>
+
+// Disable constexpr support unless we are using clang in C++14 mode.
+#if __clang__ && __cpp_constexpr >= 201304
+#define CONSTEXPR_D constexpr // data
+#define CONSTEXPR_F constexpr // function
+#define CONSTEXPR_M constexpr // member
+#else
+#define CONSTEXPR_D const
+#define CONSTEXPR_F inline
+#define CONSTEXPR_M
+#endif
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// Support years that at least span the range of 64-bit time_t values.
+using year_t = std::int_fast64_t;
+
+// Type alias that indicates an argument is not normalized (e.g., the
+// constructor parameters and operands/results of addition/subtraction).
+using diff_t = std::int_fast64_t;
+
+namespace detail {
+
+// Type aliases that indicate normalized argument values.
+using month_t = std::int_fast8_t; // [1:12]
+using day_t = std::int_fast8_t; // [1:31]
+using hour_t = std::int_fast8_t; // [0:23]
+using minute_t = std::int_fast8_t; // [0:59]
+using second_t = std::int_fast8_t; // [0:59]
+
+// Normalized civil-time fields: Y-M-D HH:MM:SS.
+struct fields {
+ CONSTEXPR_M fields(year_t year, month_t month, day_t day,
+ hour_t hour, minute_t minute, second_t second)
+ : y(year), m(month), d(day), hh(hour), mm(minute), ss(second) {}
+ std::int_least64_t y;
+ std::int_least8_t m;
+ std::int_least8_t d;
+ std::int_least8_t hh;
+ std::int_least8_t mm;
+ std::int_least8_t ss;
+};
+
+struct second_tag {};
+struct minute_tag : second_tag {};
+struct hour_tag : minute_tag {};
+struct day_tag : hour_tag {};
+struct month_tag : day_tag {};
+struct year_tag : month_tag {};
+
+////////////////////////////////////////////////////////////////////////
+
+// Field normalization (without avoidable overflow).
+
+namespace impl {
+
+CONSTEXPR_F bool is_leap_year(year_t y) noexcept {
+ return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0);
+}
+CONSTEXPR_F int year_index(year_t y, month_t m) noexcept {
+ return (static_cast<int>((y + (m > 2)) % 400) + 400) % 400;
+}
+CONSTEXPR_F int days_per_century(year_t y, month_t m) noexcept {
+ const int yi = year_index(y, m);
+ return 36524 + (yi == 0 || yi > 300);
+}
+CONSTEXPR_F int days_per_4years(year_t y, month_t m) noexcept {
+ const int yi = year_index(y, m);
+ return 1460 + (yi == 0 || yi > 300 || (yi - 1) % 100 < 96);
+}
+CONSTEXPR_F int days_per_year(year_t y, month_t m) noexcept {
+ return is_leap_year(y + (m > 2)) ? 366 : 365;
+}
+CONSTEXPR_F int days_per_month(year_t y, month_t m) noexcept {
+ CONSTEXPR_D int k_days_per_month[1 + 12] = {
+ -1, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 // non leap year
+ };
+ return k_days_per_month[m] + (m == 2 && is_leap_year(y));
+}
+
+CONSTEXPR_F fields n_day(year_t y, month_t m, diff_t d, diff_t cd,
+ hour_t hh, minute_t mm, second_t ss) noexcept {
+ y += (cd / 146097) * 400;
+ cd %= 146097;
+ if (cd < 0) {
+ y -= 400;
+ cd += 146097;
+ }
+ y += (d / 146097) * 400;
+ d = d % 146097 + cd;
+ if (d > 0) {
+ if (d > 146097) {
+ y += 400;
+ d -= 146097;
+ }
+ } else {
+ if (d > -365) {
+ // We often hit the previous year when stepping a civil time backwards,
+ // so special case it to avoid counting up by 100/4/1-year chunks.
+ y -= 1;
+ d += days_per_year(y, m);
+ } else {
+ y -= 400;
+ d += 146097;
+ }
+ }
+ if (d > 365) {
+ for (int n = days_per_century(y, m); d > n; n = days_per_century(y, m)) {
+ d -= n;
+ y += 100;
+ }
+ for (int n = days_per_4years(y, m); d > n; n = days_per_4years(y, m)) {
+ d -= n;
+ y += 4;
+ }
+ for (int n = days_per_year(y, m); d > n; n = days_per_year(y, m)) {
+ d -= n;
+ ++y;
+ }
+ }
+ if (d > 28) {
+ for (int n = days_per_month(y, m); d > n; n = days_per_month(y, m)) {
+ d -= n;
+ if (++m > 12) {
+ ++y;
+ m = 1;
+ }
+ }
+ }
+ return fields(y, m, static_cast<day_t>(d), hh, mm, ss);
+}
+CONSTEXPR_F fields n_mon(year_t y, diff_t m, diff_t d, diff_t cd,
+ hour_t hh, minute_t mm, second_t ss) noexcept {
+ if (m != 12) {
+ y += m / 12;
+ m %= 12;
+ if (m <= 0) {
+ y -= 1;
+ m += 12;
+ }
+ }
+ return n_day(y, static_cast<month_t>(m), d, cd, hh, mm, ss);
+}
+CONSTEXPR_F fields n_hour(year_t y, diff_t m, diff_t d, diff_t cd,
+ diff_t hh, minute_t mm, second_t ss) noexcept {
+ cd += hh / 24;
+ hh %= 24;
+ if (hh < 0) {
+ cd -= 1;
+ hh += 24;
+ }
+ return n_mon(y, m, d, cd, static_cast<hour_t>(hh), mm, ss);
+}
+CONSTEXPR_F fields n_min(year_t y, diff_t m, diff_t d, diff_t hh, diff_t ch,
+ diff_t mm, second_t ss) noexcept {
+ ch += mm / 60;
+ mm %= 60;
+ if (mm < 0) {
+ ch -= 1;
+ mm += 60;
+ }
+ return n_hour(y, m, d, hh / 24 + ch / 24, hh % 24 + ch % 24,
+ static_cast<minute_t>(mm), ss);
+}
+CONSTEXPR_F fields n_sec(year_t y, diff_t m, diff_t d, diff_t hh, diff_t mm,
+ diff_t ss) noexcept {
+ // Optimization for when (non-constexpr) fields are already normalized.
+ if (0 <= ss && ss < 60) {
+ const second_t nss = static_cast<second_t>(ss);
+ if (0 <= mm && mm < 60) {
+ const minute_t nmm = static_cast<minute_t>(mm);
+ if (0 <= hh && hh < 24) {
+ const hour_t nhh = static_cast<hour_t>(hh);
+ if (1 <= d && d <= 28 && 1 <= m && m <= 12) {
+ const day_t nd = static_cast<day_t>(d);
+ const month_t nm = static_cast<month_t>(m);
+ return fields(y, nm, nd, nhh, nmm, nss);
+ }
+ return n_mon(y, m, d, 0, nhh, nmm, nss);
+ }
+ return n_hour(y, m, d, hh / 24, hh % 24, nmm, nss);
+ }
+ return n_min(y, m, d, hh, mm / 60, mm % 60, nss);
+ }
+ diff_t cm = ss / 60;
+ ss %= 60;
+ if (ss < 0) {
+ cm -= 1;
+ ss += 60;
+ }
+ return n_min(y, m, d, hh, mm / 60 + cm / 60, mm % 60 + cm % 60,
+ static_cast<second_t>(ss));
+}
+
+} // namespace impl
+
+////////////////////////////////////////////////////////////////////////
+
+// Increments the indicated (normalized) field by "n".
+CONSTEXPR_F fields step(second_tag, fields f, diff_t n) noexcept {
+ return impl::n_sec(f.y, f.m, f.d, f.hh, f.mm + n / 60, f.ss + n % 60);
+}
+CONSTEXPR_F fields step(minute_tag, fields f, diff_t n) noexcept {
+ return impl::n_min(f.y, f.m, f.d, f.hh + n / 60, 0, f.mm + n % 60, f.ss);
+}
+CONSTEXPR_F fields step(hour_tag, fields f, diff_t n) noexcept {
+ return impl::n_hour(f.y, f.m, f.d + n / 24, 0, f.hh + n % 24, f.mm, f.ss);
+}
+CONSTEXPR_F fields step(day_tag, fields f, diff_t n) noexcept {
+ return impl::n_day(f.y, f.m, f.d, n, f.hh, f.mm, f.ss);
+}
+CONSTEXPR_F fields step(month_tag, fields f, diff_t n) noexcept {
+ return impl::n_mon(f.y + n / 12, f.m + n % 12, f.d, 0, f.hh, f.mm, f.ss);
+}
+CONSTEXPR_F fields step(year_tag, fields f, diff_t n) noexcept {
+ return fields(f.y + n, f.m, f.d, f.hh, f.mm, f.ss);
+}
+
+////////////////////////////////////////////////////////////////////////
+
+namespace impl {
+
+// Returns (v * f + a) but avoiding intermediate overflow when possible.
+CONSTEXPR_F diff_t scale_add(diff_t v, diff_t f, diff_t a) noexcept {
+ return (v < 0) ? ((v + 1) * f + a) - f : ((v - 1) * f + a) + f;
+}
+
+// Map a (normalized) Y/M/D to the number of days before/after 1970-01-01.
+// Probably overflows for years outside [-292277022656:292277026595].
+CONSTEXPR_F diff_t ymd_ord(year_t y, month_t m, day_t d) noexcept {
+ const diff_t eyear = (m <= 2) ? y - 1 : y;
+ const diff_t era = (eyear >= 0 ? eyear : eyear - 399) / 400;
+ const diff_t yoe = eyear - era * 400;
+ const diff_t doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1;
+ const diff_t doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+ return era * 146097 + doe - 719468;
+}
+
+// Returns the difference in days between two normalized Y-M-D tuples.
+// ymd_ord() will encounter integer overflow given extreme year values,
+// yet the difference between two such extreme values may actually be
+// small, so we take a little care to avoid overflow when possible by
+// exploiting the 146097-day cycle.
+CONSTEXPR_F diff_t day_difference(year_t y1, month_t m1, day_t d1,
+ year_t y2, month_t m2, day_t d2) noexcept {
+ const diff_t a_c4_off = y1 % 400;
+ const diff_t b_c4_off = y2 % 400;
+ diff_t c4_diff = (y1 - a_c4_off) - (y2 - b_c4_off);
+ diff_t delta = ymd_ord(a_c4_off, m1, d1) - ymd_ord(b_c4_off, m2, d2);
+ if (c4_diff > 0 && delta < 0) {
+ delta += 2 * 146097;
+ c4_diff -= 2 * 400;
+ } else if (c4_diff < 0 && delta > 0) {
+ delta -= 2 * 146097;
+ c4_diff += 2 * 400;
+ }
+ return (c4_diff / 400 * 146097) + delta;
+}
+
+} // namespace impl
+
+// Returns the difference between fields structs using the indicated unit.
+CONSTEXPR_F diff_t difference(year_tag, fields f1, fields f2) noexcept {
+ return f1.y - f2.y;
+}
+CONSTEXPR_F diff_t difference(month_tag, fields f1, fields f2) noexcept {
+ return impl::scale_add(difference(year_tag{}, f1, f2), 12, (f1.m - f2.m));
+}
+CONSTEXPR_F diff_t difference(day_tag, fields f1, fields f2) noexcept {
+ return impl::day_difference(f1.y, f1.m, f1.d, f2.y, f2.m, f2.d);
+}
+CONSTEXPR_F diff_t difference(hour_tag, fields f1, fields f2) noexcept {
+ return impl::scale_add(difference(day_tag{}, f1, f2), 24, (f1.hh - f2.hh));
+}
+CONSTEXPR_F diff_t difference(minute_tag, fields f1, fields f2) noexcept {
+ return impl::scale_add(difference(hour_tag{}, f1, f2), 60, (f1.mm - f2.mm));
+}
+CONSTEXPR_F diff_t difference(second_tag, fields f1, fields f2) noexcept {
+ return impl::scale_add(difference(minute_tag{}, f1, f2), 60, f1.ss - f2.ss);
+}
+
+////////////////////////////////////////////////////////////////////////
+
+// Aligns the (normalized) fields struct to the indicated field.
+CONSTEXPR_F fields align(second_tag, fields f) noexcept {
+ return f;
+}
+CONSTEXPR_F fields align(minute_tag, fields f) noexcept {
+ return fields{f.y, f.m, f.d, f.hh, f.mm, 0};
+}
+CONSTEXPR_F fields align(hour_tag, fields f) noexcept {
+ return fields{f.y, f.m, f.d, f.hh, 0, 0};
+}
+CONSTEXPR_F fields align(day_tag, fields f) noexcept {
+ return fields{f.y, f.m, f.d, 0, 0, 0};
+}
+CONSTEXPR_F fields align(month_tag, fields f) noexcept {
+ return fields{f.y, f.m, 1, 0, 0, 0};
+}
+CONSTEXPR_F fields align(year_tag, fields f) noexcept {
+ return fields{f.y, 1, 1, 0, 0, 0};
+}
+
+////////////////////////////////////////////////////////////////////////
+
+template <typename T>
+class civil_time {
+ public:
+ explicit CONSTEXPR_M civil_time(year_t y, diff_t m = 1, diff_t d = 1,
+ diff_t hh = 0, diff_t mm = 0,
+ diff_t ss = 0) noexcept
+ : civil_time(impl::n_sec(y, m, d, hh, mm, ss)) {}
+
+ CONSTEXPR_M civil_time() noexcept : f_{1970, 1, 1, 0, 0, 0} {}
+ civil_time(const civil_time&) = default;
+ civil_time& operator=(const civil_time&) = default;
+
+ // Conversion between civil times of different alignment. Conversion to
+ // a more precise alignment is allowed implicitly (e.g., day -> hour),
+ // but conversion where information is discarded must be explicit
+ // (e.g., second -> minute).
+ template <typename U, typename S>
+ using preserves_data =
+ typename std::enable_if<std::is_base_of<U, S>::value>::type;
+ template <typename U>
+ CONSTEXPR_M civil_time(const civil_time<U>& ct,
+ preserves_data<T, U>* = nullptr) noexcept
+ : civil_time(ct.f_) {}
+ template <typename U>
+ explicit CONSTEXPR_M civil_time(const civil_time<U>& ct,
+ preserves_data<U, T>* = nullptr) noexcept
+ : civil_time(ct.f_) {}
+
+ // Factories for the maximum/minimum representable civil_time.
+ static civil_time max() {
+ const auto max_year = std::numeric_limits<std::int_least64_t>::max();
+ return civil_time(max_year, 12, 31, 23, 59, 59);
+ }
+ static civil_time min() {
+ const auto min_year = std::numeric_limits<std::int_least64_t>::min();
+ return civil_time(min_year, 1, 1, 0, 0, 0);
+ }
+
+ // Field accessors. Note: All but year() return an int.
+ CONSTEXPR_M year_t year() const noexcept { return f_.y; }
+ CONSTEXPR_M int month() const noexcept { return f_.m; }
+ CONSTEXPR_M int day() const noexcept { return f_.d; }
+ CONSTEXPR_M int hour() const noexcept { return f_.hh; }
+ CONSTEXPR_M int minute() const noexcept { return f_.mm; }
+ CONSTEXPR_M int second() const noexcept { return f_.ss; }
+
+ // Assigning arithmetic.
+ CONSTEXPR_M civil_time& operator+=(diff_t n) noexcept {
+ f_ = step(T{}, f_, n);
+ return *this;
+ }
+ CONSTEXPR_M civil_time& operator-=(diff_t n) noexcept {
+ if (n != std::numeric_limits<diff_t>::min()) {
+ f_ = step(T{}, f_, -n);
+ } else {
+ f_ = step(T{}, step(T{}, f_, -(n + 1)), 1);
+ }
+ return *this;
+ }
+ CONSTEXPR_M civil_time& operator++() noexcept {
+ return *this += 1;
+ }
+ CONSTEXPR_M civil_time operator++(int) noexcept {
+ const civil_time a = *this;
+ ++*this;
+ return a;
+ }
+ CONSTEXPR_M civil_time& operator--() noexcept {
+ return *this -= 1;
+ }
+ CONSTEXPR_M civil_time operator--(int) noexcept {
+ const civil_time a = *this;
+ --*this;
+ return a;
+ }
+
+ // Binary arithmetic operators.
+ inline friend CONSTEXPR_M civil_time operator+(civil_time a,
+ diff_t n) noexcept {
+ return a += n;
+ }
+ inline friend CONSTEXPR_M civil_time operator+(diff_t n,
+ civil_time a) noexcept {
+ return a += n;
+ }
+ inline friend CONSTEXPR_M civil_time operator-(civil_time a,
+ diff_t n) noexcept {
+ return a -= n;
+ }
+ inline friend CONSTEXPR_M diff_t operator-(const civil_time& lhs,
+ const civil_time& rhs) noexcept {
+ return difference(T{}, lhs.f_, rhs.f_);
+ }
+
+ private:
+ // All instantiations of this template are allowed to call the following
+ // private constructor and access the private fields member.
+ template <typename U>
+ friend class civil_time;
+
+ // The designated constructor that all others eventually call.
+ explicit CONSTEXPR_M civil_time(fields f) noexcept : f_(align(T{}, f)) {}
+
+ fields f_;
+};
+
+// Disallows difference between differently aligned types.
+// auto n = civil_day(...) - civil_hour(...); // would be confusing.
+template <typename Tag1, typename Tag2>
+CONSTEXPR_F diff_t operator-(civil_time<Tag1>, civil_time<Tag2>) = delete;
+
+using civil_year = civil_time<year_tag>;
+using civil_month = civil_time<month_tag>;
+using civil_day = civil_time<day_tag>;
+using civil_hour = civil_time<hour_tag>;
+using civil_minute = civil_time<minute_tag>;
+using civil_second = civil_time<second_tag>;
+
+////////////////////////////////////////////////////////////////////////
+
+// Relational operators that work with differently aligned objects.
+// Always compares all six fields.
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator<(const civil_time<T1>& lhs,
+ const civil_time<T2>& rhs) noexcept {
+ return (lhs.year() < rhs.year() ||
+ (lhs.year() == rhs.year() &&
+ (lhs.month() < rhs.month() ||
+ (lhs.month() == rhs.month() &&
+ (lhs.day() < rhs.day() ||
+ (lhs.day() == rhs.day() &&
+ (lhs.hour() < rhs.hour() ||
+ (lhs.hour() == rhs.hour() &&
+ (lhs.minute() < rhs.minute() ||
+ (lhs.minute() == rhs.minute() &&
+ (lhs.second() < rhs.second())))))))))));
+}
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator<=(const civil_time<T1>& lhs,
+ const civil_time<T2>& rhs) noexcept {
+ return !(rhs < lhs);
+}
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator>=(const civil_time<T1>& lhs,
+ const civil_time<T2>& rhs) noexcept {
+ return !(lhs < rhs);
+}
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator>(const civil_time<T1>& lhs,
+ const civil_time<T2>& rhs) noexcept {
+ return rhs < lhs;
+}
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator==(const civil_time<T1>& lhs,
+ const civil_time<T2>& rhs) noexcept {
+ return lhs.year() == rhs.year() && lhs.month() == rhs.month() &&
+ lhs.day() == rhs.day() && lhs.hour() == rhs.hour() &&
+ lhs.minute() == rhs.minute() && lhs.second() == rhs.second();
+}
+template <typename T1, typename T2>
+CONSTEXPR_F bool operator!=(const civil_time<T1>& lhs,
+ const civil_time<T2>& rhs) noexcept {
+ return !(lhs == rhs);
+}
+
+////////////////////////////////////////////////////////////////////////
+
+enum class weekday {
+ monday,
+ tuesday,
+ wednesday,
+ thursday,
+ friday,
+ saturday,
+ sunday,
+};
+
+CONSTEXPR_F weekday get_weekday(const civil_day& cd) noexcept {
+ CONSTEXPR_D weekday k_weekday_by_sun_off[7] = {
+ weekday::sunday, weekday::monday, weekday::tuesday,
+ weekday::wednesday, weekday::thursday, weekday::friday,
+ weekday::saturday,
+ };
+ CONSTEXPR_D int k_weekday_offsets[1 + 12] = {
+ -1, 0, 3, 2, 5, 0, 3, 5, 1, 4, 6, 2, 4,
+ };
+ year_t wd = cd.year() - (cd.month() < 3);
+ if (wd >= 0) {
+ wd += wd / 4 - wd / 100 + wd / 400;
+ } else {
+ wd += (wd - 3) / 4 - (wd - 99) / 100 + (wd - 399) / 400;
+ }
+ wd += k_weekday_offsets[cd.month()] + cd.day();
+ return k_weekday_by_sun_off[(wd % 7 + 7) % 7];
+}
+
+////////////////////////////////////////////////////////////////////////
+
+CONSTEXPR_F civil_day next_weekday(civil_day cd, weekday wd) noexcept {
+ do { cd += 1; } while (get_weekday(cd) != wd);
+ return cd;
+}
+
+CONSTEXPR_F civil_day prev_weekday(civil_day cd, weekday wd) noexcept {
+ do { cd -= 1; } while (get_weekday(cd) != wd);
+ return cd;
+}
+
+CONSTEXPR_F int get_yearday(const civil_day& cd) noexcept {
+ CONSTEXPR_D int k_month_offsets[1 + 12] = {
+ -1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334,
+ };
+ const int feb29 = (cd.month() > 2 && impl::is_leap_year(cd.year()));
+ return k_month_offsets[cd.month()] + feb29 + cd.day();
+}
+
+////////////////////////////////////////////////////////////////////////
+
+std::ostream& operator<<(std::ostream& os, const civil_year& y);
+std::ostream& operator<<(std::ostream& os, const civil_month& m);
+std::ostream& operator<<(std::ostream& os, const civil_day& d);
+std::ostream& operator<<(std::ostream& os, const civil_hour& h);
+std::ostream& operator<<(std::ostream& os, const civil_minute& m);
+std::ostream& operator<<(std::ostream& os, const civil_second& s);
+std::ostream& operator<<(std::ostream& os, weekday wd);
+
+} // namespace detail
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+#undef CONSTEXPR_M
+#undef CONSTEXPR_F
+#undef CONSTEXPR_D
+
+#endif // ABSL_TIME_INTERNAL_CCTZ_CIVIL_TIME_DETAIL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/time_zone.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/time_zone.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/time_zone.h
new file mode 100644
index 0000000..31abc2c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/time_zone.h
@@ -0,0 +1,316 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// A library for translating between absolute times (represented by
+// std::chrono::time_points of the std::chrono::system_clock) and civil
+// times (represented by cctz::civil_second) using the rules defined by
+// a time zone (cctz::time_zone).
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
+
+#include <chrono>
+#include <cstdint>
+#include <string>
+#include <utility>
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// Convenience aliases. Not intended as public API points.
+template <typename D>
+using time_point = std::chrono::time_point<std::chrono::system_clock, D>;
+using sys_seconds = std::chrono::duration<std::int_fast64_t>;
+
+namespace detail {
+template <typename D>
+inline std::pair<time_point<sys_seconds>, D>
+split_seconds(const time_point<D>& tp) {
+ auto sec = std::chrono::time_point_cast<sys_seconds>(tp);
+ auto sub = tp - sec;
+ if (sub.count() < 0) {
+ sec -= sys_seconds(1);
+ sub += sys_seconds(1);
+ }
+ return {sec, std::chrono::duration_cast<D>(sub)};
+}
+inline std::pair<time_point<sys_seconds>, sys_seconds>
+split_seconds(const time_point<sys_seconds>& tp) {
+ return {tp, sys_seconds(0)};
+}
+} // namespace detail
+
+// cctz::time_zone is an opaque, small, value-type class representing a
+// geo-political region within which particular rules are used for mapping
+// between absolute and civil times. Time zones are named using the TZ
+// identifiers from the IANA Time Zone Database, such as "America/Los_Angeles"
+// or "Australia/Sydney". Time zones are created from factory functions such
+// as load_time_zone(). Note: strings like "PST" and "EDT" are not valid TZ
+// identifiers.
+//
+// Example:
+// cctz::time_zone utc = cctz::utc_time_zone();
+// cctz::time_zone pst = cctz::fixed_time_zone(std::chrono::hours(-8));
+// cctz::time_zone loc = cctz::local_time_zone();
+// cctz::time_zone lax;
+// if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
+//
+// See also:
+// - http://www.iana.org/time-zones
+// - http://en.wikipedia.org/wiki/Zoneinfo
+class time_zone {
+ public:
+ time_zone() : time_zone(nullptr) {} // Equivalent to UTC
+ time_zone(const time_zone&) = default;
+ time_zone& operator=(const time_zone&) = default;
+
+ std::string name() const;
+
+ // An absolute_lookup represents the civil time (cctz::civil_second) within
+ // this time_zone at the given absolute time (time_point). There are
+ // additionally a few other fields that may be useful when working with
+ // older APIs, such as std::tm.
+ //
+ // Example:
+ // const cctz::time_zone tz = ...
+ // const auto tp = std::chrono::system_clock::now();
+ // const cctz::time_zone::absolute_lookup al = tz.lookup(tp);
+ struct absolute_lookup {
+ civil_second cs;
+ // Note: The following fields exist for backward compatibility with older
+ // APIs. Accessing these fields directly is a sign of imprudent logic in
+ // the calling code. Modern time-related code should only access this data
+ // indirectly by way of cctz::format().
+ int offset; // civil seconds east of UTC
+ bool is_dst; // is offset non-standard?
+ const char* abbr; // time-zone abbreviation (e.g., "PST")
+ };
+ absolute_lookup lookup(const time_point<sys_seconds>& tp) const;
+ template <typename D>
+ absolute_lookup lookup(const time_point<D>& tp) const {
+ return lookup(detail::split_seconds(tp).first);
+ }
+
+ // A civil_lookup represents the absolute time(s) (time_point) that
+ // correspond to the given civil time (cctz::civil_second) within this
+ // time_zone. Usually the given civil time represents a unique instant
+ // in time, in which case the conversion is unambiguous. However,
+ // within this time zone, the given civil time may be skipped (e.g.,
+ // during a positive UTC offset shift), or repeated (e.g., during a
+ // negative UTC offset shift). To account for these possibilities,
+ // civil_lookup is richer than just a single time_point.
+ //
+ // In all cases the civil_lookup::kind enum will indicate the nature
+ // of the given civil-time argument, and the pre, trans, and post
+ // members will give the absolute time answers using the pre-transition
+ // offset, the transition point itself, and the post-transition offset,
+ // respectively (all three times are equal if kind == UNIQUE). If any
+ // of these three absolute times is outside the representable range of a
+ // time_point<sys_seconds> the field is set to its maximum/minimum value.
+ //
+ // Example:
+ // cctz::time_zone lax;
+ // if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
+ //
+ // // A unique civil time.
+ // auto jan01 = lax.lookup(cctz::civil_second(2011, 1, 1, 0, 0, 0));
+ // // jan01.kind == cctz::time_zone::civil_lookup::UNIQUE
+ // // jan01.pre is 2011/01/01 00:00:00 -0800
+ // // jan01.trans is 2011/01/01 00:00:00 -0800
+ // // jan01.post is 2011/01/01 00:00:00 -0800
+ //
+ // // A Spring DST transition, when there is a gap in civil time.
+ // auto mar13 = lax.lookup(cctz::civil_second(2011, 3, 13, 2, 15, 0));
+ // // mar13.kind == cctz::time_zone::civil_lookup::SKIPPED
+ // // mar13.pre is 2011/03/13 03:15:00 -0700
+ // // mar13.trans is 2011/03/13 03:00:00 -0700
+ // // mar13.post is 2011/03/13 01:15:00 -0800
+ //
+ // // A Fall DST transition, when civil times are repeated.
+ // auto nov06 = lax.lookup(cctz::civil_second(2011, 11, 6, 1, 15, 0));
+ // // nov06.kind == cctz::time_zone::civil_lookup::REPEATED
+ // // nov06.pre is 2011/11/06 01:15:00 -0700
+ // // nov06.trans is 2011/11/06 01:00:00 -0800
+ // // nov06.post is 2011/11/06 01:15:00 -0800
+ struct civil_lookup {
+ enum civil_kind {
+ UNIQUE, // the civil time was singular (pre == trans == post)
+ SKIPPED, // the civil time did not exist (pre >= trans > post)
+ REPEATED, // the civil time was ambiguous (pre < trans <= post)
+ } kind;
+ time_point<sys_seconds> pre; // uses the pre-transition offset
+ time_point<sys_seconds> trans; // instant of civil-offset change
+ time_point<sys_seconds> post; // uses the post-transition offset
+ };
+ civil_lookup lookup(const civil_second& cs) const;
+
+ class Impl;
+
+ private:
+ explicit time_zone(const Impl* impl) : impl_(impl) {}
+ const Impl* impl_;
+};
+
+// Relational operators.
+bool operator==(time_zone lhs, time_zone rhs);
+inline bool operator!=(time_zone lhs, time_zone rhs) { return !(lhs == rhs); }
+
+// Loads the named time zone. May perform I/O on the initial load.
+// If the name is invalid, or some other kind of error occurs, returns
+// false and "*tz" is set to the UTC time zone.
+bool load_time_zone(const std::string& name, time_zone* tz);
+
+// Returns a time_zone representing UTC. Cannot fail.
+time_zone utc_time_zone();
+
+// Returns a time zone that is a fixed offset (seconds east) from UTC.
+// Note: If the absolute value of the offset is greater than 24 hours
+// you'll get UTC (i.e., zero offset) instead.
+time_zone fixed_time_zone(const sys_seconds& offset);
+
+// Returns a time zone representing the local time zone. Falls back to UTC.
+time_zone local_time_zone();
+
+// Returns the civil time (cctz::civil_second) within the given time zone at
+// the given absolute time (time_point). Since the additional fields provided
+// by the time_zone::absolute_lookup struct should rarely be needed in modern
+// code, this convert() function is simpler and should be preferred.
+template <typename D>
+inline civil_second convert(const time_point<D>& tp, const time_zone& tz) {
+ return tz.lookup(tp).cs;
+}
+
+// Returns the absolute time (time_point) that corresponds to the given civil
+// time within the given time zone. If the civil time is not unique (i.e., if
+// it was either repeated or non-existent), then the returned time_point is
+// the best estimate that preserves relative order. That is, this function
+// guarantees that if cs1 < cs2, then convert(cs1, tz) <= convert(cs2, tz).
+inline time_point<sys_seconds> convert(const civil_second& cs,
+ const time_zone& tz) {
+ const time_zone::civil_lookup cl = tz.lookup(cs);
+ if (cl.kind == time_zone::civil_lookup::SKIPPED) return cl.trans;
+ return cl.pre;
+}
+
+namespace detail {
+using femtoseconds = std::chrono::duration<std::int_fast64_t, std::femto>;
+std::string format(const std::string&, const time_point<sys_seconds>&,
+ const femtoseconds&, const time_zone&);
+bool parse(const std::string&, const std::string&, const time_zone&,
+ time_point<sys_seconds>*, femtoseconds*, std::string* err = nullptr);
+} // namespace detail
+
+// Formats the given time_point in the given cctz::time_zone according to
+// the provided format std::string. Uses strftime()-like formatting options,
+// with the following extensions:
+//
+// - %Ez - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
+// - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
+// - %E#S - Seconds with # digits of fractional precision
+// - %E*S - Seconds with full fractional precision (a literal '*')
+// - %E#f - Fractional seconds with # digits of precision
+// - %E*f - Fractional seconds with full precision (a literal '*')
+// - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
+//
+// Note that %E0S behaves like %S, and %E0f produces no characters. In
+// contrast %E*f always produces at least one digit, which may be '0'.
+//
+// Note that %Y produces as many characters as it takes to fully render the
+// year. A year outside of [-999:9999] when formatted with %E4Y will produce
+// more than four characters, just like %Y.
+//
+// Tip: Format strings should include the UTC offset (e.g., %z, %Ez, or %E*z)
+// so that the resulting std::string uniquely identifies an absolute time.
+//
+// Example:
+// cctz::time_zone lax;
+// if (!cctz::load_time_zone("America/Los_Angeles", &lax)) { ... }
+// auto tp = cctz::convert(cctz::civil_second(2013, 1, 2, 3, 4, 5), lax);
+// std::string f = cctz::format("%H:%M:%S", tp, lax); // "03:04:05"
+// f = cctz::format("%H:%M:%E3S", tp, lax); // "03:04:05.000"
+template <typename D>
+inline std::string format(const std::string& fmt, const time_point<D>& tp,
+ const time_zone& tz) {
+ const auto p = detail::split_seconds(tp);
+ const auto n = std::chrono::duration_cast<detail::femtoseconds>(p.second);
+ return detail::format(fmt, p.first, n, tz);
+}
+
+// Parses an input std::string according to the provided format std::string and
+// returns the corresponding time_point. Uses strftime()-like formatting
+// options, with the same extensions as cctz::format(), but with the
+// exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f. %Ez
+// and %E*z also accept the same inputs.
+//
+// %Y consumes as many numeric characters as it can, so the matching data
+// should always be terminated with a non-numeric. %E4Y always consumes
+// exactly four characters, including any sign.
+//
+// Unspecified fields are taken from the default date and time of ...
+//
+// "1970-01-01 00:00:00.0 +0000"
+//
+// For example, parsing a std::string of "15:45" (%H:%M) will return a time_point
+// that represents "1970-01-01 15:45:00.0 +0000".
+//
+// Note that parse() returns time instants, so it makes most sense to parse
+// fully-specified date/time strings that include a UTC offset (%z, %Ez, or
+// %E*z).
+//
+// Note also that parse() only heeds the fields year, month, day, hour,
+// minute, (fractional) second, and UTC offset. Other fields, like weekday (%a
+// or %A), while parsed for syntactic validity, are ignored in the conversion.
+//
+// Date and time fields that are out-of-range will be treated as errors rather
+// than normalizing them like cctz::civil_second() would do. For example, it
+// is an error to parse the date "Oct 32, 2013" because 32 is out of range.
+//
+// A second of ":60" is normalized to ":00" of the following minute with
+// fractional seconds discarded. The following table shows how the given
+// seconds and subseconds will be parsed:
+//
+// "59.x" -> 59.x // exact
+// "60.x" -> 00.0 // normalized
+// "00.x" -> 00.x // exact
+//
+// Errors are indicated by returning false.
+//
+// Example:
+// const cctz::time_zone tz = ...
+// std::chrono::system_clock::time_point tp;
+// if (cctz::parse("%Y-%m-%d", "2015-10-09", tz, &tp)) {
+// ...
+// }
+template <typename D>
+inline bool parse(const std::string& fmt, const std::string& input,
+ const time_zone& tz, time_point<D>* tpp) {
+ time_point<sys_seconds> sec;
+ detail::femtoseconds fs;
+ const bool b = detail::parse(fmt, input, tz, &sec, &fs);
+ if (b) {
+ // TODO: Return false if unrepresentable as a time_point<D>.
+ *tpp = std::chrono::time_point_cast<D>(sec);
+ *tpp += std::chrono::duration_cast<D>(fs);
+ }
+ return b;
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+#endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/zone_info_source.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/zone_info_source.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/zone_info_source.h
new file mode 100644
index 0000000..4d9d8f8
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/include/cctz/zone_info_source.h
@@ -0,0 +1,91 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
+#define ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
+
+#include <cstddef>
+#include <functional>
+#include <memory>
+#include <string>
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// A stdio-like interface for providing zoneinfo data for a particular zone.
+class ZoneInfoSource {
+ public:
+ virtual ~ZoneInfoSource();
+
+ virtual std::size_t Read(void* ptr, std::size_t size) = 0; // like fread()
+ virtual int Skip(std::size_t offset) = 0; // like fseek()
+};
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+namespace absl {
+namespace time_internal {
+namespace cctz_extension {
+
+// A function-pointer type for a factory that returns a ZoneInfoSource
+// given the name of a time zone and a fallback factory. Returns null
+// when the data for the named zone cannot be found.
+using ZoneInfoSourceFactory =
+ std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource> (*)(
+ const std::string&,
+ const std::function<std::unique_ptr<absl::time_internal::cctz::ZoneInfoSource>(
+ const std::string&)>&);
+
+// The user can control the mapping of zone names to zoneinfo data by
+// providing a definition for cctz_extension::zone_info_source_factory.
+// For example, given functions my_factory() and my_other_factory() that
+// can return a ZoneInfoSource for a named zone, we could inject them into
+// cctz::load_time_zone() with:
+//
+// namespace cctz_extension {
+// namespace {
+// std::unique_ptr<cctz::ZoneInfoSource> CustomFactory(
+// const std::string& name,
+// const std::function<std::unique_ptr<cctz::ZoneInfoSource>(
+// const std::string& name)>& fallback_factory) {
+// if (auto zip = my_factory(name)) return zip;
+// if (auto zip = fallback_factory(name)) return zip;
+// if (auto zip = my_other_factory(name)) return zip;
+// return nullptr;
+// }
+// } // namespace
+// ZoneInfoSourceFactory zone_info_source_factory = CustomFactory;
+// } // namespace cctz_extension
+//
+// This might be used, say, to use zoneinfo data embedded in the program,
+// or read from a (possibly compressed) file archive, or both.
+//
+// cctz_extension::zone_info_source_factory() will be called:
+// (1) from the same thread as the cctz::load_time_zone() call,
+// (2) only once for any zone name, and
+// (3) serially (i.e., no concurrent execution).
+//
+// The fallback factory obtains zoneinfo data by reading files in ${TZDIR},
+// and it is used automatically when no zone_info_source_factory definition
+// is linked into the program.
+extern ZoneInfoSourceFactory zone_info_source_factory;
+
+} // namespace cctz_extension
+} // namespace time_internal
+} // namespace absl
+
+#endif // ABSL_TIME_INTERNAL_CCTZ_ZONE_INFO_SOURCE_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/civil_time_detail.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/civil_time_detail.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/civil_time_detail.cc
new file mode 100644
index 0000000..780d5c9
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/civil_time_detail.cc
@@ -0,0 +1,90 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/internal/cctz/include/cctz/civil_time_detail.h"
+
+#include <iomanip>
+#include <ostream>
+#include <sstream>
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+namespace detail {
+
+// Output stream operators output a format matching YYYY-MM-DDThh:mm:ss,
+// while omitting fields inferior to the type's alignment. For example,
+// civil_day is formatted only as YYYY-MM-DD.
+std::ostream& operator<<(std::ostream& os, const civil_year& y) {
+ std::stringstream ss;
+ ss << y.year(); // No padding.
+ return os << ss.str();
+}
+std::ostream& operator<<(std::ostream& os, const civil_month& m) {
+ std::stringstream ss;
+ ss << civil_year(m) << '-';
+ ss << std::setfill('0') << std::setw(2) << m.month();
+ return os << ss.str();
+}
+std::ostream& operator<<(std::ostream& os, const civil_day& d) {
+ std::stringstream ss;
+ ss << civil_month(d) << '-';
+ ss << std::setfill('0') << std::setw(2) << d.day();
+ return os << ss.str();
+}
+std::ostream& operator<<(std::ostream& os, const civil_hour& h) {
+ std::stringstream ss;
+ ss << civil_day(h) << 'T';
+ ss << std::setfill('0') << std::setw(2) << h.hour();
+ return os << ss.str();
+}
+std::ostream& operator<<(std::ostream& os, const civil_minute& m) {
+ std::stringstream ss;
+ ss << civil_hour(m) << ':';
+ ss << std::setfill('0') << std::setw(2) << m.minute();
+ return os << ss.str();
+}
+std::ostream& operator<<(std::ostream& os, const civil_second& s) {
+ std::stringstream ss;
+ ss << civil_minute(s) << ':';
+ ss << std::setfill('0') << std::setw(2) << s.second();
+ return os << ss.str();
+}
+
+////////////////////////////////////////////////////////////////////////
+
+std::ostream& operator<<(std::ostream& os, weekday wd) {
+ switch (wd) {
+ case weekday::monday:
+ return os << "Monday";
+ case weekday::tuesday:
+ return os << "Tuesday";
+ case weekday::wednesday:
+ return os << "Wednesday";
+ case weekday::thursday:
+ return os << "Thursday";
+ case weekday::friday:
+ return os << "Friday";
+ case weekday::saturday:
+ return os << "Saturday";
+ case weekday::sunday:
+ return os << "Sunday";
+ }
+ return os; // Should never get here, but -Wreturn-type may warn without this.
+}
+
+} // namespace detail
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
[27/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split_test.cc
new file mode 100644
index 0000000..c172a76
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_split_test.cc
@@ -0,0 +1,907 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/str_split.h"
+
+#include <deque>
+#include <initializer_list>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <unordered_map>
+#include <unordered_set>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/dynamic_annotations.h" // for RunningOnValgrind
+#include "absl/base/macros.h"
+#include "absl/strings/numbers.h"
+
+namespace {
+
+using ::testing::ElementsAre;
+using ::testing::Pair;
+using ::testing::UnorderedElementsAre;
+
+// This tests the overall split API, which is made up of the absl::StrSplit()
+// function and the Delimiter objects in the absl:: namespace.
+// This TEST macro is outside of any namespace to require full specification of
+// namespaces just like callers will need to use.
+TEST(Split, APIExamples) {
+ {
+ // Passes std::string delimiter. Assumes the default of Literal.
+ std::vector<std::string> v = absl::StrSplit("a,b,c", ',');
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+
+ // Equivalent to...
+ using absl::ByString;
+ v = absl::StrSplit("a,b,c", ByString(","));
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+
+ // Equivalent to...
+ EXPECT_THAT(absl::StrSplit("a,b,c", ByString(",")),
+ ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Same as above, but using a single character as the delimiter.
+ std::vector<std::string> v = absl::StrSplit("a,b,c", ',');
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+
+ // Equivalent to...
+ using absl::ByChar;
+ v = absl::StrSplit("a,b,c", ByChar(','));
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Same as above, but using std::string
+ std::vector<std::string> v = absl::StrSplit("a,b,c", ',');
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+
+ // Equivalent to...
+ using absl::ByChar;
+ v = absl::StrSplit("a,b,c", ByChar(','));
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Uses the Literal std::string "=>" as the delimiter.
+ const std::vector<std::string> v = absl::StrSplit("a=>b=>c", "=>");
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // The substrings are returned as string_views, eliminating copying.
+ std::vector<absl::string_view> v = absl::StrSplit("a,b,c", ',');
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Leading and trailing empty substrings.
+ std::vector<std::string> v = absl::StrSplit(",a,b,c,", ',');
+ EXPECT_THAT(v, ElementsAre("", "a", "b", "c", ""));
+ }
+
+ {
+ // Splits on a delimiter that is not found.
+ std::vector<std::string> v = absl::StrSplit("abc", ',');
+ EXPECT_THAT(v, ElementsAre("abc"));
+ }
+
+ {
+ // Splits the input std::string into individual characters by using an empty
+ // std::string as the delimiter.
+ std::vector<std::string> v = absl::StrSplit("abc", "");
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Splits std::string data with embedded NUL characters, using NUL as the
+ // delimiter. A simple delimiter of "\0" doesn't work because strlen() will
+ // say that's the empty std::string when constructing the absl::string_view
+ // delimiter. Instead, a non-empty std::string containing NUL can be used as the
+ // delimiter.
+ std::string embedded_nulls("a\0b\0c", 5);
+ std::string null_delim("\0", 1);
+ std::vector<std::string> v = absl::StrSplit(embedded_nulls, null_delim);
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Stores first two split strings as the members in a std::pair.
+ std::pair<std::string, std::string> p = absl::StrSplit("a,b,c", ',');
+ EXPECT_EQ("a", p.first);
+ EXPECT_EQ("b", p.second);
+ // "c" is omitted because std::pair can hold only two elements.
+ }
+
+ {
+ // Results stored in std::set<std::string>
+ std::set<std::string> v = absl::StrSplit("a,b,c,a,b,c,a,b,c", ',');
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Uses a non-const char* delimiter.
+ char a[] = ",";
+ char* d = a + 0;
+ std::vector<std::string> v = absl::StrSplit("a,b,c", d);
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Results split using either of , or ;
+ using absl::ByAnyChar;
+ std::vector<std::string> v = absl::StrSplit("a,b;c", ByAnyChar(",;"));
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Uses the SkipWhitespace predicate.
+ using absl::SkipWhitespace;
+ std::vector<std::string> v = absl::StrSplit(" a , ,,b,", ',', SkipWhitespace());
+ EXPECT_THAT(v, ElementsAre(" a ", "b"));
+ }
+
+ {
+ // Uses the ByLength delimiter.
+ using absl::ByLength;
+ std::vector<std::string> v = absl::StrSplit("abcdefg", ByLength(3));
+ EXPECT_THAT(v, ElementsAre("abc", "def", "g"));
+ }
+
+ {
+ // Different forms of initialization / conversion.
+ std::vector<std::string> v1 = absl::StrSplit("a,b,c", ',');
+ EXPECT_THAT(v1, ElementsAre("a", "b", "c"));
+ std::vector<std::string> v2(absl::StrSplit("a,b,c", ','));
+ EXPECT_THAT(v2, ElementsAre("a", "b", "c"));
+ auto v3 = std::vector<std::string>(absl::StrSplit("a,b,c", ','));
+ EXPECT_THAT(v3, ElementsAre("a", "b", "c"));
+ v3 = absl::StrSplit("a,b,c", ',');
+ EXPECT_THAT(v3, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Results stored in a std::map.
+ std::map<std::string, std::string> m = absl::StrSplit("a,1,b,2,a,3", ',');
+ EXPECT_EQ(2, m.size());
+ EXPECT_EQ("3", m["a"]);
+ EXPECT_EQ("2", m["b"]);
+ }
+
+ {
+ // Results stored in a std::multimap.
+ std::multimap<std::string, std::string> m = absl::StrSplit("a,1,b,2,a,3", ',');
+ EXPECT_EQ(3, m.size());
+ auto it = m.find("a");
+ EXPECT_EQ("1", it->second);
+ ++it;
+ EXPECT_EQ("3", it->second);
+ it = m.find("b");
+ EXPECT_EQ("2", it->second);
+ }
+
+ {
+ // Demonstrates use in a range-based for loop in C++11.
+ std::string s = "x,x,x,x,x,x,x";
+ for (absl::string_view sp : absl::StrSplit(s, ',')) {
+ EXPECT_EQ("x", sp);
+ }
+ }
+
+ {
+ // Demonstrates use with a Predicate in a range-based for loop.
+ using absl::SkipWhitespace;
+ std::string s = " ,x,,x,,x,x,x,,";
+ for (absl::string_view sp : absl::StrSplit(s, ',', SkipWhitespace())) {
+ EXPECT_EQ("x", sp);
+ }
+ }
+
+ {
+ // Demonstrates a "smart" split to std::map using two separate calls to
+ // absl::StrSplit. One call to split the records, and another call to split
+ // the keys and values. This also uses the Limit delimiter so that the
+ // std::string "a=b=c" will split to "a" -> "b=c".
+ std::map<std::string, std::string> m;
+ for (absl::string_view sp : absl::StrSplit("a=b=c,d=e,f=,g", ',')) {
+ m.insert(absl::StrSplit(sp, absl::MaxSplits('=', 1)));
+ }
+ EXPECT_EQ("b=c", m.find("a")->second);
+ EXPECT_EQ("e", m.find("d")->second);
+ EXPECT_EQ("", m.find("f")->second);
+ EXPECT_EQ("", m.find("g")->second);
+ }
+}
+
+//
+// Tests for SplitIterator
+//
+
+TEST(SplitIterator, Basics) {
+ auto splitter = absl::StrSplit("a,b", ',');
+ auto it = splitter.begin();
+ auto end = splitter.end();
+
+ EXPECT_NE(it, end);
+ EXPECT_EQ("a", *it); // tests dereference
+ ++it; // tests preincrement
+ EXPECT_NE(it, end);
+ EXPECT_EQ("b", std::string(it->data(), it->size())); // tests dereference as ptr
+ it++; // tests postincrement
+ EXPECT_EQ(it, end);
+}
+
+// Simple Predicate to skip a particular std::string.
+class Skip {
+ public:
+ explicit Skip(const std::string& s) : s_(s) {}
+ bool operator()(absl::string_view sp) { return sp != s_; }
+
+ private:
+ std::string s_;
+};
+
+TEST(SplitIterator, Predicate) {
+ auto splitter = absl::StrSplit("a,b,c", ',', Skip("b"));
+ auto it = splitter.begin();
+ auto end = splitter.end();
+
+ EXPECT_NE(it, end);
+ EXPECT_EQ("a", *it); // tests dereference
+ ++it; // tests preincrement -- "b" should be skipped here.
+ EXPECT_NE(it, end);
+ EXPECT_EQ("c", std::string(it->data(), it->size())); // tests dereference as ptr
+ it++; // tests postincrement
+ EXPECT_EQ(it, end);
+}
+
+TEST(SplitIterator, EdgeCases) {
+ // Expected input and output, assuming a delimiter of ','
+ struct {
+ std::string in;
+ std::vector<std::string> expect;
+ } specs[] = {
+ {"", {""}},
+ {"foo", {"foo"}},
+ {",", {"", ""}},
+ {",foo", {"", "foo"}},
+ {"foo,", {"foo", ""}},
+ {",foo,", {"", "foo", ""}},
+ {"foo,bar", {"foo", "bar"}},
+ };
+
+ for (const auto& spec : specs) {
+ SCOPED_TRACE(spec.in);
+ auto splitter = absl::StrSplit(spec.in, ',');
+ auto it = splitter.begin();
+ auto end = splitter.end();
+ for (const auto& expected : spec.expect) {
+ EXPECT_NE(it, end);
+ EXPECT_EQ(expected, *it++);
+ }
+ EXPECT_EQ(it, end);
+ }
+}
+
+TEST(Splitter, Const) {
+ const auto splitter = absl::StrSplit("a,b,c", ',');
+ EXPECT_THAT(splitter, ElementsAre("a", "b", "c"));
+}
+
+TEST(Split, EmptyAndNull) {
+ // Attention: Splitting a null absl::string_view is different than splitting
+ // an empty absl::string_view even though both string_views are considered
+ // equal. This behavior is likely surprising and undesirable. However, to
+ // maintain backward compatibility, there is a small "hack" in
+ // str_split_internal.h that preserves this behavior. If that behavior is ever
+ // changed/fixed, this test will need to be updated.
+ EXPECT_THAT(absl::StrSplit(absl::string_view(""), '-'), ElementsAre(""));
+ EXPECT_THAT(absl::StrSplit(absl::string_view(), '-'), ElementsAre());
+}
+
+TEST(SplitIterator, EqualityAsEndCondition) {
+ auto splitter = absl::StrSplit("a,b,c", ',');
+ auto it = splitter.begin();
+ auto it2 = it;
+
+ // Increments it2 twice to point to "c" in the input text.
+ ++it2;
+ ++it2;
+ EXPECT_EQ("c", *it2);
+
+ // This test uses a non-end SplitIterator as the terminating condition in a
+ // for loop. This relies on SplitIterator equality for non-end SplitIterators
+ // working correctly. At this point it2 points to "c", and we use that as the
+ // "end" condition in this test.
+ std::vector<absl::string_view> v;
+ for (; it != it2; ++it) {
+ v.push_back(*it);
+ }
+ EXPECT_THAT(v, ElementsAre("a", "b"));
+}
+
+//
+// Tests for Splitter
+//
+
+TEST(Splitter, RangeIterators) {
+ auto splitter = absl::StrSplit("a,b,c", ',');
+ std::vector<absl::string_view> output;
+ for (const absl::string_view p : splitter) {
+ output.push_back(p);
+ }
+ EXPECT_THAT(output, ElementsAre("a", "b", "c"));
+}
+
+// Some template functions for use in testing conversion operators
+template <typename ContainerType, typename Splitter>
+void TestConversionOperator(const Splitter& splitter) {
+ ContainerType output = splitter;
+ EXPECT_THAT(output, UnorderedElementsAre("a", "b", "c", "d"));
+}
+
+template <typename MapType, typename Splitter>
+void TestMapConversionOperator(const Splitter& splitter) {
+ MapType m = splitter;
+ EXPECT_THAT(m, UnorderedElementsAre(Pair("a", "b"), Pair("c", "d")));
+}
+
+template <typename FirstType, typename SecondType, typename Splitter>
+void TestPairConversionOperator(const Splitter& splitter) {
+ std::pair<FirstType, SecondType> p = splitter;
+ EXPECT_EQ(p, (std::pair<FirstType, SecondType>("a", "b")));
+}
+
+TEST(Splitter, ConversionOperator) {
+ auto splitter = absl::StrSplit("a,b,c,d", ',');
+
+ TestConversionOperator<std::vector<absl::string_view>>(splitter);
+ TestConversionOperator<std::vector<std::string>>(splitter);
+ TestConversionOperator<std::list<absl::string_view>>(splitter);
+ TestConversionOperator<std::list<std::string>>(splitter);
+ TestConversionOperator<std::deque<absl::string_view>>(splitter);
+ TestConversionOperator<std::deque<std::string>>(splitter);
+ TestConversionOperator<std::set<absl::string_view>>(splitter);
+ TestConversionOperator<std::set<std::string>>(splitter);
+ TestConversionOperator<std::multiset<absl::string_view>>(splitter);
+ TestConversionOperator<std::multiset<std::string>>(splitter);
+ TestConversionOperator<std::unordered_set<std::string>>(splitter);
+
+ // Tests conversion to map-like objects.
+
+ TestMapConversionOperator<std::map<absl::string_view, absl::string_view>>(
+ splitter);
+ TestMapConversionOperator<std::map<absl::string_view, std::string>>(splitter);
+ TestMapConversionOperator<std::map<std::string, absl::string_view>>(splitter);
+ TestMapConversionOperator<std::map<std::string, std::string>>(splitter);
+ TestMapConversionOperator<
+ std::multimap<absl::string_view, absl::string_view>>(splitter);
+ TestMapConversionOperator<std::multimap<absl::string_view, std::string>>(splitter);
+ TestMapConversionOperator<std::multimap<std::string, absl::string_view>>(splitter);
+ TestMapConversionOperator<std::multimap<std::string, std::string>>(splitter);
+ TestMapConversionOperator<std::unordered_map<std::string, std::string>>(splitter);
+
+ // Tests conversion to std::pair
+
+ TestPairConversionOperator<absl::string_view, absl::string_view>(splitter);
+ TestPairConversionOperator<absl::string_view, std::string>(splitter);
+ TestPairConversionOperator<std::string, absl::string_view>(splitter);
+ TestPairConversionOperator<std::string, std::string>(splitter);
+}
+
+// A few additional tests for conversion to std::pair. This conversion is
+// different from others because a std::pair always has exactly two elements:
+// .first and .second. The split has to work even when the split has
+// less-than, equal-to, and more-than 2 strings.
+TEST(Splitter, ToPair) {
+ {
+ // Empty std::string
+ std::pair<std::string, std::string> p = absl::StrSplit("", ',');
+ EXPECT_EQ("", p.first);
+ EXPECT_EQ("", p.second);
+ }
+
+ {
+ // Only first
+ std::pair<std::string, std::string> p = absl::StrSplit("a", ',');
+ EXPECT_EQ("a", p.first);
+ EXPECT_EQ("", p.second);
+ }
+
+ {
+ // Only second
+ std::pair<std::string, std::string> p = absl::StrSplit(",b", ',');
+ EXPECT_EQ("", p.first);
+ EXPECT_EQ("b", p.second);
+ }
+
+ {
+ // First and second.
+ std::pair<std::string, std::string> p = absl::StrSplit("a,b", ',');
+ EXPECT_EQ("a", p.first);
+ EXPECT_EQ("b", p.second);
+ }
+
+ {
+ // First and second and then more stuff that will be ignored.
+ std::pair<std::string, std::string> p = absl::StrSplit("a,b,c", ',');
+ EXPECT_EQ("a", p.first);
+ EXPECT_EQ("b", p.second);
+ // "c" is omitted.
+ }
+}
+
+TEST(Splitter, Predicates) {
+ static const char kTestChars[] = ",a, ,b,";
+ using absl::AllowEmpty;
+ using absl::SkipEmpty;
+ using absl::SkipWhitespace;
+
+ {
+ // No predicate. Does not skip empties.
+ auto splitter = absl::StrSplit(kTestChars, ',');
+ std::vector<std::string> v = splitter;
+ EXPECT_THAT(v, ElementsAre("", "a", " ", "b", ""));
+ }
+
+ {
+ // Allows empty strings. Same behavior as no predicate at all.
+ auto splitter = absl::StrSplit(kTestChars, ',', AllowEmpty());
+ std::vector<std::string> v_allowempty = splitter;
+ EXPECT_THAT(v_allowempty, ElementsAre("", "a", " ", "b", ""));
+
+ // Ensures AllowEmpty equals the behavior with no predicate.
+ auto splitter_nopredicate = absl::StrSplit(kTestChars, ',');
+ std::vector<std::string> v_nopredicate = splitter_nopredicate;
+ EXPECT_EQ(v_allowempty, v_nopredicate);
+ }
+
+ {
+ // Skips empty strings.
+ auto splitter = absl::StrSplit(kTestChars, ',', SkipEmpty());
+ std::vector<std::string> v = splitter;
+ EXPECT_THAT(v, ElementsAre("a", " ", "b"));
+ }
+
+ {
+ // Skips empty and all-whitespace strings.
+ auto splitter = absl::StrSplit(kTestChars, ',', SkipWhitespace());
+ std::vector<std::string> v = splitter;
+ EXPECT_THAT(v, ElementsAre("a", "b"));
+ }
+}
+
+//
+// Tests for StrSplit()
+//
+
+TEST(Split, Basics) {
+ {
+ // Doesn't really do anything useful because the return value is ignored,
+ // but it should work.
+ absl::StrSplit("a,b,c", ',');
+ }
+
+ {
+ std::vector<absl::string_view> v = absl::StrSplit("a,b,c", ',');
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ std::vector<std::string> v = absl::StrSplit("a,b,c", ',');
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ }
+
+ {
+ // Ensures that assignment works. This requires a little extra work with
+ // C++11 because of overloads with initializer_list.
+ std::vector<std::string> v;
+ v = absl::StrSplit("a,b,c", ',');
+
+ EXPECT_THAT(v, ElementsAre("a", "b", "c"));
+ std::map<std::string, std::string> m;
+ m = absl::StrSplit("a,b,c", ',');
+ EXPECT_EQ(2, m.size());
+ std::unordered_map<std::string, std::string> hm;
+ hm = absl::StrSplit("a,b,c", ',');
+ EXPECT_EQ(2, hm.size());
+ }
+}
+
+absl::string_view ReturnStringView() { return "Hello World"; }
+const char* ReturnConstCharP() { return "Hello World"; }
+char* ReturnCharP() { return const_cast<char*>("Hello World"); }
+
+TEST(Split, AcceptsCertainTemporaries) {
+ std::vector<std::string> v;
+ v = absl::StrSplit(ReturnStringView(), ' ');
+ EXPECT_THAT(v, ElementsAre("Hello", "World"));
+ v = absl::StrSplit(ReturnConstCharP(), ' ');
+ EXPECT_THAT(v, ElementsAre("Hello", "World"));
+ v = absl::StrSplit(ReturnCharP(), ' ');
+ EXPECT_THAT(v, ElementsAre("Hello", "World"));
+}
+
+TEST(Split, Temporary) {
+ // Use a std::string longer than the small-std::string-optimization length, so that when
+ // the temporary is destroyed, if the splitter keeps a reference to the
+ // std::string's contents, it'll reference freed memory instead of just dead
+ // on-stack memory.
+ const char input[] = "a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u";
+ EXPECT_LT(sizeof(std::string), ABSL_ARRAYSIZE(input))
+ << "Input should be larger than fits on the stack.";
+
+ // This happens more often in C++11 as part of a range-based for loop.
+ auto splitter = absl::StrSplit(std::string(input), ',');
+ std::string expected = "a";
+ for (absl::string_view letter : splitter) {
+ EXPECT_EQ(expected, letter);
+ ++expected[0];
+ }
+ EXPECT_EQ("v", expected);
+
+ // This happens more often in C++11 as part of a range-based for loop.
+ auto std_splitter = absl::StrSplit(std::string(input), ',');
+ expected = "a";
+ for (absl::string_view letter : std_splitter) {
+ EXPECT_EQ(expected, letter);
+ ++expected[0];
+ }
+ EXPECT_EQ("v", expected);
+}
+
+template <typename T>
+static std::unique_ptr<T> CopyToHeap(const T& value) {
+ return std::unique_ptr<T>(new T(value));
+}
+
+TEST(Split, LvalueCaptureIsCopyable) {
+ std::string input = "a,b";
+ auto heap_splitter = CopyToHeap(absl::StrSplit(input, ','));
+ auto stack_splitter = *heap_splitter;
+ heap_splitter.reset();
+ std::vector<std::string> result = stack_splitter;
+ EXPECT_THAT(result, testing::ElementsAre("a", "b"));
+}
+
+TEST(Split, TemporaryCaptureIsCopyable) {
+ auto heap_splitter = CopyToHeap(absl::StrSplit(std::string("a,b"), ','));
+ auto stack_splitter = *heap_splitter;
+ heap_splitter.reset();
+ std::vector<std::string> result = stack_splitter;
+ EXPECT_THAT(result, testing::ElementsAre("a", "b"));
+}
+
+TEST(Split, SplitterIsCopyableAndMoveable) {
+ auto a = absl::StrSplit("foo", '-');
+
+ // Ensures that the following expressions compile.
+ auto b = a; // Copy construct
+ auto c = std::move(a); // Move construct
+ b = c; // Copy assign
+ c = std::move(b); // Move assign
+
+ EXPECT_THAT(c, ElementsAre("foo"));
+}
+
+TEST(Split, StringDelimiter) {
+ {
+ std::vector<absl::string_view> v = absl::StrSplit("a,b", ',');
+ EXPECT_THAT(v, ElementsAre("a", "b"));
+ }
+
+ {
+ std::vector<absl::string_view> v = absl::StrSplit("a,b", std::string(","));
+ EXPECT_THAT(v, ElementsAre("a", "b"));
+ }
+
+ {
+ std::vector<absl::string_view> v =
+ absl::StrSplit("a,b", absl::string_view(","));
+ EXPECT_THAT(v, ElementsAre("a", "b"));
+ }
+}
+
+TEST(Split, UTF8) {
+ // Tests splitting utf8 strings and utf8 delimiters.
+ std::string utf8_string = u8"\u03BA\u1F79\u03C3\u03BC\u03B5";
+ {
+ // A utf8 input std::string with an ascii delimiter.
+ std::string to_split = "a," + utf8_string;
+ std::vector<absl::string_view> v = absl::StrSplit(to_split, ',');
+ EXPECT_THAT(v, ElementsAre("a", utf8_string));
+ }
+
+ {
+ // A utf8 input std::string and a utf8 delimiter.
+ std::string to_split = "a," + utf8_string + ",b";
+ std::string unicode_delimiter = "," + utf8_string + ",";
+ std::vector<absl::string_view> v =
+ absl::StrSplit(to_split, unicode_delimiter);
+ EXPECT_THAT(v, ElementsAre("a", "b"));
+ }
+
+ {
+ // A utf8 input std::string and ByAnyChar with ascii chars.
+ std::vector<absl::string_view> v =
+ absl::StrSplit(u8"Foo h\u00E4llo th\u4E1Ere", absl::ByAnyChar(" \t"));
+ EXPECT_THAT(v, ElementsAre("Foo", u8"h\u00E4llo", u8"th\u4E1Ere"));
+ }
+}
+
+TEST(Split, EmptyStringDelimiter) {
+ {
+ std::vector<std::string> v = absl::StrSplit("", "");
+ EXPECT_THAT(v, ElementsAre(""));
+ }
+
+ {
+ std::vector<std::string> v = absl::StrSplit("a", "");
+ EXPECT_THAT(v, ElementsAre("a"));
+ }
+
+ {
+ std::vector<std::string> v = absl::StrSplit("ab", "");
+ EXPECT_THAT(v, ElementsAre("a", "b"));
+ }
+
+ {
+ std::vector<std::string> v = absl::StrSplit("a b", "");
+ EXPECT_THAT(v, ElementsAre("a", " ", "b"));
+ }
+}
+
+TEST(Split, SubstrDelimiter) {
+ std::vector<absl::string_view> results;
+ absl::string_view delim("//");
+
+ results = absl::StrSplit("", delim);
+ EXPECT_THAT(results, ElementsAre(""));
+
+ results = absl::StrSplit("//", delim);
+ EXPECT_THAT(results, ElementsAre("", ""));
+
+ results = absl::StrSplit("ab", delim);
+ EXPECT_THAT(results, ElementsAre("ab"));
+
+ results = absl::StrSplit("ab//", delim);
+ EXPECT_THAT(results, ElementsAre("ab", ""));
+
+ results = absl::StrSplit("ab/", delim);
+ EXPECT_THAT(results, ElementsAre("ab/"));
+
+ results = absl::StrSplit("a/b", delim);
+ EXPECT_THAT(results, ElementsAre("a/b"));
+
+ results = absl::StrSplit("a//b", delim);
+ EXPECT_THAT(results, ElementsAre("a", "b"));
+
+ results = absl::StrSplit("a///b", delim);
+ EXPECT_THAT(results, ElementsAre("a", "/b"));
+
+ results = absl::StrSplit("a////b", delim);
+ EXPECT_THAT(results, ElementsAre("a", "", "b"));
+}
+
+TEST(Split, EmptyResults) {
+ std::vector<absl::string_view> results;
+
+ results = absl::StrSplit("", '#');
+ EXPECT_THAT(results, ElementsAre(""));
+
+ results = absl::StrSplit("#", '#');
+ EXPECT_THAT(results, ElementsAre("", ""));
+
+ results = absl::StrSplit("#cd", '#');
+ EXPECT_THAT(results, ElementsAre("", "cd"));
+
+ results = absl::StrSplit("ab#cd#", '#');
+ EXPECT_THAT(results, ElementsAre("ab", "cd", ""));
+
+ results = absl::StrSplit("ab##cd", '#');
+ EXPECT_THAT(results, ElementsAre("ab", "", "cd"));
+
+ results = absl::StrSplit("ab##", '#');
+ EXPECT_THAT(results, ElementsAre("ab", "", ""));
+
+ results = absl::StrSplit("ab#ab#", '#');
+ EXPECT_THAT(results, ElementsAre("ab", "ab", ""));
+
+ results = absl::StrSplit("aaaa", 'a');
+ EXPECT_THAT(results, ElementsAre("", "", "", "", ""));
+
+ results = absl::StrSplit("", '#', absl::SkipEmpty());
+ EXPECT_THAT(results, ElementsAre());
+}
+
+template <typename Delimiter>
+static bool IsFoundAtStartingPos(absl::string_view text, Delimiter d,
+ size_t starting_pos, int expected_pos) {
+ absl::string_view found = d.Find(text, starting_pos);
+ return found.data() != text.end() &&
+ expected_pos == found.data() - text.data();
+}
+
+// Helper function for testing Delimiter objects. Returns true if the given
+// Delimiter is found in the given std::string at the given position. This function
+// tests two cases:
+// 1. The actual text given, staring at position 0
+// 2. The text given with leading padding that should be ignored
+template <typename Delimiter>
+static bool IsFoundAt(absl::string_view text, Delimiter d, int expected_pos) {
+ const std::string leading_text = ",x,y,z,";
+ return IsFoundAtStartingPos(text, d, 0, expected_pos) &&
+ IsFoundAtStartingPos(leading_text + std::string(text), d,
+ leading_text.length(),
+ expected_pos + leading_text.length());
+}
+
+//
+// Tests for Literal
+//
+
+// Tests using any delimiter that represents a single comma.
+template <typename Delimiter>
+void TestComma(Delimiter d) {
+ EXPECT_TRUE(IsFoundAt(",", d, 0));
+ EXPECT_TRUE(IsFoundAt("a,", d, 1));
+ EXPECT_TRUE(IsFoundAt(",b", d, 0));
+ EXPECT_TRUE(IsFoundAt("a,b", d, 1));
+ EXPECT_TRUE(IsFoundAt("a,b,", d, 1));
+ EXPECT_TRUE(IsFoundAt("a,b,c", d, 1));
+ EXPECT_FALSE(IsFoundAt("", d, -1));
+ EXPECT_FALSE(IsFoundAt(" ", d, -1));
+ EXPECT_FALSE(IsFoundAt("a", d, -1));
+ EXPECT_FALSE(IsFoundAt("a b c", d, -1));
+ EXPECT_FALSE(IsFoundAt("a;b;c", d, -1));
+ EXPECT_FALSE(IsFoundAt(";", d, -1));
+}
+
+TEST(Delimiter, Literal) {
+ using absl::ByString;
+ TestComma(ByString(","));
+
+ // Works as named variable.
+ ByString comma_string(",");
+ TestComma(comma_string);
+
+ // The first occurrence of empty std::string ("") in a std::string is at position 0.
+ // There is a test below that demonstrates this for absl::string_view::find().
+ // If the ByString delimiter returned position 0 for this, there would
+ // be an infinite loop in the SplitIterator code. To avoid this, empty std::string
+ // is a special case in that it always returns the item at position 1.
+ absl::string_view abc("abc");
+ EXPECT_EQ(0, abc.find("")); // "" is found at position 0
+ ByString empty("");
+ EXPECT_FALSE(IsFoundAt("", empty, 0));
+ EXPECT_FALSE(IsFoundAt("a", empty, 0));
+ EXPECT_TRUE(IsFoundAt("ab", empty, 1));
+ EXPECT_TRUE(IsFoundAt("abc", empty, 1));
+}
+
+TEST(Split, ByChar) {
+ using absl::ByChar;
+ TestComma(ByChar(','));
+
+ // Works as named variable.
+ ByChar comma_char(',');
+ TestComma(comma_char);
+}
+
+//
+// Tests for ByAnyChar
+//
+
+TEST(Delimiter, ByAnyChar) {
+ using absl::ByAnyChar;
+ ByAnyChar one_delim(",");
+ // Found
+ EXPECT_TRUE(IsFoundAt(",", one_delim, 0));
+ EXPECT_TRUE(IsFoundAt("a,", one_delim, 1));
+ EXPECT_TRUE(IsFoundAt("a,b", one_delim, 1));
+ EXPECT_TRUE(IsFoundAt(",b", one_delim, 0));
+ // Not found
+ EXPECT_FALSE(IsFoundAt("", one_delim, -1));
+ EXPECT_FALSE(IsFoundAt(" ", one_delim, -1));
+ EXPECT_FALSE(IsFoundAt("a", one_delim, -1));
+ EXPECT_FALSE(IsFoundAt("a;b;c", one_delim, -1));
+ EXPECT_FALSE(IsFoundAt(";", one_delim, -1));
+
+ ByAnyChar two_delims(",;");
+ // Found
+ EXPECT_TRUE(IsFoundAt(",", two_delims, 0));
+ EXPECT_TRUE(IsFoundAt(";", two_delims, 0));
+ EXPECT_TRUE(IsFoundAt(",;", two_delims, 0));
+ EXPECT_TRUE(IsFoundAt(";,", two_delims, 0));
+ EXPECT_TRUE(IsFoundAt(",;b", two_delims, 0));
+ EXPECT_TRUE(IsFoundAt(";,b", two_delims, 0));
+ EXPECT_TRUE(IsFoundAt("a;,", two_delims, 1));
+ EXPECT_TRUE(IsFoundAt("a,;", two_delims, 1));
+ EXPECT_TRUE(IsFoundAt("a;,b", two_delims, 1));
+ EXPECT_TRUE(IsFoundAt("a,;b", two_delims, 1));
+ // Not found
+ EXPECT_FALSE(IsFoundAt("", two_delims, -1));
+ EXPECT_FALSE(IsFoundAt(" ", two_delims, -1));
+ EXPECT_FALSE(IsFoundAt("a", two_delims, -1));
+ EXPECT_FALSE(IsFoundAt("a=b=c", two_delims, -1));
+ EXPECT_FALSE(IsFoundAt("=", two_delims, -1));
+
+ // ByAnyChar behaves just like ByString when given a delimiter of empty
+ // std::string. That is, it always returns a zero-length absl::string_view
+ // referring to the item at position 1, not position 0.
+ ByAnyChar empty("");
+ EXPECT_FALSE(IsFoundAt("", empty, 0));
+ EXPECT_FALSE(IsFoundAt("a", empty, 0));
+ EXPECT_TRUE(IsFoundAt("ab", empty, 1));
+ EXPECT_TRUE(IsFoundAt("abc", empty, 1));
+}
+
+//
+// Tests for ByLength
+//
+
+TEST(Delimiter, ByLength) {
+ using absl::ByLength;
+
+ ByLength four_char_delim(4);
+
+ // Found
+ EXPECT_TRUE(IsFoundAt("abcde", four_char_delim, 4));
+ EXPECT_TRUE(IsFoundAt("abcdefghijklmnopqrstuvwxyz", four_char_delim, 4));
+ EXPECT_TRUE(IsFoundAt("a b,c\nd", four_char_delim, 4));
+ // Not found
+ EXPECT_FALSE(IsFoundAt("", four_char_delim, 0));
+ EXPECT_FALSE(IsFoundAt("a", four_char_delim, 0));
+ EXPECT_FALSE(IsFoundAt("ab", four_char_delim, 0));
+ EXPECT_FALSE(IsFoundAt("abc", four_char_delim, 0));
+ EXPECT_FALSE(IsFoundAt("abcd", four_char_delim, 0));
+}
+
+TEST(Split, WorksWithLargeStrings) {
+ if (sizeof(size_t) > 4) {
+ std::string s((uint32_t{1} << 31) + 1, 'x'); // 2G + 1 byte
+ s.back() = '-';
+ std::vector<absl::string_view> v = absl::StrSplit(s, '-');
+ EXPECT_EQ(2, v.size());
+ // The first element will contain 2G of 'x's.
+ // testing::StartsWith is too slow with a 2G std::string.
+ EXPECT_EQ('x', v[0][0]);
+ EXPECT_EQ('x', v[0][1]);
+ EXPECT_EQ('x', v[0][3]);
+ EXPECT_EQ("", v[1]);
+ }
+}
+
+TEST(SplitInternalTest, TypeTraits) {
+ EXPECT_FALSE(absl::strings_internal::HasMappedType<int>::value);
+ EXPECT_TRUE(
+ (absl::strings_internal::HasMappedType<std::map<int, int>>::value));
+ EXPECT_FALSE(absl::strings_internal::HasValueType<int>::value);
+ EXPECT_TRUE(
+ (absl::strings_internal::HasValueType<std::map<int, int>>::value));
+ EXPECT_FALSE(absl::strings_internal::HasConstIterator<int>::value);
+ EXPECT_TRUE(
+ (absl::strings_internal::HasConstIterator<std::map<int, int>>::value));
+ EXPECT_FALSE(absl::strings_internal::IsInitializerList<int>::value);
+ EXPECT_TRUE((absl::strings_internal::IsInitializerList<
+ std::initializer_list<int>>::value));
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view.cc
new file mode 100644
index 0000000..0e17295
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view.cc
@@ -0,0 +1,247 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/string_view.h"
+
+#ifndef ABSL_HAVE_STD_STRING_VIEW
+
+#include <algorithm>
+#include <climits>
+#include <cstring>
+#include <ostream>
+
+#include "absl/strings/internal/memutil.h"
+#include "absl/strings/internal/resize_uninitialized.h"
+#include "absl/strings/match.h"
+
+namespace absl {
+
+namespace {
+void WritePadding(std::ostream& o, size_t pad) {
+ char fill_buf[32];
+ memset(fill_buf, o.fill(), sizeof(fill_buf));
+ while (pad) {
+ size_t n = std::min(pad, sizeof(fill_buf));
+ o.write(fill_buf, n);
+ pad -= n;
+ }
+}
+
+class LookupTable {
+ public:
+ // For each character in wanted, sets the index corresponding
+ // to the ASCII code of that character. This is used by
+ // the find_.*_of methods below to tell whether or not a character is in
+ // the lookup table in constant time.
+ explicit LookupTable(string_view wanted) {
+ for (char c : wanted) {
+ table_[Index(c)] = true;
+ }
+ }
+ bool operator[](char c) const { return table_[Index(c)]; }
+
+ private:
+ static unsigned char Index(char c) { return static_cast<unsigned char>(c); }
+ bool table_[UCHAR_MAX + 1] = {};
+};
+
+} // namespace
+
+std::ostream& operator<<(std::ostream& o, string_view piece) {
+ std::ostream::sentry sentry(o);
+ if (sentry) {
+ size_t lpad = 0;
+ size_t rpad = 0;
+ if (static_cast<size_t>(o.width()) > piece.size()) {
+ size_t pad = o.width() - piece.size();
+ if ((o.flags() & o.adjustfield) == o.left) {
+ rpad = pad;
+ } else {
+ lpad = pad;
+ }
+ }
+ if (lpad) WritePadding(o, lpad);
+ o.write(piece.data(), piece.size());
+ if (rpad) WritePadding(o, rpad);
+ o.width(0);
+ }
+ return o;
+}
+
+string_view::size_type string_view::copy(char* buf, size_type n,
+ size_type pos) const {
+ size_type ulen = length_;
+ assert(pos <= ulen);
+ size_type rlen = std::min(ulen - pos, n);
+ if (rlen > 0) {
+ const char* start = ptr_ + pos;
+ std::copy(start, start + rlen, buf);
+ }
+ return rlen;
+}
+
+string_view::size_type string_view::find(string_view s, size_type pos) const
+ noexcept {
+ if (empty() || pos > length_) {
+ if (empty() && pos == 0 && s.empty()) return 0;
+ return npos;
+ }
+ const char* result =
+ strings_internal::memmatch(ptr_ + pos, length_ - pos, s.ptr_, s.length_);
+ return result ? result - ptr_ : npos;
+}
+
+string_view::size_type string_view::find(char c, size_type pos) const noexcept {
+ if (empty() || pos >= length_) {
+ return npos;
+ }
+ const char* result =
+ static_cast<const char*>(memchr(ptr_ + pos, c, length_ - pos));
+ return result != nullptr ? result - ptr_ : npos;
+}
+
+string_view::size_type string_view::rfind(string_view s, size_type pos) const
+ noexcept {
+ if (length_ < s.length_) return npos;
+ if (s.empty()) return std::min(length_, pos);
+ const char* last = ptr_ + std::min(length_ - s.length_, pos) + s.length_;
+ const char* result = std::find_end(ptr_, last, s.ptr_, s.ptr_ + s.length_);
+ return result != last ? result - ptr_ : npos;
+}
+
+// Search range is [0..pos] inclusive. If pos == npos, search everything.
+string_view::size_type string_view::rfind(char c, size_type pos) const
+ noexcept {
+ // Note: memrchr() is not available on Windows.
+ if (empty()) return npos;
+ for (size_type i = std::min(pos, length_ - 1);; --i) {
+ if (ptr_[i] == c) {
+ return i;
+ }
+ if (i == 0) break;
+ }
+ return npos;
+}
+
+string_view::size_type string_view::find_first_of(string_view s,
+ size_type pos) const
+ noexcept {
+ if (empty() || s.empty()) {
+ return npos;
+ }
+ // Avoid the cost of LookupTable() for a single-character search.
+ if (s.length_ == 1) return find_first_of(s.ptr_[0], pos);
+ LookupTable tbl(s);
+ for (size_type i = pos; i < length_; ++i) {
+ if (tbl[ptr_[i]]) {
+ return i;
+ }
+ }
+ return npos;
+}
+
+string_view::size_type string_view::find_first_not_of(string_view s,
+ size_type pos) const
+ noexcept {
+ if (empty()) return npos;
+ // Avoid the cost of LookupTable() for a single-character search.
+ if (s.length_ == 1) return find_first_not_of(s.ptr_[0], pos);
+ LookupTable tbl(s);
+ for (size_type i = pos; i < length_; ++i) {
+ if (!tbl[ptr_[i]]) {
+ return i;
+ }
+ }
+ return npos;
+}
+
+string_view::size_type string_view::find_first_not_of(char c,
+ size_type pos) const
+ noexcept {
+ if (empty()) return npos;
+ for (; pos < length_; ++pos) {
+ if (ptr_[pos] != c) {
+ return pos;
+ }
+ }
+ return npos;
+}
+
+string_view::size_type string_view::find_last_of(string_view s,
+ size_type pos) const noexcept {
+ if (empty() || s.empty()) return npos;
+ // Avoid the cost of LookupTable() for a single-character search.
+ if (s.length_ == 1) return find_last_of(s.ptr_[0], pos);
+ LookupTable tbl(s);
+ for (size_type i = std::min(pos, length_ - 1);; --i) {
+ if (tbl[ptr_[i]]) {
+ return i;
+ }
+ if (i == 0) break;
+ }
+ return npos;
+}
+
+string_view::size_type string_view::find_last_not_of(string_view s,
+ size_type pos) const
+ noexcept {
+ if (empty()) return npos;
+ size_type i = std::min(pos, length_ - 1);
+ if (s.empty()) return i;
+ // Avoid the cost of LookupTable() for a single-character search.
+ if (s.length_ == 1) return find_last_not_of(s.ptr_[0], pos);
+ LookupTable tbl(s);
+ for (;; --i) {
+ if (!tbl[ptr_[i]]) {
+ return i;
+ }
+ if (i == 0) break;
+ }
+ return npos;
+}
+
+string_view::size_type string_view::find_last_not_of(char c,
+ size_type pos) const
+ noexcept {
+ if (empty()) return npos;
+ size_type i = std::min(pos, length_ - 1);
+ for (;; --i) {
+ if (ptr_[i] != c) {
+ return i;
+ }
+ if (i == 0) break;
+ }
+ return npos;
+}
+
+// MSVC has non-standard behavior that implicitly creates definitions for static
+// const members. These implicit definitions conflict with explicit out-of-class
+// member definitions that are required by the C++ standard, resulting in
+// LNK1169 "multiply defined" errors at link time. __declspec(selectany) asks
+// MSVC to choose only one definition for the symbol it decorates. See details
+// at http://msdn.microsoft.com/en-us/library/34h23df8(v=vs.100).aspx
+#ifdef _MSC_VER
+#define ABSL_STRING_VIEW_SELECTANY __declspec(selectany)
+#else
+#define ABSL_STRING_VIEW_SELECTANY
+#endif
+
+ABSL_STRING_VIEW_SELECTANY
+constexpr string_view::size_type string_view::npos;
+ABSL_STRING_VIEW_SELECTANY
+constexpr string_view::size_type string_view::kMaxSize;
+
+} // namespace absl
+
+#endif // ABSL_HAVE_STD_STRING_VIEW
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view.h
new file mode 100644
index 0000000..9162bb3
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view.h
@@ -0,0 +1,570 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: string_view.h
+// -----------------------------------------------------------------------------
+//
+// This file contains the definition of the `absl::string_view` class. A
+// `string_view` points to a contiguous span of characters, often part or all of
+// another `std::string`, double-quoted std::string literal, character array, or even
+// another `string_view`.
+//
+// This `absl::string_view` abstraction is designed to be a drop-in
+// replacement for the C++17 `std::string_view` abstraction.
+#ifndef ABSL_STRINGS_STRING_VIEW_H_
+#define ABSL_STRINGS_STRING_VIEW_H_
+
+#include <algorithm>
+#include "absl/base/config.h"
+
+#ifdef ABSL_HAVE_STD_STRING_VIEW
+
+#include <string_view>
+
+namespace absl {
+using std::string_view;
+};
+
+#else // ABSL_HAVE_STD_STRING_VIEW
+
+#include <cassert>
+#include <cstddef>
+#include <cstring>
+#include <iosfwd>
+#include <iterator>
+#include <limits>
+#include <string>
+
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+
+namespace absl {
+
+// absl::string_view
+//
+// A `string_view` provides a lightweight view into the std::string data provided by
+// a `std::string`, double-quoted std::string literal, character array, or even
+// another `string_view`. A `string_view` does *not* own the std::string to which it
+// points, and that data cannot be modified through the view.
+//
+// You can use `string_view` as a function or method parameter anywhere a
+// parameter can receive a double-quoted std::string literal, `const char*`,
+// `std::string`, or another `absl::string_view` argument with no need to copy
+// the std::string data. Systematic use of `string_view` within function arguments
+// reduces data copies and `strlen()` calls.
+//
+// Because of its small size, prefer passing `string_view` by value:
+//
+// void MyFunction(absl::string_view arg);
+//
+// If circumstances require, you may also pass one by const reference:
+//
+// void MyFunction(const absl::string_view& arg); // not preferred
+//
+// Passing by value generates slightly smaller code for many architectures.
+//
+// In either case, the source data of the `string_view` must outlive the
+// `string_view` itself.
+//
+// A `string_view` is also suitable for local variables if you know that the
+// lifetime of the underlying object is longer than the lifetime of your
+// `string_view` variable. However, beware of binding a `string_view` to a
+// temporary value:
+//
+// // BAD use of string_view: lifetime problem
+// absl::string_view sv = obj.ReturnAString();
+//
+// // GOOD use of string_view: str outlives sv
+// std::string str = obj.ReturnAString();
+// absl::string_view sv = str;
+//
+// Due to lifetime issues, a `string_view` is sometimes a poor choice for a
+// return value and usually a poor choice for a data member. If you do use a
+// `string_view` this way, it is your responsibility to ensure that the object
+// pointed to by the `string_view` outlives the `string_view`.
+//
+// A `string_view` may represent a whole std::string or just part of a std::string. For
+// example, when splitting a std::string, `std::vector<absl::string_view>` is a
+// natural data type for the output.
+//
+//
+// When constructed from a source which is nul-terminated, the `string_view`
+// itself will not include the nul-terminator unless a specific size (including
+// the nul) is passed to the constructor. As a result, common idioms that work
+// on nul-terminated strings do not work on `string_view` objects. If you write
+// code that scans a `string_view`, you must check its length rather than test
+// for nul, for example. Note, however, that nuls may still be embedded within
+// a `string_view` explicitly.
+//
+// You may create a null `string_view` in two ways:
+//
+// absl::string_view sv();
+// absl::string_view sv(nullptr, 0);
+//
+// For the above, `sv.data() == nullptr`, `sv.length() == 0`, and
+// `sv.empty() == true`. Also, if you create a `string_view` with a non-null
+// pointer then `sv.data() != nullptr`. Thus, you can use `string_view()` to
+// signal an undefined value that is different from other `string_view` values
+// in a similar fashion to how `const char* p1 = nullptr;` is different from
+// `const char* p2 = "";`. However, in practice, it is not recommended to rely
+// on this behavior.
+//
+// Be careful not to confuse a null `string_view` with an empty one. A null
+// `string_view` is an empty `string_view`, but some empty `string_view`s are
+// not null. Prefer checking for emptiness over checking for null.
+//
+// There are many ways to create an empty string_view:
+//
+// const char* nullcp = nullptr;
+// // string_view.size() will return 0 in all cases.
+// absl::string_view();
+// absl::string_view(nullcp, 0);
+// absl::string_view("");
+// absl::string_view("", 0);
+// absl::string_view("abcdef", 0);
+// absl::string_view("abcdef" + 6, 0);
+//
+// All empty `string_view` objects whether null or not, are equal:
+//
+// absl::string_view() == absl::string_view("", 0)
+// absl::string_view(nullptr, 0) == absl:: string_view("abcdef"+6, 0)
+class string_view {
+ public:
+ using traits_type = std::char_traits<char>;
+ using value_type = char;
+ using pointer = char*;
+ using const_pointer = const char*;
+ using reference = char&;
+ using const_reference = const char&;
+ using const_iterator = const char*;
+ using iterator = const_iterator;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+ using reverse_iterator = const_reverse_iterator;
+ using size_type = size_t;
+ using difference_type = std::ptrdiff_t;
+
+ static constexpr size_type npos = static_cast<size_type>(-1);
+
+ // Null `string_view` constructor
+ constexpr string_view() noexcept : ptr_(nullptr), length_(0) {}
+
+ // Implicit constructors
+
+ template <typename Allocator>
+ string_view( // NOLINT(runtime/explicit)
+ const std::basic_string<char, std::char_traits<char>, Allocator>&
+ str) noexcept
+ : ptr_(str.data()), length_(CheckLengthInternal(str.size())) {}
+
+ // Implicit constructor of a `string_view` from nul-terminated `str`. When
+ // accepting possibly null strings, use `absl::NullSafeStringView(str)`
+ // instead (see below).
+ constexpr string_view(const char* str) // NOLINT(runtime/explicit)
+ : ptr_(str), length_(CheckLengthInternal(StrLenInternal(str))) {}
+
+ // Implicit constructor of a `string_view` from a `const char*` and length.
+ constexpr string_view(const char* data, size_type len)
+ : ptr_(data), length_(CheckLengthInternal(len)) {}
+
+ // NOTE: Harmlessly omitted to work around gdb bug.
+ // constexpr string_view(const string_view&) noexcept = default;
+ // string_view& operator=(const string_view&) noexcept = default;
+
+ // Iterators
+
+ // string_view::begin()
+ //
+ // Returns an iterator pointing to the first character at the beginning of the
+ // `string_view`, or `end()` if the `string_view` is empty.
+ constexpr const_iterator begin() const noexcept { return ptr_; }
+
+ // string_view::end()
+ //
+ // Returns an iterator pointing just beyond the last character at the end of
+ // the `string_view`. This iterator acts as a placeholder; attempting to
+ // access it results in undefined behavior.
+ constexpr const_iterator end() const noexcept { return ptr_ + length_; }
+
+ // string_view::cbegin()
+ //
+ // Returns a const iterator pointing to the first character at the beginning
+ // of the `string_view`, or `end()` if the `string_view` is empty.
+ constexpr const_iterator cbegin() const noexcept { return begin(); }
+
+ // string_view::cend()
+ //
+ // Returns a const iterator pointing just beyond the last character at the end
+ // of the `string_view`. This pointer acts as a placeholder; attempting to
+ // access its element results in undefined behavior.
+ constexpr const_iterator cend() const noexcept { return end(); }
+
+ // string_view::rbegin()
+ //
+ // Returns a reverse iterator pointing to the last character at the end of the
+ // `string_view`, or `rend()` if the `string_view` is empty.
+ const_reverse_iterator rbegin() const noexcept {
+ return const_reverse_iterator(end());
+ }
+
+ // string_view::rend()
+ //
+ // Returns a reverse iterator pointing just before the first character at the
+ // beginning of the `string_view`. This pointer acts as a placeholder;
+ // attempting to access its element results in undefined behavior.
+ const_reverse_iterator rend() const noexcept {
+ return const_reverse_iterator(begin());
+ }
+
+ // string_view::crbegin()
+ //
+ // Returns a const reverse iterator pointing to the last character at the end
+ // of the `string_view`, or `crend()` if the `string_view` is empty.
+ const_reverse_iterator crbegin() const noexcept { return rbegin(); }
+
+ // string_view::crend()
+ //
+ // Returns a const reverse iterator pointing just before the first character
+ // at the beginning of the `string_view`. This pointer acts as a placeholder;
+ // attempting to access its element results in undefined behavior.
+ const_reverse_iterator crend() const noexcept { return rend(); }
+
+ // Capacity Utilities
+
+ // string_view::size()
+ //
+ // Returns the number of characters in the `string_view`.
+ constexpr size_type size() const noexcept {
+ return length_;
+ }
+
+ // string_view::length()
+ //
+ // Returns the number of characters in the `string_view`. Alias for `size()`.
+ constexpr size_type length() const noexcept { return size(); }
+
+ // string_view::max_size()
+ //
+ // Returns the maximum number of characters the `string_view` can hold.
+ constexpr size_type max_size() const noexcept { return kMaxSize; }
+
+ // string_view::empty()
+ //
+ // Checks if the `string_view` is empty (refers to no characters).
+ constexpr bool empty() const noexcept { return length_ == 0; }
+
+ // std::string:view::operator[]
+ //
+ // Returns the ith element of an `string_view` using the array operator.
+ // Note that this operator does not perform any bounds checking.
+ constexpr const_reference operator[](size_type i) const { return ptr_[i]; }
+
+ // string_view::front()
+ //
+ // Returns the first element of a `string_view`.
+ constexpr const_reference front() const { return ptr_[0]; }
+
+ // string_view::back()
+ //
+ // Returns the last element of a `string_view`.
+ constexpr const_reference back() const { return ptr_[size() - 1]; }
+
+ // string_view::data()
+ //
+ // Returns a pointer to the underlying character array (which is of course
+ // stored elsewhere). Note that `string_view::data()` may contain embedded nul
+ // characters, but the returned buffer may or may not be nul-terminated;
+ // therefore, do not pass `data()` to a routine that expects a nul-terminated
+ // std::string.
+ constexpr const_pointer data() const noexcept { return ptr_; }
+
+ // Modifiers
+
+ // string_view::remove_prefix()
+ //
+ // Removes the first `n` characters from the `string_view`. Note that the
+ // underlying std::string is not changed, only the view.
+ void remove_prefix(size_type n) {
+ assert(n <= length_);
+ ptr_ += n;
+ length_ -= n;
+ }
+
+ // string_view::remove_suffix()
+ //
+ // Removes the last `n` characters from the `string_view`. Note that the
+ // underlying std::string is not changed, only the view.
+ void remove_suffix(size_type n) {
+ assert(n <= length_);
+ length_ -= n;
+ }
+
+ // string_view::swap()
+ //
+ // Swaps this `string_view` with another `string_view`.
+ void swap(string_view& s) noexcept {
+ auto t = *this;
+ *this = s;
+ s = t;
+ }
+
+ // Explicit conversion operators
+
+ // Converts to `std::basic_string`.
+ template <typename A>
+ explicit operator std::basic_string<char, traits_type, A>() const {
+ if (!data()) return {};
+ return std::basic_string<char, traits_type, A>(data(), size());
+ }
+
+ // string_view::copy()
+ //
+ // Copies the contents of the `string_view` at offset `pos` and length `n`
+ // into `buf`.
+ size_type copy(char* buf, size_type n, size_type pos = 0) const;
+
+ // string_view::substr()
+ //
+ // Returns a "substring" of the `string_view` (at offset `pos` and length
+ // `n`) as another string_view. This function throws `std::out_of_bounds` if
+ // `pos > size'.
+ string_view substr(size_type pos, size_type n = npos) const {
+ if (ABSL_PREDICT_FALSE(pos > length_))
+ base_internal::ThrowStdOutOfRange("absl::string_view::substr");
+ n = std::min(n, length_ - pos);
+ return string_view(ptr_ + pos, n);
+ }
+
+ // string_view::compare()
+ //
+ // Performs a lexicographical comparison between the `string_view` and
+ // another `absl::string_view), returning -1 if `this` is less than, 0 if
+ // `this` is equal to, and 1 if `this` is greater than the passed std::string
+ // view. Note that in the case of data equality, a further comparison is made
+ // on the respective sizes of the two `string_view`s to determine which is
+ // smaller, equal, or greater.
+ int compare(string_view x) const noexcept {
+ auto min_length = std::min(length_, x.length_);
+ if (min_length > 0) {
+ int r = memcmp(ptr_, x.ptr_, min_length);
+ if (r < 0) return -1;
+ if (r > 0) return 1;
+ }
+ if (length_ < x.length_) return -1;
+ if (length_ > x.length_) return 1;
+ return 0;
+ }
+
+ // Overload of `string_view::compare()` for comparing a substring of the
+ // 'string_view` and another `absl::string_view`.
+ int compare(size_type pos1, size_type count1, string_view v) const {
+ return substr(pos1, count1).compare(v);
+ }
+
+ // Overload of `string_view::compare()` for comparing a substring of the
+ // `string_view` and a substring of another `absl::string_view`.
+ int compare(size_type pos1, size_type count1, string_view v, size_type pos2,
+ size_type count2) const {
+ return substr(pos1, count1).compare(v.substr(pos2, count2));
+ }
+
+ // Overload of `string_view::compare()` for comparing a `string_view` and a
+ // a different C-style std::string `s`.
+ int compare(const char* s) const { return compare(string_view(s)); }
+
+ // Overload of `string_view::compare()` for comparing a substring of the
+ // `string_view` and a different std::string C-style std::string `s`.
+ int compare(size_type pos1, size_type count1, const char* s) const {
+ return substr(pos1, count1).compare(string_view(s));
+ }
+
+ // Overload of `string_view::compare()` for comparing a substring of the
+ // `string_view` and a substring of a different C-style std::string `s`.
+ int compare(size_type pos1, size_type count1, const char* s,
+ size_type count2) const {
+ return substr(pos1, count1).compare(string_view(s, count2));
+ }
+
+ // Find Utilities
+
+ // string_view::find()
+ //
+ // Finds the first occurrence of the substring `s` within the `string_view`,
+ // returning the position of the first character's match, or `npos` if no
+ // match was found.
+ size_type find(string_view s, size_type pos = 0) const noexcept;
+
+ // Overload of `string_view::find()` for finding the given character `c`
+ // within the `string_view`.
+ size_type find(char c, size_type pos = 0) const noexcept;
+
+ // string_view::rfind()
+ //
+ // Finds the last occurrence of a substring `s` within the `string_view`,
+ // returning the position of the first character's match, or `npos` if no
+ // match was found.
+ size_type rfind(string_view s, size_type pos = npos) const
+ noexcept;
+
+ // Overload of `string_view::rfind()` for finding the last given character `c`
+ // within the `string_view`.
+ size_type rfind(char c, size_type pos = npos) const noexcept;
+
+ // string_view::find_first_of()
+ //
+ // Finds the first occurrence of any of the characters in `s` within the
+ // `string_view`, returning the start position of the match, or `npos` if no
+ // match was found.
+ size_type find_first_of(string_view s, size_type pos = 0) const
+ noexcept;
+
+ // Overload of `string_view::find_first_of()` for finding a character `c`
+ // within the `string_view`.
+ size_type find_first_of(char c, size_type pos = 0) const
+ noexcept {
+ return find(c, pos);
+ }
+
+ // string_view::find_last_of()
+ //
+ // Finds the last occurrence of any of the characters in `s` within the
+ // `string_view`, returning the start position of the match, or `npos` if no
+ // match was found.
+ size_type find_last_of(string_view s, size_type pos = npos) const
+ noexcept;
+
+ // Overload of `string_view::find_last_of()` for finding a character `c`
+ // within the `string_view`.
+ size_type find_last_of(char c, size_type pos = npos) const
+ noexcept {
+ return rfind(c, pos);
+ }
+
+ // string_view::find_first_not_of()
+ //
+ // Finds the first occurrence of any of the characters not in `s` within the
+ // `string_view`, returning the start position of the first non-match, or
+ // `npos` if no non-match was found.
+ size_type find_first_not_of(string_view s, size_type pos = 0) const noexcept;
+
+ // Overload of `string_view::find_first_not_of()` for finding a character
+ // that is not `c` within the `string_view`.
+ size_type find_first_not_of(char c, size_type pos = 0) const noexcept;
+
+ // string_view::find_last_not_of()
+ //
+ // Finds the last occurrence of any of the characters not in `s` within the
+ // `string_view`, returning the start position of the last non-match, or
+ // `npos` if no non-match was found.
+ size_type find_last_not_of(string_view s,
+ size_type pos = npos) const noexcept;
+
+ // Overload of `string_view::find_last_not_of()` for finding a character
+ // that is not `c` within the `string_view`.
+ size_type find_last_not_of(char c, size_type pos = npos) const
+ noexcept;
+
+ private:
+ static constexpr size_type kMaxSize =
+ std::numeric_limits<difference_type>::max();
+
+ // check whether __builtin_strlen is provided by the compiler.
+ // GCC doesn't have __has_builtin()
+ // (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66970),
+ // but has __builtin_strlen according to
+ // https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Other-Builtins.html.
+#if ABSL_HAVE_BUILTIN(__builtin_strlen) || \
+ (defined(__GNUC__) && !defined(__clang__))
+ static constexpr size_type StrLenInternal(const char* str) {
+ return str ? __builtin_strlen(str) : 0;
+ }
+#else
+ static constexpr size_type StrLenInternal(const char* str) {
+ return str ? strlen(str) : 0;
+ }
+#endif
+
+ static constexpr size_type CheckLengthInternal(size_type len) {
+ return ABSL_ASSERT(len <= kMaxSize), len;
+ }
+
+ const char* ptr_;
+ size_type length_;
+};
+
+// This large function is defined inline so that in a fairly common case where
+// one of the arguments is a literal, the compiler can elide a lot of the
+// following comparisons.
+inline bool operator==(string_view x, string_view y) noexcept {
+ auto len = x.size();
+ if (len != y.size()) {
+ return false;
+ }
+ return x.data() == y.data() || len <= 0 ||
+ memcmp(x.data(), y.data(), len) == 0;
+}
+
+inline bool operator!=(string_view x, string_view y) noexcept {
+ return !(x == y);
+}
+
+inline bool operator<(string_view x, string_view y) noexcept {
+ auto min_size = std::min(x.size(), y.size());
+ const int r = min_size == 0 ? 0 : memcmp(x.data(), y.data(), min_size);
+ return (r < 0) || (r == 0 && x.size() < y.size());
+}
+
+inline bool operator>(string_view x, string_view y) noexcept { return y < x; }
+
+inline bool operator<=(string_view x, string_view y) noexcept {
+ return !(y < x);
+}
+
+inline bool operator>=(string_view x, string_view y) noexcept {
+ return !(x < y);
+}
+
+// IO Insertion Operator
+std::ostream& operator<<(std::ostream& o, string_view piece);
+
+} // namespace absl
+
+#endif // ABSL_HAVE_STD_STRING_VIEW
+
+namespace absl {
+
+// ClippedSubstr()
+//
+// Like `s.substr(pos, n)`, but clips `pos` to an upper bound of `s.size()`.
+// Provided because std::string_view::substr throws if `pos > size()`
+inline string_view ClippedSubstr(string_view s, size_t pos,
+ size_t n = string_view::npos) {
+ pos = std::min(pos, static_cast<size_t>(s.size()));
+ return s.substr(pos, n);
+}
+
+// NullSafeStringView()
+//
+// Creates an `absl::string_view` from a pointer `p` even if it's null-valued.
+// This function should be used where an `absl::string_view` can be created from
+// a possibly-null pointer.
+inline string_view NullSafeStringView(const char* p) {
+ return p ? string_view(p) : string_view();
+}
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_STRING_VIEW_H_
[55/62] [abbrv] marmotta git commit: Add 3rd-party code from ostrich
(abseil+gtest) to the NOTICE.txt
Posted by ja...@apache.org.
Add 3rd-party code from ostrich (abseil+gtest) to the NOTICE.txt
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/04fbf29a
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/04fbf29a
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/04fbf29a
Branch: refs/heads/master
Commit: 04fbf29ab9dc4dd5c34a0b2df5b0f99974bd5317
Parents: a0f5452
Author: Jakob Frank <ja...@apache.org>
Authored: Tue May 1 20:47:14 2018 +0200
Committer: Jakob Frank <ja...@apache.org>
Committed: Tue May 1 20:47:14 2018 +0200
----------------------------------------------------------------------
NOTICE.txt | 14 +++++++++++---
libraries/ostrich/README.md | 11 +++++++++++
2 files changed, 22 insertions(+), 3 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/marmotta/blob/04fbf29a/NOTICE.txt
----------------------------------------------------------------------
diff --git a/NOTICE.txt b/NOTICE.txt
index 50e9d5d..c69fda1 100644
--- a/NOTICE.txt
+++ b/NOTICE.txt
@@ -17,9 +17,17 @@ This product also includes some third-party source components:
is licensed under BSD license. The original source code is available from
http://javolution.org
- * The module kiwi/kiwi-triplestore contains a modified and customized version
- of the ScriptRunner.java script. ScriptRunner has copyright (c) 2004 Clinton
+ * The module kiwi/kiwi-triplestore contains a modified and customized version
+ of the ScriptRunner.java script. ScriptRunner has copyright (c) 2004 Clinton
Begin, with minor later contributions by several authors, and is licensed
- under Apache License 2.0. The original source dode is available from
+ under Apache License 2.0. The original source code is available from
https://gist.github.com/joe776/831762
+ * The module libraries/ostrich/backend contains unmodified versions of
+ Abseil - C++ Common Libraries and Google Test:
+ - Abseil - C++ Common Libraries (libraries/ostrich/backend/3rdparty/abseil)
+ is licensed under Apache License 2.0, the original source code is available
+ from https://github.com/abseil/abseil-cpp
+ - Google Test (libraries/ostrich/backend/3rdparty/gtest) is licensed under
+ BSD-3-Clause, the original source code is available from
+ https://github.com/google/googletest
http://git-wip-us.apache.org/repos/asf/marmotta/blob/04fbf29a/libraries/ostrich/README.md
----------------------------------------------------------------------
diff --git a/libraries/ostrich/README.md b/libraries/ostrich/README.md
index 62db012..2ee6120 100644
--- a/libraries/ostrich/README.md
+++ b/libraries/ostrich/README.md
@@ -103,3 +103,14 @@ a large turtle file, run:
The client connects by default to `localhost:10000` (change with `--host` and `--port` flags).
+## 3rd-Party Source Code
+
+The native backend implementation contains 3rd-party source code (located in `backend/3rdparty`).
+
+* **Abseil - C++ Common Libraries** (`backend/3rdparty/abseil`)
+ is licensed under *Apache License 2.0*, the original source code is available
+ from https://github.com/abseil/abseil-cpp
+* **Google Test** (`backend/3rdparty/gtest`) is licensed under
+ *BSD-3-Clause*, the original source code is available from
+ https://github.com/google/googletest
+
[29/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers_test.cc
new file mode 100644
index 0000000..5bb39ca
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers_test.cc
@@ -0,0 +1,1186 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file tests std::string processing functions related to numeric values.
+
+#include "absl/strings/numbers.h"
+
+#include <sys/types.h>
+#include <cfenv> // NOLINT(build/c++11)
+#include <cinttypes>
+#include <climits>
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <limits>
+#include <numeric>
+#include <random>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/strings/str_cat.h"
+
+#include "absl/strings/internal/numbers_test_common.inc"
+
+namespace {
+
+using absl::numbers_internal::kSixDigitsToBufferSize;
+using absl::numbers_internal::safe_strto32_base;
+using absl::numbers_internal::safe_strto64_base;
+using absl::numbers_internal::safe_strtou32_base;
+using absl::numbers_internal::safe_strtou64_base;
+using absl::numbers_internal::SixDigitsToBuffer;
+using absl::SimpleAtoi;
+using testing::Eq;
+using testing::MatchesRegex;
+
+// Number of floats to test with.
+// 10,000,000 is a reasonable default for a test that only takes a few seconds.
+// 1,000,000,000+ triggers checking for all possible mantissa values for
+// double-precision tests. 2,000,000,000+ triggers checking for every possible
+// single-precision float.
+#ifdef _MSC_VER
+// Use a smaller number on MSVC to avoid test time out (1 min)
+const int kFloatNumCases = 5000000;
+#else
+const int kFloatNumCases = 10000000;
+#endif
+
+// This is a slow, brute-force routine to compute the exact base-10
+// representation of a double-precision floating-point number. It
+// is useful for debugging only.
+std::string PerfectDtoa(double d) {
+ if (d == 0) return "0";
+ if (d < 0) return "-" + PerfectDtoa(-d);
+
+ // Basic theory: decompose d into mantissa and exp, where
+ // d = mantissa * 2^exp, and exp is as close to zero as possible.
+ int64_t mantissa, exp = 0;
+ while (d >= 1ULL << 63) ++exp, d *= 0.5;
+ while ((mantissa = d) != d) --exp, d *= 2.0;
+
+ // Then convert mantissa to ASCII, and either double it (if
+ // exp > 0) or halve it (if exp < 0) repeatedly. "halve it"
+ // in this case means multiplying it by five and dividing by 10.
+ constexpr int maxlen = 1100; // worst case is actually 1030 or so.
+ char buf[maxlen + 5];
+ for (int64_t num = mantissa, pos = maxlen; --pos >= 0;) {
+ buf[pos] = '0' + (num % 10);
+ num /= 10;
+ }
+ char* begin = &buf[0];
+ char* end = buf + maxlen;
+ for (int i = 0; i != exp; i += (exp > 0) ? 1 : -1) {
+ int carry = 0;
+ for (char* p = end; --p != begin;) {
+ int dig = *p - '0';
+ dig = dig * (exp > 0 ? 2 : 5) + carry;
+ carry = dig / 10;
+ dig %= 10;
+ *p = '0' + dig;
+ }
+ }
+ if (exp < 0) {
+ // "dividing by 10" above means we have to add the decimal point.
+ memmove(end + 1 + exp, end + exp, 1 - exp);
+ end[exp] = '.';
+ ++end;
+ }
+ while (*begin == '0' && begin[1] != '.') ++begin;
+ return {begin, end};
+}
+
+TEST(ToString, PerfectDtoa) {
+ EXPECT_THAT(PerfectDtoa(1), Eq("1"));
+ EXPECT_THAT(PerfectDtoa(0.1),
+ Eq("0.1000000000000000055511151231257827021181583404541015625"));
+ EXPECT_THAT(PerfectDtoa(1e24), Eq("999999999999999983222784"));
+ EXPECT_THAT(PerfectDtoa(5e-324), MatchesRegex("0.0000.*625"));
+ for (int i = 0; i < 100; ++i) {
+ for (double multiplier :
+ {1e-300, 1e-200, 1e-100, 0.1, 1.0, 10.0, 1e100, 1e300}) {
+ double d = multiplier * i;
+ std::string s = PerfectDtoa(d);
+ EXPECT_EQ(d, strtod(s.c_str(), nullptr));
+ }
+ }
+}
+
+template <typename integer>
+struct MyInteger {
+ integer i;
+ explicit constexpr MyInteger(integer i) : i(i) {}
+ constexpr operator integer() const { return i; }
+
+ constexpr MyInteger operator+(MyInteger other) const { return i + other.i; }
+ constexpr MyInteger operator-(MyInteger other) const { return i - other.i; }
+ constexpr MyInteger operator*(MyInteger other) const { return i * other.i; }
+ constexpr MyInteger operator/(MyInteger other) const { return i / other.i; }
+
+ constexpr bool operator<(MyInteger other) const { return i < other.i; }
+ constexpr bool operator<=(MyInteger other) const { return i <= other.i; }
+ constexpr bool operator==(MyInteger other) const { return i == other.i; }
+ constexpr bool operator>=(MyInteger other) const { return i >= other.i; }
+ constexpr bool operator>(MyInteger other) const { return i > other.i; }
+ constexpr bool operator!=(MyInteger other) const { return i != other.i; }
+
+ integer as_integer() const { return i; }
+};
+
+typedef MyInteger<int64_t> MyInt64;
+typedef MyInteger<uint64_t> MyUInt64;
+
+void CheckInt32(int32_t x) {
+ char buffer[absl::numbers_internal::kFastToBufferSize];
+ char* actual = absl::numbers_internal::FastIntToBuffer(x, buffer);
+ std::string expected = std::to_string(x);
+ EXPECT_EQ(expected, std::string(buffer, actual)) << " Input " << x;
+
+ char* generic_actual = absl::numbers_internal::FastIntToBuffer(x, buffer);
+ EXPECT_EQ(expected, std::string(buffer, generic_actual)) << " Input " << x;
+}
+
+void CheckInt64(int64_t x) {
+ char buffer[absl::numbers_internal::kFastToBufferSize + 3];
+ buffer[0] = '*';
+ buffer[23] = '*';
+ buffer[24] = '*';
+ char* actual = absl::numbers_internal::FastIntToBuffer(x, &buffer[1]);
+ std::string expected = std::to_string(x);
+ EXPECT_EQ(expected, std::string(&buffer[1], actual)) << " Input " << x;
+ EXPECT_EQ(buffer[0], '*');
+ EXPECT_EQ(buffer[23], '*');
+ EXPECT_EQ(buffer[24], '*');
+
+ char* my_actual =
+ absl::numbers_internal::FastIntToBuffer(MyInt64(x), &buffer[1]);
+ EXPECT_EQ(expected, std::string(&buffer[1], my_actual)) << " Input " << x;
+}
+
+void CheckUInt32(uint32_t x) {
+ char buffer[absl::numbers_internal::kFastToBufferSize];
+ char* actual = absl::numbers_internal::FastIntToBuffer(x, buffer);
+ std::string expected = std::to_string(x);
+ EXPECT_EQ(expected, std::string(buffer, actual)) << " Input " << x;
+
+ char* generic_actual = absl::numbers_internal::FastIntToBuffer(x, buffer);
+ EXPECT_EQ(expected, std::string(buffer, generic_actual)) << " Input " << x;
+}
+
+void CheckUInt64(uint64_t x) {
+ char buffer[absl::numbers_internal::kFastToBufferSize + 1];
+ char* actual = absl::numbers_internal::FastIntToBuffer(x, &buffer[1]);
+ std::string expected = std::to_string(x);
+ EXPECT_EQ(expected, std::string(&buffer[1], actual)) << " Input " << x;
+
+ char* generic_actual = absl::numbers_internal::FastIntToBuffer(x, &buffer[1]);
+ EXPECT_EQ(expected, std::string(&buffer[1], generic_actual)) << " Input " << x;
+
+ char* my_actual =
+ absl::numbers_internal::FastIntToBuffer(MyUInt64(x), &buffer[1]);
+ EXPECT_EQ(expected, std::string(&buffer[1], my_actual)) << " Input " << x;
+}
+
+void CheckHex64(uint64_t v) {
+ char expected[16 + 1];
+ std::string actual = absl::StrCat(absl::Hex(v, absl::kZeroPad16));
+ snprintf(expected, sizeof(expected), "%016" PRIx64, static_cast<uint64_t>(v));
+ EXPECT_EQ(expected, actual) << " Input " << v;
+}
+
+TEST(Numbers, TestFastPrints) {
+ for (int i = -100; i <= 100; i++) {
+ CheckInt32(i);
+ CheckInt64(i);
+ }
+ for (int i = 0; i <= 100; i++) {
+ CheckUInt32(i);
+ CheckUInt64(i);
+ }
+ // Test min int to make sure that works
+ CheckInt32(INT_MIN);
+ CheckInt32(INT_MAX);
+ CheckInt64(LONG_MIN);
+ CheckInt64(uint64_t{1000000000});
+ CheckInt64(uint64_t{9999999999});
+ CheckInt64(uint64_t{100000000000000});
+ CheckInt64(uint64_t{999999999999999});
+ CheckInt64(uint64_t{1000000000000000000});
+ CheckInt64(uint64_t{1199999999999999999});
+ CheckInt64(int64_t{-700000000000000000});
+ CheckInt64(LONG_MAX);
+ CheckUInt32(std::numeric_limits<uint32_t>::max());
+ CheckUInt64(uint64_t{1000000000});
+ CheckUInt64(uint64_t{9999999999});
+ CheckUInt64(uint64_t{100000000000000});
+ CheckUInt64(uint64_t{999999999999999});
+ CheckUInt64(uint64_t{1000000000000000000});
+ CheckUInt64(uint64_t{1199999999999999999});
+ CheckUInt64(std::numeric_limits<uint64_t>::max());
+
+ for (int i = 0; i < 10000; i++) {
+ CheckHex64(i);
+ }
+ CheckHex64(uint64_t{0x123456789abcdef0});
+}
+
+template <typename int_type, typename in_val_type>
+void VerifySimpleAtoiGood(in_val_type in_value, int_type exp_value) {
+ std::string s = absl::StrCat(in_value);
+ int_type x = static_cast<int_type>(~exp_value);
+ EXPECT_TRUE(SimpleAtoi(s, &x))
+ << "in_value=" << in_value << " s=" << s << " x=" << x;
+ EXPECT_EQ(exp_value, x);
+ x = static_cast<int_type>(~exp_value);
+ EXPECT_TRUE(SimpleAtoi(s.c_str(), &x));
+ EXPECT_EQ(exp_value, x);
+}
+
+template <typename int_type, typename in_val_type>
+void VerifySimpleAtoiBad(in_val_type in_value) {
+ std::string s = absl::StrCat(in_value);
+ int_type x;
+ EXPECT_FALSE(SimpleAtoi(s, &x));
+ EXPECT_FALSE(SimpleAtoi(s.c_str(), &x));
+}
+
+TEST(NumbersTest, Atoi) {
+ // SimpleAtoi(absl::string_view, int32_t)
+ VerifySimpleAtoiGood<int32_t>(0, 0);
+ VerifySimpleAtoiGood<int32_t>(42, 42);
+ VerifySimpleAtoiGood<int32_t>(-42, -42);
+
+ VerifySimpleAtoiGood<int32_t>(std::numeric_limits<int32_t>::min(),
+ std::numeric_limits<int32_t>::min());
+ VerifySimpleAtoiGood<int32_t>(std::numeric_limits<int32_t>::max(),
+ std::numeric_limits<int32_t>::max());
+
+ // SimpleAtoi(absl::string_view, uint32_t)
+ VerifySimpleAtoiGood<uint32_t>(0, 0);
+ VerifySimpleAtoiGood<uint32_t>(42, 42);
+ VerifySimpleAtoiBad<uint32_t>(-42);
+
+ VerifySimpleAtoiBad<uint32_t>(std::numeric_limits<int32_t>::min());
+ VerifySimpleAtoiGood<uint32_t>(std::numeric_limits<int32_t>::max(),
+ std::numeric_limits<int32_t>::max());
+ VerifySimpleAtoiGood<uint32_t>(std::numeric_limits<uint32_t>::max(),
+ std::numeric_limits<uint32_t>::max());
+ VerifySimpleAtoiBad<uint32_t>(std::numeric_limits<int64_t>::min());
+ VerifySimpleAtoiBad<uint32_t>(std::numeric_limits<int64_t>::max());
+ VerifySimpleAtoiBad<uint32_t>(std::numeric_limits<uint64_t>::max());
+
+ // SimpleAtoi(absl::string_view, int64_t)
+ VerifySimpleAtoiGood<int64_t>(0, 0);
+ VerifySimpleAtoiGood<int64_t>(42, 42);
+ VerifySimpleAtoiGood<int64_t>(-42, -42);
+
+ VerifySimpleAtoiGood<int64_t>(std::numeric_limits<int32_t>::min(),
+ std::numeric_limits<int32_t>::min());
+ VerifySimpleAtoiGood<int64_t>(std::numeric_limits<int32_t>::max(),
+ std::numeric_limits<int32_t>::max());
+ VerifySimpleAtoiGood<int64_t>(std::numeric_limits<uint32_t>::max(),
+ std::numeric_limits<uint32_t>::max());
+ VerifySimpleAtoiGood<int64_t>(std::numeric_limits<int64_t>::min(),
+ std::numeric_limits<int64_t>::min());
+ VerifySimpleAtoiGood<int64_t>(std::numeric_limits<int64_t>::max(),
+ std::numeric_limits<int64_t>::max());
+ VerifySimpleAtoiBad<int64_t>(std::numeric_limits<uint64_t>::max());
+
+ // SimpleAtoi(absl::string_view, uint64_t)
+ VerifySimpleAtoiGood<uint64_t>(0, 0);
+ VerifySimpleAtoiGood<uint64_t>(42, 42);
+ VerifySimpleAtoiBad<uint64_t>(-42);
+
+ VerifySimpleAtoiBad<uint64_t>(std::numeric_limits<int32_t>::min());
+ VerifySimpleAtoiGood<uint64_t>(std::numeric_limits<int32_t>::max(),
+ std::numeric_limits<int32_t>::max());
+ VerifySimpleAtoiGood<uint64_t>(std::numeric_limits<uint32_t>::max(),
+ std::numeric_limits<uint32_t>::max());
+ VerifySimpleAtoiBad<uint64_t>(std::numeric_limits<int64_t>::min());
+ VerifySimpleAtoiGood<uint64_t>(std::numeric_limits<int64_t>::max(),
+ std::numeric_limits<int64_t>::max());
+ VerifySimpleAtoiGood<uint64_t>(std::numeric_limits<uint64_t>::max(),
+ std::numeric_limits<uint64_t>::max());
+
+ // Some other types
+ VerifySimpleAtoiGood<int>(-42, -42);
+ VerifySimpleAtoiGood<int32_t>(-42, -42);
+ VerifySimpleAtoiGood<uint32_t>(42, 42);
+ VerifySimpleAtoiGood<unsigned int>(42, 42);
+ VerifySimpleAtoiGood<int64_t>(-42, -42);
+ VerifySimpleAtoiGood<long>(-42, -42); // NOLINT(runtime/int)
+ VerifySimpleAtoiGood<uint64_t>(42, 42);
+ VerifySimpleAtoiGood<size_t>(42, 42);
+ VerifySimpleAtoiGood<std::string::size_type>(42, 42);
+}
+
+TEST(NumbersTest, Atoenum) {
+ enum E01 {
+ E01_zero = 0,
+ E01_one = 1,
+ };
+
+ VerifySimpleAtoiGood<E01>(E01_zero, E01_zero);
+ VerifySimpleAtoiGood<E01>(E01_one, E01_one);
+
+ enum E_101 {
+ E_101_minusone = -1,
+ E_101_zero = 0,
+ E_101_one = 1,
+ };
+
+ VerifySimpleAtoiGood<E_101>(E_101_minusone, E_101_minusone);
+ VerifySimpleAtoiGood<E_101>(E_101_zero, E_101_zero);
+ VerifySimpleAtoiGood<E_101>(E_101_one, E_101_one);
+
+ enum E_bigint {
+ E_bigint_zero = 0,
+ E_bigint_one = 1,
+ E_bigint_max31 = static_cast<int32_t>(0x7FFFFFFF),
+ };
+
+ VerifySimpleAtoiGood<E_bigint>(E_bigint_zero, E_bigint_zero);
+ VerifySimpleAtoiGood<E_bigint>(E_bigint_one, E_bigint_one);
+ VerifySimpleAtoiGood<E_bigint>(E_bigint_max31, E_bigint_max31);
+
+ enum E_fullint {
+ E_fullint_zero = 0,
+ E_fullint_one = 1,
+ E_fullint_max31 = static_cast<int32_t>(0x7FFFFFFF),
+ E_fullint_min32 = INT32_MIN,
+ };
+
+ VerifySimpleAtoiGood<E_fullint>(E_fullint_zero, E_fullint_zero);
+ VerifySimpleAtoiGood<E_fullint>(E_fullint_one, E_fullint_one);
+ VerifySimpleAtoiGood<E_fullint>(E_fullint_max31, E_fullint_max31);
+ VerifySimpleAtoiGood<E_fullint>(E_fullint_min32, E_fullint_min32);
+
+ enum E_biguint {
+ E_biguint_zero = 0,
+ E_biguint_one = 1,
+ E_biguint_max31 = static_cast<uint32_t>(0x7FFFFFFF),
+ E_biguint_max32 = static_cast<uint32_t>(0xFFFFFFFF),
+ };
+
+ VerifySimpleAtoiGood<E_biguint>(E_biguint_zero, E_biguint_zero);
+ VerifySimpleAtoiGood<E_biguint>(E_biguint_one, E_biguint_one);
+ VerifySimpleAtoiGood<E_biguint>(E_biguint_max31, E_biguint_max31);
+ VerifySimpleAtoiGood<E_biguint>(E_biguint_max32, E_biguint_max32);
+}
+
+TEST(stringtest, safe_strto32_base) {
+ int32_t value;
+ EXPECT_TRUE(safe_strto32_base("0x34234324", &value, 16));
+ EXPECT_EQ(0x34234324, value);
+
+ EXPECT_TRUE(safe_strto32_base("0X34234324", &value, 16));
+ EXPECT_EQ(0x34234324, value);
+
+ EXPECT_TRUE(safe_strto32_base("34234324", &value, 16));
+ EXPECT_EQ(0x34234324, value);
+
+ EXPECT_TRUE(safe_strto32_base("0", &value, 16));
+ EXPECT_EQ(0, value);
+
+ EXPECT_TRUE(safe_strto32_base(" \t\n -0x34234324", &value, 16));
+ EXPECT_EQ(-0x34234324, value);
+
+ EXPECT_TRUE(safe_strto32_base(" \t\n -34234324", &value, 16));
+ EXPECT_EQ(-0x34234324, value);
+
+ EXPECT_TRUE(safe_strto32_base("7654321", &value, 8));
+ EXPECT_EQ(07654321, value);
+
+ EXPECT_TRUE(safe_strto32_base("-01234", &value, 8));
+ EXPECT_EQ(-01234, value);
+
+ EXPECT_FALSE(safe_strto32_base("1834", &value, 8));
+
+ // Autodetect base.
+ EXPECT_TRUE(safe_strto32_base("0", &value, 0));
+ EXPECT_EQ(0, value);
+
+ EXPECT_TRUE(safe_strto32_base("077", &value, 0));
+ EXPECT_EQ(077, value); // Octal interpretation
+
+ // Leading zero indicates octal, but then followed by invalid digit.
+ EXPECT_FALSE(safe_strto32_base("088", &value, 0));
+
+ // Leading 0x indicated hex, but then followed by invalid digit.
+ EXPECT_FALSE(safe_strto32_base("0xG", &value, 0));
+
+ // Base-10 version.
+ EXPECT_TRUE(safe_strto32_base("34234324", &value, 10));
+ EXPECT_EQ(34234324, value);
+
+ EXPECT_TRUE(safe_strto32_base("0", &value, 10));
+ EXPECT_EQ(0, value);
+
+ EXPECT_TRUE(safe_strto32_base(" \t\n -34234324", &value, 10));
+ EXPECT_EQ(-34234324, value);
+
+ EXPECT_TRUE(safe_strto32_base("34234324 \n\t ", &value, 10));
+ EXPECT_EQ(34234324, value);
+
+ // Invalid ints.
+ EXPECT_FALSE(safe_strto32_base("", &value, 10));
+ EXPECT_FALSE(safe_strto32_base(" ", &value, 10));
+ EXPECT_FALSE(safe_strto32_base("abc", &value, 10));
+ EXPECT_FALSE(safe_strto32_base("34234324a", &value, 10));
+ EXPECT_FALSE(safe_strto32_base("34234.3", &value, 10));
+
+ // Out of bounds.
+ EXPECT_FALSE(safe_strto32_base("2147483648", &value, 10));
+ EXPECT_FALSE(safe_strto32_base("-2147483649", &value, 10));
+
+ // String version.
+ EXPECT_TRUE(safe_strto32_base(std::string("0x1234"), &value, 16));
+ EXPECT_EQ(0x1234, value);
+
+ // Base-10 std::string version.
+ EXPECT_TRUE(safe_strto32_base("1234", &value, 10));
+ EXPECT_EQ(1234, value);
+}
+
+TEST(stringtest, safe_strto32_range) {
+ // These tests verify underflow/overflow behaviour.
+ int32_t value;
+ EXPECT_FALSE(safe_strto32_base("2147483648", &value, 10));
+ EXPECT_EQ(std::numeric_limits<int32_t>::max(), value);
+
+ EXPECT_TRUE(safe_strto32_base("-2147483648", &value, 10));
+ EXPECT_EQ(std::numeric_limits<int32_t>::min(), value);
+
+ EXPECT_FALSE(safe_strto32_base("-2147483649", &value, 10));
+ EXPECT_EQ(std::numeric_limits<int32_t>::min(), value);
+}
+
+TEST(stringtest, safe_strto64_range) {
+ // These tests verify underflow/overflow behaviour.
+ int64_t value;
+ EXPECT_FALSE(safe_strto64_base("9223372036854775808", &value, 10));
+ EXPECT_EQ(std::numeric_limits<int64_t>::max(), value);
+
+ EXPECT_TRUE(safe_strto64_base("-9223372036854775808", &value, 10));
+ EXPECT_EQ(std::numeric_limits<int64_t>::min(), value);
+
+ EXPECT_FALSE(safe_strto64_base("-9223372036854775809", &value, 10));
+ EXPECT_EQ(std::numeric_limits<int64_t>::min(), value);
+}
+
+TEST(stringtest, safe_strto32_leading_substring) {
+ // These tests verify this comment in numbers.h:
+ // On error, returns false, and sets *value to: [...]
+ // conversion of leading substring if available ("123@@@" -> 123)
+ // 0 if no leading substring available
+ int32_t value;
+ EXPECT_FALSE(safe_strto32_base("04069@@@", &value, 10));
+ EXPECT_EQ(4069, value);
+
+ EXPECT_FALSE(safe_strto32_base("04069@@@", &value, 8));
+ EXPECT_EQ(0406, value);
+
+ EXPECT_FALSE(safe_strto32_base("04069balloons", &value, 10));
+ EXPECT_EQ(4069, value);
+
+ EXPECT_FALSE(safe_strto32_base("04069balloons", &value, 16));
+ EXPECT_EQ(0x4069ba, value);
+
+ EXPECT_FALSE(safe_strto32_base("@@@", &value, 10));
+ EXPECT_EQ(0, value); // there was no leading substring
+}
+
+TEST(stringtest, safe_strto64_leading_substring) {
+ // These tests verify this comment in numbers.h:
+ // On error, returns false, and sets *value to: [...]
+ // conversion of leading substring if available ("123@@@" -> 123)
+ // 0 if no leading substring available
+ int64_t value;
+ EXPECT_FALSE(safe_strto64_base("04069@@@", &value, 10));
+ EXPECT_EQ(4069, value);
+
+ EXPECT_FALSE(safe_strto64_base("04069@@@", &value, 8));
+ EXPECT_EQ(0406, value);
+
+ EXPECT_FALSE(safe_strto64_base("04069balloons", &value, 10));
+ EXPECT_EQ(4069, value);
+
+ EXPECT_FALSE(safe_strto64_base("04069balloons", &value, 16));
+ EXPECT_EQ(0x4069ba, value);
+
+ EXPECT_FALSE(safe_strto64_base("@@@", &value, 10));
+ EXPECT_EQ(0, value); // there was no leading substring
+}
+
+TEST(stringtest, safe_strto64_base) {
+ int64_t value;
+ EXPECT_TRUE(safe_strto64_base("0x3423432448783446", &value, 16));
+ EXPECT_EQ(int64_t{0x3423432448783446}, value);
+
+ EXPECT_TRUE(safe_strto64_base("3423432448783446", &value, 16));
+ EXPECT_EQ(int64_t{0x3423432448783446}, value);
+
+ EXPECT_TRUE(safe_strto64_base("0", &value, 16));
+ EXPECT_EQ(0, value);
+
+ EXPECT_TRUE(safe_strto64_base(" \t\n -0x3423432448783446", &value, 16));
+ EXPECT_EQ(int64_t{-0x3423432448783446}, value);
+
+ EXPECT_TRUE(safe_strto64_base(" \t\n -3423432448783446", &value, 16));
+ EXPECT_EQ(int64_t{-0x3423432448783446}, value);
+
+ EXPECT_TRUE(safe_strto64_base("123456701234567012", &value, 8));
+ EXPECT_EQ(int64_t{0123456701234567012}, value);
+
+ EXPECT_TRUE(safe_strto64_base("-017777777777777", &value, 8));
+ EXPECT_EQ(int64_t{-017777777777777}, value);
+
+ EXPECT_FALSE(safe_strto64_base("19777777777777", &value, 8));
+
+ // Autodetect base.
+ EXPECT_TRUE(safe_strto64_base("0", &value, 0));
+ EXPECT_EQ(0, value);
+
+ EXPECT_TRUE(safe_strto64_base("077", &value, 0));
+ EXPECT_EQ(077, value); // Octal interpretation
+
+ // Leading zero indicates octal, but then followed by invalid digit.
+ EXPECT_FALSE(safe_strto64_base("088", &value, 0));
+
+ // Leading 0x indicated hex, but then followed by invalid digit.
+ EXPECT_FALSE(safe_strto64_base("0xG", &value, 0));
+
+ // Base-10 version.
+ EXPECT_TRUE(safe_strto64_base("34234324487834466", &value, 10));
+ EXPECT_EQ(int64_t{34234324487834466}, value);
+
+ EXPECT_TRUE(safe_strto64_base("0", &value, 10));
+ EXPECT_EQ(0, value);
+
+ EXPECT_TRUE(safe_strto64_base(" \t\n -34234324487834466", &value, 10));
+ EXPECT_EQ(int64_t{-34234324487834466}, value);
+
+ EXPECT_TRUE(safe_strto64_base("34234324487834466 \n\t ", &value, 10));
+ EXPECT_EQ(int64_t{34234324487834466}, value);
+
+ // Invalid ints.
+ EXPECT_FALSE(safe_strto64_base("", &value, 10));
+ EXPECT_FALSE(safe_strto64_base(" ", &value, 10));
+ EXPECT_FALSE(safe_strto64_base("abc", &value, 10));
+ EXPECT_FALSE(safe_strto64_base("34234324487834466a", &value, 10));
+ EXPECT_FALSE(safe_strto64_base("34234487834466.3", &value, 10));
+
+ // Out of bounds.
+ EXPECT_FALSE(safe_strto64_base("9223372036854775808", &value, 10));
+ EXPECT_FALSE(safe_strto64_base("-9223372036854775809", &value, 10));
+
+ // String version.
+ EXPECT_TRUE(safe_strto64_base(std::string("0x1234"), &value, 16));
+ EXPECT_EQ(0x1234, value);
+
+ // Base-10 std::string version.
+ EXPECT_TRUE(safe_strto64_base("1234", &value, 10));
+ EXPECT_EQ(1234, value);
+}
+
+const size_t kNumRandomTests = 10000;
+
+template <typename IntType>
+void test_random_integer_parse_base(bool (*parse_func)(absl::string_view,
+ IntType* value,
+ int base)) {
+ using RandomEngine = std::minstd_rand0;
+ std::random_device rd;
+ RandomEngine rng(rd());
+ std::uniform_int_distribution<IntType> random_int(
+ std::numeric_limits<IntType>::min());
+ std::uniform_int_distribution<int> random_base(2, 35);
+ for (size_t i = 0; i < kNumRandomTests; i++) {
+ IntType value = random_int(rng);
+ int base = random_base(rng);
+ std::string str_value;
+ EXPECT_TRUE(Itoa<IntType>(value, base, &str_value));
+ IntType parsed_value;
+
+ // Test successful parse
+ EXPECT_TRUE(parse_func(str_value, &parsed_value, base));
+ EXPECT_EQ(parsed_value, value);
+
+ // Test overflow
+ EXPECT_FALSE(
+ parse_func(absl::StrCat(std::numeric_limits<IntType>::max(), value),
+ &parsed_value, base));
+
+ // Test underflow
+ if (std::numeric_limits<IntType>::min() < 0) {
+ EXPECT_FALSE(
+ parse_func(absl::StrCat(std::numeric_limits<IntType>::min(), value),
+ &parsed_value, base));
+ } else {
+ EXPECT_FALSE(parse_func(absl::StrCat("-", value), &parsed_value, base));
+ }
+ }
+}
+
+TEST(stringtest, safe_strto32_random) {
+ test_random_integer_parse_base<int32_t>(&safe_strto32_base);
+}
+TEST(stringtest, safe_strto64_random) {
+ test_random_integer_parse_base<int64_t>(&safe_strto64_base);
+}
+TEST(stringtest, safe_strtou32_random) {
+ test_random_integer_parse_base<uint32_t>(&safe_strtou32_base);
+}
+TEST(stringtest, safe_strtou64_random) {
+ test_random_integer_parse_base<uint64_t>(&safe_strtou64_base);
+}
+
+TEST(stringtest, safe_strtou32_base) {
+ for (int i = 0; strtouint32_test_cases[i].str != nullptr; ++i) {
+ const auto& e = strtouint32_test_cases[i];
+ uint32_t value;
+ EXPECT_EQ(e.expect_ok, safe_strtou32_base(e.str, &value, e.base))
+ << "str=\"" << e.str << "\" base=" << e.base;
+ if (e.expect_ok) {
+ EXPECT_EQ(e.expected, value) << "i=" << i << " str=\"" << e.str
+ << "\" base=" << e.base;
+ }
+ }
+}
+
+TEST(stringtest, safe_strtou32_base_length_delimited) {
+ for (int i = 0; strtouint32_test_cases[i].str != nullptr; ++i) {
+ const auto& e = strtouint32_test_cases[i];
+ std::string tmp(e.str);
+ tmp.append("12"); // Adds garbage at the end.
+
+ uint32_t value;
+ EXPECT_EQ(e.expect_ok,
+ safe_strtou32_base(absl::string_view(tmp.data(), strlen(e.str)),
+ &value, e.base))
+ << "str=\"" << e.str << "\" base=" << e.base;
+ if (e.expect_ok) {
+ EXPECT_EQ(e.expected, value) << "i=" << i << " str=" << e.str
+ << " base=" << e.base;
+ }
+ }
+}
+
+TEST(stringtest, safe_strtou64_base) {
+ for (int i = 0; strtouint64_test_cases[i].str != nullptr; ++i) {
+ const auto& e = strtouint64_test_cases[i];
+ uint64_t value;
+ EXPECT_EQ(e.expect_ok, safe_strtou64_base(e.str, &value, e.base))
+ << "str=\"" << e.str << "\" base=" << e.base;
+ if (e.expect_ok) {
+ EXPECT_EQ(e.expected, value) << "str=" << e.str << " base=" << e.base;
+ }
+ }
+}
+
+TEST(stringtest, safe_strtou64_base_length_delimited) {
+ for (int i = 0; strtouint64_test_cases[i].str != nullptr; ++i) {
+ const auto& e = strtouint64_test_cases[i];
+ std::string tmp(e.str);
+ tmp.append("12"); // Adds garbage at the end.
+
+ uint64_t value;
+ EXPECT_EQ(e.expect_ok,
+ safe_strtou64_base(absl::string_view(tmp.data(), strlen(e.str)),
+ &value, e.base))
+ << "str=\"" << e.str << "\" base=" << e.base;
+ if (e.expect_ok) {
+ EXPECT_EQ(e.expected, value) << "str=\"" << e.str << "\" base=" << e.base;
+ }
+ }
+}
+
+// feenableexcept() and fedisableexcept() are missing on Mac OS X, MSVC.
+#if defined(_MSC_VER) || defined(__APPLE__)
+#define ABSL_MISSING_FEENABLEEXCEPT 1
+#define ABSL_MISSING_FEDISABLEEXCEPT 1
+#endif
+
+class SimpleDtoaTest : public testing::Test {
+ protected:
+ void SetUp() override {
+ // Store the current floating point env & clear away any pending exceptions.
+ feholdexcept(&fp_env_);
+#ifndef ABSL_MISSING_FEENABLEEXCEPT
+ // Turn on floating point exceptions.
+ feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
+#endif
+ }
+
+ void TearDown() override {
+ // Restore the floating point environment to the original state.
+ // In theory fedisableexcept is unnecessary; fesetenv will also do it.
+ // In practice, our toolchains have subtle bugs.
+#ifndef ABSL_MISSING_FEDISABLEEXCEPT
+ fedisableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW);
+#endif
+ fesetenv(&fp_env_);
+ }
+
+ std::string ToNineDigits(double value) {
+ char buffer[16]; // more than enough for %.9g
+ snprintf(buffer, sizeof(buffer), "%.9g", value);
+ return buffer;
+ }
+
+ fenv_t fp_env_;
+};
+
+// Run the given runnable functor for "cases" test cases, chosen over the
+// available range of float. pi and e and 1/e are seeded, and then all
+// available integer powers of 2 and 10 are multiplied against them. In
+// addition to trying all those values, we try the next higher and next lower
+// float, and then we add additional test cases evenly distributed between them.
+// Each test case is passed to runnable as both a positive and negative value.
+template <typename R>
+void ExhaustiveFloat(uint32_t cases, R&& runnable) {
+ runnable(0.0f);
+ runnable(-0.0f);
+ if (cases >= 2e9) { // more than 2 billion? Might as well run them all.
+ for (float f = 0; f < std::numeric_limits<float>::max(); ) {
+ f = nextafterf(f, std::numeric_limits<float>::max());
+ runnable(-f);
+ runnable(f);
+ }
+ return;
+ }
+ std::set<float> floats = {3.4028234e38f};
+ for (float f : {1.0, 3.14159265, 2.718281828, 1 / 2.718281828}) {
+ for (float testf = f; testf != 0; testf *= 0.1f) floats.insert(testf);
+ for (float testf = f; testf != 0; testf *= 0.5f) floats.insert(testf);
+ for (float testf = f; testf < 3e38f / 2; testf *= 2.0f)
+ floats.insert(testf);
+ for (float testf = f; testf < 3e38f / 10; testf *= 10) floats.insert(testf);
+ }
+
+ float last = *floats.begin();
+
+ runnable(last);
+ runnable(-last);
+ int iters_per_float = cases / floats.size();
+ if (iters_per_float == 0) iters_per_float = 1;
+ for (float f : floats) {
+ if (f == last) continue;
+ float testf = nextafter(last, std::numeric_limits<float>::max());
+ runnable(testf);
+ runnable(-testf);
+ last = testf;
+ if (f == last) continue;
+ double step = (double{f} - last) / iters_per_float;
+ for (double d = last + step; d < f; d += step) {
+ testf = d;
+ if (testf != last) {
+ runnable(testf);
+ runnable(-testf);
+ last = testf;
+ }
+ }
+ testf = nextafter(f, 0.0f);
+ if (testf > last) {
+ runnable(testf);
+ runnable(-testf);
+ last = testf;
+ }
+ if (f != last) {
+ runnable(f);
+ runnable(-f);
+ last = f;
+ }
+ }
+}
+
+TEST_F(SimpleDtoaTest, ExhaustiveDoubleToSixDigits) {
+ uint64_t test_count = 0;
+ std::vector<double> mismatches;
+ auto checker = [&](double d) {
+ if (d != d) return; // rule out NaNs
+ ++test_count;
+ char sixdigitsbuf[kSixDigitsToBufferSize] = {0};
+ SixDigitsToBuffer(d, sixdigitsbuf);
+ char snprintfbuf[kSixDigitsToBufferSize] = {0};
+ snprintf(snprintfbuf, kSixDigitsToBufferSize, "%g", d);
+ if (strcmp(sixdigitsbuf, snprintfbuf) != 0) {
+ mismatches.push_back(d);
+ if (mismatches.size() < 10) {
+ ABSL_RAW_LOG(ERROR, "%s",
+ absl::StrCat("Six-digit failure with double. ", "d=", d,
+ "=", d, " sixdigits=", sixdigitsbuf,
+ " printf(%g)=", snprintfbuf)
+ .c_str());
+ }
+ }
+ };
+ // Some quick sanity checks...
+ checker(5e-324);
+ checker(1e-308);
+ checker(1.0);
+ checker(1.000005);
+ checker(1.7976931348623157e308);
+ checker(0.00390625);
+#ifndef _MSC_VER
+ // on MSVC, snprintf() rounds it to 0.00195313. SixDigitsToBuffer() rounds it
+ // to 0.00195312 (round half to even).
+ checker(0.001953125);
+#endif
+ checker(0.005859375);
+ // Some cases where the rounding is very very close
+ checker(1.089095e-15);
+ checker(3.274195e-55);
+ checker(6.534355e-146);
+ checker(2.920845e+234);
+
+ if (mismatches.empty()) {
+ test_count = 0;
+ ExhaustiveFloat(kFloatNumCases, checker);
+
+ test_count = 0;
+ std::vector<int> digit_testcases{
+ 100000, 100001, 100002, 100005, 100010, 100020, 100050, 100100, // misc
+ 195312, 195313, // 1.953125 is a case where we round down, just barely.
+ 200000, 500000, 800000, // misc mid-range cases
+ 585937, 585938, // 5.859375 is a case where we round up, just barely.
+ 900000, 990000, 999000, 999900, 999990, 999996, 999997, 999998, 999999};
+ if (kFloatNumCases >= 1e9) {
+ // If at least 1 billion test cases were requested, user wants an
+ // exhaustive test. So let's test all mantissas, too.
+ constexpr int min_mantissa = 100000, max_mantissa = 999999;
+ digit_testcases.resize(max_mantissa - min_mantissa + 1);
+ std::iota(digit_testcases.begin(), digit_testcases.end(), min_mantissa);
+ }
+
+ for (int exponent = -324; exponent <= 308; ++exponent) {
+ double powten = pow(10.0, exponent);
+ if (powten == 0) powten = 5e-324;
+ if (kFloatNumCases >= 1e9) {
+ // The exhaustive test takes a very long time, so log progress.
+ char buf[kSixDigitsToBufferSize];
+ ABSL_RAW_LOG(
+ INFO, "%s",
+ absl::StrCat("Exp ", exponent, " powten=", powten, "(",
+ powten, ") (",
+ std::string(buf, SixDigitsToBuffer(powten, buf)), ")")
+ .c_str());
+ }
+ for (int digits : digit_testcases) {
+ if (exponent == 308 && digits >= 179769) break; // don't overflow!
+ double digiform = (digits + 0.5) * 0.00001;
+ double testval = digiform * powten;
+ double pretestval = nextafter(testval, 0);
+ double posttestval = nextafter(testval, 1.7976931348623157e308);
+ checker(testval);
+ checker(pretestval);
+ checker(posttestval);
+ }
+ }
+ } else {
+ EXPECT_EQ(mismatches.size(), 0);
+ for (size_t i = 0; i < mismatches.size(); ++i) {
+ if (i > 100) i = mismatches.size() - 1;
+ double d = mismatches[i];
+ char sixdigitsbuf[kSixDigitsToBufferSize] = {0};
+ SixDigitsToBuffer(d, sixdigitsbuf);
+ char snprintfbuf[kSixDigitsToBufferSize] = {0};
+ snprintf(snprintfbuf, kSixDigitsToBufferSize, "%g", d);
+ double before = nextafter(d, 0.0);
+ double after = nextafter(d, 1.7976931348623157e308);
+ char b1[32], b2[kSixDigitsToBufferSize];
+ ABSL_RAW_LOG(
+ ERROR, "%s",
+ absl::StrCat(
+ "Mismatch #", i, " d=", d, " (", ToNineDigits(d), ")",
+ " sixdigits='", sixdigitsbuf, "'", " snprintf='", snprintfbuf,
+ "'", " Before.=", PerfectDtoa(before), " ",
+ (SixDigitsToBuffer(before, b2), b2),
+ " vs snprintf=", (snprintf(b1, sizeof(b1), "%g", before), b1),
+ " Perfect=", PerfectDtoa(d), " ", (SixDigitsToBuffer(d, b2), b2),
+ " vs snprintf=", (snprintf(b1, sizeof(b1), "%g", d), b1),
+ " After.=.", PerfectDtoa(after), " ",
+ (SixDigitsToBuffer(after, b2), b2),
+ " vs snprintf=", (snprintf(b1, sizeof(b1), "%g", after), b1))
+ .c_str());
+ }
+ }
+}
+
+TEST(StrToInt32, Partial) {
+ struct Int32TestLine {
+ std::string input;
+ bool status;
+ int32_t value;
+ };
+ const int32_t int32_min = std::numeric_limits<int32_t>::min();
+ const int32_t int32_max = std::numeric_limits<int32_t>::max();
+ Int32TestLine int32_test_line[] = {
+ {"", false, 0},
+ {" ", false, 0},
+ {"-", false, 0},
+ {"123@@@", false, 123},
+ {absl::StrCat(int32_min, int32_max), false, int32_min},
+ {absl::StrCat(int32_max, int32_max), false, int32_max},
+ };
+
+ for (const Int32TestLine& test_line : int32_test_line) {
+ int32_t value = -2;
+ bool status = safe_strto32_base(test_line.input, &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ value = -2;
+ status = safe_strto32_base(test_line.input, &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ value = -2;
+ status = safe_strto32_base(absl::string_view(test_line.input), &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ }
+}
+
+TEST(StrToUint32, Partial) {
+ struct Uint32TestLine {
+ std::string input;
+ bool status;
+ uint32_t value;
+ };
+ const uint32_t uint32_max = std::numeric_limits<uint32_t>::max();
+ Uint32TestLine uint32_test_line[] = {
+ {"", false, 0},
+ {" ", false, 0},
+ {"-", false, 0},
+ {"123@@@", false, 123},
+ {absl::StrCat(uint32_max, uint32_max), false, uint32_max},
+ };
+
+ for (const Uint32TestLine& test_line : uint32_test_line) {
+ uint32_t value = 2;
+ bool status = safe_strtou32_base(test_line.input, &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ value = 2;
+ status = safe_strtou32_base(test_line.input, &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ value = 2;
+ status = safe_strtou32_base(absl::string_view(test_line.input), &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ }
+}
+
+TEST(StrToInt64, Partial) {
+ struct Int64TestLine {
+ std::string input;
+ bool status;
+ int64_t value;
+ };
+ const int64_t int64_min = std::numeric_limits<int64_t>::min();
+ const int64_t int64_max = std::numeric_limits<int64_t>::max();
+ Int64TestLine int64_test_line[] = {
+ {"", false, 0},
+ {" ", false, 0},
+ {"-", false, 0},
+ {"123@@@", false, 123},
+ {absl::StrCat(int64_min, int64_max), false, int64_min},
+ {absl::StrCat(int64_max, int64_max), false, int64_max},
+ };
+
+ for (const Int64TestLine& test_line : int64_test_line) {
+ int64_t value = -2;
+ bool status = safe_strto64_base(test_line.input, &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ value = -2;
+ status = safe_strto64_base(test_line.input, &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ value = -2;
+ status = safe_strto64_base(absl::string_view(test_line.input), &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ }
+}
+
+TEST(StrToUint64, Partial) {
+ struct Uint64TestLine {
+ std::string input;
+ bool status;
+ uint64_t value;
+ };
+ const uint64_t uint64_max = std::numeric_limits<uint64_t>::max();
+ Uint64TestLine uint64_test_line[] = {
+ {"", false, 0},
+ {" ", false, 0},
+ {"-", false, 0},
+ {"123@@@", false, 123},
+ {absl::StrCat(uint64_max, uint64_max), false, uint64_max},
+ };
+
+ for (const Uint64TestLine& test_line : uint64_test_line) {
+ uint64_t value = 2;
+ bool status = safe_strtou64_base(test_line.input, &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ value = 2;
+ status = safe_strtou64_base(test_line.input, &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ value = 2;
+ status = safe_strtou64_base(absl::string_view(test_line.input), &value, 10);
+ EXPECT_EQ(test_line.status, status) << test_line.input;
+ EXPECT_EQ(test_line.value, value) << test_line.input;
+ }
+}
+
+TEST(StrToInt32Base, PrefixOnly) {
+ struct Int32TestLine {
+ std::string input;
+ bool status;
+ int32_t value;
+ };
+ Int32TestLine int32_test_line[] = {
+ { "", false, 0 },
+ { "-", false, 0 },
+ { "-0", true, 0 },
+ { "0", true, 0 },
+ { "0x", false, 0 },
+ { "-0x", false, 0 },
+ };
+ const int base_array[] = { 0, 2, 8, 10, 16 };
+
+ for (const Int32TestLine& line : int32_test_line) {
+ for (const int base : base_array) {
+ int32_t value = 2;
+ bool status = safe_strto32_base(line.input.c_str(), &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ value = 2;
+ status = safe_strto32_base(line.input, &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ value = 2;
+ status = safe_strto32_base(absl::string_view(line.input), &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ }
+ }
+}
+
+TEST(StrToUint32Base, PrefixOnly) {
+ struct Uint32TestLine {
+ std::string input;
+ bool status;
+ uint32_t value;
+ };
+ Uint32TestLine uint32_test_line[] = {
+ { "", false, 0 },
+ { "0", true, 0 },
+ { "0x", false, 0 },
+ };
+ const int base_array[] = { 0, 2, 8, 10, 16 };
+
+ for (const Uint32TestLine& line : uint32_test_line) {
+ for (const int base : base_array) {
+ uint32_t value = 2;
+ bool status = safe_strtou32_base(line.input.c_str(), &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ value = 2;
+ status = safe_strtou32_base(line.input, &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ value = 2;
+ status = safe_strtou32_base(absl::string_view(line.input), &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ }
+ }
+}
+
+TEST(StrToInt64Base, PrefixOnly) {
+ struct Int64TestLine {
+ std::string input;
+ bool status;
+ int64_t value;
+ };
+ Int64TestLine int64_test_line[] = {
+ { "", false, 0 },
+ { "-", false, 0 },
+ { "-0", true, 0 },
+ { "0", true, 0 },
+ { "0x", false, 0 },
+ { "-0x", false, 0 },
+ };
+ const int base_array[] = { 0, 2, 8, 10, 16 };
+
+ for (const Int64TestLine& line : int64_test_line) {
+ for (const int base : base_array) {
+ int64_t value = 2;
+ bool status = safe_strto64_base(line.input.c_str(), &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ value = 2;
+ status = safe_strto64_base(line.input, &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ value = 2;
+ status = safe_strto64_base(absl::string_view(line.input), &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ }
+ }
+}
+
+TEST(StrToUint64Base, PrefixOnly) {
+ struct Uint64TestLine {
+ std::string input;
+ bool status;
+ uint64_t value;
+ };
+ Uint64TestLine uint64_test_line[] = {
+ { "", false, 0 },
+ { "0", true, 0 },
+ { "0x", false, 0 },
+ };
+ const int base_array[] = { 0, 2, 8, 10, 16 };
+
+ for (const Uint64TestLine& line : uint64_test_line) {
+ for (const int base : base_array) {
+ uint64_t value = 2;
+ bool status = safe_strtou64_base(line.input.c_str(), &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ value = 2;
+ status = safe_strtou64_base(line.input, &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ value = 2;
+ status = safe_strtou64_base(absl::string_view(line.input), &value, base);
+ EXPECT_EQ(line.status, status) << line.input << " " << base;
+ EXPECT_EQ(line.value, value) << line.input << " " << base;
+ }
+ }
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat.cc
new file mode 100644
index 0000000..3fe8c95
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat.cc
@@ -0,0 +1,239 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/str_cat.h"
+
+#include <assert.h>
+#include <algorithm>
+#include <cstdint>
+#include <cstring>
+
+#include "absl/strings/ascii.h"
+#include "absl/strings/internal/resize_uninitialized.h"
+
+namespace absl {
+
+AlphaNum::AlphaNum(Hex hex) {
+ char* const end = &digits_[numbers_internal::kFastToBufferSize];
+ char* writer = end;
+ uint64_t value = hex.value;
+ static const char hexdigits[] = "0123456789abcdef";
+ do {
+ *--writer = hexdigits[value & 0xF];
+ value >>= 4;
+ } while (value != 0);
+
+ char* beg;
+ if (end - writer < hex.width) {
+ beg = end - hex.width;
+ std::fill_n(beg, writer - beg, hex.fill);
+ } else {
+ beg = writer;
+ }
+
+ piece_ = absl::string_view(beg, end - beg);
+}
+
+AlphaNum::AlphaNum(Dec dec) {
+ assert(dec.width <= numbers_internal::kFastToBufferSize);
+ char* const end = &digits_[numbers_internal::kFastToBufferSize];
+ char* const minfill = end - dec.width;
+ char* writer = end;
+ uint64_t value = dec.value;
+ bool neg = dec.neg;
+ while (value > 9) {
+ *--writer = '0' + (value % 10);
+ value /= 10;
+ }
+ *--writer = '0' + value;
+ if (neg) *--writer = '-';
+
+ ptrdiff_t fillers = writer - minfill;
+ if (fillers > 0) {
+ // Tricky: if the fill character is ' ', then it's <fill><+/-><digits>
+ // But...: if the fill character is '0', then it's <+/-><fill><digits>
+ bool add_sign_again = false;
+ if (neg && dec.fill == '0') { // If filling with '0',
+ ++writer; // ignore the sign we just added
+ add_sign_again = true; // and re-add the sign later.
+ }
+ writer -= fillers;
+ std::fill_n(writer, fillers, dec.fill);
+ if (add_sign_again) *--writer = '-';
+ }
+
+ piece_ = absl::string_view(writer, end - writer);
+}
+
+// ----------------------------------------------------------------------
+// StrCat()
+// This merges the given strings or integers, with no delimiter. This
+// is designed to be the fastest possible way to construct a std::string out
+// of a mix of raw C strings, StringPieces, strings, and integer values.
+// ----------------------------------------------------------------------
+
+// Append is merely a version of memcpy that returns the address of the byte
+// after the area just overwritten.
+static char* Append(char* out, const AlphaNum& x) {
+ // memcpy is allowed to overwrite arbitrary memory, so doing this after the
+ // call would force an extra fetch of x.size().
+ char* after = out + x.size();
+ memcpy(out, x.data(), x.size());
+ return after;
+}
+
+std::string StrCat(const AlphaNum& a, const AlphaNum& b) {
+ std::string result;
+ absl::strings_internal::STLStringResizeUninitialized(&result,
+ a.size() + b.size());
+ char* const begin = &*result.begin();
+ char* out = begin;
+ out = Append(out, a);
+ out = Append(out, b);
+ assert(out == begin + result.size());
+ return result;
+}
+
+std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c) {
+ std::string result;
+ strings_internal::STLStringResizeUninitialized(
+ &result, a.size() + b.size() + c.size());
+ char* const begin = &*result.begin();
+ char* out = begin;
+ out = Append(out, a);
+ out = Append(out, b);
+ out = Append(out, c);
+ assert(out == begin + result.size());
+ return result;
+}
+
+std::string StrCat(const AlphaNum& a, const AlphaNum& b, const AlphaNum& c,
+ const AlphaNum& d) {
+ std::string result;
+ strings_internal::STLStringResizeUninitialized(
+ &result, a.size() + b.size() + c.size() + d.size());
+ char* const begin = &*result.begin();
+ char* out = begin;
+ out = Append(out, a);
+ out = Append(out, b);
+ out = Append(out, c);
+ out = Append(out, d);
+ assert(out == begin + result.size());
+ return result;
+}
+
+namespace strings_internal {
+
+// Do not call directly - these are not part of the public API.
+std::string CatPieces(std::initializer_list<absl::string_view> pieces) {
+ std::string result;
+ size_t total_size = 0;
+ for (const absl::string_view piece : pieces) total_size += piece.size();
+ strings_internal::STLStringResizeUninitialized(&result, total_size);
+
+ char* const begin = &*result.begin();
+ char* out = begin;
+ for (const absl::string_view piece : pieces) {
+ const size_t this_size = piece.size();
+ memcpy(out, piece.data(), this_size);
+ out += this_size;
+ }
+ assert(out == begin + result.size());
+ return result;
+}
+
+// It's possible to call StrAppend with an absl::string_view that is itself a
+// fragment of the std::string we're appending to. However the results of this are
+// random. Therefore, check for this in debug mode. Use unsigned math so we
+// only have to do one comparison. Note, there's an exception case: appending an
+// empty std::string is always allowed.
+#define ASSERT_NO_OVERLAP(dest, src) \
+ assert(((src).size() == 0) || \
+ (uintptr_t((src).data() - (dest).data()) > uintptr_t((dest).size())))
+
+void AppendPieces(std::string* dest,
+ std::initializer_list<absl::string_view> pieces) {
+ size_t old_size = dest->size();
+ size_t total_size = old_size;
+ for (const absl::string_view piece : pieces) {
+ ASSERT_NO_OVERLAP(*dest, piece);
+ total_size += piece.size();
+ }
+ strings_internal::STLStringResizeUninitialized(dest, total_size);
+
+ char* const begin = &*dest->begin();
+ char* out = begin + old_size;
+ for (const absl::string_view piece : pieces) {
+ const size_t this_size = piece.size();
+ memcpy(out, piece.data(), this_size);
+ out += this_size;
+ }
+ assert(out == begin + dest->size());
+}
+
+} // namespace strings_internal
+
+void StrAppend(std::string* dest, const AlphaNum& a) {
+ ASSERT_NO_OVERLAP(*dest, a);
+ dest->append(a.data(), a.size());
+}
+
+void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b) {
+ ASSERT_NO_OVERLAP(*dest, a);
+ ASSERT_NO_OVERLAP(*dest, b);
+ std::string::size_type old_size = dest->size();
+ strings_internal::STLStringResizeUninitialized(
+ dest, old_size + a.size() + b.size());
+ char* const begin = &*dest->begin();
+ char* out = begin + old_size;
+ out = Append(out, a);
+ out = Append(out, b);
+ assert(out == begin + dest->size());
+}
+
+void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
+ const AlphaNum& c) {
+ ASSERT_NO_OVERLAP(*dest, a);
+ ASSERT_NO_OVERLAP(*dest, b);
+ ASSERT_NO_OVERLAP(*dest, c);
+ std::string::size_type old_size = dest->size();
+ strings_internal::STLStringResizeUninitialized(
+ dest, old_size + a.size() + b.size() + c.size());
+ char* const begin = &*dest->begin();
+ char* out = begin + old_size;
+ out = Append(out, a);
+ out = Append(out, b);
+ out = Append(out, c);
+ assert(out == begin + dest->size());
+}
+
+void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
+ const AlphaNum& c, const AlphaNum& d) {
+ ASSERT_NO_OVERLAP(*dest, a);
+ ASSERT_NO_OVERLAP(*dest, b);
+ ASSERT_NO_OVERLAP(*dest, c);
+ ASSERT_NO_OVERLAP(*dest, d);
+ std::string::size_type old_size = dest->size();
+ strings_internal::STLStringResizeUninitialized(
+ dest, old_size + a.size() + b.size() + c.size() + d.size());
+ char* const begin = &*dest->begin();
+ char* out = begin + old_size;
+ out = Append(out, a);
+ out = Append(out, b);
+ out = Append(out, c);
+ out = Append(out, d);
+ assert(out == begin + dest->size());
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat.h
new file mode 100644
index 0000000..e38369c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat.h
@@ -0,0 +1,385 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: str_cat.h
+// -----------------------------------------------------------------------------
+//
+// This package contains functions for efficiently concatenating and appending
+// strings: `StrCat()` and `StrAppend()`. Most of the work within these routines
+// is actually handled through use of a special AlphaNum type, which was
+// designed to be used as a parameter type that efficiently manages conversion
+// to strings and avoids copies in the above operations.
+//
+// Any routine accepting either a std::string or a number may accept `AlphaNum`.
+// The basic idea is that by accepting a `const AlphaNum &` as an argument
+// to your function, your callers will automagically convert bools, integers,
+// and floating point values to strings for you.
+//
+// NOTE: Use of `AlphaNum` outside of the //absl/strings package is unsupported
+// except for the specific case of function parameters of type `AlphaNum` or
+// `const AlphaNum &`. In particular, instantiating `AlphaNum` directly as a
+// stack variable is not supported.
+//
+// Conversion from 8-bit values is not accepted because, if it were, then an
+// attempt to pass ':' instead of ":" might result in a 58 ending up in your
+// result.
+//
+// Bools convert to "0" or "1".
+//
+// Floating point numbers are formatted with six-digit precision, which is
+// the default for "std::cout <<" or printf "%g" (the same as "%.6g").
+//
+//
+// You can convert to hexadecimal output rather than decimal output using the
+// `Hex` type contained here. To do so, pass `Hex(my_int)` as a parameter to
+// `StrCat()` or `StrAppend()`. You may specify a minimum hex field width using
+// a `PadSpec` enum.
+//
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_STRINGS_STR_CAT_H_
+#define ABSL_STRINGS_STR_CAT_H_
+
+#include <array>
+#include <cstdint>
+#include <string>
+#include <type_traits>
+
+#include "absl/base/port.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+
+namespace strings_internal {
+// AlphaNumBuffer allows a way to pass a std::string to StrCat without having to do
+// memory allocation. It is simply a pair of a fixed-size character array, and
+// a size. Please don't use outside of absl, yet.
+template <size_t max_size>
+struct AlphaNumBuffer {
+ std::array<char, max_size> data;
+ size_t size;
+};
+
+} // namespace strings_internal
+
+// Enum that specifies the number of significant digits to return in a `Hex` or
+// `Dec` conversion and fill character to use. A `kZeroPad2` value, for example,
+// would produce hexadecimal strings such as "0A","0F" and a 'kSpacePad5' value
+// would produce hexadecimal strings such as " A"," F".
+enum PadSpec {
+ kNoPad = 1,
+ kZeroPad2,
+ kZeroPad3,
+ kZeroPad4,
+ kZeroPad5,
+ kZeroPad6,
+ kZeroPad7,
+ kZeroPad8,
+ kZeroPad9,
+ kZeroPad10,
+ kZeroPad11,
+ kZeroPad12,
+ kZeroPad13,
+ kZeroPad14,
+ kZeroPad15,
+ kZeroPad16,
+
+ kSpacePad2 = kZeroPad2 + 64,
+ kSpacePad3,
+ kSpacePad4,
+ kSpacePad5,
+ kSpacePad6,
+ kSpacePad7,
+ kSpacePad8,
+ kSpacePad9,
+ kSpacePad10,
+ kSpacePad11,
+ kSpacePad12,
+ kSpacePad13,
+ kSpacePad14,
+ kSpacePad15,
+ kSpacePad16,
+};
+
+// -----------------------------------------------------------------------------
+// Hex
+// -----------------------------------------------------------------------------
+//
+// `Hex` stores a set of hexadecimal std::string conversion parameters for use
+// within `AlphaNum` std::string conversions.
+struct Hex {
+ uint64_t value;
+ uint8_t width;
+ char fill;
+
+ template <typename Int>
+ explicit Hex(
+ Int v, PadSpec spec = absl::kNoPad,
+ typename std::enable_if<sizeof(Int) == 1 &&
+ !std::is_pointer<Int>::value>::type* = nullptr)
+ : Hex(spec, static_cast<uint8_t>(v)) {}
+ template <typename Int>
+ explicit Hex(
+ Int v, PadSpec spec = absl::kNoPad,
+ typename std::enable_if<sizeof(Int) == 2 &&
+ !std::is_pointer<Int>::value>::type* = nullptr)
+ : Hex(spec, static_cast<uint16_t>(v)) {}
+ template <typename Int>
+ explicit Hex(
+ Int v, PadSpec spec = absl::kNoPad,
+ typename std::enable_if<sizeof(Int) == 4 &&
+ !std::is_pointer<Int>::value>::type* = nullptr)
+ : Hex(spec, static_cast<uint32_t>(v)) {}
+ template <typename Int>
+ explicit Hex(
+ Int v, PadSpec spec = absl::kNoPad,
+ typename std::enable_if<sizeof(Int) == 8 &&
+ !std::is_pointer<Int>::value>::type* = nullptr)
+ : Hex(spec, static_cast<uint64_t>(v)) {}
+ template <typename Pointee>
+ explicit Hex(Pointee* v, PadSpec spec = absl::kNoPad)
+ : Hex(spec, reinterpret_cast<uintptr_t>(v)) {}
+
+ private:
+ Hex(PadSpec spec, uint64_t v)
+ : value(v),
+ width(spec == absl::kNoPad
+ ? 1
+ : spec >= absl::kSpacePad2 ? spec - absl::kSpacePad2 + 2
+ : spec - absl::kZeroPad2 + 2),
+ fill(spec >= absl::kSpacePad2 ? ' ' : '0') {}
+};
+
+// -----------------------------------------------------------------------------
+// Dec
+// -----------------------------------------------------------------------------
+//
+// `Dec` stores a set of decimal std::string conversion parameters for use
+// within `AlphaNum` std::string conversions. Dec is slower than the default
+// integer conversion, so use it only if you need padding.
+struct Dec {
+ uint64_t value;
+ uint8_t width;
+ char fill;
+ bool neg;
+
+ template <typename Int>
+ explicit Dec(Int v, PadSpec spec = absl::kNoPad,
+ typename std::enable_if<(sizeof(Int) <= 8)>::type* = nullptr)
+ : value(v >= 0 ? static_cast<uint64_t>(v)
+ : uint64_t{0} - static_cast<uint64_t>(v)),
+ width(spec == absl::kNoPad
+ ? 1
+ : spec >= absl::kSpacePad2 ? spec - absl::kSpacePad2 + 2
+ : spec - absl::kZeroPad2 + 2),
+ fill(spec >= absl::kSpacePad2 ? ' ' : '0'),
+ neg(v < 0) {}
+};
+
+// -----------------------------------------------------------------------------
+// AlphaNum
+// -----------------------------------------------------------------------------
+//
+// The `AlphaNum` class acts as the main parameter type for `StrCat()` and
+// `StrAppend()`, providing efficient conversion of numeric, boolean, and
+// hexadecimal values (through the `Hex` type) into strings.
+
+class AlphaNum {
+ public:
+ // No bool ctor -- bools convert to an integral type.
+ // A bool ctor would also convert incoming pointers (bletch).
+
+ AlphaNum(int x) // NOLINT(runtime/explicit)
+ : piece_(digits_,
+ numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]) {}
+ AlphaNum(unsigned int x) // NOLINT(runtime/explicit)
+ : piece_(digits_,
+ numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]) {}
+ AlphaNum(long x) // NOLINT(*)
+ : piece_(digits_,
+ numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]) {}
+ AlphaNum(unsigned long x) // NOLINT(*)
+ : piece_(digits_,
+ numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]) {}
+ AlphaNum(long long x) // NOLINT(*)
+ : piece_(digits_,
+ numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]) {}
+ AlphaNum(unsigned long long x) // NOLINT(*)
+ : piece_(digits_,
+ numbers_internal::FastIntToBuffer(x, digits_) - &digits_[0]) {}
+
+ AlphaNum(float f) // NOLINT(runtime/explicit)
+ : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
+ AlphaNum(double f) // NOLINT(runtime/explicit)
+ : piece_(digits_, numbers_internal::SixDigitsToBuffer(f, digits_)) {}
+
+ AlphaNum(Hex hex); // NOLINT(runtime/explicit)
+ AlphaNum(Dec dec); // NOLINT(runtime/explicit)
+
+ template <size_t size>
+ AlphaNum( // NOLINT(runtime/explicit)
+ const strings_internal::AlphaNumBuffer<size>& buf)
+ : piece_(&buf.data[0], buf.size) {}
+
+ AlphaNum(const char* c_str) : piece_(c_str) {} // NOLINT(runtime/explicit)
+ AlphaNum(absl::string_view pc) : piece_(pc) {} // NOLINT(runtime/explicit)
+ template <typename Allocator>
+ AlphaNum( // NOLINT(runtime/explicit)
+ const std::basic_string<char, std::char_traits<char>, Allocator>& str)
+ : piece_(str) {}
+
+ // Use std::string literals ":" instead of character literals ':'.
+ AlphaNum(char c) = delete; // NOLINT(runtime/explicit)
+
+ AlphaNum(const AlphaNum&) = delete;
+ AlphaNum& operator=(const AlphaNum&) = delete;
+
+ absl::string_view::size_type size() const { return piece_.size(); }
+ const char* data() const { return piece_.data(); }
+ absl::string_view Piece() const { return piece_; }
+
+ // Normal enums are already handled by the integer formatters.
+ // This overload matches only scoped enums.
+ template <typename T,
+ typename = typename std::enable_if<
+ std::is_enum<T>{} && !std::is_convertible<T, int>{}>::type>
+ AlphaNum(T e) // NOLINT(runtime/explicit)
+ : AlphaNum(static_cast<typename std::underlying_type<T>::type>(e)) {}
+
+ private:
+ absl::string_view piece_;
+ char digits_[numbers_internal::kFastToBufferSize];
+};
+
+// -----------------------------------------------------------------------------
+// StrCat()
+// -----------------------------------------------------------------------------
+//
+// Merges given strings or numbers, using no delimiter(s).
+//
+// `StrCat()` is designed to be the fastest possible way to construct a std::string
+// out of a mix of raw C strings, string_views, strings, bool values,
+// and numeric values.
+//
+// Don't use `StrCat()` for user-visible strings. The localization process
+// works poorly on strings built up out of fragments.
+//
+// For clarity and performance, don't use `StrCat()` when appending to a
+// std::string. Use `StrAppend()` instead. In particular, avoid using any of these
+// (anti-)patterns:
+//
+// str.append(StrCat(...))
+// str += StrCat(...)
+// str = StrCat(str, ...)
+//
+// The last case is the worst, with a potential to change a loop
+// from a linear time operation with O(1) dynamic allocations into a
+// quadratic time operation with O(n) dynamic allocations.
+//
+// See `StrAppend()` below for more information.
+
+namespace strings_internal {
+
+// Do not call directly - this is not part of the public API.
+std::string CatPieces(std::initializer_list<absl::string_view> pieces);
+void AppendPieces(std::string* dest,
+ std::initializer_list<absl::string_view> pieces);
+
+} // namespace strings_internal
+
+ABSL_MUST_USE_RESULT inline std::string StrCat() { return std::string(); }
+
+ABSL_MUST_USE_RESULT inline std::string StrCat(const AlphaNum& a) {
+ return std::string(a.data(), a.size());
+}
+
+ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b);
+ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+ const AlphaNum& c);
+ABSL_MUST_USE_RESULT std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+ const AlphaNum& c, const AlphaNum& d);
+
+// Support 5 or more arguments
+template <typename... AV>
+ABSL_MUST_USE_RESULT inline std::string StrCat(const AlphaNum& a, const AlphaNum& b,
+ const AlphaNum& c, const AlphaNum& d,
+ const AlphaNum& e,
+ const AV&... args) {
+ return strings_internal::CatPieces(
+ {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
+ static_cast<const AlphaNum&>(args).Piece()...});
+}
+
+// -----------------------------------------------------------------------------
+// StrAppend()
+// -----------------------------------------------------------------------------
+//
+// Appends a std::string or set of strings to an existing std::string, in a similar
+// fashion to `StrCat()`.
+//
+// WARNING: `StrAppend(&str, a, b, c, ...)` requires that none of the
+// a, b, c, parameters be a reference into str. For speed, `StrAppend()` does
+// not try to check each of its input arguments to be sure that they are not
+// a subset of the std::string being appended to. That is, while this will work:
+//
+// std::string s = "foo";
+// s += s;
+//
+// This output is undefined:
+//
+// std::string s = "foo";
+// StrAppend(&s, s);
+//
+// This output is undefined as well, since `absl::string_view` does not own its
+// data:
+//
+// std::string s = "foobar";
+// absl::string_view p = s;
+// StrAppend(&s, p);
+
+inline void StrAppend(std::string*) {}
+void StrAppend(std::string* dest, const AlphaNum& a);
+void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b);
+void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
+ const AlphaNum& c);
+void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
+ const AlphaNum& c, const AlphaNum& d);
+
+// Support 5 or more arguments
+template <typename... AV>
+inline void StrAppend(std::string* dest, const AlphaNum& a, const AlphaNum& b,
+ const AlphaNum& c, const AlphaNum& d, const AlphaNum& e,
+ const AV&... args) {
+ strings_internal::AppendPieces(
+ dest, {a.Piece(), b.Piece(), c.Piece(), d.Piece(), e.Piece(),
+ static_cast<const AlphaNum&>(args).Piece()...});
+}
+
+// Helper function for the future StrCat default floating-point format, %.6g
+// This is fast.
+inline strings_internal::AlphaNumBuffer<
+ numbers_internal::kSixDigitsToBufferSize>
+SixDigits(double d) {
+ strings_internal::AlphaNumBuffer<numbers_internal::kSixDigitsToBufferSize>
+ result;
+ result.size = numbers_internal::SixDigitsToBuffer(d, &result.data[0]);
+ return result;
+}
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_STR_CAT_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat_test.cc
new file mode 100644
index 0000000..c86a595
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/str_cat_test.cc
@@ -0,0 +1,539 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Unit tests for all str_cat.h functions
+
+#include "absl/strings/str_cat.h"
+
+#include <cstdint>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "absl/strings/substitute.h"
+
+namespace {
+
+// Test absl::StrCat of ints and longs of various sizes and signdedness.
+TEST(StrCat, Ints) {
+ const short s = -1; // NOLINT(runtime/int)
+ const uint16_t us = 2;
+ const int i = -3;
+ const unsigned int ui = 4;
+ const long l = -5; // NOLINT(runtime/int)
+ const unsigned long ul = 6; // NOLINT(runtime/int)
+ const long long ll = -7; // NOLINT(runtime/int)
+ const unsigned long long ull = 8; // NOLINT(runtime/int)
+ const ptrdiff_t ptrdiff = -9;
+ const size_t size = 10;
+ const intptr_t intptr = -12;
+ const uintptr_t uintptr = 13;
+ std::string answer;
+ answer = absl::StrCat(s, us);
+ EXPECT_EQ(answer, "-12");
+ answer = absl::StrCat(i, ui);
+ EXPECT_EQ(answer, "-34");
+ answer = absl::StrCat(l, ul);
+ EXPECT_EQ(answer, "-56");
+ answer = absl::StrCat(ll, ull);
+ EXPECT_EQ(answer, "-78");
+ answer = absl::StrCat(ptrdiff, size);
+ EXPECT_EQ(answer, "-910");
+ answer = absl::StrCat(ptrdiff, intptr);
+ EXPECT_EQ(answer, "-9-12");
+ answer = absl::StrCat(uintptr, 0);
+ EXPECT_EQ(answer, "130");
+}
+
+TEST(StrCat, Enums) {
+ enum SmallNumbers { One = 1, Ten = 10 } e = Ten;
+ EXPECT_EQ("10", absl::StrCat(e));
+ EXPECT_EQ("-5", absl::StrCat(SmallNumbers(-5)));
+
+ enum class Option { Boxers = 1, Briefs = -1 };
+
+ EXPECT_EQ("-1", absl::StrCat(Option::Briefs));
+
+ enum class Airplane : uint64_t {
+ Airbus = 1,
+ Boeing = 1000,
+ Canary = 10000000000 // too big for "int"
+ };
+
+ EXPECT_EQ("10000000000", absl::StrCat(Airplane::Canary));
+
+ enum class TwoGig : int32_t {
+ TwoToTheZero = 1,
+ TwoToTheSixteenth = 1 << 16,
+ TwoToTheThirtyFirst = INT32_MIN
+ };
+ EXPECT_EQ("65536", absl::StrCat(TwoGig::TwoToTheSixteenth));
+ EXPECT_EQ("-2147483648", absl::StrCat(TwoGig::TwoToTheThirtyFirst));
+ EXPECT_EQ("-1", absl::StrCat(static_cast<TwoGig>(-1)));
+
+ enum class FourGig : uint32_t {
+ TwoToTheZero = 1,
+ TwoToTheSixteenth = 1 << 16,
+ TwoToTheThirtyFirst = 1U << 31 // too big for "int"
+ };
+ EXPECT_EQ("65536", absl::StrCat(FourGig::TwoToTheSixteenth));
+ EXPECT_EQ("2147483648", absl::StrCat(FourGig::TwoToTheThirtyFirst));
+ EXPECT_EQ("4294967295", absl::StrCat(static_cast<FourGig>(-1)));
+
+ EXPECT_EQ("10000000000", absl::StrCat(Airplane::Canary));
+}
+
+TEST(StrCat, Basics) {
+ std::string result;
+
+ std::string strs[] = {
+ "Hello",
+ "Cruel",
+ "World"
+ };
+
+ std::string stdstrs[] = {
+ "std::Hello",
+ "std::Cruel",
+ "std::World"
+ };
+
+ absl::string_view pieces[] = {"Hello", "Cruel", "World"};
+
+ const char* c_strs[] = {
+ "Hello",
+ "Cruel",
+ "World"
+ };
+
+ int32_t i32s[] = {'H', 'C', 'W'};
+ uint64_t ui64s[] = {12345678910LL, 10987654321LL};
+
+ EXPECT_EQ(absl::StrCat(), "");
+
+ result = absl::StrCat(false, true, 2, 3);
+ EXPECT_EQ(result, "0123");
+
+ result = absl::StrCat(-1);
+ EXPECT_EQ(result, "-1");
+
+ result = absl::StrCat(absl::SixDigits(0.5));
+ EXPECT_EQ(result, "0.5");
+
+ result = absl::StrCat(strs[1], pieces[2]);
+ EXPECT_EQ(result, "CruelWorld");
+
+ result = absl::StrCat(stdstrs[1], " ", stdstrs[2]);
+ EXPECT_EQ(result, "std::Cruel std::World");
+
+ result = absl::StrCat(strs[0], ", ", pieces[2]);
+ EXPECT_EQ(result, "Hello, World");
+
+ result = absl::StrCat(strs[0], ", ", strs[1], " ", strs[2], "!");
+ EXPECT_EQ(result, "Hello, Cruel World!");
+
+ result = absl::StrCat(pieces[0], ", ", pieces[1], " ", pieces[2]);
+ EXPECT_EQ(result, "Hello, Cruel World");
+
+ result = absl::StrCat(c_strs[0], ", ", c_strs[1], " ", c_strs[2]);
+ EXPECT_EQ(result, "Hello, Cruel World");
+
+ result = absl::StrCat("ASCII ", i32s[0], ", ", i32s[1], " ", i32s[2], "!");
+ EXPECT_EQ(result, "ASCII 72, 67 87!");
+
+ result = absl::StrCat(ui64s[0], ", ", ui64s[1], "!");
+ EXPECT_EQ(result, "12345678910, 10987654321!");
+
+ std::string one = "1"; // Actually, it's the size of this std::string that we want; a
+ // 64-bit build distinguishes between size_t and uint64_t,
+ // even though they're both unsigned 64-bit values.
+ result = absl::StrCat("And a ", one.size(), " and a ",
+ &result[2] - &result[0], " and a ", one, " 2 3 4", "!");
+ EXPECT_EQ(result, "And a 1 and a 2 and a 1 2 3 4!");
+
+ // result = absl::StrCat("Single chars won't compile", '!');
+ // result = absl::StrCat("Neither will nullptrs", nullptr);
+ result =
+ absl::StrCat("To output a char by ASCII/numeric value, use +: ", '!' + 0);
+ EXPECT_EQ(result, "To output a char by ASCII/numeric value, use +: 33");
+
+ float f = 100000.5;
+ result = absl::StrCat("A hundred K and a half is ", absl::SixDigits(f));
+ EXPECT_EQ(result, "A hundred K and a half is 100000");
+
+ f = 100001.5;
+ result =
+ absl::StrCat("A hundred K and one and a half is ", absl::SixDigits(f));
+ EXPECT_EQ(result, "A hundred K and one and a half is 100002");
+
+ double d = 100000.5;
+ d *= d;
+ result =
+ absl::StrCat("A hundred K and a half squared is ", absl::SixDigits(d));
+ EXPECT_EQ(result, "A hundred K and a half squared is 1.00001e+10");
+
+ result = absl::StrCat(1, 2, 333, 4444, 55555, 666666, 7777777, 88888888,
+ 999999999);
+ EXPECT_EQ(result, "12333444455555666666777777788888888999999999");
+}
+
+// A minimal allocator that uses malloc().
+template <typename T>
+struct Mallocator {
+ typedef T value_type;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef T* pointer;
+ typedef const T* const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+
+ size_type max_size() const {
+ return size_t(std::numeric_limits<size_type>::max()) / sizeof(value_type);
+ }
+ template <typename U>
+ struct rebind {
+ typedef Mallocator<U> other;
+ };
+ Mallocator() = default;
+ template <class U>
+ Mallocator(const Mallocator<U>&) {} // NOLINT(runtime/explicit)
+
+ T* allocate(size_t n) { return static_cast<T*>(std::malloc(n * sizeof(T))); }
+ void deallocate(T* p, size_t) { std::free(p); }
+};
+template <typename T, typename U>
+bool operator==(const Mallocator<T>&, const Mallocator<U>&) {
+ return true;
+}
+template <typename T, typename U>
+bool operator!=(const Mallocator<T>&, const Mallocator<U>&) {
+ return false;
+}
+
+TEST(StrCat, CustomAllocator) {
+ using mstring =
+ std::basic_string<char, std::char_traits<char>, Mallocator<char>>;
+ const mstring str1("PARACHUTE OFF A BLIMP INTO MOSCONE!!");
+
+ const mstring str2("Read this book about coffee tables");
+
+ std::string result = absl::StrCat(str1, str2);
+ EXPECT_EQ(result,
+ "PARACHUTE OFF A BLIMP INTO MOSCONE!!"
+ "Read this book about coffee tables");
+}
+
+TEST(StrCat, MaxArgs) {
+ std::string result;
+ // Test 10 up to 26 arguments, the old maximum
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a");
+ EXPECT_EQ(result, "123456789a");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b");
+ EXPECT_EQ(result, "123456789ab");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c");
+ EXPECT_EQ(result, "123456789abc");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d");
+ EXPECT_EQ(result, "123456789abcd");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e");
+ EXPECT_EQ(result, "123456789abcde");
+ result =
+ absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f");
+ EXPECT_EQ(result, "123456789abcdef");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g");
+ EXPECT_EQ(result, "123456789abcdefg");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h");
+ EXPECT_EQ(result, "123456789abcdefgh");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i");
+ EXPECT_EQ(result, "123456789abcdefghi");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j");
+ EXPECT_EQ(result, "123456789abcdefghij");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k");
+ EXPECT_EQ(result, "123456789abcdefghijk");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l");
+ EXPECT_EQ(result, "123456789abcdefghijkl");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l", "m");
+ EXPECT_EQ(result, "123456789abcdefghijklm");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l", "m", "n");
+ EXPECT_EQ(result, "123456789abcdefghijklmn");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l", "m", "n", "o");
+ EXPECT_EQ(result, "123456789abcdefghijklmno");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l", "m", "n", "o", "p");
+ EXPECT_EQ(result, "123456789abcdefghijklmnop");
+ result = absl::StrCat(1, 2, 3, 4, 5, 6, 7, 8, 9, "a", "b", "c", "d", "e", "f",
+ "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q");
+ EXPECT_EQ(result, "123456789abcdefghijklmnopq");
+ // No limit thanks to C++11's variadic templates
+ result = absl::StrCat(
+ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, "a", "b", "c", "d", "e", "f", "g", "h",
+ "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w",
+ "x", "y", "z", "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L",
+ "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z");
+ EXPECT_EQ(result,
+ "12345678910abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
+}
+
+TEST(StrAppend, Basics) {
+ std::string result = "existing text";
+
+ std::string strs[] = {
+ "Hello",
+ "Cruel",
+ "World"
+ };
+
+ std::string stdstrs[] = {
+ "std::Hello",
+ "std::Cruel",
+ "std::World"
+ };
+
+ absl::string_view pieces[] = {"Hello", "Cruel", "World"};
+
+ const char* c_strs[] = {
+ "Hello",
+ "Cruel",
+ "World"
+ };
+
+ int32_t i32s[] = {'H', 'C', 'W'};
+ uint64_t ui64s[] = {12345678910LL, 10987654321LL};
+
+ std::string::size_type old_size = result.size();
+ absl::StrAppend(&result);
+ EXPECT_EQ(result.size(), old_size);
+
+ old_size = result.size();
+ absl::StrAppend(&result, strs[0]);
+ EXPECT_EQ(result.substr(old_size), "Hello");
+
+ old_size = result.size();
+ absl::StrAppend(&result, strs[1], pieces[2]);
+ EXPECT_EQ(result.substr(old_size), "CruelWorld");
+
+ old_size = result.size();
+ absl::StrAppend(&result, stdstrs[0], ", ", pieces[2]);
+ EXPECT_EQ(result.substr(old_size), "std::Hello, World");
+
+ old_size = result.size();
+ absl::StrAppend(&result, strs[0], ", ", stdstrs[1], " ", strs[2], "!");
+ EXPECT_EQ(result.substr(old_size), "Hello, std::Cruel World!");
+
+ old_size = result.size();
+ absl::StrAppend(&result, pieces[0], ", ", pieces[1], " ", pieces[2]);
+ EXPECT_EQ(result.substr(old_size), "Hello, Cruel World");
+
+ old_size = result.size();
+ absl::StrAppend(&result, c_strs[0], ", ", c_strs[1], " ", c_strs[2]);
+ EXPECT_EQ(result.substr(old_size), "Hello, Cruel World");
+
+ old_size = result.size();
+ absl::StrAppend(&result, "ASCII ", i32s[0], ", ", i32s[1], " ", i32s[2], "!");
+ EXPECT_EQ(result.substr(old_size), "ASCII 72, 67 87!");
+
+ old_size = result.size();
+ absl::StrAppend(&result, ui64s[0], ", ", ui64s[1], "!");
+ EXPECT_EQ(result.substr(old_size), "12345678910, 10987654321!");
+
+ std::string one = "1"; // Actually, it's the size of this std::string that we want; a
+ // 64-bit build distinguishes between size_t and uint64_t,
+ // even though they're both unsigned 64-bit values.
+ old_size = result.size();
+ absl::StrAppend(&result, "And a ", one.size(), " and a ",
+ &result[2] - &result[0], " and a ", one, " 2 3 4", "!");
+ EXPECT_EQ(result.substr(old_size), "And a 1 and a 2 and a 1 2 3 4!");
+
+ // result = absl::StrCat("Single chars won't compile", '!');
+ // result = absl::StrCat("Neither will nullptrs", nullptr);
+ old_size = result.size();
+ absl::StrAppend(&result,
+ "To output a char by ASCII/numeric value, use +: ", '!' + 0);
+ EXPECT_EQ(result.substr(old_size),
+ "To output a char by ASCII/numeric value, use +: 33");
+
+ // Test 9 arguments, the old maximum
+ old_size = result.size();
+ absl::StrAppend(&result, 1, 22, 333, 4444, 55555, 666666, 7777777, 88888888,
+ 9);
+ EXPECT_EQ(result.substr(old_size), "1223334444555556666667777777888888889");
+
+ // No limit thanks to C++11's variadic templates
+ old_size = result.size();
+ absl::StrAppend(
+ &result, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, //
+ "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", //
+ "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z", //
+ "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M", //
+ "N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z", //
+ "No limit thanks to C++11's variadic templates");
+ EXPECT_EQ(result.substr(old_size),
+ "12345678910abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+ "No limit thanks to C++11's variadic templates");
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+TEST(StrAppend, Death) {
+ std::string s = "self";
+ // on linux it's "assertion", on mac it's "Assertion",
+ // on chromiumos it's "Assertion ... failed".
+ EXPECT_DEBUG_DEATH(absl::StrAppend(&s, s.c_str() + 1), "ssertion.*failed");
+ EXPECT_DEBUG_DEATH(absl::StrAppend(&s, s), "ssertion.*failed");
+}
+#endif // GTEST_HAS_DEATH_TEST
+
+TEST(StrAppend, EmptyString) {
+ std::string s = "";
+ absl::StrAppend(&s, s);
+ EXPECT_EQ(s, "");
+}
+
+template <typename IntType>
+void CheckHex(IntType v, const char* nopad_format, const char* zeropad_format,
+ const char* spacepad_format) {
+ char expected[256];
+
+ std::string actual = absl::StrCat(absl::Hex(v, absl::kNoPad));
+ snprintf(expected, sizeof(expected), nopad_format, v);
+ EXPECT_EQ(expected, actual) << " decimal value " << v;
+
+ for (int spec = absl::kZeroPad2; spec <= absl::kZeroPad16; ++spec) {
+ std::string actual =
+ absl::StrCat(absl::Hex(v, static_cast<absl::PadSpec>(spec)));
+ snprintf(expected, sizeof(expected), zeropad_format,
+ spec - absl::kZeroPad2 + 2, v);
+ EXPECT_EQ(expected, actual) << " decimal value " << v;
+ }
+
+ for (int spec = absl::kSpacePad2; spec <= absl::kSpacePad16; ++spec) {
+ std::string actual =
+ absl::StrCat(absl::Hex(v, static_cast<absl::PadSpec>(spec)));
+ snprintf(expected, sizeof(expected), spacepad_format,
+ spec - absl::kSpacePad2 + 2, v);
+ EXPECT_EQ(expected, actual) << " decimal value " << v;
+ }
+}
+
+template <typename IntType>
+void CheckDec(IntType v, const char* nopad_format, const char* zeropad_format,
+ const char* spacepad_format) {
+ char expected[256];
+
+ std::string actual = absl::StrCat(absl::Dec(v, absl::kNoPad));
+ snprintf(expected, sizeof(expected), nopad_format, v);
+ EXPECT_EQ(expected, actual) << " decimal value " << v;
+
+ for (int spec = absl::kZeroPad2; spec <= absl::kZeroPad16; ++spec) {
+ std::string actual =
+ absl::StrCat(absl::Dec(v, static_cast<absl::PadSpec>(spec)));
+ snprintf(expected, sizeof(expected), zeropad_format,
+ spec - absl::kZeroPad2 + 2, v);
+ EXPECT_EQ(expected, actual)
+ << " decimal value " << v << " format '" << zeropad_format
+ << "' digits " << (spec - absl::kZeroPad2 + 2);
+ }
+
+ for (int spec = absl::kSpacePad2; spec <= absl::kSpacePad16; ++spec) {
+ std::string actual =
+ absl::StrCat(absl::Dec(v, static_cast<absl::PadSpec>(spec)));
+ snprintf(expected, sizeof(expected), spacepad_format,
+ spec - absl::kSpacePad2 + 2, v);
+ EXPECT_EQ(expected, actual)
+ << " decimal value " << v << " format '" << spacepad_format
+ << "' digits " << (spec - absl::kSpacePad2 + 2);
+ }
+}
+
+void CheckHexDec64(uint64_t v) {
+ unsigned long long ullv = v; // NOLINT(runtime/int)
+
+ CheckHex(ullv, "%llx", "%0*llx", "%*llx");
+ CheckDec(ullv, "%llu", "%0*llu", "%*llu");
+
+ long long llv = static_cast<long long>(ullv); // NOLINT(runtime/int)
+ CheckDec(llv, "%lld", "%0*lld", "%*lld");
+
+ if (sizeof(v) == sizeof(&v)) {
+ auto uintptr = static_cast<uintptr_t>(v);
+ void* ptr = reinterpret_cast<void*>(uintptr);
+ CheckHex(ptr, "%llx", "%0*llx", "%*llx");
+ }
+}
+
+void CheckHexDec32(uint32_t uv) {
+ CheckHex(uv, "%x", "%0*x", "%*x");
+ CheckDec(uv, "%u", "%0*u", "%*u");
+ int32_t v = static_cast<int32_t>(uv);
+ CheckDec(v, "%d", "%0*d", "%*d");
+
+ if (sizeof(v) == sizeof(&v)) {
+ auto uintptr = static_cast<uintptr_t>(v);
+ void* ptr = reinterpret_cast<void*>(uintptr);
+ CheckHex(ptr, "%x", "%0*x", "%*x");
+ }
+}
+
+void CheckAll(uint64_t v) {
+ CheckHexDec64(v);
+ CheckHexDec32(static_cast<uint32_t>(v));
+}
+
+void TestFastPrints() {
+ // Test all small ints; there aren't many and they're common.
+ for (int i = 0; i < 10000; i++) {
+ CheckAll(i);
+ }
+
+ CheckAll(std::numeric_limits<uint64_t>::max());
+ CheckAll(std::numeric_limits<uint64_t>::max() - 1);
+ CheckAll(std::numeric_limits<int64_t>::min());
+ CheckAll(std::numeric_limits<int64_t>::min() + 1);
+ CheckAll(std::numeric_limits<uint32_t>::max());
+ CheckAll(std::numeric_limits<uint32_t>::max() - 1);
+ CheckAll(std::numeric_limits<int32_t>::min());
+ CheckAll(std::numeric_limits<int32_t>::min() + 1);
+ CheckAll(999999999); // fits in 32 bits
+ CheckAll(1000000000); // fits in 32 bits
+ CheckAll(9999999999); // doesn't fit in 32 bits
+ CheckAll(10000000000); // doesn't fit in 32 bits
+ CheckAll(999999999999999999); // fits in signed 64-bit
+ CheckAll(9999999999999999999u); // fits in unsigned 64-bit, but not signed.
+ CheckAll(1000000000000000000); // fits in signed 64-bit
+ CheckAll(10000000000000000000u); // fits in unsigned 64-bit, but not signed.
+
+ CheckAll(999999999876543210); // check all decimal digits, signed
+ CheckAll(9999999999876543210u); // check all decimal digits, unsigned.
+ CheckAll(0x123456789abcdef0); // check all hex digits
+ CheckAll(0x12345678);
+
+ int8_t minus_one_8bit = -1;
+ EXPECT_EQ("ff", absl::StrCat(absl::Hex(minus_one_8bit)));
+
+ int16_t minus_one_16bit = -1;
+ EXPECT_EQ("ffff", absl::StrCat(absl::Hex(minus_one_16bit)));
+}
+
+TEST(Numbers, TestFunctionsMovedOverFromNumbersMain) {
+ TestFastPrints();
+}
+
+} // namespace
[39/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle.cc
new file mode 100644
index 0000000..c9ca2f3
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle.cc
@@ -0,0 +1,1862 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// For reference check out:
+// https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
+//
+// Note that we only have partial C++11 support yet.
+
+#include "absl/debugging/internal/demangle.h"
+
+#include <cstdint>
+#include <cstdio>
+#include <limits>
+
+namespace absl {
+namespace debugging_internal {
+
+typedef struct {
+ const char *abbrev;
+ const char *real_name;
+ // Number of arguments in <expression> context, or 0 if disallowed.
+ int arity;
+} AbbrevPair;
+
+// List of operators from Itanium C++ ABI.
+static const AbbrevPair kOperatorList[] = {
+ // New has special syntax (not currently supported).
+ {"nw", "new", 0},
+ {"na", "new[]", 0},
+
+ // Works except that the 'gs' prefix is not supported.
+ {"dl", "delete", 1},
+ {"da", "delete[]", 1},
+
+ {"ps", "+", 1}, // "positive"
+ {"ng", "-", 1}, // "negative"
+ {"ad", "&", 1}, // "address-of"
+ {"de", "*", 1}, // "dereference"
+ {"co", "~", 1},
+
+ {"pl", "+", 2},
+ {"mi", "-", 2},
+ {"ml", "*", 2},
+ {"dv", "/", 2},
+ {"rm", "%", 2},
+ {"an", "&", 2},
+ {"or", "|", 2},
+ {"eo", "^", 2},
+ {"aS", "=", 2},
+ {"pL", "+=", 2},
+ {"mI", "-=", 2},
+ {"mL", "*=", 2},
+ {"dV", "/=", 2},
+ {"rM", "%=", 2},
+ {"aN", "&=", 2},
+ {"oR", "|=", 2},
+ {"eO", "^=", 2},
+ {"ls", "<<", 2},
+ {"rs", ">>", 2},
+ {"lS", "<<=", 2},
+ {"rS", ">>=", 2},
+ {"eq", "==", 2},
+ {"ne", "!=", 2},
+ {"lt", "<", 2},
+ {"gt", ">", 2},
+ {"le", "<=", 2},
+ {"ge", ">=", 2},
+ {"nt", "!", 1},
+ {"aa", "&&", 2},
+ {"oo", "||", 2},
+ {"pp", "++", 1},
+ {"mm", "--", 1},
+ {"cm", ",", 2},
+ {"pm", "->*", 2},
+ {"pt", "->", 0}, // Special syntax
+ {"cl", "()", 0}, // Special syntax
+ {"ix", "[]", 2},
+ {"qu", "?", 3},
+ {"st", "sizeof", 0}, // Special syntax
+ {"sz", "sizeof", 1}, // Not a real operator name, but used in expressions.
+ {nullptr, nullptr, 0},
+};
+
+// List of builtin types from Itanium C++ ABI.
+static const AbbrevPair kBuiltinTypeList[] = {
+ {"v", "void", 0},
+ {"w", "wchar_t", 0},
+ {"b", "bool", 0},
+ {"c", "char", 0},
+ {"a", "signed char", 0},
+ {"h", "unsigned char", 0},
+ {"s", "short", 0},
+ {"t", "unsigned short", 0},
+ {"i", "int", 0},
+ {"j", "unsigned int", 0},
+ {"l", "long", 0},
+ {"m", "unsigned long", 0},
+ {"x", "long long", 0},
+ {"y", "unsigned long long", 0},
+ {"n", "__int128", 0},
+ {"o", "unsigned __int128", 0},
+ {"f", "float", 0},
+ {"d", "double", 0},
+ {"e", "long double", 0},
+ {"g", "__float128", 0},
+ {"z", "ellipsis", 0},
+ {nullptr, nullptr, 0},
+};
+
+// List of substitutions Itanium C++ ABI.
+static const AbbrevPair kSubstitutionList[] = {
+ {"St", "", 0},
+ {"Sa", "allocator", 0},
+ {"Sb", "basic_string", 0},
+ // std::basic_string<char, std::char_traits<char>,std::allocator<char> >
+ {"Ss", "string", 0},
+ // std::basic_istream<char, std::char_traits<char> >
+ {"Si", "istream", 0},
+ // std::basic_ostream<char, std::char_traits<char> >
+ {"So", "ostream", 0},
+ // std::basic_iostream<char, std::char_traits<char> >
+ {"Sd", "iostream", 0},
+ {nullptr, nullptr, 0},
+};
+
+// State needed for demangling. This struct is copied in almost every stack
+// frame, so every byte counts.
+typedef struct {
+ int mangled_idx; // Cursor of mangled name.
+ int out_cur_idx; // Cursor of output std::string.
+ int prev_name_idx; // For constructors/destructors.
+ signed int prev_name_length : 16; // For constructors/destructors.
+ signed int nest_level : 15; // For nested names.
+ unsigned int append : 1; // Append flag.
+ // Note: for some reason MSVC can't pack "bool append : 1" into the same int
+ // with the above two fields, so we use an int instead. Amusingly it can pack
+ // "signed bool" as expected, but relying on that to continue to be a legal
+ // type seems ill-advised (as it's illegal in at least clang).
+} ParseState;
+
+static_assert(sizeof(ParseState) == 4 * sizeof(int),
+ "unexpected size of ParseState");
+
+// One-off state for demangling that's not subject to backtracking -- either
+// constant data, data that's intentionally immune to backtracking (steps), or
+// data that would never be changed by backtracking anyway (recursion_depth).
+//
+// Only one copy of this exists for each call to Demangle, so the size of this
+// struct is nearly inconsequential.
+typedef struct {
+ const char *mangled_begin; // Beginning of input std::string.
+ char *out; // Beginning of output std::string.
+ int out_end_idx; // One past last allowed output character.
+ int recursion_depth; // For stack exhaustion prevention.
+ int steps; // Cap how much work we'll do, regardless of depth.
+ ParseState parse_state; // Backtrackable state copied for most frames.
+} State;
+
+namespace {
+// Prevent deep recursion / stack exhaustion.
+// Also prevent unbounded handling of complex inputs.
+class ComplexityGuard {
+ public:
+ explicit ComplexityGuard(State *state) : state_(state) {
+ ++state->recursion_depth;
+ ++state->steps;
+ }
+ ~ComplexityGuard() { --state_->recursion_depth; }
+
+ // 256 levels of recursion seems like a reasonable upper limit on depth.
+ // 128 is not enough to demagle synthetic tests from demangle_unittest.txt:
+ // "_ZaaZZZZ..." and "_ZaaZcvZcvZ..."
+ static constexpr int kRecursionDepthLimit = 256;
+
+ // We're trying to pick a charitable upper-limit on how many parse steps are
+ // necessary to handle something that a human could actually make use of.
+ // This is mostly in place as a bound on how much work we'll do if we are
+ // asked to demangle an mangled name from an untrusted source, so it should be
+ // much larger than the largest expected symbol, but much smaller than the
+ // amount of work we can do in, e.g., a second.
+ //
+ // Some real-world symbols from an arbitrary binary started failing between
+ // 2^12 and 2^13, so we multiply the latter by an extra factor of 16 to set
+ // the limit.
+ //
+ // Spending one second on 2^17 parse steps would require each step to take
+ // 7.6us, or ~30000 clock cycles, so it's safe to say this can be done in
+ // under a second.
+ static constexpr int kParseStepsLimit = 1 << 17;
+
+ bool IsTooComplex() const {
+ return state_->recursion_depth > kRecursionDepthLimit ||
+ state_->steps > kParseStepsLimit;
+ }
+
+ private:
+ State *state_;
+};
+} // namespace
+
+// We don't use strlen() in libc since it's not guaranteed to be async
+// signal safe.
+static size_t StrLen(const char *str) {
+ size_t len = 0;
+ while (*str != '\0') {
+ ++str;
+ ++len;
+ }
+ return len;
+}
+
+// Returns true if "str" has at least "n" characters remaining.
+static bool AtLeastNumCharsRemaining(const char *str, int n) {
+ for (int i = 0; i < n; ++i) {
+ if (str[i] == '\0') {
+ return false;
+ }
+ }
+ return true;
+}
+
+// Returns true if "str" has "prefix" as a prefix.
+static bool StrPrefix(const char *str, const char *prefix) {
+ size_t i = 0;
+ while (str[i] != '\0' && prefix[i] != '\0' && str[i] == prefix[i]) {
+ ++i;
+ }
+ return prefix[i] == '\0'; // Consumed everything in "prefix".
+}
+
+static void InitState(State *state, const char *mangled, char *out,
+ int out_size) {
+ state->mangled_begin = mangled;
+ state->out = out;
+ state->out_end_idx = out_size;
+ state->recursion_depth = 0;
+ state->steps = 0;
+
+ state->parse_state.mangled_idx = 0;
+ state->parse_state.out_cur_idx = 0;
+ state->parse_state.prev_name_idx = 0;
+ state->parse_state.prev_name_length = -1;
+ state->parse_state.nest_level = -1;
+ state->parse_state.append = true;
+}
+
+static inline const char *RemainingInput(State *state) {
+ return &state->mangled_begin[state->parse_state.mangled_idx];
+}
+
+// Returns true and advances "mangled_idx" if we find "one_char_token"
+// at "mangled_idx" position. It is assumed that "one_char_token" does
+// not contain '\0'.
+static bool ParseOneCharToken(State *state, const char one_char_token) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (RemainingInput(state)[0] == one_char_token) {
+ ++state->parse_state.mangled_idx;
+ return true;
+ }
+ return false;
+}
+
+// Returns true and advances "mangled_cur" if we find "two_char_token"
+// at "mangled_cur" position. It is assumed that "two_char_token" does
+// not contain '\0'.
+static bool ParseTwoCharToken(State *state, const char *two_char_token) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (RemainingInput(state)[0] == two_char_token[0] &&
+ RemainingInput(state)[1] == two_char_token[1]) {
+ state->parse_state.mangled_idx += 2;
+ return true;
+ }
+ return false;
+}
+
+// Returns true and advances "mangled_cur" if we find any character in
+// "char_class" at "mangled_cur" position.
+static bool ParseCharClass(State *state, const char *char_class) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (RemainingInput(state)[0] == '\0') {
+ return false;
+ }
+ const char *p = char_class;
+ for (; *p != '\0'; ++p) {
+ if (RemainingInput(state)[0] == *p) {
+ ++state->parse_state.mangled_idx;
+ return true;
+ }
+ }
+ return false;
+}
+
+static bool ParseDigit(State *state, int *digit) {
+ char c = RemainingInput(state)[0];
+ if (ParseCharClass(state, "0123456789")) {
+ if (digit != nullptr) {
+ *digit = c - '0';
+ }
+ return true;
+ }
+ return false;
+}
+
+// This function is used for handling an optional non-terminal.
+static bool Optional(bool /*status*/) { return true; }
+
+// This function is used for handling <non-terminal>+ syntax.
+typedef bool (*ParseFunc)(State *);
+static bool OneOrMore(ParseFunc parse_func, State *state) {
+ if (parse_func(state)) {
+ while (parse_func(state)) {
+ }
+ return true;
+ }
+ return false;
+}
+
+// This function is used for handling <non-terminal>* syntax. The function
+// always returns true and must be followed by a termination token or a
+// terminating sequence not handled by parse_func (e.g.
+// ParseOneCharToken(state, 'E')).
+static bool ZeroOrMore(ParseFunc parse_func, State *state) {
+ while (parse_func(state)) {
+ }
+ return true;
+}
+
+// Append "str" at "out_cur_idx". If there is an overflow, out_cur_idx is
+// set to out_end_idx+1. The output std::string is ensured to
+// always terminate with '\0' as long as there is no overflow.
+static void Append(State *state, const char *const str, const int length) {
+ for (int i = 0; i < length; ++i) {
+ if (state->parse_state.out_cur_idx + 1 <
+ state->out_end_idx) { // +1 for '\0'
+ state->out[state->parse_state.out_cur_idx++] = str[i];
+ } else {
+ // signal overflow
+ state->parse_state.out_cur_idx = state->out_end_idx + 1;
+ break;
+ }
+ }
+ if (state->parse_state.out_cur_idx < state->out_end_idx) {
+ state->out[state->parse_state.out_cur_idx] =
+ '\0'; // Terminate it with '\0'
+ }
+}
+
+// We don't use equivalents in libc to avoid locale issues.
+static bool IsLower(char c) { return c >= 'a' && c <= 'z'; }
+
+static bool IsAlpha(char c) {
+ return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
+}
+
+static bool IsDigit(char c) { return c >= '0' && c <= '9'; }
+
+// Returns true if "str" is a function clone suffix. These suffixes are used
+// by GCC 4.5.x and later versions (and our locally-modified version of GCC
+// 4.4.x) to indicate functions which have been cloned during optimization.
+// We treat any sequence (.<alpha>+.<digit>+)+ as a function clone suffix.
+static bool IsFunctionCloneSuffix(const char *str) {
+ size_t i = 0;
+ while (str[i] != '\0') {
+ // Consume a single .<alpha>+.<digit>+ sequence.
+ if (str[i] != '.' || !IsAlpha(str[i + 1])) {
+ return false;
+ }
+ i += 2;
+ while (IsAlpha(str[i])) {
+ ++i;
+ }
+ if (str[i] != '.' || !IsDigit(str[i + 1])) {
+ return false;
+ }
+ i += 2;
+ while (IsDigit(str[i])) {
+ ++i;
+ }
+ }
+ return true; // Consumed everything in "str".
+}
+
+static bool EndsWith(State *state, const char chr) {
+ return state->parse_state.out_cur_idx > 0 &&
+ chr == state->out[state->parse_state.out_cur_idx - 1];
+}
+
+// Append "str" with some tweaks, iff "append" state is true.
+static void MaybeAppendWithLength(State *state, const char *const str,
+ const int length) {
+ if (state->parse_state.append && length > 0) {
+ // Append a space if the output buffer ends with '<' and "str"
+ // starts with '<' to avoid <<<.
+ if (str[0] == '<' && EndsWith(state, '<')) {
+ Append(state, " ", 1);
+ }
+ // Remember the last identifier name for ctors/dtors.
+ if (IsAlpha(str[0]) || str[0] == '_') {
+ state->parse_state.prev_name_idx = state->parse_state.out_cur_idx;
+ state->parse_state.prev_name_length = length;
+ }
+ Append(state, str, length);
+ }
+}
+
+// Appends a positive decimal number to the output if appending is enabled.
+static bool MaybeAppendDecimal(State *state, unsigned int val) {
+ // Max {32-64}-bit unsigned int is 20 digits.
+ constexpr size_t kMaxLength = 20;
+ char buf[kMaxLength];
+
+ // We can't use itoa or sprintf as neither is specified to be
+ // async-signal-safe.
+ if (state->parse_state.append) {
+ // We can't have a one-before-the-beginning pointer, so instead start with
+ // one-past-the-end and manipulate one character before the pointer.
+ char *p = &buf[kMaxLength];
+ do { // val=0 is the only input that should write a leading zero digit.
+ *--p = (val % 10) + '0';
+ val /= 10;
+ } while (p > buf && val != 0);
+
+ // 'p' landed on the last character we set. How convenient.
+ Append(state, p, kMaxLength - (p - buf));
+ }
+
+ return true;
+}
+
+// A convenient wrapper around MaybeAppendWithLength().
+// Returns true so that it can be placed in "if" conditions.
+static bool MaybeAppend(State *state, const char *const str) {
+ if (state->parse_state.append) {
+ int length = StrLen(str);
+ MaybeAppendWithLength(state, str, length);
+ }
+ return true;
+}
+
+// This function is used for handling nested names.
+static bool EnterNestedName(State *state) {
+ state->parse_state.nest_level = 0;
+ return true;
+}
+
+// This function is used for handling nested names.
+static bool LeaveNestedName(State *state, int16_t prev_value) {
+ state->parse_state.nest_level = prev_value;
+ return true;
+}
+
+// Disable the append mode not to print function parameters, etc.
+static bool DisableAppend(State *state) {
+ state->parse_state.append = false;
+ return true;
+}
+
+// Restore the append mode to the previous state.
+static bool RestoreAppend(State *state, bool prev_value) {
+ state->parse_state.append = prev_value;
+ return true;
+}
+
+// Increase the nest level for nested names.
+static void MaybeIncreaseNestLevel(State *state) {
+ if (state->parse_state.nest_level > -1) {
+ ++state->parse_state.nest_level;
+ }
+}
+
+// Appends :: for nested names if necessary.
+static void MaybeAppendSeparator(State *state) {
+ if (state->parse_state.nest_level >= 1) {
+ MaybeAppend(state, "::");
+ }
+}
+
+// Cancel the last separator if necessary.
+static void MaybeCancelLastSeparator(State *state) {
+ if (state->parse_state.nest_level >= 1 && state->parse_state.append &&
+ state->parse_state.out_cur_idx >= 2) {
+ state->parse_state.out_cur_idx -= 2;
+ state->out[state->parse_state.out_cur_idx] = '\0';
+ }
+}
+
+// Returns true if the identifier of the given length pointed to by
+// "mangled_cur" is anonymous namespace.
+static bool IdentifierIsAnonymousNamespace(State *state, int length) {
+ // Returns true if "anon_prefix" is a proper prefix of "mangled_cur".
+ static const char anon_prefix[] = "_GLOBAL__N_";
+ return (length > static_cast<int>(sizeof(anon_prefix) - 1) &&
+ StrPrefix(RemainingInput(state), anon_prefix));
+}
+
+// Forward declarations of our parsing functions.
+static bool ParseMangledName(State *state);
+static bool ParseEncoding(State *state);
+static bool ParseName(State *state);
+static bool ParseUnscopedName(State *state);
+static bool ParseNestedName(State *state);
+static bool ParsePrefix(State *state);
+static bool ParseUnqualifiedName(State *state);
+static bool ParseSourceName(State *state);
+static bool ParseLocalSourceName(State *state);
+static bool ParseUnnamedTypeName(State *state);
+static bool ParseNumber(State *state, int *number_out);
+static bool ParseFloatNumber(State *state);
+static bool ParseSeqId(State *state);
+static bool ParseIdentifier(State *state, int length);
+static bool ParseOperatorName(State *state, int *arity);
+static bool ParseSpecialName(State *state);
+static bool ParseCallOffset(State *state);
+static bool ParseNVOffset(State *state);
+static bool ParseVOffset(State *state);
+static bool ParseCtorDtorName(State *state);
+static bool ParseDecltype(State *state);
+static bool ParseType(State *state);
+static bool ParseCVQualifiers(State *state);
+static bool ParseBuiltinType(State *state);
+static bool ParseFunctionType(State *state);
+static bool ParseBareFunctionType(State *state);
+static bool ParseClassEnumType(State *state);
+static bool ParseArrayType(State *state);
+static bool ParsePointerToMemberType(State *state);
+static bool ParseTemplateParam(State *state);
+static bool ParseTemplateTemplateParam(State *state);
+static bool ParseTemplateArgs(State *state);
+static bool ParseTemplateArg(State *state);
+static bool ParseBaseUnresolvedName(State *state);
+static bool ParseUnresolvedName(State *state);
+static bool ParseExpression(State *state);
+static bool ParseExprPrimary(State *state);
+static bool ParseExprCastValue(State *state);
+static bool ParseLocalName(State *state);
+static bool ParseLocalNameSuffix(State *state);
+static bool ParseDiscriminator(State *state);
+static bool ParseSubstitution(State *state, bool accept_std);
+
+// Implementation note: the following code is a straightforward
+// translation of the Itanium C++ ABI defined in BNF with a couple of
+// exceptions.
+//
+// - Support GNU extensions not defined in the Itanium C++ ABI
+// - <prefix> and <template-prefix> are combined to avoid infinite loop
+// - Reorder patterns to shorten the code
+// - Reorder patterns to give greedier functions precedence
+// We'll mark "Less greedy than" for these cases in the code
+//
+// Each parsing function changes the parse state and returns true on
+// success, or returns false and doesn't change the parse state (note:
+// the parse-steps counter increases regardless of success or failure).
+// To ensure that the parse state isn't changed in the latter case, we
+// save the original state before we call multiple parsing functions
+// consecutively with &&, and restore it if unsuccessful. See
+// ParseEncoding() as an example of this convention. We follow the
+// convention throughout the code.
+//
+// Originally we tried to do demangling without following the full ABI
+// syntax but it turned out we needed to follow the full syntax to
+// parse complicated cases like nested template arguments. Note that
+// implementing a full-fledged demangler isn't trivial (libiberty's
+// cp-demangle.c has +4300 lines).
+//
+// Note that (foo) in <(foo) ...> is a modifier to be ignored.
+//
+// Reference:
+// - Itanium C++ ABI
+// <https://mentorembedded.github.io/cxx-abi/abi.html#mangling>
+
+// <mangled-name> ::= _Z <encoding>
+static bool ParseMangledName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ return ParseTwoCharToken(state, "_Z") && ParseEncoding(state);
+}
+
+// <encoding> ::= <(function) name> <bare-function-type>
+// ::= <(data) name>
+// ::= <special-name>
+static bool ParseEncoding(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ // Implementing the first two productions together as <name>
+ // [<bare-function-type>] avoids exponential blowup of backtracking.
+ //
+ // Since Optional(...) can't fail, there's no need to copy the state for
+ // backtracking.
+ if (ParseName(state) && Optional(ParseBareFunctionType(state))) {
+ return true;
+ }
+
+ if (ParseSpecialName(state)) {
+ return true;
+ }
+ return false;
+}
+
+// <name> ::= <nested-name>
+// ::= <unscoped-template-name> <template-args>
+// ::= <unscoped-name>
+// ::= <local-name>
+static bool ParseName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (ParseNestedName(state) || ParseLocalName(state)) {
+ return true;
+ }
+
+ // We reorganize the productions to avoid re-parsing unscoped names.
+ // - Inline <unscoped-template-name> productions:
+ // <name> ::= <substitution> <template-args>
+ // ::= <unscoped-name> <template-args>
+ // ::= <unscoped-name>
+ // - Merge the two productions that start with unscoped-name:
+ // <name> ::= <unscoped-name> [<template-args>]
+
+ ParseState copy = state->parse_state;
+ // "std<...>" isn't a valid name.
+ if (ParseSubstitution(state, /*accept_std=*/false) &&
+ ParseTemplateArgs(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Note there's no need to restore state after this since only the first
+ // subparser can fail.
+ return ParseUnscopedName(state) && Optional(ParseTemplateArgs(state));
+}
+
+// <unscoped-name> ::= <unqualified-name>
+// ::= St <unqualified-name>
+static bool ParseUnscopedName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (ParseUnqualifiedName(state)) {
+ return true;
+ }
+
+ ParseState copy = state->parse_state;
+ if (ParseTwoCharToken(state, "St") && MaybeAppend(state, "std::") &&
+ ParseUnqualifiedName(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <ref-qualifer> ::= R // lvalue method reference qualifier
+// ::= O // rvalue method reference qualifier
+static inline bool ParseRefQualifier(State *state) {
+ return ParseCharClass(state, "OR");
+}
+
+// <nested-name> ::= N [<CV-qualifiers>] [<ref-qualifier>] <prefix>
+// <unqualified-name> E
+// ::= N [<CV-qualifiers>] [<ref-qualifier>] <template-prefix>
+// <template-args> E
+static bool ParseNestedName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'N') && EnterNestedName(state) &&
+ Optional(ParseCVQualifiers(state)) &&
+ Optional(ParseRefQualifier(state)) && ParsePrefix(state) &&
+ LeaveNestedName(state, copy.nest_level) &&
+ ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// This part is tricky. If we literally translate them to code, we'll
+// end up infinite loop. Hence we merge them to avoid the case.
+//
+// <prefix> ::= <prefix> <unqualified-name>
+// ::= <template-prefix> <template-args>
+// ::= <template-param>
+// ::= <substitution>
+// ::= # empty
+// <template-prefix> ::= <prefix> <(template) unqualified-name>
+// ::= <template-param>
+// ::= <substitution>
+static bool ParsePrefix(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ bool has_something = false;
+ while (true) {
+ MaybeAppendSeparator(state);
+ if (ParseTemplateParam(state) ||
+ ParseSubstitution(state, /*accept_std=*/true) ||
+ ParseUnscopedName(state) ||
+ (ParseOneCharToken(state, 'M') && ParseUnnamedTypeName(state))) {
+ has_something = true;
+ MaybeIncreaseNestLevel(state);
+ continue;
+ }
+ MaybeCancelLastSeparator(state);
+ if (has_something && ParseTemplateArgs(state)) {
+ return ParsePrefix(state);
+ } else {
+ break;
+ }
+ }
+ return true;
+}
+
+// <unqualified-name> ::= <operator-name>
+// ::= <ctor-dtor-name>
+// ::= <source-name>
+// ::= <local-source-name> // GCC extension; see below.
+// ::= <unnamed-type-name>
+static bool ParseUnqualifiedName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ return (ParseOperatorName(state, nullptr) || ParseCtorDtorName(state) ||
+ ParseSourceName(state) || ParseLocalSourceName(state) ||
+ ParseUnnamedTypeName(state));
+}
+
+// <source-name> ::= <positive length number> <identifier>
+static bool ParseSourceName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ int length = -1;
+ if (ParseNumber(state, &length) && ParseIdentifier(state, length)) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <local-source-name> ::= L <source-name> [<discriminator>]
+//
+// References:
+// http://gcc.gnu.org/bugzilla/show_bug.cgi?id=31775
+// http://gcc.gnu.org/viewcvs?view=rev&revision=124467
+static bool ParseLocalSourceName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'L') && ParseSourceName(state) &&
+ Optional(ParseDiscriminator(state))) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <unnamed-type-name> ::= Ut [<(nonnegative) number>] _
+// ::= <closure-type-name>
+// <closure-type-name> ::= Ul <lambda-sig> E [<(nonnegative) number>] _
+// <lambda-sig> ::= <(parameter) type>+
+static bool ParseUnnamedTypeName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ // Type's 1-based index n is encoded as { "", n == 1; itoa(n-2), otherwise }.
+ // Optionally parse the encoded value into 'which' and add 2 to get the index.
+ int which = -1;
+
+ // Unnamed type local to function or class.
+ if (ParseTwoCharToken(state, "Ut") && Optional(ParseNumber(state, &which)) &&
+ which <= std::numeric_limits<int>::max() - 2 && // Don't overflow.
+ ParseOneCharToken(state, '_')) {
+ MaybeAppend(state, "{unnamed type#");
+ MaybeAppendDecimal(state, 2 + which);
+ MaybeAppend(state, "}");
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Closure type.
+ which = -1;
+ if (ParseTwoCharToken(state, "Ul") && DisableAppend(state) &&
+ OneOrMore(ParseType, state) && RestoreAppend(state, copy.append) &&
+ ParseOneCharToken(state, 'E') && Optional(ParseNumber(state, &which)) &&
+ which <= std::numeric_limits<int>::max() - 2 && // Don't overflow.
+ ParseOneCharToken(state, '_')) {
+ MaybeAppend(state, "{lambda()#");
+ MaybeAppendDecimal(state, 2 + which);
+ MaybeAppend(state, "}");
+ return true;
+ }
+ state->parse_state = copy;
+
+ return false;
+}
+
+// <number> ::= [n] <non-negative decimal integer>
+// If "number_out" is non-null, then *number_out is set to the value of the
+// parsed number on success.
+static bool ParseNumber(State *state, int *number_out) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ bool negative = false;
+ if (ParseOneCharToken(state, 'n')) {
+ negative = true;
+ }
+ const char *p = RemainingInput(state);
+ uint64_t number = 0;
+ for (; *p != '\0'; ++p) {
+ if (IsDigit(*p)) {
+ number = number * 10 + (*p - '0');
+ } else {
+ break;
+ }
+ }
+ // Apply the sign with uint64_t arithmetic so overflows aren't UB. Gives
+ // "incorrect" results for out-of-range inputs, but negative values only
+ // appear for literals, which aren't printed.
+ if (negative) {
+ number = ~number + 1;
+ }
+ if (p != RemainingInput(state)) { // Conversion succeeded.
+ state->parse_state.mangled_idx += p - RemainingInput(state);
+ if (number_out != nullptr) {
+ // Note: possibly truncate "number".
+ *number_out = number;
+ }
+ return true;
+ }
+ return false;
+}
+
+// Floating-point literals are encoded using a fixed-length lowercase
+// hexadecimal std::string.
+static bool ParseFloatNumber(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ const char *p = RemainingInput(state);
+ for (; *p != '\0'; ++p) {
+ if (!IsDigit(*p) && !(*p >= 'a' && *p <= 'f')) {
+ break;
+ }
+ }
+ if (p != RemainingInput(state)) { // Conversion succeeded.
+ state->parse_state.mangled_idx += p - RemainingInput(state);
+ return true;
+ }
+ return false;
+}
+
+// The <seq-id> is a sequence number in base 36,
+// using digits and upper case letters
+static bool ParseSeqId(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ const char *p = RemainingInput(state);
+ for (; *p != '\0'; ++p) {
+ if (!IsDigit(*p) && !(*p >= 'A' && *p <= 'Z')) {
+ break;
+ }
+ }
+ if (p != RemainingInput(state)) { // Conversion succeeded.
+ state->parse_state.mangled_idx += p - RemainingInput(state);
+ return true;
+ }
+ return false;
+}
+
+// <identifier> ::= <unqualified source code identifier> (of given length)
+static bool ParseIdentifier(State *state, int length) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (length < 0 || !AtLeastNumCharsRemaining(RemainingInput(state), length)) {
+ return false;
+ }
+ if (IdentifierIsAnonymousNamespace(state, length)) {
+ MaybeAppend(state, "(anonymous namespace)");
+ } else {
+ MaybeAppendWithLength(state, RemainingInput(state), length);
+ }
+ state->parse_state.mangled_idx += length;
+ return true;
+}
+
+// <operator-name> ::= nw, and other two letters cases
+// ::= cv <type> # (cast)
+// ::= v <digit> <source-name> # vendor extended operator
+static bool ParseOperatorName(State *state, int *arity) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (!AtLeastNumCharsRemaining(RemainingInput(state), 2)) {
+ return false;
+ }
+ // First check with "cv" (cast) case.
+ ParseState copy = state->parse_state;
+ if (ParseTwoCharToken(state, "cv") && MaybeAppend(state, "operator ") &&
+ EnterNestedName(state) && ParseType(state) &&
+ LeaveNestedName(state, copy.nest_level)) {
+ if (arity != nullptr) {
+ *arity = 1;
+ }
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Then vendor extended operators.
+ if (ParseOneCharToken(state, 'v') && ParseDigit(state, arity) &&
+ ParseSourceName(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Other operator names should start with a lower alphabet followed
+ // by a lower/upper alphabet.
+ if (!(IsLower(RemainingInput(state)[0]) &&
+ IsAlpha(RemainingInput(state)[1]))) {
+ return false;
+ }
+ // We may want to perform a binary search if we really need speed.
+ const AbbrevPair *p;
+ for (p = kOperatorList; p->abbrev != nullptr; ++p) {
+ if (RemainingInput(state)[0] == p->abbrev[0] &&
+ RemainingInput(state)[1] == p->abbrev[1]) {
+ if (arity != nullptr) {
+ *arity = p->arity;
+ }
+ MaybeAppend(state, "operator");
+ if (IsLower(*p->real_name)) { // new, delete, etc.
+ MaybeAppend(state, " ");
+ }
+ MaybeAppend(state, p->real_name);
+ state->parse_state.mangled_idx += 2;
+ return true;
+ }
+ }
+ return false;
+}
+
+// <special-name> ::= TV <type>
+// ::= TT <type>
+// ::= TI <type>
+// ::= TS <type>
+// ::= Tc <call-offset> <call-offset> <(base) encoding>
+// ::= GV <(object) name>
+// ::= T <call-offset> <(base) encoding>
+// G++ extensions:
+// ::= TC <type> <(offset) number> _ <(base) type>
+// ::= TF <type>
+// ::= TJ <type>
+// ::= GR <name>
+// ::= GA <encoding>
+// ::= Th <call-offset> <(base) encoding>
+// ::= Tv <call-offset> <(base) encoding>
+//
+// Note: we don't care much about them since they don't appear in
+// stack traces. The are special data.
+static bool ParseSpecialName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'T') && ParseCharClass(state, "VTIS") &&
+ ParseType(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseTwoCharToken(state, "Tc") && ParseCallOffset(state) &&
+ ParseCallOffset(state) && ParseEncoding(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseTwoCharToken(state, "GV") && ParseName(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseOneCharToken(state, 'T') && ParseCallOffset(state) &&
+ ParseEncoding(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ // G++ extensions
+ if (ParseTwoCharToken(state, "TC") && ParseType(state) &&
+ ParseNumber(state, nullptr) && ParseOneCharToken(state, '_') &&
+ DisableAppend(state) && ParseType(state)) {
+ RestoreAppend(state, copy.append);
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseOneCharToken(state, 'T') && ParseCharClass(state, "FJ") &&
+ ParseType(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseTwoCharToken(state, "GR") && ParseName(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseTwoCharToken(state, "GA") && ParseEncoding(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseOneCharToken(state, 'T') && ParseCharClass(state, "hv") &&
+ ParseCallOffset(state) && ParseEncoding(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <call-offset> ::= h <nv-offset> _
+// ::= v <v-offset> _
+static bool ParseCallOffset(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'h') && ParseNVOffset(state) &&
+ ParseOneCharToken(state, '_')) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseOneCharToken(state, 'v') && ParseVOffset(state) &&
+ ParseOneCharToken(state, '_')) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ return false;
+}
+
+// <nv-offset> ::= <(offset) number>
+static bool ParseNVOffset(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ return ParseNumber(state, nullptr);
+}
+
+// <v-offset> ::= <(offset) number> _ <(virtual offset) number>
+static bool ParseVOffset(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseNumber(state, nullptr) && ParseOneCharToken(state, '_') &&
+ ParseNumber(state, nullptr)) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <ctor-dtor-name> ::= C1 | C2 | C3
+// ::= D0 | D1 | D2
+// # GCC extensions: "unified" constructor/destructor. See
+// # https://github.com/gcc-mirror/gcc/blob/7ad17b583c3643bd4557f29b8391ca7ef08391f5/gcc/cp/mangle.c#L1847
+// ::= C4 | D4
+static bool ParseCtorDtorName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'C') && ParseCharClass(state, "1234")) {
+ const char *const prev_name = state->out + state->parse_state.prev_name_idx;
+ MaybeAppendWithLength(state, prev_name,
+ state->parse_state.prev_name_length);
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseOneCharToken(state, 'D') && ParseCharClass(state, "0124")) {
+ const char *const prev_name = state->out + state->parse_state.prev_name_idx;
+ MaybeAppend(state, "~");
+ MaybeAppendWithLength(state, prev_name,
+ state->parse_state.prev_name_length);
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <decltype> ::= Dt <expression> E # decltype of an id-expression or class
+// # member access (C++0x)
+// ::= DT <expression> E # decltype of an expression (C++0x)
+static bool ParseDecltype(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'D') && ParseCharClass(state, "tT") &&
+ ParseExpression(state) && ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ return false;
+}
+
+// <type> ::= <CV-qualifiers> <type>
+// ::= P <type> # pointer-to
+// ::= R <type> # reference-to
+// ::= O <type> # rvalue reference-to (C++0x)
+// ::= C <type> # complex pair (C 2000)
+// ::= G <type> # imaginary (C 2000)
+// ::= U <source-name> <type> # vendor extended type qualifier
+// ::= <builtin-type>
+// ::= <function-type>
+// ::= <class-enum-type> # note: just an alias for <name>
+// ::= <array-type>
+// ::= <pointer-to-member-type>
+// ::= <template-template-param> <template-args>
+// ::= <template-param>
+// ::= <decltype>
+// ::= <substitution>
+// ::= Dp <type> # pack expansion of (C++0x)
+//
+static bool ParseType(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+
+ // We should check CV-qualifers, and PRGC things first.
+ //
+ // CV-qualifiers overlap with some operator names, but an operator name is not
+ // valid as a type. To avoid an ambiguity that can lead to exponential time
+ // complexity, refuse to backtrack the CV-qualifiers.
+ //
+ // _Z4aoeuIrMvvE
+ // => _Z 4aoeuI rM v v E
+ // aoeu<operator%=, void, void>
+ // => _Z 4aoeuI r Mv v E
+ // aoeu<void void::* restrict>
+ //
+ // By consuming the CV-qualifiers first, the former parse is disabled.
+ if (ParseCVQualifiers(state)) {
+ const bool result = ParseType(state);
+ if (!result) state->parse_state = copy;
+ return result;
+ }
+ state->parse_state = copy;
+
+ // Similarly, these tag characters can overlap with other <name>s resulting in
+ // two different parse prefixes that land on <template-args> in the same
+ // place, such as "C3r1xI...". So, disable the "ctor-name = C3" parse by
+ // refusing to backtrack the tag characters.
+ if (ParseCharClass(state, "OPRCG")) {
+ const bool result = ParseType(state);
+ if (!result) state->parse_state = copy;
+ return result;
+ }
+ state->parse_state = copy;
+
+ if (ParseTwoCharToken(state, "Dp") && ParseType(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseOneCharToken(state, 'U') && ParseSourceName(state) &&
+ ParseType(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseBuiltinType(state) || ParseFunctionType(state) ||
+ ParseClassEnumType(state) || ParseArrayType(state) ||
+ ParsePointerToMemberType(state) || ParseDecltype(state) ||
+ // "std" on its own isn't a type.
+ ParseSubstitution(state, /*accept_std=*/false)) {
+ return true;
+ }
+
+ if (ParseTemplateTemplateParam(state) && ParseTemplateArgs(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Less greedy than <template-template-param> <template-args>.
+ if (ParseTemplateParam(state)) {
+ return true;
+ }
+
+ return false;
+}
+
+// <CV-qualifiers> ::= [r] [V] [K]
+// We don't allow empty <CV-qualifiers> to avoid infinite loop in
+// ParseType().
+static bool ParseCVQualifiers(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ int num_cv_qualifiers = 0;
+ num_cv_qualifiers += ParseOneCharToken(state, 'r');
+ num_cv_qualifiers += ParseOneCharToken(state, 'V');
+ num_cv_qualifiers += ParseOneCharToken(state, 'K');
+ return num_cv_qualifiers > 0;
+}
+
+// <builtin-type> ::= v, etc.
+// ::= u <source-name>
+static bool ParseBuiltinType(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ const AbbrevPair *p;
+ for (p = kBuiltinTypeList; p->abbrev != nullptr; ++p) {
+ if (RemainingInput(state)[0] == p->abbrev[0]) {
+ MaybeAppend(state, p->real_name);
+ ++state->parse_state.mangled_idx;
+ return true;
+ }
+ }
+
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'u') && ParseSourceName(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <function-type> ::= F [Y] <bare-function-type> E
+static bool ParseFunctionType(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'F') &&
+ Optional(ParseOneCharToken(state, 'Y')) && ParseBareFunctionType(state) &&
+ ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <bare-function-type> ::= <(signature) type>+
+static bool ParseBareFunctionType(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ DisableAppend(state);
+ if (OneOrMore(ParseType, state)) {
+ RestoreAppend(state, copy.append);
+ MaybeAppend(state, "()");
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <class-enum-type> ::= <name>
+static bool ParseClassEnumType(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ return ParseName(state);
+}
+
+// <array-type> ::= A <(positive dimension) number> _ <(element) type>
+// ::= A [<(dimension) expression>] _ <(element) type>
+static bool ParseArrayType(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'A') && ParseNumber(state, nullptr) &&
+ ParseOneCharToken(state, '_') && ParseType(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseOneCharToken(state, 'A') && Optional(ParseExpression(state)) &&
+ ParseOneCharToken(state, '_') && ParseType(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <pointer-to-member-type> ::= M <(class) type> <(member) type>
+static bool ParsePointerToMemberType(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'M') && ParseType(state) && ParseType(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <template-param> ::= T_
+// ::= T <parameter-2 non-negative number> _
+static bool ParseTemplateParam(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (ParseTwoCharToken(state, "T_")) {
+ MaybeAppend(state, "?"); // We don't support template substitutions.
+ return true;
+ }
+
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'T') && ParseNumber(state, nullptr) &&
+ ParseOneCharToken(state, '_')) {
+ MaybeAppend(state, "?"); // We don't support template substitutions.
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <template-template-param> ::= <template-param>
+// ::= <substitution>
+static bool ParseTemplateTemplateParam(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ return (ParseTemplateParam(state) ||
+ // "std" on its own isn't a template.
+ ParseSubstitution(state, /*accept_std=*/false));
+}
+
+// <template-args> ::= I <template-arg>+ E
+static bool ParseTemplateArgs(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ DisableAppend(state);
+ if (ParseOneCharToken(state, 'I') && OneOrMore(ParseTemplateArg, state) &&
+ ParseOneCharToken(state, 'E')) {
+ RestoreAppend(state, copy.append);
+ MaybeAppend(state, "<>");
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <template-arg> ::= <type>
+// ::= <expr-primary>
+// ::= J <template-arg>* E # argument pack
+// ::= X <expression> E
+static bool ParseTemplateArg(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'J') && ZeroOrMore(ParseTemplateArg, state) &&
+ ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ // There can be significant overlap between the following leading to
+ // exponential backtracking:
+ //
+ // <expr-primary> ::= L <type> <expr-cast-value> E
+ // e.g. L 2xxIvE 1 E
+ // <type> ==> <local-source-name> <template-args>
+ // e.g. L 2xx IvE
+ //
+ // This means parsing an entire <type> twice, and <type> can contain
+ // <template-arg>, so this can generate exponential backtracking. There is
+ // only overlap when the remaining input starts with "L <source-name>", so
+ // parse all cases that can start this way jointly to share the common prefix.
+ //
+ // We have:
+ //
+ // <template-arg> ::= <type>
+ // ::= <expr-primary>
+ //
+ // First, drop all the productions of <type> that must start with something
+ // other than 'L'. All that's left is <class-enum-type>; inline it.
+ //
+ // <type> ::= <nested-name> # starts with 'N'
+ // ::= <unscoped-name>
+ // ::= <unscoped-template-name> <template-args>
+ // ::= <local-name> # starts with 'Z'
+ //
+ // Drop and inline again:
+ //
+ // <type> ::= <unscoped-name>
+ // ::= <unscoped-name> <template-args>
+ // ::= <substitution> <template-args> # starts with 'S'
+ //
+ // Merge the first two, inline <unscoped-name>, drop last:
+ //
+ // <type> ::= <unqualified-name> [<template-args>]
+ // ::= St <unqualified-name> [<template-args>] # starts with 'S'
+ //
+ // Drop and inline:
+ //
+ // <type> ::= <operator-name> [<template-args>] # starts with lowercase
+ // ::= <ctor-dtor-name> [<template-args>] # starts with 'C' or 'D'
+ // ::= <source-name> [<template-args>] # starts with digit
+ // ::= <local-source-name> [<template-args>]
+ // ::= <unnamed-type-name> [<template-args>] # starts with 'U'
+ //
+ // One more time:
+ //
+ // <type> ::= L <source-name> [<template-args>]
+ //
+ // Likewise with <expr-primary>:
+ //
+ // <expr-primary> ::= L <type> <expr-cast-value> E
+ // ::= LZ <encoding> E # cannot overlap; drop
+ // ::= L <mangled_name> E # cannot overlap; drop
+ //
+ // By similar reasoning as shown above, the only <type>s starting with
+ // <source-name> are "<source-name> [<template-args>]". Inline this.
+ //
+ // <expr-primary> ::= L <source-name> [<template-args>] <expr-cast-value> E
+ //
+ // Now inline both of these into <template-arg>:
+ //
+ // <template-arg> ::= L <source-name> [<template-args>]
+ // ::= L <source-name> [<template-args>] <expr-cast-value> E
+ //
+ // Merge them and we're done:
+ // <template-arg>
+ // ::= L <source-name> [<template-args>] [<expr-cast-value> E]
+ if (ParseLocalSourceName(state) && Optional(ParseTemplateArgs(state))) {
+ copy = state->parse_state;
+ if (ParseExprCastValue(state) && ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy;
+ return true;
+ }
+
+ // Now that the overlapping cases can't reach this code, we can safely call
+ // both of these.
+ if (ParseType(state) || ParseExprPrimary(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseOneCharToken(state, 'X') && ParseExpression(state) &&
+ ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <unresolved-type> ::= <template-param> [<template-args>]
+// ::= <decltype>
+// ::= <substitution>
+static inline bool ParseUnresolvedType(State *state) {
+ // No ComplexityGuard because we don't copy the state in this stack frame.
+ return (ParseTemplateParam(state) && Optional(ParseTemplateArgs(state))) ||
+ ParseDecltype(state) || ParseSubstitution(state, /*accept_std=*/false);
+}
+
+// <simple-id> ::= <source-name> [<template-args>]
+static inline bool ParseSimpleId(State *state) {
+ // No ComplexityGuard because we don't copy the state in this stack frame.
+
+ // Note: <simple-id> cannot be followed by a parameter pack; see comment in
+ // ParseUnresolvedType.
+ return ParseSourceName(state) && Optional(ParseTemplateArgs(state));
+}
+
+// <base-unresolved-name> ::= <source-name> [<template-args>]
+// ::= on <operator-name> [<template-args>]
+// ::= dn <destructor-name>
+static bool ParseBaseUnresolvedName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+
+ if (ParseSimpleId(state)) {
+ return true;
+ }
+
+ ParseState copy = state->parse_state;
+ if (ParseTwoCharToken(state, "on") && ParseOperatorName(state, nullptr) &&
+ Optional(ParseTemplateArgs(state))) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseTwoCharToken(state, "dn") &&
+ (ParseUnresolvedType(state) || ParseSimpleId(state))) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ return false;
+}
+
+// <unresolved-name> ::= [gs] <base-unresolved-name>
+// ::= sr <unresolved-type> <base-unresolved-name>
+// ::= srN <unresolved-type> <unresolved-qualifier-level>+ E
+// <base-unresolved-name>
+// ::= [gs] sr <unresolved-qualifier-level>+ E
+// <base-unresolved-name>
+static bool ParseUnresolvedName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+
+ ParseState copy = state->parse_state;
+ if (Optional(ParseTwoCharToken(state, "gs")) &&
+ ParseBaseUnresolvedName(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseTwoCharToken(state, "sr") && ParseUnresolvedType(state) &&
+ ParseBaseUnresolvedName(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseTwoCharToken(state, "sr") && ParseOneCharToken(state, 'N') &&
+ ParseUnresolvedType(state) &&
+ OneOrMore(/* <unresolved-qualifier-level> ::= */ ParseSimpleId, state) &&
+ ParseOneCharToken(state, 'E') && ParseBaseUnresolvedName(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (Optional(ParseTwoCharToken(state, "gs")) &&
+ ParseTwoCharToken(state, "sr") &&
+ OneOrMore(/* <unresolved-qualifier-level> ::= */ ParseSimpleId, state) &&
+ ParseOneCharToken(state, 'E') && ParseBaseUnresolvedName(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ return false;
+}
+
+// <expression> ::= <1-ary operator-name> <expression>
+// ::= <2-ary operator-name> <expression> <expression>
+// ::= <3-ary operator-name> <expression> <expression> <expression>
+// ::= cl <expression>+ E
+// ::= cv <type> <expression> # type (expression)
+// ::= cv <type> _ <expression>* E # type (expr-list)
+// ::= st <type>
+// ::= <template-param>
+// ::= <function-param>
+// ::= <expr-primary>
+// ::= dt <expression> <unresolved-name> # expr.name
+// ::= pt <expression> <unresolved-name> # expr->name
+// ::= sp <expression> # argument pack expansion
+// ::= sr <type> <unqualified-name> <template-args>
+// ::= sr <type> <unqualified-name>
+// <function-param> ::= fp <(top-level) CV-qualifiers> _
+// ::= fp <(top-level) CV-qualifiers> <number> _
+// ::= fL <number> p <(top-level) CV-qualifiers> _
+// ::= fL <number> p <(top-level) CV-qualifiers> <number> _
+static bool ParseExpression(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (ParseTemplateParam(state) || ParseExprPrimary(state)) {
+ return true;
+ }
+
+ // Object/function call expression.
+ ParseState copy = state->parse_state;
+ if (ParseTwoCharToken(state, "cl") && OneOrMore(ParseExpression, state) &&
+ ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Function-param expression (level 0).
+ if (ParseTwoCharToken(state, "fp") && Optional(ParseCVQualifiers(state)) &&
+ Optional(ParseNumber(state, nullptr)) && ParseOneCharToken(state, '_')) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Function-param expression (level 1+).
+ if (ParseTwoCharToken(state, "fL") && Optional(ParseNumber(state, nullptr)) &&
+ ParseOneCharToken(state, 'p') && Optional(ParseCVQualifiers(state)) &&
+ Optional(ParseNumber(state, nullptr)) && ParseOneCharToken(state, '_')) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Parse the conversion expressions jointly to avoid re-parsing the <type> in
+ // their common prefix. Parsed as:
+ // <expression> ::= cv <type> <conversion-args>
+ // <conversion-args> ::= _ <expression>* E
+ // ::= <expression>
+ //
+ // Also don't try ParseOperatorName after seeing "cv", since ParseOperatorName
+ // also needs to accept "cv <type>" in other contexts.
+ if (ParseTwoCharToken(state, "cv")) {
+ if (ParseType(state)) {
+ ParseState copy2 = state->parse_state;
+ if (ParseOneCharToken(state, '_') && ZeroOrMore(ParseExpression, state) &&
+ ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy2;
+ if (ParseExpression(state)) {
+ return true;
+ }
+ }
+ } else {
+ // Parse unary, binary, and ternary operator expressions jointly, taking
+ // care not to re-parse subexpressions repeatedly. Parse like:
+ // <expression> ::= <operator-name> <expression>
+ // [<one-to-two-expressions>]
+ // <one-to-two-expressions> ::= <expression> [<expression>]
+ int arity = -1;
+ if (ParseOperatorName(state, &arity) &&
+ arity > 0 && // 0 arity => disabled.
+ (arity < 3 || ParseExpression(state)) &&
+ (arity < 2 || ParseExpression(state)) &&
+ (arity < 1 || ParseExpression(state))) {
+ return true;
+ }
+ }
+ state->parse_state = copy;
+
+ // sizeof type
+ if (ParseTwoCharToken(state, "st") && ParseType(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Object and pointer member access expressions.
+ if ((ParseTwoCharToken(state, "dt") || ParseTwoCharToken(state, "pt")) &&
+ ParseExpression(state) && ParseType(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Parameter pack expansion
+ if (ParseTwoCharToken(state, "sp") && ParseExpression(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ return ParseUnresolvedName(state);
+}
+
+// <expr-primary> ::= L <type> <(value) number> E
+// ::= L <type> <(value) float> E
+// ::= L <mangled-name> E
+// // A bug in g++'s C++ ABI version 2 (-fabi-version=2).
+// ::= LZ <encoding> E
+//
+// Warning, subtle: the "bug" LZ production above is ambiguous with the first
+// production where <type> starts with <local-name>, which can lead to
+// exponential backtracking in two scenarios:
+//
+// - When whatever follows the E in the <local-name> in the first production is
+// not a name, we backtrack the whole <encoding> and re-parse the whole thing.
+//
+// - When whatever follows the <local-name> in the first production is not a
+// number and this <expr-primary> may be followed by a name, we backtrack the
+// <name> and re-parse it.
+//
+// Moreover this ambiguity isn't always resolved -- for example, the following
+// has two different parses:
+//
+// _ZaaILZ4aoeuE1x1EvE
+// => operator&&<aoeu, x, E, void>
+// => operator&&<(aoeu::x)(1), void>
+//
+// To resolve this, we just do what GCC's demangler does, and refuse to parse
+// casts to <local-name> types.
+static bool ParseExprPrimary(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+
+ // The "LZ" special case: if we see LZ, we commit to accept "LZ <encoding> E"
+ // or fail, no backtracking.
+ if (ParseTwoCharToken(state, "LZ")) {
+ if (ParseEncoding(state) && ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+
+ state->parse_state = copy;
+ return false;
+ }
+
+ // The merged cast production.
+ if (ParseOneCharToken(state, 'L') && ParseType(state) &&
+ ParseExprCastValue(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseOneCharToken(state, 'L') && ParseMangledName(state) &&
+ ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ return false;
+}
+
+// <number> or <float>, followed by 'E', as described above ParseExprPrimary.
+static bool ParseExprCastValue(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ // We have to be able to backtrack after accepting a number because we could
+ // have e.g. "7fffE", which will accept "7" as a number but then fail to find
+ // the 'E'.
+ ParseState copy = state->parse_state;
+ if (ParseNumber(state, nullptr) && ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ if (ParseFloatNumber(state) && ParseOneCharToken(state, 'E')) {
+ return true;
+ }
+ state->parse_state = copy;
+
+ return false;
+}
+
+// <local-name> ::= Z <(function) encoding> E <(entity) name> [<discriminator>]
+// ::= Z <(function) encoding> E s [<discriminator>]
+//
+// Parsing a common prefix of these two productions together avoids an
+// exponential blowup of backtracking. Parse like:
+// <local-name> := Z <encoding> E <local-name-suffix>
+// <local-name-suffix> ::= s [<discriminator>]
+// ::= <name> [<discriminator>]
+
+static bool ParseLocalNameSuffix(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+
+ if (MaybeAppend(state, "::") && ParseName(state) &&
+ Optional(ParseDiscriminator(state))) {
+ return true;
+ }
+
+ // Since we're not going to overwrite the above "::" by re-parsing the
+ // <encoding> (whose trailing '\0' byte was in the byte now holding the
+ // first ':'), we have to rollback the "::" if the <name> parse failed.
+ if (state->parse_state.append) {
+ state->out[state->parse_state.out_cur_idx - 2] = '\0';
+ }
+
+ return ParseOneCharToken(state, 's') && Optional(ParseDiscriminator(state));
+}
+
+static bool ParseLocalName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'Z') && ParseEncoding(state) &&
+ ParseOneCharToken(state, 'E') && ParseLocalNameSuffix(state)) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <discriminator> := _ <(non-negative) number>
+static bool ParseDiscriminator(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, '_') && ParseNumber(state, nullptr)) {
+ return true;
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// <substitution> ::= S_
+// ::= S <seq-id> _
+// ::= St, etc.
+//
+// "St" is special in that it's not valid as a standalone name, and it *is*
+// allowed to precede a name without being wrapped in "N...E". This means that
+// if we accept it on its own, we can accept "St1a" and try to parse
+// template-args, then fail and backtrack, accept "St" on its own, then "1a" as
+// an unqualified name and re-parse the same template-args. To block this
+// exponential backtracking, we disable it with 'accept_std=false' in
+// problematic contexts.
+static bool ParseSubstitution(State *state, bool accept_std) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (ParseTwoCharToken(state, "S_")) {
+ MaybeAppend(state, "?"); // We don't support substitutions.
+ return true;
+ }
+
+ ParseState copy = state->parse_state;
+ if (ParseOneCharToken(state, 'S') && ParseSeqId(state) &&
+ ParseOneCharToken(state, '_')) {
+ MaybeAppend(state, "?"); // We don't support substitutions.
+ return true;
+ }
+ state->parse_state = copy;
+
+ // Expand abbreviations like "St" => "std".
+ if (ParseOneCharToken(state, 'S')) {
+ const AbbrevPair *p;
+ for (p = kSubstitutionList; p->abbrev != nullptr; ++p) {
+ if (RemainingInput(state)[0] == p->abbrev[1] &&
+ (accept_std || p->abbrev[1] != 't')) {
+ MaybeAppend(state, "std");
+ if (p->real_name[0] != '\0') {
+ MaybeAppend(state, "::");
+ MaybeAppend(state, p->real_name);
+ }
+ ++state->parse_state.mangled_idx;
+ return true;
+ }
+ }
+ }
+ state->parse_state = copy;
+ return false;
+}
+
+// Parse <mangled-name>, optionally followed by either a function-clone suffix
+// or version suffix. Returns true only if all of "mangled_cur" was consumed.
+static bool ParseTopLevelMangledName(State *state) {
+ ComplexityGuard guard(state);
+ if (guard.IsTooComplex()) return false;
+ if (ParseMangledName(state)) {
+ if (RemainingInput(state)[0] != '\0') {
+ // Drop trailing function clone suffix, if any.
+ if (IsFunctionCloneSuffix(RemainingInput(state))) {
+ return true;
+ }
+ // Append trailing version suffix if any.
+ // ex. _Z3foo@@GLIBCXX_3.4
+ if (RemainingInput(state)[0] == '@') {
+ MaybeAppend(state, RemainingInput(state));
+ return true;
+ }
+ return false; // Unconsumed suffix.
+ }
+ return true;
+ }
+ return false;
+}
+
+static bool Overflowed(const State *state) {
+ return state->parse_state.out_cur_idx >= state->out_end_idx;
+}
+
+// The demangler entry point.
+bool Demangle(const char *mangled, char *out, int out_size) {
+ State state;
+ InitState(&state, mangled, out, out_size);
+ return ParseTopLevelMangledName(&state) && !Overflowed(&state);
+}
+
+} // namespace debugging_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle.h
new file mode 100644
index 0000000..2e75564
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle.h
@@ -0,0 +1,67 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// An async-signal-safe and thread-safe demangler for Itanium C++ ABI
+// (aka G++ V3 ABI).
+//
+// The demangler is implemented to be used in async signal handlers to
+// symbolize stack traces. We cannot use libstdc++'s
+// abi::__cxa_demangle() in such signal handlers since it's not async
+// signal safe (it uses malloc() internally).
+//
+// Note that this demangler doesn't support full demangling. More
+// specifically, it doesn't print types of function parameters and
+// types of template arguments. It just skips them. However, it's
+// still very useful to extract basic information such as class,
+// function, constructor, destructor, and operator names.
+//
+// See the implementation note in demangle.cc if you are interested.
+//
+// Example:
+//
+// | Mangled Name | The Demangler | abi::__cxa_demangle()
+// |---------------|---------------|-----------------------
+// | _Z1fv | f() | f()
+// | _Z1fi | f() | f(int)
+// | _Z3foo3bar | foo() | foo(bar)
+// | _Z1fIiEvi | f<>() | void f<int>(int)
+// | _ZN1N1fE | N::f | N::f
+// | _ZN3Foo3BarEv | Foo::Bar() | Foo::Bar()
+// | _Zrm1XS_" | operator%() | operator%(X, X)
+// | _ZN3FooC1Ev | Foo::Foo() | Foo::Foo()
+// | _Z1fSs | f() | f(std::basic_string<char,
+// | | | std::char_traits<char>,
+// | | | std::allocator<char> >)
+//
+// See the unit test for more examples.
+//
+// Note: we might want to write demanglers for ABIs other than Itanium
+// C++ ABI in the future.
+//
+
+#ifndef ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
+#define ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
+
+namespace absl {
+namespace debugging_internal {
+
+// Demangle `mangled`. On success, return true and write the
+// demangled symbol name to `out`. Otherwise, return false.
+// `out` is modified even if demangling is unsuccessful.
+bool Demangle(const char *mangled, char *out, int out_size);
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_DEMANGLE_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle_test.cc
new file mode 100644
index 0000000..b9d9008
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/demangle_test.cc
@@ -0,0 +1,191 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/debugging/internal/demangle.h"
+
+#include <cstdlib>
+#include <string>
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/debugging/internal/stack_consumption.h"
+#include "absl/memory/memory.h"
+
+namespace absl {
+namespace debugging_internal {
+namespace {
+
+// A wrapper function for Demangle() to make the unit test simple.
+static const char *DemangleIt(const char * const mangled) {
+ static char demangled[4096];
+ if (Demangle(mangled, demangled, sizeof(demangled))) {
+ return demangled;
+ } else {
+ return mangled;
+ }
+}
+
+// Test corner cases of bounary conditions.
+TEST(Demangle, CornerCases) {
+ char tmp[10];
+ EXPECT_TRUE(Demangle("_Z6foobarv", tmp, sizeof(tmp)));
+ // sizeof("foobar()") == 9
+ EXPECT_STREQ("foobar()", tmp);
+ EXPECT_TRUE(Demangle("_Z6foobarv", tmp, 9));
+ EXPECT_STREQ("foobar()", tmp);
+ EXPECT_FALSE(Demangle("_Z6foobarv", tmp, 8)); // Not enough.
+ EXPECT_FALSE(Demangle("_Z6foobarv", tmp, 1));
+ EXPECT_FALSE(Demangle("_Z6foobarv", tmp, 0));
+ EXPECT_FALSE(Demangle("_Z6foobarv", nullptr, 0)); // Should not cause SEGV.
+ EXPECT_FALSE(Demangle("_Z1000000", tmp, 9));
+}
+
+// Test handling of functions suffixed with .clone.N, which is used
+// by GCC 4.5.x (and our locally-modified version of GCC 4.4.x), and
+// .constprop.N and .isra.N, which are used by GCC 4.6.x. These
+// suffixes are used to indicate functions which have been cloned
+// during optimization. We ignore these suffixes.
+TEST(Demangle, Clones) {
+ char tmp[20];
+ EXPECT_TRUE(Demangle("_ZL3Foov", tmp, sizeof(tmp)));
+ EXPECT_STREQ("Foo()", tmp);
+ EXPECT_TRUE(Demangle("_ZL3Foov.clone.3", tmp, sizeof(tmp)));
+ EXPECT_STREQ("Foo()", tmp);
+ EXPECT_TRUE(Demangle("_ZL3Foov.constprop.80", tmp, sizeof(tmp)));
+ EXPECT_STREQ("Foo()", tmp);
+ EXPECT_TRUE(Demangle("_ZL3Foov.isra.18", tmp, sizeof(tmp)));
+ EXPECT_STREQ("Foo()", tmp);
+ EXPECT_TRUE(Demangle("_ZL3Foov.isra.2.constprop.18", tmp, sizeof(tmp)));
+ EXPECT_STREQ("Foo()", tmp);
+ // Invalid (truncated), should not demangle.
+ EXPECT_FALSE(Demangle("_ZL3Foov.clo", tmp, sizeof(tmp)));
+ // Invalid (.clone. not followed by number), should not demangle.
+ EXPECT_FALSE(Demangle("_ZL3Foov.clone.", tmp, sizeof(tmp)));
+ // Invalid (.clone. followed by non-number), should not demangle.
+ EXPECT_FALSE(Demangle("_ZL3Foov.clone.foo", tmp, sizeof(tmp)));
+ // Invalid (.constprop. not followed by number), should not demangle.
+ EXPECT_FALSE(Demangle("_ZL3Foov.isra.2.constprop.", tmp, sizeof(tmp)));
+}
+
+// Tests that verify that Demangle footprint is within some limit.
+// They are not to be run under sanitizers as the sanitizers increase
+// stack consumption by about 4x.
+#if defined(ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION) && \
+ !ADDRESS_SANITIZER && !MEMORY_SANITIZER && !THREAD_SANITIZER
+
+static const char *g_mangled;
+static char g_demangle_buffer[4096];
+static char *g_demangle_result;
+
+static void DemangleSignalHandler(int signo) {
+ if (Demangle(g_mangled, g_demangle_buffer, sizeof(g_demangle_buffer))) {
+ g_demangle_result = g_demangle_buffer;
+ } else {
+ g_demangle_result = nullptr;
+ }
+}
+
+// Call Demangle and figure out the stack footprint of this call.
+static const char *DemangleStackConsumption(const char *mangled,
+ int *stack_consumed) {
+ g_mangled = mangled;
+ *stack_consumed = GetSignalHandlerStackConsumption(DemangleSignalHandler);
+ ABSL_RAW_LOG(INFO, "Stack consumption of Demangle: %d", *stack_consumed);
+ return g_demangle_result;
+}
+
+// Demangle stack consumption should be within 8kB for simple mangled names
+// with some level of nesting. With alternate signal stack we have 64K,
+// but some signal handlers run on thread stack, and could have arbitrarily
+// little space left (so we don't want to make this number too large).
+const int kStackConsumptionUpperLimit = 8192;
+
+// Returns a mangled name nested to the given depth.
+static std::string NestedMangledName(int depth) {
+ std::string mangled_name = "_Z1a";
+ if (depth > 0) {
+ mangled_name += "IXL";
+ mangled_name += NestedMangledName(depth - 1);
+ mangled_name += "EEE";
+ }
+ return mangled_name;
+}
+
+TEST(Demangle, DemangleStackConsumption) {
+ // Measure stack consumption of Demangle for nested mangled names of varying
+ // depth. Since Demangle is implemented as a recursive descent parser,
+ // stack consumption will grow as the nesting depth increases. By measuring
+ // the stack consumption for increasing depths, we can see the growing
+ // impact of any stack-saving changes made to the code for Demangle.
+ int stack_consumed = 0;
+
+ const char *demangled =
+ DemangleStackConsumption("_Z6foobarv", &stack_consumed);
+ EXPECT_STREQ("foobar()", demangled);
+ EXPECT_GT(stack_consumed, 0);
+ EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
+
+ const std::string nested_mangled_name0 = NestedMangledName(0);
+ demangled = DemangleStackConsumption(nested_mangled_name0.c_str(),
+ &stack_consumed);
+ EXPECT_STREQ("a", demangled);
+ EXPECT_GT(stack_consumed, 0);
+ EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
+
+ const std::string nested_mangled_name1 = NestedMangledName(1);
+ demangled = DemangleStackConsumption(nested_mangled_name1.c_str(),
+ &stack_consumed);
+ EXPECT_STREQ("a<>", demangled);
+ EXPECT_GT(stack_consumed, 0);
+ EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
+
+ const std::string nested_mangled_name2 = NestedMangledName(2);
+ demangled = DemangleStackConsumption(nested_mangled_name2.c_str(),
+ &stack_consumed);
+ EXPECT_STREQ("a<>", demangled);
+ EXPECT_GT(stack_consumed, 0);
+ EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
+
+ const std::string nested_mangled_name3 = NestedMangledName(3);
+ demangled = DemangleStackConsumption(nested_mangled_name3.c_str(),
+ &stack_consumed);
+ EXPECT_STREQ("a<>", demangled);
+ EXPECT_GT(stack_consumed, 0);
+ EXPECT_LT(stack_consumed, kStackConsumptionUpperLimit);
+}
+
+#endif // Stack consumption tests
+
+static void TestOnInput(const char* input) {
+ static const int kOutSize = 1048576;
+ auto out = absl::make_unique<char[]>(kOutSize);
+ Demangle(input, out.get(), kOutSize);
+}
+
+TEST(DemangleRegression, NegativeLength) {
+ TestOnInput("_ZZn4");
+}
+TEST(DemangleRegression, DeeplyNestedArrayType) {
+ const int depth = 100000;
+ std::string data = "_ZStI";
+ data.reserve(data.size() + 3 * depth + 1);
+ for (int i = 0; i < depth; i++) {
+ data += "A1_";
+ }
+ TestOnInput(data.c_str());
+}
+
+} // namespace
+} // namespace debugging_internal
+} // namespace absl
[46/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/cycleclock.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/cycleclock.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/cycleclock.cc
new file mode 100644
index 0000000..a742df0
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/cycleclock.cc
@@ -0,0 +1,81 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The implementation of CycleClock::Frequency.
+//
+// NOTE: only i386 and x86_64 have been well tested.
+// PPC, sparc, alpha, and ia64 are based on
+// http://peter.kuscsik.com/wordpress/?p=14
+// with modifications by m3b. See also
+// https://setisvn.ssl.berkeley.edu/svn/lib/fftw-3.0.1/kernel/cycle.h
+
+#include "absl/base/internal/cycleclock.h"
+
+#include <chrono> // NOLINT(build/c++11)
+
+#include "absl/base/internal/unscaledcycleclock.h"
+
+namespace absl {
+namespace base_internal {
+
+#if ABSL_USE_UNSCALED_CYCLECLOCK
+
+namespace {
+
+#ifdef NDEBUG
+#ifdef ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
+// Not debug mode and the UnscaledCycleClock frequency is the CPU
+// frequency. Scale the CycleClock to prevent overflow if someone
+// tries to represent the time as cycles since the Unix epoch.
+static constexpr int32_t kShift = 1;
+#else
+// Not debug mode and the UnscaledCycleClock isn't operating at the
+// raw CPU frequency. There is no need to do any scaling, so don't
+// needlessly sacrifice precision.
+static constexpr int32_t kShift = 0;
+#endif
+#else
+// In debug mode use a different shift to discourage depending on a
+// particular shift value.
+static constexpr int32_t kShift = 2;
+#endif
+
+static constexpr double kFrequencyScale = 1.0 / (1 << kShift);
+
+} // namespace
+
+int64_t CycleClock::Now() {
+ return base_internal::UnscaledCycleClock::Now() >> kShift;
+}
+
+double CycleClock::Frequency() {
+ return kFrequencyScale * base_internal::UnscaledCycleClock::Frequency();
+}
+
+#else
+
+int64_t CycleClock::Now() {
+ return std::chrono::duration_cast<std::chrono::nanoseconds>(
+ std::chrono::steady_clock::now().time_since_epoch())
+ .count();
+}
+
+double CycleClock::Frequency() {
+ return 1e9;
+}
+
+#endif
+
+} // namespace base_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/cycleclock.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/cycleclock.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/cycleclock.h
new file mode 100644
index 0000000..60e9715
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/cycleclock.h
@@ -0,0 +1,77 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// -----------------------------------------------------------------------------
+// File: cycleclock.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a `CycleClock`, which yields the value and frequency
+// of a cycle counter that increments at a rate that is approximately constant.
+//
+// NOTE:
+//
+// The cycle counter frequency is not necessarily related to the core clock
+// frequency and should not be treated as such. That is, `CycleClock` cycles are
+// not necessarily "CPU cycles" and code should not rely on that behavior, even
+// if experimentally observed.
+//
+//
+// An arbitrary offset may have been added to the counter at power on.
+//
+// On some platforms, the rate and offset of the counter may differ
+// slightly when read from different CPUs of a multiprocessor. Usually,
+// we try to ensure that the operating system adjusts values periodically
+// so that values agree approximately. If you need stronger guarantees,
+// consider using alternate interfaces.
+//
+// The CPU is not required to maintain the ordering of a cycle counter read
+// with respect to surrounding instructions.
+
+#ifndef ABSL_BASE_INTERNAL_CYCLECLOCK_H_
+#define ABSL_BASE_INTERNAL_CYCLECLOCK_H_
+
+#include <cstdint>
+
+namespace absl {
+namespace base_internal {
+
+// -----------------------------------------------------------------------------
+// CycleClock
+// -----------------------------------------------------------------------------
+class CycleClock {
+ public:
+ // CycleClock::Now()
+ //
+ // Returns the value of a cycle counter that counts at a rate that is
+ // approximately constant.
+ static int64_t Now();
+
+ // CycleClock::Frequency()
+ //
+ // Returns the amount by which `CycleClock::Now()` increases per second. Note
+ // that this value may not necessarily match the core CPU clock frequency.
+ static double Frequency();
+
+ private:
+ CycleClock() = delete; // no instances
+ CycleClock(const CycleClock&) = delete;
+ CycleClock& operator=(const CycleClock&) = delete;
+};
+
+} // namespace base_internal
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_CYCLECLOCK_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/direct_mmap.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/direct_mmap.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/direct_mmap.h
new file mode 100644
index 0000000..4bd273e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/direct_mmap.h
@@ -0,0 +1,151 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Functions for directly invoking mmap() via syscall, avoiding the case where
+// mmap() has been locally overridden.
+
+#ifndef ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
+#define ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
+
+#include "absl/base/config.h"
+
+#if ABSL_HAVE_MMAP
+
+#include <sys/mman.h>
+
+#ifdef __linux__
+
+#include <sys/types.h>
+#ifdef __BIONIC__
+#include <sys/syscall.h>
+#else
+#include <syscall.h>
+#endif
+
+#include <linux/unistd.h>
+#include <unistd.h>
+#include <cerrno>
+#include <cstdarg>
+#include <cstdint>
+
+#ifdef __mips__
+// Include definitions of the ABI currently in use.
+#ifdef __BIONIC__
+// Android doesn't have sgidefs.h, but does have asm/sgidefs.h, which has the
+// definitions we need.
+#include <asm/sgidefs.h>
+#else
+#include <sgidefs.h>
+#endif // __BIONIC__
+#endif // __mips__
+
+// SYS_mmap and SYS_munmap are not defined in Android.
+#ifdef __BIONIC__
+extern "C" void* __mmap2(void*, size_t, int, int, int, long);
+#if defined(__NR_mmap) && !defined(SYS_mmap)
+#define SYS_mmap __NR_mmap
+#endif
+#ifndef SYS_munmap
+#define SYS_munmap __NR_munmap
+#endif
+#endif // __BIONIC__
+
+namespace absl {
+namespace base_internal {
+
+// Platform specific logic extracted from
+// https://chromium.googlesource.com/linux-syscall-support/+/master/linux_syscall_support.h
+inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
+ off64_t offset) noexcept {
+#if defined(__i386__) || defined(__ARM_ARCH_3__) || defined(__ARM_EABI__) || \
+ (defined(__mips__) && _MIPS_SIM == _MIPS_SIM_ABI32) || \
+ (defined(__PPC__) && !defined(__PPC64__)) || \
+ (defined(__s390__) && !defined(__s390x__))
+ // On these architectures, implement mmap with mmap2.
+ static int pagesize = 0;
+ if (pagesize == 0) {
+ pagesize = getpagesize();
+ }
+ if (offset < 0 || offset % pagesize != 0) {
+ errno = EINVAL;
+ return MAP_FAILED;
+ }
+#ifdef __BIONIC__
+ // SYS_mmap2 has problems on Android API level <= 16.
+ // Workaround by invoking __mmap2() instead.
+ return __mmap2(start, length, prot, flags, fd, offset / pagesize);
+#else
+ return reinterpret_cast<void*>(
+ syscall(SYS_mmap2, start, length, prot, flags, fd,
+ static_cast<off_t>(offset / pagesize)));
+#endif
+#elif defined(__s390x__)
+ // On s390x, mmap() arguments are passed in memory.
+ uint32_t buf[6] = {
+ reinterpret_cast<uint32_t>(start), static_cast<uint32_t>(length),
+ static_cast<uint32_t>(prot), static_cast<uint32_t>(flags),
+ static_cast<uint32_t>(fd), static_cast<uint32_t>(offset)};
+ return reintrepret_cast<void*>(syscall(SYS_mmap, buf));
+#elif defined(__x86_64__)
+// The x32 ABI has 32 bit longs, but the syscall interface is 64 bit.
+// We need to explicitly cast to an unsigned 64 bit type to avoid implicit
+// sign extension. We can't cast pointers directly because those are
+// 32 bits, and gcc will dump ugly warnings about casting from a pointer
+// to an integer of a different size. We also need to make sure __off64_t
+// isn't truncated to 32-bits under x32.
+#define MMAP_SYSCALL_ARG(x) ((uint64_t)(uintptr_t)(x))
+ return reinterpret_cast<void*>(
+ syscall(SYS_mmap, MMAP_SYSCALL_ARG(start), MMAP_SYSCALL_ARG(length),
+ MMAP_SYSCALL_ARG(prot), MMAP_SYSCALL_ARG(flags),
+ MMAP_SYSCALL_ARG(fd), static_cast<uint64_t>(offset)));
+#undef MMAP_SYSCALL_ARG
+#else // Remaining 64-bit aritectures.
+ static_assert(sizeof(unsigned long) == 8, "Platform is not 64-bit");
+ return reinterpret_cast<void*>(
+ syscall(SYS_mmap, start, length, prot, flags, fd, offset));
+#endif
+}
+
+inline int DirectMunmap(void* start, size_t length) {
+ return static_cast<int>(syscall(SYS_munmap, start, length));
+}
+
+} // namespace base_internal
+} // namespace absl
+
+#else // !__linux__
+
+// For non-linux platforms where we have mmap, just dispatch directly to the
+// actual mmap()/munmap() methods.
+
+namespace absl {
+namespace base_internal {
+
+inline void* DirectMmap(void* start, size_t length, int prot, int flags, int fd,
+ off_t offset) {
+ return mmap(start, length, prot, flags, fd, offset);
+}
+
+inline int DirectMunmap(void* start, size_t length) {
+ return munmap(start, length);
+}
+
+} // namespace base_internal
+} // namespace absl
+
+#endif // __linux__
+
+#endif // ABSL_HAVE_MMAP
+
+#endif // ABSL_BASE_INTERNAL_DIRECT_MMAP_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/endian.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/endian.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/endian.h
new file mode 100644
index 0000000..edc10f1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/endian.h
@@ -0,0 +1,269 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_BASE_INTERNAL_ENDIAN_H_
+#define ABSL_BASE_INTERNAL_ENDIAN_H_
+
+// The following guarantees declaration of the byte swap functions
+#ifdef _MSC_VER
+#include <stdlib.h> // NOLINT(build/include)
+#elif defined(__APPLE__)
+// Mac OS X / Darwin features
+#include <libkern/OSByteOrder.h>
+#elif defined(__FreeBSD__)
+#include <sys/endian.h>
+#elif defined(__GLIBC__)
+#include <byteswap.h> // IWYU pragma: export
+#endif
+
+#include <cstdint>
+#include "absl/base/config.h"
+#include "absl/base/internal/unaligned_access.h"
+#include "absl/base/port.h"
+
+namespace absl {
+
+// Use compiler byte-swapping intrinsics if they are available. 32-bit
+// and 64-bit versions are available in Clang and GCC as of GCC 4.3.0.
+// The 16-bit version is available in Clang and GCC only as of GCC 4.8.0.
+// For simplicity, we enable them all only for GCC 4.8.0 or later.
+#if defined(__clang__) || \
+ (defined(__GNUC__) && \
+ ((__GNUC__ == 4 && __GNUC_MINOR__ >= 8) || __GNUC__ >= 5))
+inline uint64_t gbswap_64(uint64_t host_int) {
+ return __builtin_bswap64(host_int);
+}
+inline uint32_t gbswap_32(uint32_t host_int) {
+ return __builtin_bswap32(host_int);
+}
+inline uint16_t gbswap_16(uint16_t host_int) {
+ return __builtin_bswap16(host_int);
+}
+
+#elif defined(_MSC_VER)
+inline uint64_t gbswap_64(uint64_t host_int) {
+ return _byteswap_uint64(host_int);
+}
+inline uint32_t gbswap_32(uint32_t host_int) {
+ return _byteswap_ulong(host_int);
+}
+inline uint16_t gbswap_16(uint16_t host_int) {
+ return _byteswap_ushort(host_int);
+}
+
+#elif defined(__APPLE__)
+inline uint64_t gbswap_64(uint64_t host_int) { return OSSwapInt16(host_int); }
+inline uint32_t gbswap_32(uint32_t host_int) { return OSSwapInt32(host_int); }
+inline uint16_t gbswap_16(uint16_t host_int) { return OSSwapInt64(host_int); }
+
+#else
+inline uint64_t gbswap_64(uint64_t host_int) {
+#if defined(__GNUC__) && defined(__x86_64__) && !defined(__APPLE__)
+ // Adapted from /usr/include/byteswap.h. Not available on Mac.
+ if (__builtin_constant_p(host_int)) {
+ return __bswap_constant_64(host_int);
+ } else {
+ register uint64_t result;
+ __asm__("bswap %0" : "=r"(result) : "0"(host_int));
+ return result;
+ }
+#elif defined(__GLIBC__)
+ return bswap_64(host_int);
+#else
+ return (((x & uint64_t{(0xFF}) << 56) |
+ ((x & uint64_t{(0xFF00}) << 40) |
+ ((x & uint64_t{(0xFF0000}) << 24) |
+ ((x & uint64_t{(0xFF000000}) << 8) |
+ ((x & uint64_t{(0xFF00000000}) >> 8) |
+ ((x & uint64_t{(0xFF0000000000}) >> 24) |
+ ((x & uint64_t{(0xFF000000000000}) >> 40) |
+ ((x & uint64_t{(0xFF00000000000000}) >> 56));
+#endif // bswap_64
+}
+
+inline uint32_t gbswap_32(uint32_t host_int) {
+#if defined(__GLIBC__)
+ return bswap_32(host_int);
+#else
+ return (((x & 0xFF) << 24) | ((x & 0xFF00) << 8) | ((x & 0xFF0000) >> 8) |
+ ((x & 0xFF000000) >> 24));
+#endif
+}
+
+inline uint16_t gbswap_16(uint16_t host_int) {
+#if defined(__GLIBC__)
+ return bswap_16(host_int);
+#else
+ return uint16_t{((x & 0xFF) << 8) | ((x & 0xFF00) >> 8)};
+#endif
+}
+
+#endif // intrinics available
+
+#ifdef ABSL_IS_LITTLE_ENDIAN
+
+// Definitions for ntohl etc. that don't require us to include
+// netinet/in.h. We wrap gbswap_32 and gbswap_16 in functions rather
+// than just #defining them because in debug mode, gcc doesn't
+// correctly handle the (rather involved) definitions of bswap_32.
+// gcc guarantees that inline functions are as fast as macros, so
+// this isn't a performance hit.
+inline uint16_t ghtons(uint16_t x) { return gbswap_16(x); }
+inline uint32_t ghtonl(uint32_t x) { return gbswap_32(x); }
+inline uint64_t ghtonll(uint64_t x) { return gbswap_64(x); }
+
+#elif defined ABSL_IS_BIG_ENDIAN
+
+// These definitions are simpler on big-endian machines
+// These are functions instead of macros to avoid self-assignment warnings
+// on calls such as "i = ghtnol(i);". This also provides type checking.
+inline uint16_t ghtons(uint16_t x) { return x; }
+inline uint32_t ghtonl(uint32_t x) { return x; }
+inline uint64_t ghtonll(uint64_t x) { return x; }
+
+#else
+#error \
+ "Unsupported byte order: Either ABSL_IS_BIG_ENDIAN or " \
+ "ABSL_IS_LITTLE_ENDIAN must be defined"
+#endif // byte order
+
+inline uint16_t gntohs(uint16_t x) { return ghtons(x); }
+inline uint32_t gntohl(uint32_t x) { return ghtonl(x); }
+inline uint64_t gntohll(uint64_t x) { return ghtonll(x); }
+
+// Utilities to convert numbers between the current hosts's native byte
+// order and little-endian byte order
+//
+// Load/Store methods are alignment safe
+namespace little_endian {
+// Conversion functions.
+#ifdef ABSL_IS_LITTLE_ENDIAN
+
+inline uint16_t FromHost16(uint16_t x) { return x; }
+inline uint16_t ToHost16(uint16_t x) { return x; }
+
+inline uint32_t FromHost32(uint32_t x) { return x; }
+inline uint32_t ToHost32(uint32_t x) { return x; }
+
+inline uint64_t FromHost64(uint64_t x) { return x; }
+inline uint64_t ToHost64(uint64_t x) { return x; }
+
+inline constexpr bool IsLittleEndian() { return true; }
+
+#elif defined ABSL_IS_BIG_ENDIAN
+
+inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
+inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
+
+inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
+inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
+
+inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
+inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
+
+inline constexpr bool IsLittleEndian() { return false; }
+
+#endif /* ENDIAN */
+
+// Functions to do unaligned loads and stores in little-endian order.
+inline uint16_t Load16(const void *p) {
+ return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
+}
+
+inline void Store16(void *p, uint16_t v) {
+ ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+}
+
+inline uint32_t Load32(const void *p) {
+ return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
+}
+
+inline void Store32(void *p, uint32_t v) {
+ ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+}
+
+inline uint64_t Load64(const void *p) {
+ return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
+}
+
+inline void Store64(void *p, uint64_t v) {
+ ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+}
+
+} // namespace little_endian
+
+// Utilities to convert numbers between the current hosts's native byte
+// order and big-endian byte order (same as network byte order)
+//
+// Load/Store methods are alignment safe
+namespace big_endian {
+#ifdef ABSL_IS_LITTLE_ENDIAN
+
+inline uint16_t FromHost16(uint16_t x) { return gbswap_16(x); }
+inline uint16_t ToHost16(uint16_t x) { return gbswap_16(x); }
+
+inline uint32_t FromHost32(uint32_t x) { return gbswap_32(x); }
+inline uint32_t ToHost32(uint32_t x) { return gbswap_32(x); }
+
+inline uint64_t FromHost64(uint64_t x) { return gbswap_64(x); }
+inline uint64_t ToHost64(uint64_t x) { return gbswap_64(x); }
+
+inline constexpr bool IsLittleEndian() { return true; }
+
+#elif defined ABSL_IS_BIG_ENDIAN
+
+inline uint16_t FromHost16(uint16_t x) { return x; }
+inline uint16_t ToHost16(uint16_t x) { return x; }
+
+inline uint32_t FromHost32(uint32_t x) { return x; }
+inline uint32_t ToHost32(uint32_t x) { return x; }
+
+inline uint64_t FromHost64(uint64_t x) { return x; }
+inline uint64_t ToHost64(uint64_t x) { return x; }
+
+inline constexpr bool IsLittleEndian() { return false; }
+
+#endif /* ENDIAN */
+
+// Functions to do unaligned loads and stores in big-endian order.
+inline uint16_t Load16(const void *p) {
+ return ToHost16(ABSL_INTERNAL_UNALIGNED_LOAD16(p));
+}
+
+inline void Store16(void *p, uint16_t v) {
+ ABSL_INTERNAL_UNALIGNED_STORE16(p, FromHost16(v));
+}
+
+inline uint32_t Load32(const void *p) {
+ return ToHost32(ABSL_INTERNAL_UNALIGNED_LOAD32(p));
+}
+
+inline void Store32(void *p, uint32_t v) {
+ ABSL_INTERNAL_UNALIGNED_STORE32(p, FromHost32(v));
+}
+
+inline uint64_t Load64(const void *p) {
+ return ToHost64(ABSL_INTERNAL_UNALIGNED_LOAD64(p));
+}
+
+inline void Store64(void *p, uint64_t v) {
+ ABSL_INTERNAL_UNALIGNED_STORE64(p, FromHost64(v));
+}
+
+} // namespace big_endian
+
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_ENDIAN_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/endian_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/endian_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/endian_test.cc
new file mode 100644
index 0000000..f3ff4b3
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/endian_test.cc
@@ -0,0 +1,279 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/endian.h"
+
+#include <algorithm>
+#include <cstdint>
+#include <limits>
+#include <random>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+
+namespace absl {
+namespace {
+
+const uint64_t kInitialNumber{0x0123456789abcdef};
+const uint64_t k64Value{kInitialNumber};
+const uint32_t k32Value{0x01234567};
+const uint16_t k16Value{0x0123};
+const int kNumValuesToTest = 1000000;
+const int kRandomSeed = 12345;
+
+#ifdef ABSL_IS_BIG_ENDIAN
+const uint64_t kInitialInNetworkOrder{kInitialNumber};
+const uint64_t k64ValueLE{0xefcdab8967452301};
+const uint32_t k32ValueLE{0x67452301};
+const uint16_t k16ValueLE{0x2301};
+const uint8_t k8ValueLE{k8Value};
+const uint64_t k64IValueLE{0xefcdab89674523a1};
+const uint32_t k32IValueLE{0x67452391};
+const uint16_t k16IValueLE{0x85ff};
+const uint8_t k8IValueLE{0xff};
+const uint64_t kDoubleValueLE{0x6e861bf0f9210940};
+const uint32_t kFloatValueLE{0xd00f4940};
+const uint8_t kBoolValueLE{0x1};
+
+const uint64_t k64ValueBE{kInitialNumber};
+const uint32_t k32ValueBE{k32Value};
+const uint16_t k16ValueBE{k16Value};
+const uint8_t k8ValueBE{k8Value};
+const uint64_t k64IValueBE{0xa123456789abcdef};
+const uint32_t k32IValueBE{0x91234567};
+const uint16_t k16IValueBE{0xff85};
+const uint8_t k8IValueBE{0xff};
+const uint64_t kDoubleValueBE{0x400921f9f01b866e};
+const uint32_t kFloatValueBE{0x40490fd0};
+const uint8_t kBoolValueBE{0x1};
+#elif defined ABSL_IS_LITTLE_ENDIAN
+const uint64_t kInitialInNetworkOrder{0xefcdab8967452301};
+const uint64_t k64ValueLE{kInitialNumber};
+const uint32_t k32ValueLE{k32Value};
+const uint16_t k16ValueLE{k16Value};
+
+const uint64_t k64ValueBE{0xefcdab8967452301};
+const uint32_t k32ValueBE{0x67452301};
+const uint16_t k16ValueBE{0x2301};
+#endif
+
+template<typename T>
+std::vector<T> GenerateAllValuesForType() {
+ std::vector<T> result;
+ T next = std::numeric_limits<T>::min();
+ while (true) {
+ result.push_back(next);
+ if (next == std::numeric_limits<T>::max()) {
+ return result;
+ }
+ ++next;
+ }
+}
+
+template<typename T>
+std::vector<T> GenerateRandomIntegers(size_t numValuesToTest) {
+ std::vector<T> result;
+ std::mt19937_64 rng(kRandomSeed);
+ for (size_t i = 0; i < numValuesToTest; ++i) {
+ result.push_back(rng());
+ }
+ return result;
+}
+
+void ManualByteSwap(char* bytes, int length) {
+ if (length == 1)
+ return;
+
+ EXPECT_EQ(0, length % 2);
+ for (int i = 0; i < length / 2; ++i) {
+ int j = (length - 1) - i;
+ using std::swap;
+ swap(bytes[i], bytes[j]);
+ }
+}
+
+template<typename T>
+inline T UnalignedLoad(const char* p) {
+ static_assert(
+ sizeof(T) == 1 || sizeof(T) == 2 || sizeof(T) == 4 || sizeof(T) == 8,
+ "Unexpected type size");
+
+ switch (sizeof(T)) {
+ case 1: return *reinterpret_cast<const T*>(p);
+ case 2:
+ return ABSL_INTERNAL_UNALIGNED_LOAD16(p);
+ case 4:
+ return ABSL_INTERNAL_UNALIGNED_LOAD32(p);
+ case 8:
+ return ABSL_INTERNAL_UNALIGNED_LOAD64(p);
+ default:
+ // Suppresses invalid "not all control paths return a value" on MSVC
+ return {};
+ }
+}
+
+template <typename T, typename ByteSwapper>
+static void GBSwapHelper(const std::vector<T>& host_values_to_test,
+ const ByteSwapper& byte_swapper) {
+ // Test byte_swapper against a manual byte swap.
+ for (typename std::vector<T>::const_iterator it = host_values_to_test.begin();
+ it != host_values_to_test.end(); ++it) {
+ T host_value = *it;
+
+ char actual_value[sizeof(host_value)];
+ memcpy(actual_value, &host_value, sizeof(host_value));
+ byte_swapper(actual_value);
+
+ char expected_value[sizeof(host_value)];
+ memcpy(expected_value, &host_value, sizeof(host_value));
+ ManualByteSwap(expected_value, sizeof(host_value));
+
+ ASSERT_EQ(0, memcmp(actual_value, expected_value, sizeof(host_value)))
+ << "Swap output for 0x" << std::hex << host_value << " does not match. "
+ << "Expected: 0x" << UnalignedLoad<T>(expected_value) << "; "
+ << "actual: 0x" << UnalignedLoad<T>(actual_value);
+ }
+}
+
+void Swap16(char* bytes) {
+ ABSL_INTERNAL_UNALIGNED_STORE16(
+ bytes, gbswap_16(ABSL_INTERNAL_UNALIGNED_LOAD16(bytes)));
+}
+
+void Swap32(char* bytes) {
+ ABSL_INTERNAL_UNALIGNED_STORE32(
+ bytes, gbswap_32(ABSL_INTERNAL_UNALIGNED_LOAD32(bytes)));
+}
+
+void Swap64(char* bytes) {
+ ABSL_INTERNAL_UNALIGNED_STORE64(
+ bytes, gbswap_64(ABSL_INTERNAL_UNALIGNED_LOAD64(bytes)));
+}
+
+TEST(EndianessTest, Uint16) {
+ GBSwapHelper(GenerateAllValuesForType<uint16_t>(), &Swap16);
+}
+
+TEST(EndianessTest, Uint32) {
+ GBSwapHelper(GenerateRandomIntegers<uint32_t>(kNumValuesToTest), &Swap32);
+}
+
+TEST(EndianessTest, Uint64) {
+ GBSwapHelper(GenerateRandomIntegers<uint64_t>(kNumValuesToTest), &Swap64);
+}
+
+TEST(EndianessTest, ghtonll_gntohll) {
+ // Test that absl::ghtonl compiles correctly
+ uint32_t test = 0x01234567;
+ EXPECT_EQ(absl::gntohl(absl::ghtonl(test)), test);
+
+ uint64_t comp = absl::ghtonll(kInitialNumber);
+ EXPECT_EQ(comp, kInitialInNetworkOrder);
+ comp = absl::gntohll(kInitialInNetworkOrder);
+ EXPECT_EQ(comp, kInitialNumber);
+
+ // Test that htonll and ntohll are each others' inverse functions on a
+ // somewhat assorted batch of numbers. 37 is chosen to not be anything
+ // particularly nice base 2.
+ uint64_t value = 1;
+ for (int i = 0; i < 100; ++i) {
+ comp = absl::ghtonll(absl::gntohll(value));
+ EXPECT_EQ(value, comp);
+ comp = absl::gntohll(absl::ghtonll(value));
+ EXPECT_EQ(value, comp);
+ value *= 37;
+ }
+}
+
+TEST(EndianessTest, little_endian) {
+ // Check little_endian uint16_t.
+ uint64_t comp = little_endian::FromHost16(k16Value);
+ EXPECT_EQ(comp, k16ValueLE);
+ comp = little_endian::ToHost16(k16ValueLE);
+ EXPECT_EQ(comp, k16Value);
+
+ // Check little_endian uint32_t.
+ comp = little_endian::FromHost32(k32Value);
+ EXPECT_EQ(comp, k32ValueLE);
+ comp = little_endian::ToHost32(k32ValueLE);
+ EXPECT_EQ(comp, k32Value);
+
+ // Check little_endian uint64_t.
+ comp = little_endian::FromHost64(k64Value);
+ EXPECT_EQ(comp, k64ValueLE);
+ comp = little_endian::ToHost64(k64ValueLE);
+ EXPECT_EQ(comp, k64Value);
+
+ // Check little-endian Load and store functions.
+ uint16_t u16Buf;
+ uint32_t u32Buf;
+ uint64_t u64Buf;
+
+ little_endian::Store16(&u16Buf, k16Value);
+ EXPECT_EQ(u16Buf, k16ValueLE);
+ comp = little_endian::Load16(&u16Buf);
+ EXPECT_EQ(comp, k16Value);
+
+ little_endian::Store32(&u32Buf, k32Value);
+ EXPECT_EQ(u32Buf, k32ValueLE);
+ comp = little_endian::Load32(&u32Buf);
+ EXPECT_EQ(comp, k32Value);
+
+ little_endian::Store64(&u64Buf, k64Value);
+ EXPECT_EQ(u64Buf, k64ValueLE);
+ comp = little_endian::Load64(&u64Buf);
+ EXPECT_EQ(comp, k64Value);
+}
+
+TEST(EndianessTest, big_endian) {
+ // Check big-endian Load and store functions.
+ uint16_t u16Buf;
+ uint32_t u32Buf;
+ uint64_t u64Buf;
+
+ unsigned char buffer[10];
+ big_endian::Store16(&u16Buf, k16Value);
+ EXPECT_EQ(u16Buf, k16ValueBE);
+ uint64_t comp = big_endian::Load16(&u16Buf);
+ EXPECT_EQ(comp, k16Value);
+
+ big_endian::Store32(&u32Buf, k32Value);
+ EXPECT_EQ(u32Buf, k32ValueBE);
+ comp = big_endian::Load32(&u32Buf);
+ EXPECT_EQ(comp, k32Value);
+
+ big_endian::Store64(&u64Buf, k64Value);
+ EXPECT_EQ(u64Buf, k64ValueBE);
+ comp = big_endian::Load64(&u64Buf);
+ EXPECT_EQ(comp, k64Value);
+
+ big_endian::Store16(buffer + 1, k16Value);
+ EXPECT_EQ(u16Buf, k16ValueBE);
+ comp = big_endian::Load16(buffer + 1);
+ EXPECT_EQ(comp, k16Value);
+
+ big_endian::Store32(buffer + 1, k32Value);
+ EXPECT_EQ(u32Buf, k32ValueBE);
+ comp = big_endian::Load32(buffer + 1);
+ EXPECT_EQ(comp, k32Value);
+
+ big_endian::Store64(buffer + 1, k64Value);
+ EXPECT_EQ(u64Buf, k64ValueBE);
+ comp = big_endian::Load64(buffer + 1);
+ EXPECT_EQ(comp, k64Value);
+}
+
+} // namespace
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_safety_testing.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_safety_testing.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_safety_testing.cc
new file mode 100644
index 0000000..c6f7c7c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_safety_testing.cc
@@ -0,0 +1,41 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/exception_safety_testing.h"
+
+#include "gtest/gtest.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+
+exceptions_internal::NoThrowTag no_throw_ctor;
+exceptions_internal::StrongGuaranteeTagType strong_guarantee;
+
+namespace exceptions_internal {
+
+int countdown = -1;
+
+void MaybeThrow(absl::string_view msg, bool throw_bad_alloc) {
+ if (countdown-- == 0) {
+ if (throw_bad_alloc) throw TestBadAllocException(msg);
+ throw TestException(msg);
+ }
+}
+
+testing::AssertionResult FailureMessage(const TestException& e,
+ int countdown) noexcept {
+ return testing::AssertionFailure() << "Exception thrown from " << e.what();
+}
+} // namespace exceptions_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_safety_testing.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_safety_testing.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_safety_testing.h
new file mode 100644
index 0000000..c014fb3
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_safety_testing.h
@@ -0,0 +1,997 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Utilities for testing exception-safety
+
+#ifndef ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
+#define ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <initializer_list>
+#include <iosfwd>
+#include <string>
+#include <tuple>
+#include <unordered_map>
+
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/pretty_function.h"
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/substitute.h"
+#include "absl/types/optional.h"
+
+namespace absl {
+
+// A configuration enum for Throwing*. Operations whose flags are set will
+// throw, everything else won't. This isn't meant to be exhaustive, more flags
+// can always be made in the future.
+enum class NoThrow : uint8_t {
+ kNone = 0,
+ kMoveCtor = 1,
+ kMoveAssign = 1 << 1,
+ kAllocation = 1 << 2,
+ kIntCtor = 1 << 3,
+ kNoThrow = static_cast<uint8_t>(-1)
+};
+
+constexpr NoThrow operator|(NoThrow a, NoThrow b) {
+ using T = absl::underlying_type_t<NoThrow>;
+ return static_cast<NoThrow>(static_cast<T>(a) | static_cast<T>(b));
+}
+
+constexpr NoThrow operator&(NoThrow a, NoThrow b) {
+ using T = absl::underlying_type_t<NoThrow>;
+ return static_cast<NoThrow>(static_cast<T>(a) & static_cast<T>(b));
+}
+
+namespace exceptions_internal {
+struct NoThrowTag {};
+struct StrongGuaranteeTagType {};
+
+constexpr bool ThrowingAllowed(NoThrow flags, NoThrow flag) {
+ return !static_cast<bool>(flags & flag);
+}
+
+// A simple exception class. We throw this so that test code can catch
+// exceptions specifically thrown by ThrowingValue.
+class TestException {
+ public:
+ explicit TestException(absl::string_view msg) : msg_(msg) {}
+ virtual ~TestException() {}
+ virtual const char* what() const noexcept { return msg_.c_str(); }
+
+ private:
+ std::string msg_;
+};
+
+// TestBadAllocException exists because allocation functions must throw an
+// exception which can be caught by a handler of std::bad_alloc. We use a child
+// class of std::bad_alloc so we can customise the error message, and also
+// derive from TestException so we don't accidentally end up catching an actual
+// bad_alloc exception in TestExceptionSafety.
+class TestBadAllocException : public std::bad_alloc, public TestException {
+ public:
+ explicit TestBadAllocException(absl::string_view msg) : TestException(msg) {}
+ using TestException::what;
+};
+
+extern int countdown;
+
+// Allows the countdown variable to be set manually (defaulting to the initial
+// value of 0)
+inline void SetCountdown(int i = 0) { countdown = i; }
+// Sets the countdown to the terminal value -1
+inline void UnsetCountdown() { SetCountdown(-1); }
+
+void MaybeThrow(absl::string_view msg, bool throw_bad_alloc = false);
+
+testing::AssertionResult FailureMessage(const TestException& e,
+ int countdown) noexcept;
+
+class ConstructorTracker;
+
+class TrackedObject {
+ public:
+ TrackedObject(const TrackedObject&) = delete;
+ TrackedObject(TrackedObject&&) = delete;
+
+ protected:
+ explicit TrackedObject(const char* child_ctor) {
+ if (!GetInstanceMap().emplace(this, child_ctor).second) {
+ ADD_FAILURE() << "Object at address " << static_cast<void*>(this)
+ << " re-constructed in ctor " << child_ctor;
+ }
+ }
+
+ ~TrackedObject() noexcept {
+ if (GetInstanceMap().erase(this) == 0) {
+ ADD_FAILURE() << "Object at address " << static_cast<void*>(this)
+ << " destroyed improperly";
+ }
+ }
+
+ private:
+ using InstanceMap = std::unordered_map<TrackedObject*, absl::string_view>;
+ static InstanceMap& GetInstanceMap() {
+ static auto* instance_map = new InstanceMap();
+ return *instance_map;
+ }
+
+ friend class ConstructorTracker;
+};
+
+// Inspects the constructions and destructions of anything inheriting from
+// TrackedObject. This allows us to safely "leak" TrackedObjects, as
+// ConstructorTracker will destroy everything left over in its destructor.
+class ConstructorTracker {
+ public:
+ explicit ConstructorTracker(int c)
+ : init_count_(c), init_instances_(TrackedObject::GetInstanceMap()) {}
+ ~ConstructorTracker() {
+ auto& cur_instances = TrackedObject::GetInstanceMap();
+ for (auto it = cur_instances.begin(); it != cur_instances.end();) {
+ if (init_instances_.count(it->first) == 0) {
+ ADD_FAILURE() << "Object at address " << static_cast<void*>(it->first)
+ << " constructed from " << it->second
+ << " where the exception countdown was set to "
+ << init_count_ << " was not destroyed";
+ // Erasing an item inside an unordered_map invalidates the existing
+ // iterator. A new one is returned for iteration to continue.
+ it = cur_instances.erase(it);
+ } else {
+ ++it;
+ }
+ }
+ }
+
+ private:
+ int init_count_;
+ TrackedObject::InstanceMap init_instances_;
+};
+
+template <typename Factory, typename Operation, typename Invariant>
+absl::optional<testing::AssertionResult> TestSingleInvariantAtCountdownImpl(
+ const Factory& factory, const Operation& operation, int count,
+ const Invariant& invariant) {
+ auto t_ptr = factory();
+ absl::optional<testing::AssertionResult> current_res;
+ SetCountdown(count);
+ try {
+ operation(t_ptr.get());
+ } catch (const exceptions_internal::TestException& e) {
+ current_res.emplace(invariant(t_ptr.get()));
+ if (!current_res.value()) {
+ *current_res << e.what() << " failed invariant check";
+ }
+ }
+ UnsetCountdown();
+ return current_res;
+}
+
+template <typename Factory, typename Operation>
+absl::optional<testing::AssertionResult> TestSingleInvariantAtCountdownImpl(
+ const Factory& factory, const Operation& operation, int count,
+ StrongGuaranteeTagType) {
+ using TPtr = typename decltype(factory())::pointer;
+ auto t_is_strong = [&](TPtr t) { return *t == *factory(); };
+ return TestSingleInvariantAtCountdownImpl(factory, operation, count,
+ t_is_strong);
+}
+
+template <typename Factory, typename Operation, typename Invariant>
+int TestSingleInvariantAtCountdown(
+ const Factory& factory, const Operation& operation, int count,
+ const Invariant& invariant,
+ absl::optional<testing::AssertionResult>* reduced_res) {
+ // If reduced_res is empty, it means the current call to
+ // TestSingleInvariantAtCountdown(...) is the first test being run so we do
+ // want to run it. Alternatively, if it's not empty (meaning a previous test
+ // has run) we want to check if it passed. If the previous test did pass, we
+ // want to contine running tests so we do want to run the current one. If it
+ // failed, we want to short circuit so as not to overwrite the AssertionResult
+ // output. If that's the case, we do not run the current test and instead we
+ // simply return.
+ if (!reduced_res->has_value() || reduced_res->value()) {
+ *reduced_res = TestSingleInvariantAtCountdownImpl(factory, operation, count,
+ invariant);
+ }
+ return 0;
+}
+
+template <typename Factory, typename Operation, typename... Invariants>
+inline absl::optional<testing::AssertionResult> TestAllInvariantsAtCountdown(
+ const Factory& factory, const Operation& operation, int count,
+ const Invariants&... invariants) {
+ absl::optional<testing::AssertionResult> reduced_res;
+
+ // Run each checker, short circuiting after the first failure
+ int dummy[] = {
+ 0, (TestSingleInvariantAtCountdown(factory, operation, count, invariants,
+ &reduced_res))...};
+ static_cast<void>(dummy);
+ return reduced_res;
+}
+
+} // namespace exceptions_internal
+
+extern exceptions_internal::NoThrowTag no_throw_ctor;
+extern exceptions_internal::StrongGuaranteeTagType strong_guarantee;
+
+// A test class which is convertible to bool. The conversion can be
+// instrumented to throw at a controlled time.
+class ThrowingBool {
+ public:
+ ThrowingBool(bool b) noexcept : b_(b) {} // NOLINT(runtime/explicit)
+ operator bool() const { // NOLINT
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return b_;
+ }
+
+ private:
+ bool b_;
+};
+
+// A testing class instrumented to throw an exception at a controlled time.
+//
+// ThrowingValue implements a slightly relaxed version of the Regular concept --
+// that is it's a value type with the expected semantics. It also implements
+// arithmetic operations. It doesn't implement member and pointer operators
+// like operator-> or operator[].
+//
+// ThrowingValue can be instrumented to have certain operations be noexcept by
+// using compile-time bitfield flag template arguments. That is, to make an
+// ThrowingValue which has a noexcept move constructor and noexcept move
+// assignment, use
+// ThrowingValue<absl::NoThrow::kMoveCtor | absl::NoThrow::kMoveAssign>.
+template <NoThrow Flags = NoThrow::kNone>
+class ThrowingValue : private exceptions_internal::TrackedObject {
+ public:
+ ThrowingValue() : TrackedObject(ABSL_PRETTY_FUNCTION) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ = 0;
+ }
+
+ ThrowingValue(const ThrowingValue& other)
+ : TrackedObject(ABSL_PRETTY_FUNCTION) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ = other.dummy_;
+ }
+
+ ThrowingValue(ThrowingValue&& other) noexcept(
+ !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveCtor))
+ : TrackedObject(ABSL_PRETTY_FUNCTION) {
+ if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveCtor)) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ }
+ dummy_ = other.dummy_;
+ }
+
+ explicit ThrowingValue(int i) noexcept(
+ !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kIntCtor))
+ : TrackedObject(ABSL_PRETTY_FUNCTION) {
+ if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kIntCtor)) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ }
+ dummy_ = i;
+ }
+
+ ThrowingValue(int i, exceptions_internal::NoThrowTag) noexcept
+ : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(i) {}
+
+ // absl expects nothrow destructors
+ ~ThrowingValue() noexcept = default;
+
+ ThrowingValue& operator=(const ThrowingValue& other) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ = other.dummy_;
+ return *this;
+ }
+
+ ThrowingValue& operator=(ThrowingValue&& other) noexcept(
+ !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveAssign)) {
+ if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kMoveAssign)) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ }
+ dummy_ = other.dummy_;
+ return *this;
+ }
+
+ // Arithmetic Operators
+ ThrowingValue operator+(const ThrowingValue& other) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_ + other.dummy_, no_throw_ctor);
+ }
+
+ ThrowingValue operator+() const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_, no_throw_ctor);
+ }
+
+ ThrowingValue operator-(const ThrowingValue& other) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_ - other.dummy_, no_throw_ctor);
+ }
+
+ ThrowingValue operator-() const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(-dummy_, no_throw_ctor);
+ }
+
+ ThrowingValue& operator++() {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ ++dummy_;
+ return *this;
+ }
+
+ ThrowingValue operator++(int) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ auto out = ThrowingValue(dummy_, no_throw_ctor);
+ ++dummy_;
+ return out;
+ }
+
+ ThrowingValue& operator--() {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ --dummy_;
+ return *this;
+ }
+
+ ThrowingValue operator--(int) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ auto out = ThrowingValue(dummy_, no_throw_ctor);
+ --dummy_;
+ return out;
+ }
+
+ ThrowingValue operator*(const ThrowingValue& other) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_ * other.dummy_, no_throw_ctor);
+ }
+
+ ThrowingValue operator/(const ThrowingValue& other) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_ / other.dummy_, no_throw_ctor);
+ }
+
+ ThrowingValue operator%(const ThrowingValue& other) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_ % other.dummy_, no_throw_ctor);
+ }
+
+ ThrowingValue operator<<(int shift) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_ << shift, no_throw_ctor);
+ }
+
+ ThrowingValue operator>>(int shift) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_ >> shift, no_throw_ctor);
+ }
+
+ // Comparison Operators
+ // NOTE: We use `ThrowingBool` instead of `bool` because most STL
+ // types/containers requires T to be convertible to bool.
+ friend ThrowingBool operator==(const ThrowingValue& a,
+ const ThrowingValue& b) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return a.dummy_ == b.dummy_;
+ }
+ friend ThrowingBool operator!=(const ThrowingValue& a,
+ const ThrowingValue& b) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return a.dummy_ != b.dummy_;
+ }
+ friend ThrowingBool operator<(const ThrowingValue& a,
+ const ThrowingValue& b) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return a.dummy_ < b.dummy_;
+ }
+ friend ThrowingBool operator<=(const ThrowingValue& a,
+ const ThrowingValue& b) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return a.dummy_ <= b.dummy_;
+ }
+ friend ThrowingBool operator>(const ThrowingValue& a,
+ const ThrowingValue& b) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return a.dummy_ > b.dummy_;
+ }
+ friend ThrowingBool operator>=(const ThrowingValue& a,
+ const ThrowingValue& b) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return a.dummy_ >= b.dummy_;
+ }
+
+ // Logical Operators
+ ThrowingBool operator!() const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return !dummy_;
+ }
+
+ ThrowingBool operator&&(const ThrowingValue& other) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return dummy_ && other.dummy_;
+ }
+
+ ThrowingBool operator||(const ThrowingValue& other) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return dummy_ || other.dummy_;
+ }
+
+ // Bitwise Logical Operators
+ ThrowingValue operator~() const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(~dummy_, no_throw_ctor);
+ }
+
+ ThrowingValue operator&(const ThrowingValue& other) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_ & other.dummy_, no_throw_ctor);
+ }
+
+ ThrowingValue operator|(const ThrowingValue& other) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_ | other.dummy_, no_throw_ctor);
+ }
+
+ ThrowingValue operator^(const ThrowingValue& other) const {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return ThrowingValue(dummy_ ^ other.dummy_, no_throw_ctor);
+ }
+
+ // Compound Assignment operators
+ ThrowingValue& operator+=(const ThrowingValue& other) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ += other.dummy_;
+ return *this;
+ }
+
+ ThrowingValue& operator-=(const ThrowingValue& other) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ -= other.dummy_;
+ return *this;
+ }
+
+ ThrowingValue& operator*=(const ThrowingValue& other) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ *= other.dummy_;
+ return *this;
+ }
+
+ ThrowingValue& operator/=(const ThrowingValue& other) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ /= other.dummy_;
+ return *this;
+ }
+
+ ThrowingValue& operator%=(const ThrowingValue& other) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ %= other.dummy_;
+ return *this;
+ }
+
+ ThrowingValue& operator&=(const ThrowingValue& other) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ &= other.dummy_;
+ return *this;
+ }
+
+ ThrowingValue& operator|=(const ThrowingValue& other) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ |= other.dummy_;
+ return *this;
+ }
+
+ ThrowingValue& operator^=(const ThrowingValue& other) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ ^= other.dummy_;
+ return *this;
+ }
+
+ ThrowingValue& operator<<=(int shift) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ <<= shift;
+ return *this;
+ }
+
+ ThrowingValue& operator>>=(int shift) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ >>= shift;
+ return *this;
+ }
+
+ // Pointer operators
+ void operator&() const = delete; // NOLINT(runtime/operator)
+
+ // Stream operators
+ friend std::ostream& operator<<(std::ostream& os, const ThrowingValue&) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return os;
+ }
+
+ friend std::istream& operator>>(std::istream& is, const ThrowingValue&) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ return is;
+ }
+
+ // Memory management operators
+ // Args.. allows us to overload regular and placement new in one shot
+ template <typename... Args>
+ static void* operator new(size_t s, Args&&... args) noexcept(
+ !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) {
+ if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+ }
+ return ::operator new(s, std::forward<Args>(args)...);
+ }
+
+ template <typename... Args>
+ static void* operator new[](size_t s, Args&&... args) noexcept(
+ !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) {
+ if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kAllocation)) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION, true);
+ }
+ return ::operator new[](s, std::forward<Args>(args)...);
+ }
+
+ // Abseil doesn't support throwing overloaded operator delete. These are
+ // provided so a throwing operator-new can clean up after itself.
+ //
+ // We provide both regular and templated operator delete because if only the
+ // templated version is provided as we did with operator new, the compiler has
+ // no way of knowing which overload of operator delete to call. See
+ // http://en.cppreference.com/w/cpp/memory/new/operator_delete and
+ // http://en.cppreference.com/w/cpp/language/delete for the gory details.
+ void operator delete(void* p) noexcept { ::operator delete(p); }
+
+ template <typename... Args>
+ void operator delete(void* p, Args&&... args) noexcept {
+ ::operator delete(p, std::forward<Args>(args)...);
+ }
+
+ void operator delete[](void* p) noexcept { return ::operator delete[](p); }
+
+ template <typename... Args>
+ void operator delete[](void* p, Args&&... args) noexcept {
+ return ::operator delete[](p, std::forward<Args>(args)...);
+ }
+
+ // Non-standard access to the actual contained value. No need for this to
+ // throw.
+ int& Get() noexcept { return dummy_; }
+ const int& Get() const noexcept { return dummy_; }
+
+ private:
+ int dummy_;
+};
+// While not having to do with exceptions, explicitly delete comma operator, to
+// make sure we don't use it on user-supplied types.
+template <NoThrow N, typename T>
+void operator,(const ThrowingValue<N>& ef, T&& t) = delete;
+template <NoThrow N, typename T>
+void operator,(T&& t, const ThrowingValue<N>& ef) = delete;
+
+// An allocator type which is instrumented to throw at a controlled time, or not
+// to throw, using NoThrow. The supported settings are the default of every
+// function which is allowed to throw in a conforming allocator possibly
+// throwing, or nothing throws, in line with the ABSL_ALLOCATOR_THROWS
+// configuration macro.
+template <typename T, NoThrow Flags = NoThrow::kNone>
+class ThrowingAllocator : private exceptions_internal::TrackedObject {
+ static_assert(Flags == NoThrow::kNone || Flags == NoThrow::kNoThrow,
+ "Invalid flag");
+
+ public:
+ using pointer = T*;
+ using const_pointer = const T*;
+ using reference = T&;
+ using const_reference = const T&;
+ using void_pointer = void*;
+ using const_void_pointer = const void*;
+ using value_type = T;
+ using size_type = size_t;
+ using difference_type = ptrdiff_t;
+
+ using is_nothrow = std::integral_constant<bool, Flags == NoThrow::kNoThrow>;
+ using propagate_on_container_copy_assignment = std::true_type;
+ using propagate_on_container_move_assignment = std::true_type;
+ using propagate_on_container_swap = std::true_type;
+ using is_always_equal = std::false_type;
+
+ ThrowingAllocator() : TrackedObject(ABSL_PRETTY_FUNCTION) {
+ exceptions_internal::MaybeThrow(ABSL_PRETTY_FUNCTION);
+ dummy_ = std::make_shared<const int>(next_id_++);
+ }
+
+ template <typename U>
+ ThrowingAllocator( // NOLINT
+ const ThrowingAllocator<U, Flags>& other) noexcept
+ : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {}
+
+ // According to C++11 standard [17.6.3.5], Table 28, the move/copy ctors of
+ // allocator shall not exit via an exception, thus they are marked noexcept.
+ ThrowingAllocator(const ThrowingAllocator& other) noexcept
+ : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(other.State()) {}
+
+ template <typename U>
+ ThrowingAllocator( // NOLINT
+ ThrowingAllocator<U, Flags>&& other) noexcept
+ : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(std::move(other.State())) {}
+
+ ThrowingAllocator(ThrowingAllocator&& other) noexcept
+ : TrackedObject(ABSL_PRETTY_FUNCTION), dummy_(std::move(other.State())) {}
+
+ ~ThrowingAllocator() noexcept = default;
+
+ ThrowingAllocator& operator=(const ThrowingAllocator& other) noexcept {
+ dummy_ = other.State();
+ return *this;
+ }
+
+ template <typename U>
+ ThrowingAllocator& operator=(
+ const ThrowingAllocator<U, Flags>& other) noexcept {
+ dummy_ = other.State();
+ return *this;
+ }
+
+ template <typename U>
+ ThrowingAllocator& operator=(ThrowingAllocator<U, Flags>&& other) noexcept {
+ dummy_ = std::move(other.State());
+ return *this;
+ }
+
+ template <typename U>
+ struct rebind {
+ using other = ThrowingAllocator<U, Flags>;
+ };
+
+ pointer allocate(size_type n) noexcept(
+ !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) {
+ ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+ return static_cast<pointer>(::operator new(n * sizeof(T)));
+ }
+ pointer allocate(size_type n, const_void_pointer) noexcept(
+ !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) {
+ return allocate(n);
+ }
+
+ void deallocate(pointer ptr, size_type) noexcept {
+ ReadState();
+ ::operator delete(static_cast<void*>(ptr));
+ }
+
+ template <typename U, typename... Args>
+ void construct(U* ptr, Args&&... args) noexcept(
+ !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) {
+ ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+ ::new (static_cast<void*>(ptr)) U(std::forward<Args>(args)...);
+ }
+
+ template <typename U>
+ void destroy(U* p) noexcept {
+ ReadState();
+ p->~U();
+ }
+
+ size_type max_size() const noexcept {
+ return std::numeric_limits<difference_type>::max() / sizeof(value_type);
+ }
+
+ ThrowingAllocator select_on_container_copy_construction() noexcept(
+ !exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) {
+ auto& out = *this;
+ ReadStateAndMaybeThrow(ABSL_PRETTY_FUNCTION);
+ return out;
+ }
+
+ template <typename U>
+ bool operator==(const ThrowingAllocator<U, Flags>& other) const noexcept {
+ return dummy_ == other.dummy_;
+ }
+
+ template <typename U>
+ bool operator!=(const ThrowingAllocator<U, Flags>& other) const noexcept {
+ return dummy_ != other.dummy_;
+ }
+
+ template <typename U, NoThrow B>
+ friend class ThrowingAllocator;
+
+ private:
+ const std::shared_ptr<const int>& State() const { return dummy_; }
+ std::shared_ptr<const int>& State() { return dummy_; }
+
+ void ReadState() {
+ // we know that this will never be true, but the compiler doesn't, so this
+ // should safely force a read of the value.
+ if (*dummy_ < 0) std::abort();
+ }
+
+ void ReadStateAndMaybeThrow(absl::string_view msg) const {
+ if (exceptions_internal::ThrowingAllowed(Flags, NoThrow::kNoThrow)) {
+ exceptions_internal::MaybeThrow(
+ absl::Substitute("Allocator id $0 threw from $1", *dummy_, msg));
+ }
+ }
+
+ static int next_id_;
+ std::shared_ptr<const int> dummy_;
+};
+
+template <typename T, NoThrow Throws>
+int ThrowingAllocator<T, Throws>::next_id_ = 0;
+
+// Tests for resource leaks by attempting to construct a T using args repeatedly
+// until successful, using the countdown method. Side effects can then be
+// tested for resource leaks.
+template <typename T, typename... Args>
+void TestThrowingCtor(Args&&... args) {
+ struct Cleanup {
+ ~Cleanup() { exceptions_internal::UnsetCountdown(); }
+ } c;
+ for (int count = 0;; ++count) {
+ exceptions_internal::ConstructorTracker ct(count);
+ exceptions_internal::SetCountdown(count);
+ try {
+ T temp(std::forward<Args>(args)...);
+ static_cast<void>(temp);
+ break;
+ } catch (const exceptions_internal::TestException&) {
+ }
+ }
+}
+
+namespace exceptions_internal {
+
+// Dummy struct for ExceptionSafetyTester<> partial state.
+struct UninitializedT {};
+
+template <typename T>
+class DefaultFactory {
+ public:
+ explicit DefaultFactory(const T& t) : t_(t) {}
+ std::unique_ptr<T> operator()() const { return absl::make_unique<T>(t_); }
+
+ private:
+ T t_;
+};
+
+template <size_t LazyInvariantsCount, typename LazyFactory,
+ typename LazyOperation>
+using EnableIfTestable = typename absl::enable_if_t<
+ LazyInvariantsCount != 0 &&
+ !std::is_same<LazyFactory, UninitializedT>::value &&
+ !std::is_same<LazyOperation, UninitializedT>::value>;
+
+template <typename Factory = UninitializedT,
+ typename Operation = UninitializedT, typename... Invariants>
+class ExceptionSafetyTester;
+
+} // namespace exceptions_internal
+
+exceptions_internal::ExceptionSafetyTester<> MakeExceptionSafetyTester();
+
+namespace exceptions_internal {
+
+/*
+ * Builds a tester object that tests if performing a operation on a T follows
+ * exception safety guarantees. Verification is done via invariant assertion
+ * callbacks applied to T instances post-throw.
+ *
+ * Template parameters for ExceptionSafetyTester:
+ *
+ * - Factory: The factory object (passed in via tester.WithFactory(...) or
+ * tester.WithInitialValue(...)) must be invocable with the signature
+ * `std::unique_ptr<T> operator()() const` where T is the type being tested.
+ * It is used for reliably creating identical T instances to test on.
+ *
+ * - Operation: The operation object (passsed in via tester.WithOperation(...)
+ * or tester.Test(...)) must be invocable with the signature
+ * `void operator()(T*) const` where T is the type being tested. It is used
+ * for performing steps on a T instance that may throw and that need to be
+ * checked for exception safety. Each call to the operation will receive a
+ * fresh T instance so it's free to modify and destroy the T instances as it
+ * pleases.
+ *
+ * - Invariants...: The invariant assertion callback objects (passed in via
+ * tester.WithInvariants(...)) must be invocable with the signature
+ * `testing::AssertionResult operator()(T*) const` where T is the type being
+ * tested. Invariant assertion callbacks are provided T instances post-throw.
+ * They must return testing::AssertionSuccess when the type invariants of the
+ * provided T instance hold. If the type invariants of the T instance do not
+ * hold, they must return testing::AssertionFailure. Execution order of
+ * Invariants... is unspecified. They will each individually get a fresh T
+ * instance so they are free to modify and destroy the T instances as they
+ * please.
+ */
+template <typename Factory, typename Operation, typename... Invariants>
+class ExceptionSafetyTester {
+ public:
+ /*
+ * Returns a new ExceptionSafetyTester with an included T factory based on the
+ * provided T instance. The existing factory will not be included in the newly
+ * created tester instance. The created factory returns a new T instance by
+ * copy-constructing the provided const T& t.
+ *
+ * Preconditions for tester.WithInitialValue(const T& t):
+ *
+ * - The const T& t object must be copy-constructible where T is the type
+ * being tested. For non-copy-constructible objects, use the method
+ * tester.WithFactory(...).
+ */
+ template <typename T>
+ ExceptionSafetyTester<DefaultFactory<T>, Operation, Invariants...>
+ WithInitialValue(const T& t) const {
+ return WithFactory(DefaultFactory<T>(t));
+ }
+
+ /*
+ * Returns a new ExceptionSafetyTester with the provided T factory included.
+ * The existing factory will not be included in the newly-created tester
+ * instance. This method is intended for use with types lacking a copy
+ * constructor. Types that can be copy-constructed should instead use the
+ * method tester.WithInitialValue(...).
+ */
+ template <typename NewFactory>
+ ExceptionSafetyTester<absl::decay_t<NewFactory>, Operation, Invariants...>
+ WithFactory(const NewFactory& new_factory) const {
+ return {new_factory, operation_, invariants_};
+ }
+
+ /*
+ * Returns a new ExceptionSafetyTester with the provided testable operation
+ * included. The existing operation will not be included in the newly created
+ * tester.
+ */
+ template <typename NewOperation>
+ ExceptionSafetyTester<Factory, absl::decay_t<NewOperation>, Invariants...>
+ WithOperation(const NewOperation& new_operation) const {
+ return {factory_, new_operation, invariants_};
+ }
+
+ /*
+ * Returns a new ExceptionSafetyTester with the provided MoreInvariants...
+ * combined with the Invariants... that were already included in the instance
+ * on which the method was called. Invariants... cannot be removed or replaced
+ * once added to an ExceptionSafetyTester instance. A fresh object must be
+ * created in order to get an empty Invariants... list.
+ *
+ * In addition to passing in custom invariant assertion callbacks, this method
+ * accepts `absl::strong_guarantee` as an argument which checks T instances
+ * post-throw against freshly created T instances via operator== to verify
+ * that any state changes made during the execution of the operation were
+ * properly rolled back.
+ */
+ template <typename... MoreInvariants>
+ ExceptionSafetyTester<Factory, Operation, Invariants...,
+ absl::decay_t<MoreInvariants>...>
+ WithInvariants(const MoreInvariants&... more_invariants) const {
+ return {factory_, operation_,
+ std::tuple_cat(invariants_,
+ std::tuple<absl::decay_t<MoreInvariants>...>(
+ more_invariants...))};
+ }
+
+ /*
+ * Returns a testing::AssertionResult that is the reduced result of the
+ * exception safety algorithm. The algorithm short circuits and returns
+ * AssertionFailure after the first invariant callback returns an
+ * AssertionFailure. Otherwise, if all invariant callbacks return an
+ * AssertionSuccess, the reduced result is AssertionSuccess.
+ *
+ * The passed-in testable operation will not be saved in a new tester instance
+ * nor will it modify/replace the existing tester instance. This is useful
+ * when each operation being tested is unique and does not need to be reused.
+ *
+ * Preconditions for tester.Test(const NewOperation& new_operation):
+ *
+ * - May only be called after at least one invariant assertion callback and a
+ * factory or initial value have been provided.
+ */
+ template <
+ typename NewOperation,
+ typename = EnableIfTestable<sizeof...(Invariants), Factory, NewOperation>>
+ testing::AssertionResult Test(const NewOperation& new_operation) const {
+ return TestImpl(new_operation, absl::index_sequence_for<Invariants...>());
+ }
+
+ /*
+ * Returns a testing::AssertionResult that is the reduced result of the
+ * exception safety algorithm. The algorithm short circuits and returns
+ * AssertionFailure after the first invariant callback returns an
+ * AssertionFailure. Otherwise, if all invariant callbacks return an
+ * AssertionSuccess, the reduced result is AssertionSuccess.
+ *
+ * Preconditions for tester.Test():
+ *
+ * - May only be called after at least one invariant assertion callback, a
+ * factory or initial value and a testable operation have been provided.
+ */
+ template <typename LazyOperation = Operation,
+ typename =
+ EnableIfTestable<sizeof...(Invariants), Factory, LazyOperation>>
+ testing::AssertionResult Test() const {
+ return TestImpl(operation_, absl::index_sequence_for<Invariants...>());
+ }
+
+ private:
+ template <typename, typename, typename...>
+ friend class ExceptionSafetyTester;
+
+ friend ExceptionSafetyTester<> absl::MakeExceptionSafetyTester();
+
+ ExceptionSafetyTester() {}
+
+ ExceptionSafetyTester(const Factory& f, const Operation& o,
+ const std::tuple<Invariants...>& i)
+ : factory_(f), operation_(o), invariants_(i) {}
+
+ template <typename SelectedOperation, size_t... Indices>
+ testing::AssertionResult TestImpl(const SelectedOperation& selected_operation,
+ absl::index_sequence<Indices...>) const {
+ // Starting from 0 and counting upwards until one of the exit conditions is
+ // hit...
+ for (int count = 0;; ++count) {
+ exceptions_internal::ConstructorTracker ct(count);
+
+ // Run the full exception safety test algorithm for the current countdown
+ auto reduced_res =
+ TestAllInvariantsAtCountdown(factory_, selected_operation, count,
+ std::get<Indices>(invariants_)...);
+ // If there is no value in the optional, no invariants were run because no
+ // exception was thrown. This means that the test is complete and the loop
+ // can exit successfully.
+ if (!reduced_res.has_value()) {
+ return testing::AssertionSuccess();
+ }
+ // If the optional is not empty and the value is falsy, an invariant check
+ // failed so the test must exit to propegate the failure.
+ if (!reduced_res.value()) {
+ return reduced_res.value();
+ }
+ // If the optional is not empty and the value is not falsy, it means
+ // exceptions were thrown but the invariants passed so the test must
+ // continue to run.
+ }
+ }
+
+ Factory factory_;
+ Operation operation_;
+ std::tuple<Invariants...> invariants_;
+};
+
+} // namespace exceptions_internal
+
+/*
+ * Constructs an empty ExceptionSafetyTester. All ExceptionSafetyTester
+ * objects are immutable and all With[thing] mutation methods return new
+ * instances of ExceptionSafetyTester.
+ *
+ * In order to test a T for exception safety, a factory for that T, a testable
+ * operation, and at least one invariant callback returning an assertion
+ * result must be applied using the respective methods.
+ */
+inline exceptions_internal::ExceptionSafetyTester<>
+MakeExceptionSafetyTester() {
+ return {};
+}
+
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_EXCEPTION_SAFETY_TESTING_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_testing.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_testing.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_testing.h
new file mode 100644
index 0000000..07d7e8e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/exception_testing.h
@@ -0,0 +1,38 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Testing utilities for ABSL types which throw exceptions.
+
+#ifndef ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
+#define ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
+
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+
+// ABSL_BASE_INTERNAL_EXPECT_FAIL tests either for a specified thrown exception
+// if exceptions are enabled, or for death with a specified text in the error
+// message
+#ifdef ABSL_HAVE_EXCEPTIONS
+
+#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
+ EXPECT_THROW(expr, exception_t)
+
+#else
+
+#define ABSL_BASE_INTERNAL_EXPECT_FAIL(expr, exception_t, text) \
+ EXPECT_DEATH(expr, text)
+
+#endif
+
+#endif // ABSL_BASE_INTERNAL_EXCEPTION_TESTING_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/identity.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/identity.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/identity.h
new file mode 100644
index 0000000..a6734b4
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/identity.h
@@ -0,0 +1,33 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_BASE_INTERNAL_IDENTITY_H_
+#define ABSL_BASE_INTERNAL_IDENTITY_H_
+
+namespace absl {
+namespace internal {
+
+template <typename T>
+struct identity {
+ typedef T type;
+};
+
+template <typename T>
+using identity_t = typename identity<T>::type;
+
+} // namespace internal
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_IDENTITY_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/inline_variable.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/inline_variable.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/inline_variable.h
new file mode 100644
index 0000000..f7bb8c5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/inline_variable.h
@@ -0,0 +1,107 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
+#define ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
+
+#include <type_traits>
+
+#include "absl/base/internal/identity.h"
+
+// File:
+// This file define a macro that allows the creation of or emulation of C++17
+// inline variables based on whether or not the feature is supported.
+
+////////////////////////////////////////////////////////////////////////////////
+// Macro: ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init)
+//
+// Description:
+// Expands to the equivalent of an inline constexpr instance of the specified
+// `type` and `name`, initialized to the value `init`. If the compiler being
+// used is detected as supporting actual inline variables as a language
+// feature, then the macro expands to an actual inline variable definition.
+//
+// Requires:
+// `type` is a type that is usable in an extern variable declaration.
+//
+// Requires: `name` is a valid identifier
+//
+// Requires:
+// `init` is an expression that can be used in the following definition:
+// constexpr type name = init;
+//
+// Usage:
+//
+// // Equivalent to: `inline constexpr size_t variant_npos = -1;`
+// ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, -1);
+//
+// Differences in implementation:
+// For a direct, language-level inline variable, decltype(name) will be the
+// type that was specified along with const qualification, whereas for
+// emulated inline variables, decltype(name) may be different (in practice
+// it will likely be a reference type).
+////////////////////////////////////////////////////////////////////////////////
+
+#ifdef __cpp_inline_variables
+
+// Clang's -Wmissing-variable-declarations option erroneously warned that
+// inline constexpr objects need to be pre-declared. This has now been fixed,
+// but we will need to support this workaround for people building with older
+// versions of clang.
+//
+// Bug: https://bugs.llvm.org/show_bug.cgi?id=35862
+//
+// Note:
+// identity_t is used here so that the const and name are in the
+// appropriate place for pointer types, reference types, function pointer
+// types, etc..
+#if defined(__clang__)
+#define ABSL_INTERNAL_EXTERN_DECL(type, name) \
+ extern const ::absl::internal::identity_t<type> name;
+#else // Otherwise, just define the macro to do nothing.
+#define ABSL_INTERNAL_EXTERN_DECL(type, name)
+#endif // defined(__clang__)
+
+// See above comment at top of file for details.
+#define ABSL_INTERNAL_INLINE_CONSTEXPR(type, name, init) \
+ ABSL_INTERNAL_EXTERN_DECL(type, name) \
+ inline constexpr ::absl::internal::identity_t<type> name = init
+
+#else
+
+// See above comment at top of file for details.
+//
+// Note:
+// identity_t is used here so that the const and name are in the
+// appropriate place for pointer types, reference types, function pointer
+// types, etc..
+#define ABSL_INTERNAL_INLINE_CONSTEXPR(var_type, name, init) \
+ template <class /*AbslInternalDummy*/ = void> \
+ struct AbslInternalInlineVariableHolder##name { \
+ static constexpr ::absl::internal::identity_t<var_type> kInstance = init; \
+ }; \
+ \
+ template <class AbslInternalDummy> \
+ constexpr ::absl::internal::identity_t<var_type> \
+ AbslInternalInlineVariableHolder##name<AbslInternalDummy>::kInstance; \
+ \
+ static constexpr const ::absl::internal::identity_t<var_type>& \
+ name = /* NOLINT */ \
+ AbslInternalInlineVariableHolder##name<>::kInstance; \
+ static_assert(sizeof(void (*)(decltype(name))) != 0, \
+ "Silence unused variable warnings.")
+
+#endif // __cpp_inline_variables
+
+#endif // ABSL_BASE_INTERNAL_INLINE_VARIABLE_EMULATION_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/inline_variable_testing.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/inline_variable_testing.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/inline_variable_testing.h
new file mode 100644
index 0000000..a0dd2bb
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/inline_variable_testing.h
@@ -0,0 +1,44 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_BASE_INLINE_VARIABLE_TESTING_H_
+#define ABSL_BASE_INLINE_VARIABLE_TESTING_H_
+
+#include "absl/base/internal/inline_variable.h"
+
+namespace absl {
+namespace inline_variable_testing_internal {
+
+struct Foo {
+ int value = 5;
+};
+
+ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, inline_variable_foo, {});
+ABSL_INTERNAL_INLINE_CONSTEXPR(Foo, other_inline_variable_foo, {});
+
+ABSL_INTERNAL_INLINE_CONSTEXPR(int, inline_variable_int, 5);
+ABSL_INTERNAL_INLINE_CONSTEXPR(int, other_inline_variable_int, 5);
+
+ABSL_INTERNAL_INLINE_CONSTEXPR(void(*)(), inline_variable_fun_ptr, nullptr);
+
+const Foo& get_foo_a();
+const Foo& get_foo_b();
+
+const int& get_int_a();
+const int& get_int_b();
+
+} // namespace inline_variable_testing_internal
+} // namespace absl
+
+#endif // ABSL_BASE_INLINE_VARIABLE_TESTING_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/invoke.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/invoke.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/invoke.h
new file mode 100644
index 0000000..8c3f4f6
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/invoke.h
@@ -0,0 +1,188 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// absl::base_internal::Invoke(f, args...) is an implementation of
+// INVOKE(f, args...) from section [func.require] of the C++ standard.
+//
+// [func.require]
+// Define INVOKE (f, t1, t2, ..., tN) as follows:
+// 1. (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
+// and t1 is an object of type T or a reference to an object of type T or a
+// reference to an object of a type derived from T;
+// 2. ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
+// class T and t1 is not one of the types described in the previous item;
+// 3. t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
+// an object of type T or a reference to an object of type T or a reference
+// to an object of a type derived from T;
+// 4. (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
+// is not one of the types described in the previous item;
+// 5. f(t1, t2, ..., tN) in all other cases.
+//
+// The implementation is SFINAE-friendly: substitution failure within Invoke()
+// isn't an error.
+
+#ifndef ABSL_BASE_INTERNAL_INVOKE_H_
+#define ABSL_BASE_INTERNAL_INVOKE_H_
+
+#include <algorithm>
+#include <type_traits>
+#include <utility>
+
+// The following code is internal implementation detail. See the comment at the
+// top of this file for the API documentation.
+
+namespace absl {
+namespace base_internal {
+
+// The five classes below each implement one of the clauses from the definition
+// of INVOKE. The inner class template Accept<F, Args...> checks whether the
+// clause is applicable; static function template Invoke(f, args...) does the
+// invocation.
+//
+// By separating the clause selection logic from invocation we make sure that
+// Invoke() does exactly what the standard says.
+
+template <typename Derived>
+struct StrippedAccept {
+ template <typename... Args>
+ struct Accept : Derived::template AcceptImpl<typename std::remove_cv<
+ typename std::remove_reference<Args>::type>::type...> {};
+};
+
+// (t1.*f)(t2, ..., tN) when f is a pointer to a member function of a class T
+// and t1 is an object of type T or a reference to an object of type T or a
+// reference to an object of a type derived from T.
+struct MemFunAndRef : StrippedAccept<MemFunAndRef> {
+ template <typename... Args>
+ struct AcceptImpl : std::false_type {};
+
+ template <typename R, typename C, typename... Params, typename Obj,
+ typename... Args>
+ struct AcceptImpl<R (C::*)(Params...), Obj, Args...>
+ : std::is_base_of<C, Obj> {};
+
+ template <typename R, typename C, typename... Params, typename Obj,
+ typename... Args>
+ struct AcceptImpl<R (C::*)(Params...) const, Obj, Args...>
+ : std::is_base_of<C, Obj> {};
+
+ template <typename MemFun, typename Obj, typename... Args>
+ static decltype((std::declval<Obj>().*
+ std::declval<MemFun>())(std::declval<Args>()...))
+ Invoke(MemFun&& mem_fun, Obj&& obj, Args&&... args) {
+ return (std::forward<Obj>(obj).*
+ std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
+ }
+};
+
+// ((*t1).*f)(t2, ..., tN) when f is a pointer to a member function of a
+// class T and t1 is not one of the types described in the previous item.
+struct MemFunAndPtr : StrippedAccept<MemFunAndPtr> {
+ template <typename... Args>
+ struct AcceptImpl : std::false_type {};
+
+ template <typename R, typename C, typename... Params, typename Ptr,
+ typename... Args>
+ struct AcceptImpl<R (C::*)(Params...), Ptr, Args...>
+ : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
+
+ template <typename R, typename C, typename... Params, typename Ptr,
+ typename... Args>
+ struct AcceptImpl<R (C::*)(Params...) const, Ptr, Args...>
+ : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
+
+ template <typename MemFun, typename Ptr, typename... Args>
+ static decltype(((*std::declval<Ptr>()).*
+ std::declval<MemFun>())(std::declval<Args>()...))
+ Invoke(MemFun&& mem_fun, Ptr&& ptr, Args&&... args) {
+ return ((*std::forward<Ptr>(ptr)).*
+ std::forward<MemFun>(mem_fun))(std::forward<Args>(args)...);
+ }
+};
+
+// t1.*f when N == 1 and f is a pointer to member data of a class T and t1 is
+// an object of type T or a reference to an object of type T or a reference
+// to an object of a type derived from T.
+struct DataMemAndRef : StrippedAccept<DataMemAndRef> {
+ template <typename... Args>
+ struct AcceptImpl : std::false_type {};
+
+ template <typename R, typename C, typename Obj>
+ struct AcceptImpl<R C::*, Obj> : std::is_base_of<C, Obj> {};
+
+ template <typename DataMem, typename Ref>
+ static decltype(std::declval<Ref>().*std::declval<DataMem>()) Invoke(
+ DataMem&& data_mem, Ref&& ref) {
+ return std::forward<Ref>(ref).*std::forward<DataMem>(data_mem);
+ }
+};
+
+// (*t1).*f when N == 1 and f is a pointer to member data of a class T and t1
+// is not one of the types described in the previous item.
+struct DataMemAndPtr : StrippedAccept<DataMemAndPtr> {
+ template <typename... Args>
+ struct AcceptImpl : std::false_type {};
+
+ template <typename R, typename C, typename Ptr>
+ struct AcceptImpl<R C::*, Ptr>
+ : std::integral_constant<bool, !std::is_base_of<C, Ptr>::value> {};
+
+ template <typename DataMem, typename Ptr>
+ static decltype((*std::declval<Ptr>()).*std::declval<DataMem>()) Invoke(
+ DataMem&& data_mem, Ptr&& ptr) {
+ return (*std::forward<Ptr>(ptr)).*std::forward<DataMem>(data_mem);
+ }
+};
+
+// f(t1, t2, ..., tN) in all other cases.
+struct Callable {
+ // Callable doesn't have Accept because it's the last clause that gets picked
+ // when none of the previous clauses are applicable.
+ template <typename F, typename... Args>
+ static decltype(std::declval<F>()(std::declval<Args>()...)) Invoke(
+ F&& f, Args&&... args) {
+ return std::forward<F>(f)(std::forward<Args>(args)...);
+ }
+};
+
+// Resolves to the first matching clause.
+template <typename... Args>
+struct Invoker {
+ typedef typename std::conditional<
+ MemFunAndRef::Accept<Args...>::value, MemFunAndRef,
+ typename std::conditional<
+ MemFunAndPtr::Accept<Args...>::value, MemFunAndPtr,
+ typename std::conditional<
+ DataMemAndRef::Accept<Args...>::value, DataMemAndRef,
+ typename std::conditional<DataMemAndPtr::Accept<Args...>::value,
+ DataMemAndPtr, Callable>::type>::type>::
+ type>::type type;
+};
+
+// The result type of Invoke<F, Args...>.
+template <typename F, typename... Args>
+using InvokeT = decltype(Invoker<F, Args...>::type::Invoke(
+ std::declval<F>(), std::declval<Args>()...));
+
+// Invoke(f, args...) is an implementation of INVOKE(f, args...) from section
+// [func.require] of the C++ standard.
+template <typename F, typename... Args>
+InvokeT<F, Args...> Invoke(F&& f, Args&&... args) {
+ return Invoker<F, Args...>::type::Invoke(std::forward<F>(f),
+ std::forward<Args>(args)...);
+}
+} // namespace base_internal
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_INVOKE_H_
[41/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/container/inlined_vector_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/container/inlined_vector_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/container/inlined_vector_test.cc
new file mode 100644
index 0000000..26a7d5b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/container/inlined_vector_test.cc
@@ -0,0 +1,1766 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/container/inlined_vector.h"
+
+#include <algorithm>
+#include <forward_list>
+#include <list>
+#include <memory>
+#include <scoped_allocator>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/attributes.h"
+#include "absl/base/internal/exception_testing.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/macros.h"
+#include "absl/container/internal/test_instance_tracker.h"
+#include "absl/memory/memory.h"
+#include "absl/strings/str_cat.h"
+
+namespace {
+
+using absl::test_internal::CopyableMovableInstance;
+using absl::test_internal::CopyableOnlyInstance;
+using absl::test_internal::InstanceTracker;
+using testing::AllOf;
+using testing::Each;
+using testing::ElementsAre;
+using testing::ElementsAreArray;
+using testing::Eq;
+using testing::Gt;
+using testing::PrintToString;
+
+using IntVec = absl::InlinedVector<int, 8>;
+
+MATCHER_P(SizeIs, n, "") {
+ return testing::ExplainMatchResult(n, arg.size(), result_listener);
+}
+
+MATCHER_P(CapacityIs, n, "") {
+ return testing::ExplainMatchResult(n, arg.capacity(), result_listener);
+}
+
+MATCHER_P(ValueIs, e, "") {
+ return testing::ExplainMatchResult(e, arg.value(), result_listener);
+}
+
+// TODO(bsamwel): Add support for movable-only types.
+
+// Test fixture for typed tests on BaseCountedInstance derived classes, see
+// test_instance_tracker.h.
+template <typename T>
+class InstanceTest : public ::testing::Test {};
+TYPED_TEST_CASE_P(InstanceTest);
+
+// A simple reference counted class to make sure that the proper elements are
+// destroyed in the erase(begin, end) test.
+class RefCounted {
+ public:
+ RefCounted(int value, int* count) : value_(value), count_(count) {
+ Ref();
+ }
+
+ RefCounted(const RefCounted& v)
+ : value_(v.value_), count_(v.count_) {
+ Ref();
+ }
+
+ ~RefCounted() {
+ Unref();
+ count_ = nullptr;
+ }
+
+ friend void swap(RefCounted& a, RefCounted& b) {
+ using std::swap;
+ swap(a.value_, b.value_);
+ swap(a.count_, b.count_);
+ }
+
+ RefCounted& operator=(RefCounted v) {
+ using std::swap;
+ swap(*this, v);
+ return *this;
+ }
+
+ void Ref() const {
+ ABSL_RAW_CHECK(count_ != nullptr, "");
+ ++(*count_);
+ }
+
+ void Unref() const {
+ --(*count_);
+ ABSL_RAW_CHECK(*count_ >= 0, "");
+ }
+
+ int value_;
+ int* count_;
+};
+
+using RefCountedVec = absl::InlinedVector<RefCounted, 8>;
+
+// A class with a vtable pointer
+class Dynamic {
+ public:
+ virtual ~Dynamic() {}
+};
+
+using DynamicVec = absl::InlinedVector<Dynamic, 8>;
+
+// Append 0..len-1 to *v
+template <typename Container>
+static void Fill(Container* v, int len, int offset = 0) {
+ for (int i = 0; i < len; i++) {
+ v->push_back(i + offset);
+ }
+}
+
+static IntVec Fill(int len, int offset = 0) {
+ IntVec v;
+ Fill(&v, len, offset);
+ return v;
+}
+
+// This is a stateful allocator, but the state lives outside of the
+// allocator (in whatever test is using the allocator). This is odd
+// but helps in tests where the allocator is propagated into nested
+// containers - that chain of allocators uses the same state and is
+// thus easier to query for aggregate allocation information.
+template <typename T>
+class CountingAllocator : public std::allocator<T> {
+ public:
+ using Alloc = std::allocator<T>;
+ using pointer = typename Alloc::pointer;
+ using size_type = typename Alloc::size_type;
+
+ CountingAllocator() : bytes_used_(nullptr) {}
+ explicit CountingAllocator(int64_t* b) : bytes_used_(b) {}
+
+ template <typename U>
+ CountingAllocator(const CountingAllocator<U>& x)
+ : Alloc(x), bytes_used_(x.bytes_used_) {}
+
+ pointer allocate(size_type n,
+ std::allocator<void>::const_pointer hint = nullptr) {
+ assert(bytes_used_ != nullptr);
+ *bytes_used_ += n * sizeof(T);
+ return Alloc::allocate(n, hint);
+ }
+
+ void deallocate(pointer p, size_type n) {
+ Alloc::deallocate(p, n);
+ assert(bytes_used_ != nullptr);
+ *bytes_used_ -= n * sizeof(T);
+ }
+
+ template<typename U>
+ class rebind {
+ public:
+ using other = CountingAllocator<U>;
+ };
+
+ friend bool operator==(const CountingAllocator& a,
+ const CountingAllocator& b) {
+ return a.bytes_used_ == b.bytes_used_;
+ }
+
+ friend bool operator!=(const CountingAllocator& a,
+ const CountingAllocator& b) {
+ return !(a == b);
+ }
+
+ int64_t* bytes_used_;
+};
+
+TEST(IntVec, SimpleOps) {
+ for (int len = 0; len < 20; len++) {
+ IntVec v;
+ const IntVec& cv = v; // const alias
+
+ Fill(&v, len);
+ EXPECT_EQ(len, v.size());
+ EXPECT_LE(len, v.capacity());
+
+ for (int i = 0; i < len; i++) {
+ EXPECT_EQ(i, v[i]);
+ EXPECT_EQ(i, v.at(i));
+ }
+ EXPECT_EQ(v.begin(), v.data());
+ EXPECT_EQ(cv.begin(), cv.data());
+
+ int counter = 0;
+ for (IntVec::iterator iter = v.begin(); iter != v.end(); ++iter) {
+ EXPECT_EQ(counter, *iter);
+ counter++;
+ }
+ EXPECT_EQ(counter, len);
+
+ counter = 0;
+ for (IntVec::const_iterator iter = v.begin(); iter != v.end(); ++iter) {
+ EXPECT_EQ(counter, *iter);
+ counter++;
+ }
+ EXPECT_EQ(counter, len);
+
+ counter = 0;
+ for (IntVec::const_iterator iter = v.cbegin(); iter != v.cend(); ++iter) {
+ EXPECT_EQ(counter, *iter);
+ counter++;
+ }
+ EXPECT_EQ(counter, len);
+
+ if (len > 0) {
+ EXPECT_EQ(0, v.front());
+ EXPECT_EQ(len - 1, v.back());
+ v.pop_back();
+ EXPECT_EQ(len - 1, v.size());
+ for (int i = 0; i < v.size(); ++i) {
+ EXPECT_EQ(i, v[i]);
+ EXPECT_EQ(i, v.at(i));
+ }
+ }
+ }
+}
+
+TEST(IntVec, AtThrows) {
+ IntVec v = {1, 2, 3};
+ EXPECT_EQ(v.at(2), 3);
+ ABSL_BASE_INTERNAL_EXPECT_FAIL(v.at(3), std::out_of_range,
+ "failed bounds check");
+}
+
+TEST(IntVec, ReverseIterator) {
+ for (int len = 0; len < 20; len++) {
+ IntVec v;
+ Fill(&v, len);
+
+ int counter = len;
+ for (IntVec::reverse_iterator iter = v.rbegin(); iter != v.rend(); ++iter) {
+ counter--;
+ EXPECT_EQ(counter, *iter);
+ }
+ EXPECT_EQ(counter, 0);
+
+ counter = len;
+ for (IntVec::const_reverse_iterator iter = v.rbegin(); iter != v.rend();
+ ++iter) {
+ counter--;
+ EXPECT_EQ(counter, *iter);
+ }
+ EXPECT_EQ(counter, 0);
+
+ counter = len;
+ for (IntVec::const_reverse_iterator iter = v.crbegin(); iter != v.crend();
+ ++iter) {
+ counter--;
+ EXPECT_EQ(counter, *iter);
+ }
+ EXPECT_EQ(counter, 0);
+ }
+}
+
+TEST(IntVec, Erase) {
+ for (int len = 1; len < 20; len++) {
+ for (int i = 0; i < len; ++i) {
+ IntVec v;
+ Fill(&v, len);
+ v.erase(v.begin() + i);
+ EXPECT_EQ(len - 1, v.size());
+ for (int j = 0; j < i; ++j) {
+ EXPECT_EQ(j, v[j]);
+ }
+ for (int j = i; j < len - 1; ++j) {
+ EXPECT_EQ(j + 1, v[j]);
+ }
+ }
+ }
+}
+
+// At the end of this test loop, the elements between [erase_begin, erase_end)
+// should have reference counts == 0, and all others elements should have
+// reference counts == 1.
+TEST(RefCountedVec, EraseBeginEnd) {
+ for (int len = 1; len < 20; ++len) {
+ for (int erase_begin = 0; erase_begin < len; ++erase_begin) {
+ for (int erase_end = erase_begin; erase_end <= len; ++erase_end) {
+ std::vector<int> counts(len, 0);
+ RefCountedVec v;
+ for (int i = 0; i < len; ++i) {
+ v.push_back(RefCounted(i, &counts[i]));
+ }
+
+ int erase_len = erase_end - erase_begin;
+
+ v.erase(v.begin() + erase_begin, v.begin() + erase_end);
+
+ EXPECT_EQ(len - erase_len, v.size());
+
+ // Check the elements before the first element erased.
+ for (int i = 0; i < erase_begin; ++i) {
+ EXPECT_EQ(i, v[i].value_);
+ }
+
+ // Check the elements after the first element erased.
+ for (int i = erase_begin; i < v.size(); ++i) {
+ EXPECT_EQ(i + erase_len, v[i].value_);
+ }
+
+ // Check that the elements at the beginning are preserved.
+ for (int i = 0; i < erase_begin; ++i) {
+ EXPECT_EQ(1, counts[i]);
+ }
+
+ // Check that the erased elements are destroyed
+ for (int i = erase_begin; i < erase_end; ++i) {
+ EXPECT_EQ(0, counts[i]);
+ }
+
+ // Check that the elements at the end are preserved.
+ for (int i = erase_end; i< len; ++i) {
+ EXPECT_EQ(1, counts[i]);
+ }
+ }
+ }
+ }
+}
+
+struct NoDefaultCtor {
+ explicit NoDefaultCtor(int) {}
+};
+struct NoCopy {
+ NoCopy() {}
+ NoCopy(const NoCopy&) = delete;
+};
+struct NoAssign {
+ NoAssign() {}
+ NoAssign& operator=(const NoAssign&) = delete;
+};
+struct MoveOnly {
+ MoveOnly() {}
+ MoveOnly(MoveOnly&&) = default;
+ MoveOnly& operator=(MoveOnly&&) = default;
+};
+TEST(InlinedVectorTest, NoDefaultCtor) {
+ absl::InlinedVector<NoDefaultCtor, 1> v(10, NoDefaultCtor(2));
+ (void)v;
+}
+TEST(InlinedVectorTest, NoCopy) {
+ absl::InlinedVector<NoCopy, 1> v(10);
+ (void)v;
+}
+TEST(InlinedVectorTest, NoAssign) {
+ absl::InlinedVector<NoAssign, 1> v(10);
+ (void)v;
+}
+TEST(InlinedVectorTest, MoveOnly) {
+ absl::InlinedVector<MoveOnly, 2> v;
+ v.push_back(MoveOnly{});
+ v.push_back(MoveOnly{});
+ v.push_back(MoveOnly{});
+ v.erase(v.begin());
+ v.push_back(MoveOnly{});
+ v.erase(v.begin(), v.begin() + 1);
+ v.insert(v.begin(), MoveOnly{});
+ v.emplace(v.begin());
+ v.emplace(v.begin(), MoveOnly{});
+}
+TEST(InlinedVectorTest, Noexcept) {
+ EXPECT_TRUE(std::is_nothrow_move_constructible<IntVec>::value);
+ EXPECT_TRUE((std::is_nothrow_move_constructible<
+ absl::InlinedVector<MoveOnly, 2>>::value));
+
+ struct MoveCanThrow {
+ MoveCanThrow(MoveCanThrow&&) {}
+ };
+ EXPECT_EQ(absl::default_allocator_is_nothrow::value,
+ (std::is_nothrow_move_constructible<
+ absl::InlinedVector<MoveCanThrow, 2>>::value));
+}
+
+TEST(InlinedVectorTest, EmplaceBack) {
+ absl::InlinedVector<std::pair<std::string, int>, 1> v;
+
+ auto& inlined_element = v.emplace_back("answer", 42);
+ EXPECT_EQ(&inlined_element, &v[0]);
+ EXPECT_EQ(inlined_element.first, "answer");
+ EXPECT_EQ(inlined_element.second, 42);
+
+ auto& allocated_element = v.emplace_back("taxicab", 1729);
+ EXPECT_EQ(&allocated_element, &v[1]);
+ EXPECT_EQ(allocated_element.first, "taxicab");
+ EXPECT_EQ(allocated_element.second, 1729);
+}
+
+TEST(InlinedVectorTest, ShrinkToFitGrowingVector) {
+ absl::InlinedVector<std::pair<std::string, int>, 1> v;
+
+ v.shrink_to_fit();
+ EXPECT_EQ(v.capacity(), 1);
+
+ v.emplace_back("answer", 42);
+ v.shrink_to_fit();
+ EXPECT_EQ(v.capacity(), 1);
+
+ v.emplace_back("taxicab", 1729);
+ EXPECT_GE(v.capacity(), 2);
+ v.shrink_to_fit();
+ EXPECT_EQ(v.capacity(), 2);
+
+ v.reserve(100);
+ EXPECT_GE(v.capacity(), 100);
+ v.shrink_to_fit();
+ EXPECT_EQ(v.capacity(), 2);
+}
+
+TEST(InlinedVectorTest, ShrinkToFitEdgeCases) {
+ {
+ absl::InlinedVector<std::pair<std::string, int>, 1> v;
+ v.emplace_back("answer", 42);
+ v.emplace_back("taxicab", 1729);
+ EXPECT_GE(v.capacity(), 2);
+ v.pop_back();
+ v.shrink_to_fit();
+ EXPECT_EQ(v.capacity(), 1);
+ EXPECT_EQ(v[0].first, "answer");
+ EXPECT_EQ(v[0].second, 42);
+ }
+
+ {
+ absl::InlinedVector<std::string, 2> v(100);
+ v.resize(0);
+ v.shrink_to_fit();
+ EXPECT_EQ(v.capacity(), 2); // inlined capacity
+ }
+
+ {
+ absl::InlinedVector<std::string, 2> v(100);
+ v.resize(1);
+ v.shrink_to_fit();
+ EXPECT_EQ(v.capacity(), 2); // inlined capacity
+ }
+
+ {
+ absl::InlinedVector<std::string, 2> v(100);
+ v.resize(2);
+ v.shrink_to_fit();
+ EXPECT_EQ(v.capacity(), 2);
+ }
+
+ {
+ absl::InlinedVector<std::string, 2> v(100);
+ v.resize(3);
+ v.shrink_to_fit();
+ EXPECT_EQ(v.capacity(), 3);
+ }
+}
+
+TEST(IntVec, Insert) {
+ for (int len = 0; len < 20; len++) {
+ for (int pos = 0; pos <= len; pos++) {
+ {
+ // Single element
+ std::vector<int> std_v;
+ Fill(&std_v, len);
+ IntVec v;
+ Fill(&v, len);
+
+ std_v.insert(std_v.begin() + pos, 9999);
+ IntVec::iterator it = v.insert(v.cbegin() + pos, 9999);
+ EXPECT_THAT(v, ElementsAreArray(std_v));
+ EXPECT_EQ(it, v.cbegin() + pos);
+ }
+ {
+ // n elements
+ std::vector<int> std_v;
+ Fill(&std_v, len);
+ IntVec v;
+ Fill(&v, len);
+
+ IntVec::size_type n = 5;
+ std_v.insert(std_v.begin() + pos, n, 9999);
+ IntVec::iterator it = v.insert(v.cbegin() + pos, n, 9999);
+ EXPECT_THAT(v, ElementsAreArray(std_v));
+ EXPECT_EQ(it, v.cbegin() + pos);
+ }
+ {
+ // Iterator range (random access iterator)
+ std::vector<int> std_v;
+ Fill(&std_v, len);
+ IntVec v;
+ Fill(&v, len);
+
+ const std::vector<int> input = {9999, 8888, 7777};
+ std_v.insert(std_v.begin() + pos, input.cbegin(), input.cend());
+ IntVec::iterator it =
+ v.insert(v.cbegin() + pos, input.cbegin(), input.cend());
+ EXPECT_THAT(v, ElementsAreArray(std_v));
+ EXPECT_EQ(it, v.cbegin() + pos);
+ }
+ {
+ // Iterator range (forward iterator)
+ std::vector<int> std_v;
+ Fill(&std_v, len);
+ IntVec v;
+ Fill(&v, len);
+
+ const std::forward_list<int> input = {9999, 8888, 7777};
+ std_v.insert(std_v.begin() + pos, input.cbegin(), input.cend());
+ IntVec::iterator it =
+ v.insert(v.cbegin() + pos, input.cbegin(), input.cend());
+ EXPECT_THAT(v, ElementsAreArray(std_v));
+ EXPECT_EQ(it, v.cbegin() + pos);
+ }
+ {
+ // Iterator range (input iterator)
+ std::vector<int> std_v;
+ Fill(&std_v, len);
+ IntVec v;
+ Fill(&v, len);
+
+ std_v.insert(std_v.begin() + pos, {9999, 8888, 7777});
+ std::istringstream input("9999 8888 7777");
+ IntVec::iterator it =
+ v.insert(v.cbegin() + pos, std::istream_iterator<int>(input),
+ std::istream_iterator<int>());
+ EXPECT_THAT(v, ElementsAreArray(std_v));
+ EXPECT_EQ(it, v.cbegin() + pos);
+ }
+ {
+ // Initializer list
+ std::vector<int> std_v;
+ Fill(&std_v, len);
+ IntVec v;
+ Fill(&v, len);
+
+ std_v.insert(std_v.begin() + pos, {9999, 8888});
+ IntVec::iterator it = v.insert(v.cbegin() + pos, {9999, 8888});
+ EXPECT_THAT(v, ElementsAreArray(std_v));
+ EXPECT_EQ(it, v.cbegin() + pos);
+ }
+ }
+ }
+}
+
+TEST(RefCountedVec, InsertConstructorDestructor) {
+ // Make sure the proper construction/destruction happen during insert
+ // operations.
+ for (int len = 0; len < 20; len++) {
+ SCOPED_TRACE(len);
+ for (int pos = 0; pos <= len; pos++) {
+ SCOPED_TRACE(pos);
+ std::vector<int> counts(len, 0);
+ int inserted_count = 0;
+ RefCountedVec v;
+ for (int i = 0; i < len; ++i) {
+ SCOPED_TRACE(i);
+ v.push_back(RefCounted(i, &counts[i]));
+ }
+
+ EXPECT_THAT(counts, Each(Eq(1)));
+
+ RefCounted insert_element(9999, &inserted_count);
+ EXPECT_EQ(1, inserted_count);
+ v.insert(v.begin() + pos, insert_element);
+ EXPECT_EQ(2, inserted_count);
+ // Check that the elements at the end are preserved.
+ EXPECT_THAT(counts, Each(Eq(1)));
+ EXPECT_EQ(2, inserted_count);
+ }
+ }
+}
+
+TEST(IntVec, Resize) {
+ for (int len = 0; len < 20; len++) {
+ IntVec v;
+ Fill(&v, len);
+
+ // Try resizing up and down by k elements
+ static const int kResizeElem = 1000000;
+ for (int k = 0; k < 10; k++) {
+ // Enlarging resize
+ v.resize(len+k, kResizeElem);
+ EXPECT_EQ(len+k, v.size());
+ EXPECT_LE(len+k, v.capacity());
+ for (int i = 0; i < len+k; i++) {
+ if (i < len) {
+ EXPECT_EQ(i, v[i]);
+ } else {
+ EXPECT_EQ(kResizeElem, v[i]);
+ }
+ }
+
+ // Shrinking resize
+ v.resize(len, kResizeElem);
+ EXPECT_EQ(len, v.size());
+ EXPECT_LE(len, v.capacity());
+ for (int i = 0; i < len; i++) {
+ EXPECT_EQ(i, v[i]);
+ }
+ }
+ }
+}
+
+TEST(IntVec, InitWithLength) {
+ for (int len = 0; len < 20; len++) {
+ IntVec v(len, 7);
+ EXPECT_EQ(len, v.size());
+ EXPECT_LE(len, v.capacity());
+ for (int i = 0; i < len; i++) {
+ EXPECT_EQ(7, v[i]);
+ }
+ }
+}
+
+TEST(IntVec, CopyConstructorAndAssignment) {
+ for (int len = 0; len < 20; len++) {
+ IntVec v;
+ Fill(&v, len);
+ EXPECT_EQ(len, v.size());
+ EXPECT_LE(len, v.capacity());
+
+ IntVec v2(v);
+ EXPECT_TRUE(v == v2) << PrintToString(v) << PrintToString(v2);
+
+ for (int start_len = 0; start_len < 20; start_len++) {
+ IntVec v3;
+ Fill(&v3, start_len, 99); // Add dummy elements that should go away
+ v3 = v;
+ EXPECT_TRUE(v == v3) << PrintToString(v) << PrintToString(v3);
+ }
+ }
+}
+
+TEST(IntVec, AliasingCopyAssignment) {
+ for (int len = 0; len < 20; ++len) {
+ IntVec original;
+ Fill(&original, len);
+ IntVec dup = original;
+ dup = *&dup;
+ EXPECT_EQ(dup, original);
+ }
+}
+
+TEST(IntVec, MoveConstructorAndAssignment) {
+ for (int len = 0; len < 20; len++) {
+ IntVec v_in;
+ const int inlined_capacity = v_in.capacity();
+ Fill(&v_in, len);
+ EXPECT_EQ(len, v_in.size());
+ EXPECT_LE(len, v_in.capacity());
+
+ {
+ IntVec v_temp(v_in);
+ auto* old_data = v_temp.data();
+ IntVec v_out(std::move(v_temp));
+ EXPECT_TRUE(v_in == v_out) << PrintToString(v_in) << PrintToString(v_out);
+ if (v_in.size() > inlined_capacity) {
+ // Allocation is moved as a whole, data stays in place.
+ EXPECT_TRUE(v_out.data() == old_data);
+ } else {
+ EXPECT_FALSE(v_out.data() == old_data);
+ }
+ }
+ for (int start_len = 0; start_len < 20; start_len++) {
+ IntVec v_out;
+ Fill(&v_out, start_len, 99); // Add dummy elements that should go away
+ IntVec v_temp(v_in);
+ auto* old_data = v_temp.data();
+ v_out = std::move(v_temp);
+ EXPECT_TRUE(v_in == v_out) << PrintToString(v_in) << PrintToString(v_out);
+ if (v_in.size() > inlined_capacity) {
+ // Allocation is moved as a whole, data stays in place.
+ EXPECT_TRUE(v_out.data() == old_data);
+ } else {
+ EXPECT_FALSE(v_out.data() == old_data);
+ }
+ }
+ }
+}
+
+class NotTriviallyDestructible {
+ public:
+ NotTriviallyDestructible() : p_(new int(1)) {}
+ explicit NotTriviallyDestructible(int i) : p_(new int(i)) {}
+
+ NotTriviallyDestructible(const NotTriviallyDestructible& other)
+ : p_(new int(*other.p_)) {}
+
+ NotTriviallyDestructible& operator=(const NotTriviallyDestructible& other) {
+ p_ = absl::make_unique<int>(*other.p_);
+ return *this;
+ }
+
+ bool operator==(const NotTriviallyDestructible& other) const {
+ return *p_ == *other.p_;
+ }
+
+ private:
+ std::unique_ptr<int> p_;
+};
+
+TEST(AliasingTest, Emplace) {
+ for (int i = 2; i < 20; ++i) {
+ absl::InlinedVector<NotTriviallyDestructible, 10> vec;
+ for (int j = 0; j < i; ++j) {
+ vec.push_back(NotTriviallyDestructible(j));
+ }
+ vec.emplace(vec.begin(), vec[0]);
+ EXPECT_EQ(vec[0], vec[1]);
+ vec.emplace(vec.begin() + i / 2, vec[i / 2]);
+ EXPECT_EQ(vec[i / 2], vec[i / 2 + 1]);
+ vec.emplace(vec.end() - 1, vec.back());
+ EXPECT_EQ(vec[vec.size() - 2], vec.back());
+ }
+}
+
+TEST(AliasingTest, InsertWithCount) {
+ for (int i = 1; i < 20; ++i) {
+ absl::InlinedVector<NotTriviallyDestructible, 10> vec;
+ for (int j = 0; j < i; ++j) {
+ vec.push_back(NotTriviallyDestructible(j));
+ }
+ for (int n = 0; n < 5; ++n) {
+ // We use back where we can because it's guaranteed to become invalidated
+ vec.insert(vec.begin(), n, vec.back());
+ auto b = vec.begin();
+ EXPECT_TRUE(
+ std::all_of(b, b + n, [&vec](const NotTriviallyDestructible& x) {
+ return x == vec.back();
+ }));
+
+ auto m_idx = vec.size() / 2;
+ vec.insert(vec.begin() + m_idx, n, vec.back());
+ auto m = vec.begin() + m_idx;
+ EXPECT_TRUE(
+ std::all_of(m, m + n, [&vec](const NotTriviallyDestructible& x) {
+ return x == vec.back();
+ }));
+
+ // We want distinct values so the equality test is meaningful,
+ // vec[vec.size() - 1] is also almost always invalidated.
+ auto old_e = vec.size() - 1;
+ auto val = vec[old_e];
+ vec.insert(vec.end(), n, vec[old_e]);
+ auto e = vec.begin() + old_e;
+ EXPECT_TRUE(std::all_of(
+ e, e + n,
+ [&val](const NotTriviallyDestructible& x) { return x == val; }));
+ }
+ }
+}
+
+TEST(OverheadTest, Storage) {
+ // Check for size overhead.
+ // In particular, ensure that std::allocator doesn't cost anything to store.
+ // The union should be absorbing some of the allocation bookkeeping overhead
+ // in the larger vectors, leaving only the size_ field as overhead.
+ EXPECT_EQ(2 * sizeof(int*),
+ sizeof(absl::InlinedVector<int*, 1>) - 1 * sizeof(int*));
+ EXPECT_EQ(1 * sizeof(int*),
+ sizeof(absl::InlinedVector<int*, 2>) - 2 * sizeof(int*));
+ EXPECT_EQ(1 * sizeof(int*),
+ sizeof(absl::InlinedVector<int*, 3>) - 3 * sizeof(int*));
+ EXPECT_EQ(1 * sizeof(int*),
+ sizeof(absl::InlinedVector<int*, 4>) - 4 * sizeof(int*));
+ EXPECT_EQ(1 * sizeof(int*),
+ sizeof(absl::InlinedVector<int*, 5>) - 5 * sizeof(int*));
+ EXPECT_EQ(1 * sizeof(int*),
+ sizeof(absl::InlinedVector<int*, 6>) - 6 * sizeof(int*));
+ EXPECT_EQ(1 * sizeof(int*),
+ sizeof(absl::InlinedVector<int*, 7>) - 7 * sizeof(int*));
+ EXPECT_EQ(1 * sizeof(int*),
+ sizeof(absl::InlinedVector<int*, 8>) - 8 * sizeof(int*));
+}
+
+TEST(IntVec, Clear) {
+ for (int len = 0; len < 20; len++) {
+ SCOPED_TRACE(len);
+ IntVec v;
+ Fill(&v, len);
+ v.clear();
+ EXPECT_EQ(0, v.size());
+ EXPECT_EQ(v.begin(), v.end());
+ }
+}
+
+TEST(IntVec, Reserve) {
+ for (int len = 0; len < 20; len++) {
+ IntVec v;
+ Fill(&v, len);
+
+ for (int newlen = 0; newlen < 100; newlen++) {
+ const int* start_rep = v.data();
+ v.reserve(newlen);
+ const int* final_rep = v.data();
+ if (newlen <= len) {
+ EXPECT_EQ(start_rep, final_rep);
+ }
+ EXPECT_LE(newlen, v.capacity());
+
+ // Filling up to newlen should not change rep
+ while (v.size() < newlen) {
+ v.push_back(0);
+ }
+ EXPECT_EQ(final_rep, v.data());
+ }
+ }
+}
+
+TEST(StringVec, SelfRefPushBack) {
+ std::vector<std::string> std_v;
+ absl::InlinedVector<std::string, 4> v;
+ const std::string s = "A quite long std::string to ensure heap.";
+ std_v.push_back(s);
+ v.push_back(s);
+ for (int i = 0; i < 20; ++i) {
+ EXPECT_THAT(v, ElementsAreArray(std_v));
+
+ v.push_back(v.back());
+ std_v.push_back(std_v.back());
+ }
+ EXPECT_THAT(v, ElementsAreArray(std_v));
+}
+
+TEST(StringVec, SelfRefPushBackWithMove) {
+ std::vector<std::string> std_v;
+ absl::InlinedVector<std::string, 4> v;
+ const std::string s = "A quite long std::string to ensure heap.";
+ std_v.push_back(s);
+ v.push_back(s);
+ for (int i = 0; i < 20; ++i) {
+ EXPECT_EQ(v.back(), std_v.back());
+
+ v.push_back(std::move(v.back()));
+ std_v.push_back(std::move(std_v.back()));
+ }
+ EXPECT_EQ(v.back(), std_v.back());
+}
+
+TEST(StringVec, SelfMove) {
+ const std::string s = "A quite long std::string to ensure heap.";
+ for (int len = 0; len < 20; len++) {
+ SCOPED_TRACE(len);
+ absl::InlinedVector<std::string, 8> v;
+ for (int i = 0; i < len; ++i) {
+ SCOPED_TRACE(i);
+ v.push_back(s);
+ }
+ // Indirection necessary to avoid compiler warning.
+ v = std::move(*(&v));
+ // Ensure that the inlined vector is still in a valid state by copying it.
+ // We don't expect specific contents since a self-move results in an
+ // unspecified valid state.
+ std::vector<std::string> copy(v.begin(), v.end());
+ }
+}
+
+TEST(IntVec, Swap) {
+ for (int l1 = 0; l1 < 20; l1++) {
+ SCOPED_TRACE(l1);
+ for (int l2 = 0; l2 < 20; l2++) {
+ SCOPED_TRACE(l2);
+ IntVec a = Fill(l1, 0);
+ IntVec b = Fill(l2, 100);
+ {
+ using std::swap;
+ swap(a, b);
+ }
+ EXPECT_EQ(l1, b.size());
+ EXPECT_EQ(l2, a.size());
+ for (int i = 0; i < l1; i++) {
+ SCOPED_TRACE(i);
+ EXPECT_EQ(i, b[i]);
+ }
+ for (int i = 0; i < l2; i++) {
+ SCOPED_TRACE(i);
+ EXPECT_EQ(100 + i, a[i]);
+ }
+ }
+ }
+}
+
+TYPED_TEST_P(InstanceTest, Swap) {
+ using Instance = TypeParam;
+ using InstanceVec = absl::InlinedVector<Instance, 8>;
+ for (int l1 = 0; l1 < 20; l1++) {
+ SCOPED_TRACE(l1);
+ for (int l2 = 0; l2 < 20; l2++) {
+ SCOPED_TRACE(l2);
+ InstanceTracker tracker;
+ InstanceVec a, b;
+ const size_t inlined_capacity = a.capacity();
+ for (int i = 0; i < l1; i++) a.push_back(Instance(i));
+ for (int i = 0; i < l2; i++) b.push_back(Instance(100+i));
+ EXPECT_EQ(tracker.instances(), l1 + l2);
+ tracker.ResetCopiesMovesSwaps();
+ {
+ using std::swap;
+ swap(a, b);
+ }
+ EXPECT_EQ(tracker.instances(), l1 + l2);
+ if (a.size() > inlined_capacity && b.size() > inlined_capacity) {
+ EXPECT_EQ(tracker.swaps(), 0); // Allocations are swapped.
+ EXPECT_EQ(tracker.moves(), 0);
+ } else if (a.size() <= inlined_capacity && b.size() <= inlined_capacity) {
+ EXPECT_EQ(tracker.swaps(), std::min(l1, l2));
+ // TODO(bsamwel): This should use moves when the type is movable.
+ EXPECT_EQ(tracker.copies(), std::max(l1, l2) - std::min(l1, l2));
+ } else {
+ // One is allocated and the other isn't. The allocation is transferred
+ // without copying elements, and the inlined instances are copied/moved.
+ EXPECT_EQ(tracker.swaps(), 0);
+ // TODO(bsamwel): This should use moves when the type is movable.
+ EXPECT_EQ(tracker.copies(), std::min(l1, l2));
+ }
+
+ EXPECT_EQ(l1, b.size());
+ EXPECT_EQ(l2, a.size());
+ for (int i = 0; i < l1; i++) {
+ EXPECT_EQ(i, b[i].value());
+ }
+ for (int i = 0; i < l2; i++) {
+ EXPECT_EQ(100 + i, a[i].value());
+ }
+ }
+ }
+}
+
+TEST(IntVec, EqualAndNotEqual) {
+ IntVec a, b;
+ EXPECT_TRUE(a == b);
+ EXPECT_FALSE(a != b);
+
+ a.push_back(3);
+ EXPECT_FALSE(a == b);
+ EXPECT_TRUE(a != b);
+
+ b.push_back(3);
+ EXPECT_TRUE(a == b);
+ EXPECT_FALSE(a != b);
+
+ b.push_back(7);
+ EXPECT_FALSE(a == b);
+ EXPECT_TRUE(a != b);
+
+ a.push_back(6);
+ EXPECT_FALSE(a == b);
+ EXPECT_TRUE(a != b);
+
+ a.clear();
+ b.clear();
+ for (int i = 0; i < 100; i++) {
+ a.push_back(i);
+ b.push_back(i);
+ EXPECT_TRUE(a == b);
+ EXPECT_FALSE(a != b);
+
+ b[i] = b[i] + 1;
+ EXPECT_FALSE(a == b);
+ EXPECT_TRUE(a != b);
+
+ b[i] = b[i] - 1; // Back to before
+ EXPECT_TRUE(a == b);
+ EXPECT_FALSE(a != b);
+ }
+}
+
+TEST(IntVec, RelationalOps) {
+ IntVec a, b;
+ EXPECT_FALSE(a < b);
+ EXPECT_FALSE(b < a);
+ EXPECT_FALSE(a > b);
+ EXPECT_FALSE(b > a);
+ EXPECT_TRUE(a <= b);
+ EXPECT_TRUE(b <= a);
+ EXPECT_TRUE(a >= b);
+ EXPECT_TRUE(b >= a);
+ b.push_back(3);
+ EXPECT_TRUE(a < b);
+ EXPECT_FALSE(b < a);
+ EXPECT_FALSE(a > b);
+ EXPECT_TRUE(b > a);
+ EXPECT_TRUE(a <= b);
+ EXPECT_FALSE(b <= a);
+ EXPECT_FALSE(a >= b);
+ EXPECT_TRUE(b >= a);
+}
+
+TYPED_TEST_P(InstanceTest, CountConstructorsDestructors) {
+ using Instance = TypeParam;
+ using InstanceVec = absl::InlinedVector<Instance, 8>;
+ InstanceTracker tracker;
+ for (int len = 0; len < 20; len++) {
+ SCOPED_TRACE(len);
+ tracker.ResetCopiesMovesSwaps();
+
+ InstanceVec v;
+ const size_t inlined_capacity = v.capacity();
+ for (int i = 0; i < len; i++) {
+ v.push_back(Instance(i));
+ }
+ EXPECT_EQ(tracker.instances(), len);
+ EXPECT_GE(tracker.copies() + tracker.moves(),
+ len); // More due to reallocation.
+ tracker.ResetCopiesMovesSwaps();
+
+ // Enlarging resize() must construct some objects
+ tracker.ResetCopiesMovesSwaps();
+ v.resize(len + 10, Instance(100));
+ EXPECT_EQ(tracker.instances(), len + 10);
+ if (len <= inlined_capacity && len + 10 > inlined_capacity) {
+ EXPECT_EQ(tracker.copies() + tracker.moves(), 10 + len);
+ } else {
+ // Only specify a minimum number of copies + moves. We don't want to
+ // depend on the reallocation policy here.
+ EXPECT_GE(tracker.copies() + tracker.moves(),
+ 10); // More due to reallocation.
+ }
+
+ // Shrinking resize() must destroy some objects
+ tracker.ResetCopiesMovesSwaps();
+ v.resize(len, Instance(100));
+ EXPECT_EQ(tracker.instances(), len);
+ EXPECT_EQ(tracker.copies(), 0);
+ EXPECT_EQ(tracker.moves(), 0);
+
+ // reserve() must not increase the number of initialized objects
+ SCOPED_TRACE("reserve");
+ v.reserve(len+1000);
+ EXPECT_EQ(tracker.instances(), len);
+ EXPECT_EQ(tracker.copies() + tracker.moves(), len);
+
+ // pop_back() and erase() must destroy one object
+ if (len > 0) {
+ tracker.ResetCopiesMovesSwaps();
+ v.pop_back();
+ EXPECT_EQ(tracker.instances(), len - 1);
+ EXPECT_EQ(tracker.copies(), 0);
+ EXPECT_EQ(tracker.moves(), 0);
+
+ if (!v.empty()) {
+ tracker.ResetCopiesMovesSwaps();
+ v.erase(v.begin());
+ EXPECT_EQ(tracker.instances(), len - 2);
+ EXPECT_EQ(tracker.copies() + tracker.moves(), len - 2);
+ }
+ }
+
+ tracker.ResetCopiesMovesSwaps();
+ int instances_before_empty_erase = tracker.instances();
+ v.erase(v.begin(), v.begin());
+ EXPECT_EQ(tracker.instances(), instances_before_empty_erase);
+ EXPECT_EQ(tracker.copies() + tracker.moves(), 0);
+ }
+}
+
+TYPED_TEST_P(InstanceTest, CountConstructorsDestructorsOnCopyConstruction) {
+ using Instance = TypeParam;
+ using InstanceVec = absl::InlinedVector<Instance, 8>;
+ InstanceTracker tracker;
+ for (int len = 0; len < 20; len++) {
+ SCOPED_TRACE(len);
+ tracker.ResetCopiesMovesSwaps();
+
+ InstanceVec v;
+ for (int i = 0; i < len; i++) {
+ v.push_back(Instance(i));
+ }
+ EXPECT_EQ(tracker.instances(), len);
+ EXPECT_GE(tracker.copies() + tracker.moves(),
+ len); // More due to reallocation.
+ tracker.ResetCopiesMovesSwaps();
+ { // Copy constructor should create 'len' more instances.
+ InstanceVec v_copy(v);
+ EXPECT_EQ(tracker.instances(), len + len);
+ EXPECT_EQ(tracker.copies(), len);
+ EXPECT_EQ(tracker.moves(), 0);
+ }
+ EXPECT_EQ(tracker.instances(), len);
+ }
+}
+
+TYPED_TEST_P(InstanceTest, CountConstructorsDestructorsOnMoveConstruction) {
+ using Instance = TypeParam;
+ using InstanceVec = absl::InlinedVector<Instance, 8>;
+ InstanceTracker tracker;
+ for (int len = 0; len < 20; len++) {
+ SCOPED_TRACE(len);
+ tracker.ResetCopiesMovesSwaps();
+
+ InstanceVec v;
+ const size_t inlined_capacity = v.capacity();
+ for (int i = 0; i < len; i++) {
+ v.push_back(Instance(i));
+ }
+ EXPECT_EQ(tracker.instances(), len);
+ EXPECT_GE(tracker.copies() + tracker.moves(),
+ len); // More due to reallocation.
+ tracker.ResetCopiesMovesSwaps();
+ {
+ InstanceVec v_copy(std::move(v));
+ if (len > inlined_capacity) {
+ // Allocation is moved as a whole.
+ EXPECT_EQ(tracker.instances(), len);
+ EXPECT_EQ(tracker.live_instances(), len);
+ // Tests an implementation detail, don't rely on this in your code.
+ EXPECT_EQ(v.size(), 0); // NOLINT misc-use-after-move
+ EXPECT_EQ(tracker.copies(), 0);
+ EXPECT_EQ(tracker.moves(), 0);
+ } else {
+ EXPECT_EQ(tracker.instances(), len + len);
+ if (Instance::supports_move()) {
+ EXPECT_EQ(tracker.live_instances(), len);
+ EXPECT_EQ(tracker.copies(), 0);
+ EXPECT_EQ(tracker.moves(), len);
+ } else {
+ EXPECT_EQ(tracker.live_instances(), len + len);
+ EXPECT_EQ(tracker.copies(), len);
+ EXPECT_EQ(tracker.moves(), 0);
+ }
+ }
+ EXPECT_EQ(tracker.swaps(), 0);
+ }
+ }
+}
+
+TYPED_TEST_P(InstanceTest, CountConstructorsDestructorsOnAssignment) {
+ using Instance = TypeParam;
+ using InstanceVec = absl::InlinedVector<Instance, 8>;
+ InstanceTracker tracker;
+ for (int len = 0; len < 20; len++) {
+ SCOPED_TRACE(len);
+ for (int longorshort = 0; longorshort <= 1; ++longorshort) {
+ SCOPED_TRACE(longorshort);
+ tracker.ResetCopiesMovesSwaps();
+
+ InstanceVec longer, shorter;
+ for (int i = 0; i < len; i++) {
+ longer.push_back(Instance(i));
+ shorter.push_back(Instance(i));
+ }
+ longer.push_back(Instance(len));
+ EXPECT_EQ(tracker.instances(), len + len + 1);
+ EXPECT_GE(tracker.copies() + tracker.moves(),
+ len + len + 1); // More due to reallocation.
+
+ tracker.ResetCopiesMovesSwaps();
+ if (longorshort) {
+ shorter = longer;
+ EXPECT_EQ(tracker.instances(), (len + 1) + (len + 1));
+ EXPECT_GE(tracker.copies() + tracker.moves(),
+ len + 1); // More due to reallocation.
+ } else {
+ longer = shorter;
+ EXPECT_EQ(tracker.instances(), len + len);
+ EXPECT_EQ(tracker.copies() + tracker.moves(), len);
+ }
+ }
+ }
+}
+
+TYPED_TEST_P(InstanceTest, CountConstructorsDestructorsOnMoveAssignment) {
+ using Instance = TypeParam;
+ using InstanceVec = absl::InlinedVector<Instance, 8>;
+ InstanceTracker tracker;
+ for (int len = 0; len < 20; len++) {
+ SCOPED_TRACE(len);
+ for (int longorshort = 0; longorshort <= 1; ++longorshort) {
+ SCOPED_TRACE(longorshort);
+ tracker.ResetCopiesMovesSwaps();
+
+ InstanceVec longer, shorter;
+ const int inlined_capacity = longer.capacity();
+ for (int i = 0; i < len; i++) {
+ longer.push_back(Instance(i));
+ shorter.push_back(Instance(i));
+ }
+ longer.push_back(Instance(len));
+ EXPECT_EQ(tracker.instances(), len + len + 1);
+ EXPECT_GE(tracker.copies() + tracker.moves(),
+ len + len + 1); // More due to reallocation.
+
+ tracker.ResetCopiesMovesSwaps();
+ int src_len;
+ if (longorshort) {
+ src_len = len + 1;
+ shorter = std::move(longer);
+ } else {
+ src_len = len;
+ longer = std::move(shorter);
+ }
+ if (src_len > inlined_capacity) {
+ // Allocation moved as a whole.
+ EXPECT_EQ(tracker.instances(), src_len);
+ EXPECT_EQ(tracker.live_instances(), src_len);
+ EXPECT_EQ(tracker.copies(), 0);
+ EXPECT_EQ(tracker.moves(), 0);
+ } else {
+ // Elements are all copied.
+ EXPECT_EQ(tracker.instances(), src_len + src_len);
+ if (Instance::supports_move()) {
+ EXPECT_EQ(tracker.copies(), 0);
+ EXPECT_EQ(tracker.moves(), src_len);
+ EXPECT_EQ(tracker.live_instances(), src_len);
+ } else {
+ EXPECT_EQ(tracker.copies(), src_len);
+ EXPECT_EQ(tracker.moves(), 0);
+ EXPECT_EQ(tracker.live_instances(), src_len + src_len);
+ }
+ }
+ EXPECT_EQ(tracker.swaps(), 0);
+ }
+ }
+}
+
+TEST(CountElemAssign, SimpleTypeWithInlineBacking) {
+ for (size_t original_size = 0; original_size <= 5; ++original_size) {
+ SCOPED_TRACE(original_size);
+ // Original contents are [12345, 12345, ...]
+ std::vector<int> original_contents(original_size, 12345);
+
+ absl::InlinedVector<int, 2> v(original_contents.begin(),
+ original_contents.end());
+ v.assign(2, 123);
+ EXPECT_THAT(v, AllOf(SizeIs(2), ElementsAre(123, 123)));
+ if (original_size <= 2) {
+ // If the original had inline backing, it should stay inline.
+ EXPECT_EQ(2, v.capacity());
+ }
+ }
+}
+
+TEST(CountElemAssign, SimpleTypeWithAllocation) {
+ for (size_t original_size = 0; original_size <= 5; ++original_size) {
+ SCOPED_TRACE(original_size);
+ // Original contents are [12345, 12345, ...]
+ std::vector<int> original_contents(original_size, 12345);
+
+ absl::InlinedVector<int, 2> v(original_contents.begin(),
+ original_contents.end());
+ v.assign(3, 123);
+ EXPECT_THAT(v, AllOf(SizeIs(3), ElementsAre(123, 123, 123)));
+ EXPECT_LE(v.size(), v.capacity());
+ }
+}
+
+TYPED_TEST_P(InstanceTest, CountElemAssignInlineBacking) {
+ using Instance = TypeParam;
+ for (size_t original_size = 0; original_size <= 5; ++original_size) {
+ SCOPED_TRACE(original_size);
+ // Original contents are [12345, 12345, ...]
+ std::vector<Instance> original_contents(original_size, Instance(12345));
+
+ absl::InlinedVector<Instance, 2> v(original_contents.begin(),
+ original_contents.end());
+ v.assign(2, Instance(123));
+ EXPECT_THAT(v, AllOf(SizeIs(2), ElementsAre(ValueIs(123), ValueIs(123))));
+ if (original_size <= 2) {
+ // If the original had inline backing, it should stay inline.
+ EXPECT_EQ(2, v.capacity());
+ }
+ }
+}
+
+template <typename Instance>
+void InstanceCountElemAssignWithAllocationTest() {
+ for (size_t original_size = 0; original_size <= 5; ++original_size) {
+ SCOPED_TRACE(original_size);
+ // Original contents are [12345, 12345, ...]
+ std::vector<Instance> original_contents(original_size, Instance(12345));
+
+ absl::InlinedVector<Instance, 2> v(original_contents.begin(),
+ original_contents.end());
+ v.assign(3, Instance(123));
+ EXPECT_THAT(v,
+ AllOf(SizeIs(3),
+ ElementsAre(ValueIs(123), ValueIs(123), ValueIs(123))));
+ EXPECT_LE(v.size(), v.capacity());
+ }
+}
+TEST(CountElemAssign, WithAllocationCopyableInstance) {
+ InstanceCountElemAssignWithAllocationTest<CopyableOnlyInstance>();
+}
+TEST(CountElemAssign, WithAllocationCopyableMovableInstance) {
+ InstanceCountElemAssignWithAllocationTest<CopyableMovableInstance>();
+}
+
+TEST(RangedConstructor, SimpleType) {
+ std::vector<int> source_v = {4, 5, 6};
+ // First try to fit in inline backing
+ absl::InlinedVector<int, 4> v(source_v.begin(), source_v.end());
+ EXPECT_EQ(3, v.size());
+ EXPECT_EQ(4, v.capacity()); // Indication that we're still on inlined storage
+ EXPECT_EQ(4, v[0]);
+ EXPECT_EQ(5, v[1]);
+ EXPECT_EQ(6, v[2]);
+
+ // Now, force a re-allocate
+ absl::InlinedVector<int, 2> realloc_v(source_v.begin(), source_v.end());
+ EXPECT_EQ(3, realloc_v.size());
+ EXPECT_LT(2, realloc_v.capacity());
+ EXPECT_EQ(4, realloc_v[0]);
+ EXPECT_EQ(5, realloc_v[1]);
+ EXPECT_EQ(6, realloc_v[2]);
+}
+
+// Test for ranged constructors using Instance as the element type and
+// SourceContainer as the source container type.
+template <typename Instance, typename SourceContainer, int inlined_capacity>
+void InstanceRangedConstructorTestForContainer() {
+ InstanceTracker tracker;
+ SourceContainer source_v = {Instance(0), Instance(1)};
+ tracker.ResetCopiesMovesSwaps();
+ absl::InlinedVector<Instance, inlined_capacity> v(source_v.begin(),
+ source_v.end());
+ EXPECT_EQ(2, v.size());
+ EXPECT_LT(1, v.capacity());
+ EXPECT_EQ(0, v[0].value());
+ EXPECT_EQ(1, v[1].value());
+ EXPECT_EQ(tracker.copies(), 2);
+ EXPECT_EQ(tracker.moves(), 0);
+}
+
+template <typename Instance, int inlined_capacity>
+void InstanceRangedConstructorTestWithCapacity() {
+ // Test with const and non-const, random access and non-random-access sources.
+ // TODO(bsamwel): Test with an input iterator source.
+ {
+ SCOPED_TRACE("std::list");
+ InstanceRangedConstructorTestForContainer<Instance, std::list<Instance>,
+ inlined_capacity>();
+ {
+ SCOPED_TRACE("const std::list");
+ InstanceRangedConstructorTestForContainer<
+ Instance, const std::list<Instance>, inlined_capacity>();
+ }
+ {
+ SCOPED_TRACE("std::vector");
+ InstanceRangedConstructorTestForContainer<Instance, std::vector<Instance>,
+ inlined_capacity>();
+ }
+ {
+ SCOPED_TRACE("const std::vector");
+ InstanceRangedConstructorTestForContainer<
+ Instance, const std::vector<Instance>, inlined_capacity>();
+ }
+ }
+}
+
+TYPED_TEST_P(InstanceTest, RangedConstructor) {
+ using Instance = TypeParam;
+ SCOPED_TRACE("capacity=1");
+ InstanceRangedConstructorTestWithCapacity<Instance, 1>();
+ SCOPED_TRACE("capacity=2");
+ InstanceRangedConstructorTestWithCapacity<Instance, 2>();
+}
+
+TEST(RangedConstructor, ElementsAreConstructed) {
+ std::vector<std::string> source_v = {"cat", "dog"};
+
+ // Force expansion and re-allocation of v. Ensures that when the vector is
+ // expanded that new elements are constructed.
+ absl::InlinedVector<std::string, 1> v(source_v.begin(), source_v.end());
+ EXPECT_EQ("cat", v[0]);
+ EXPECT_EQ("dog", v[1]);
+}
+
+TEST(RangedAssign, SimpleType) {
+ // Test for all combinations of original sizes (empty and non-empty inline,
+ // and out of line) and target sizes.
+ for (size_t original_size = 0; original_size <= 5; ++original_size) {
+ SCOPED_TRACE(original_size);
+ // Original contents are [12345, 12345, ...]
+ std::vector<int> original_contents(original_size, 12345);
+
+ for (size_t target_size = 0; target_size <= 5; ++target_size) {
+ SCOPED_TRACE(target_size);
+
+ // New contents are [3, 4, ...]
+ std::vector<int> new_contents;
+ for (size_t i = 0; i < target_size; ++i) {
+ new_contents.push_back(i + 3);
+ }
+
+ absl::InlinedVector<int, 3> v(original_contents.begin(),
+ original_contents.end());
+ v.assign(new_contents.begin(), new_contents.end());
+
+ EXPECT_EQ(new_contents.size(), v.size());
+ EXPECT_LE(new_contents.size(), v.capacity());
+ if (target_size <= 3 && original_size <= 3) {
+ // Storage should stay inline when target size is small.
+ EXPECT_EQ(3, v.capacity());
+ }
+ EXPECT_THAT(v, ElementsAreArray(new_contents));
+ }
+ }
+}
+
+// Returns true if lhs and rhs have the same value.
+template <typename Instance>
+static bool InstanceValuesEqual(const Instance& lhs, const Instance& rhs) {
+ return lhs.value() == rhs.value();
+}
+
+// Test for ranged assign() using Instance as the element type and
+// SourceContainer as the source container type.
+template <typename Instance, typename SourceContainer>
+void InstanceRangedAssignTestForContainer() {
+ // Test for all combinations of original sizes (empty and non-empty inline,
+ // and out of line) and target sizes.
+ for (size_t original_size = 0; original_size <= 5; ++original_size) {
+ SCOPED_TRACE(original_size);
+ // Original contents are [12345, 12345, ...]
+ std::vector<Instance> original_contents(original_size, Instance(12345));
+
+ for (size_t target_size = 0; target_size <= 5; ++target_size) {
+ SCOPED_TRACE(target_size);
+
+ // New contents are [3, 4, ...]
+ // Generate data using a non-const container, because SourceContainer
+ // itself may be const.
+ // TODO(bsamwel): Test with an input iterator.
+ std::vector<Instance> new_contents_in;
+ for (size_t i = 0; i < target_size; ++i) {
+ new_contents_in.push_back(Instance(i + 3));
+ }
+ SourceContainer new_contents(new_contents_in.begin(),
+ new_contents_in.end());
+
+ absl::InlinedVector<Instance, 3> v(original_contents.begin(),
+ original_contents.end());
+ v.assign(new_contents.begin(), new_contents.end());
+
+ EXPECT_EQ(new_contents.size(), v.size());
+ EXPECT_LE(new_contents.size(), v.capacity());
+ if (target_size <= 3 && original_size <= 3) {
+ // Storage should stay inline when target size is small.
+ EXPECT_EQ(3, v.capacity());
+ }
+ EXPECT_TRUE(std::equal(v.begin(), v.end(), new_contents.begin(),
+ InstanceValuesEqual<Instance>));
+ }
+ }
+}
+
+TYPED_TEST_P(InstanceTest, RangedAssign) {
+ using Instance = TypeParam;
+ // Test with const and non-const, random access and non-random-access sources.
+ // TODO(bsamwel): Test with an input iterator source.
+ SCOPED_TRACE("std::list");
+ InstanceRangedAssignTestForContainer<Instance, std::list<Instance>>();
+ SCOPED_TRACE("const std::list");
+ InstanceRangedAssignTestForContainer<Instance, const std::list<Instance>>();
+ SCOPED_TRACE("std::vector");
+ InstanceRangedAssignTestForContainer<Instance, std::vector<Instance>>();
+ SCOPED_TRACE("const std::vector");
+ InstanceRangedAssignTestForContainer<Instance, const std::vector<Instance>>();
+}
+
+TEST(InitializerListConstructor, SimpleTypeWithInlineBacking) {
+ EXPECT_THAT((absl::InlinedVector<int, 4>{4, 5, 6}),
+ AllOf(SizeIs(3), CapacityIs(4), ElementsAre(4, 5, 6)));
+}
+
+TEST(InitializerListConstructor, SimpleTypeWithReallocationRequired) {
+ EXPECT_THAT((absl::InlinedVector<int, 2>{4, 5, 6}),
+ AllOf(SizeIs(3), CapacityIs(Gt(2)), ElementsAre(4, 5, 6)));
+}
+
+TEST(InitializerListConstructor, DisparateTypesInList) {
+ EXPECT_THAT((absl::InlinedVector<int, 2>{-7, 8ULL}), ElementsAre(-7, 8));
+
+ EXPECT_THAT((absl::InlinedVector<std::string, 2>{"foo", std::string("bar")}),
+ ElementsAre("foo", "bar"));
+}
+
+TEST(InitializerListConstructor, ComplexTypeWithInlineBacking) {
+ EXPECT_THAT((absl::InlinedVector<CopyableMovableInstance, 1>{
+ CopyableMovableInstance(0)}),
+ AllOf(SizeIs(1), CapacityIs(1), ElementsAre(ValueIs(0))));
+}
+
+TEST(InitializerListConstructor, ComplexTypeWithReallocationRequired) {
+ EXPECT_THAT(
+ (absl::InlinedVector<CopyableMovableInstance, 1>{
+ CopyableMovableInstance(0), CopyableMovableInstance(1)}),
+ AllOf(SizeIs(2), CapacityIs(Gt(1)), ElementsAre(ValueIs(0), ValueIs(1))));
+}
+
+TEST(InitializerListAssign, SimpleTypeFitsInlineBacking) {
+ for (size_t original_size = 0; original_size <= 4; ++original_size) {
+ SCOPED_TRACE(original_size);
+
+ absl::InlinedVector<int, 2> v1(original_size, 12345);
+ const size_t original_capacity_v1 = v1.capacity();
+ v1.assign({3});
+ EXPECT_THAT(
+ v1, AllOf(SizeIs(1), CapacityIs(original_capacity_v1), ElementsAre(3)));
+
+ absl::InlinedVector<int, 2> v2(original_size, 12345);
+ const size_t original_capacity_v2 = v2.capacity();
+ v2 = {3};
+ EXPECT_THAT(
+ v2, AllOf(SizeIs(1), CapacityIs(original_capacity_v2), ElementsAre(3)));
+ }
+}
+
+TEST(InitializerListAssign, SimpleTypeDoesNotFitInlineBacking) {
+ for (size_t original_size = 0; original_size <= 4; ++original_size) {
+ SCOPED_TRACE(original_size);
+ absl::InlinedVector<int, 2> v1(original_size, 12345);
+ v1.assign({3, 4, 5});
+ EXPECT_THAT(v1, AllOf(SizeIs(3), ElementsAre(3, 4, 5)));
+ EXPECT_LE(3, v1.capacity());
+
+ absl::InlinedVector<int, 2> v2(original_size, 12345);
+ v2 = {3, 4, 5};
+ EXPECT_THAT(v2, AllOf(SizeIs(3), ElementsAre(3, 4, 5)));
+ EXPECT_LE(3, v2.capacity());
+ }
+}
+
+TEST(InitializerListAssign, DisparateTypesInList) {
+ absl::InlinedVector<int, 2> v_int1;
+ v_int1.assign({-7, 8ULL});
+ EXPECT_THAT(v_int1, ElementsAre(-7, 8));
+
+ absl::InlinedVector<int, 2> v_int2;
+ v_int2 = {-7, 8ULL};
+ EXPECT_THAT(v_int2, ElementsAre(-7, 8));
+
+ absl::InlinedVector<std::string, 2> v_string1;
+ v_string1.assign({"foo", std::string("bar")});
+ EXPECT_THAT(v_string1, ElementsAre("foo", "bar"));
+
+ absl::InlinedVector<std::string, 2> v_string2;
+ v_string2 = {"foo", std::string("bar")};
+ EXPECT_THAT(v_string2, ElementsAre("foo", "bar"));
+}
+
+TYPED_TEST_P(InstanceTest, InitializerListAssign) {
+ using Instance = TypeParam;
+ for (size_t original_size = 0; original_size <= 4; ++original_size) {
+ SCOPED_TRACE(original_size);
+ absl::InlinedVector<Instance, 2> v(original_size, Instance(12345));
+ const size_t original_capacity = v.capacity();
+ v.assign({Instance(3)});
+ EXPECT_THAT(v, AllOf(SizeIs(1), CapacityIs(original_capacity),
+ ElementsAre(ValueIs(3))));
+ }
+ for (size_t original_size = 0; original_size <= 4; ++original_size) {
+ SCOPED_TRACE(original_size);
+ absl::InlinedVector<Instance, 2> v(original_size, Instance(12345));
+ v.assign({Instance(3), Instance(4), Instance(5)});
+ EXPECT_THAT(v, AllOf(SizeIs(3),
+ ElementsAre(ValueIs(3), ValueIs(4), ValueIs(5))));
+ EXPECT_LE(3, v.capacity());
+ }
+}
+
+REGISTER_TYPED_TEST_CASE_P(InstanceTest, Swap, CountConstructorsDestructors,
+ CountConstructorsDestructorsOnCopyConstruction,
+ CountConstructorsDestructorsOnMoveConstruction,
+ CountConstructorsDestructorsOnAssignment,
+ CountConstructorsDestructorsOnMoveAssignment,
+ CountElemAssignInlineBacking, RangedConstructor,
+ RangedAssign, InitializerListAssign);
+
+using InstanceTypes =
+ ::testing::Types<CopyableOnlyInstance, CopyableMovableInstance>;
+INSTANTIATE_TYPED_TEST_CASE_P(InstanceTestOnTypes, InstanceTest, InstanceTypes);
+
+TEST(DynamicVec, DynamicVecCompiles) {
+ DynamicVec v;
+ (void)v;
+}
+
+TEST(AllocatorSupportTest, Constructors) {
+ using MyAlloc = CountingAllocator<int>;
+ using AllocVec = absl::InlinedVector<int, 4, MyAlloc>;
+ const int ia[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+ int64_t allocated = 0;
+ MyAlloc alloc(&allocated);
+ { AllocVec ABSL_ATTRIBUTE_UNUSED v; }
+ { AllocVec ABSL_ATTRIBUTE_UNUSED v(alloc); }
+ { AllocVec ABSL_ATTRIBUTE_UNUSED v(ia, ia + ABSL_ARRAYSIZE(ia), alloc); }
+ { AllocVec ABSL_ATTRIBUTE_UNUSED v({1, 2, 3}, alloc); }
+
+ AllocVec v2;
+ { AllocVec ABSL_ATTRIBUTE_UNUSED v(v2, alloc); }
+ { AllocVec ABSL_ATTRIBUTE_UNUSED v(std::move(v2), alloc); }
+}
+
+TEST(AllocatorSupportTest, CountAllocations) {
+ using MyAlloc = CountingAllocator<int>;
+ using AllocVec = absl::InlinedVector<int, 4, MyAlloc>;
+ const int ia[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+ int64_t allocated = 0;
+ MyAlloc alloc(&allocated);
+ {
+ AllocVec ABSL_ATTRIBUTE_UNUSED v(ia, ia + 4, alloc);
+ EXPECT_THAT(allocated, 0);
+ }
+ EXPECT_THAT(allocated, 0);
+ {
+ AllocVec ABSL_ATTRIBUTE_UNUSED v(ia, ia + ABSL_ARRAYSIZE(ia), alloc);
+ EXPECT_THAT(allocated, v.size() * sizeof(int));
+ }
+ EXPECT_THAT(allocated, 0);
+ {
+ AllocVec v(4, 1, alloc);
+ EXPECT_THAT(allocated, 0);
+
+ int64_t allocated2 = 0;
+ MyAlloc alloc2(&allocated2);
+ AllocVec v2(v, alloc2);
+ EXPECT_THAT(allocated2, 0);
+
+ int64_t allocated3 = 0;
+ MyAlloc alloc3(&allocated3);
+ AllocVec v3(std::move(v), alloc3);
+ EXPECT_THAT(allocated3, 0);
+ }
+ EXPECT_THAT(allocated, 0);
+ {
+ AllocVec v(8, 2, alloc);
+ EXPECT_THAT(allocated, v.size() * sizeof(int));
+
+ int64_t allocated2 = 0;
+ MyAlloc alloc2(&allocated2);
+ AllocVec v2(v, alloc2);
+ EXPECT_THAT(allocated2, v2.size() * sizeof(int));
+
+ int64_t allocated3 = 0;
+ MyAlloc alloc3(&allocated3);
+ AllocVec v3(std::move(v), alloc3);
+ EXPECT_THAT(allocated3, v3.size() * sizeof(int));
+ }
+ EXPECT_EQ(allocated, 0);
+ {
+ // Test shrink_to_fit deallocations.
+ AllocVec v(8, 2, alloc);
+ EXPECT_EQ(allocated, 8 * sizeof(int));
+ v.resize(5);
+ EXPECT_EQ(allocated, 8 * sizeof(int));
+ v.shrink_to_fit();
+ EXPECT_EQ(allocated, 5 * sizeof(int));
+ v.resize(4);
+ EXPECT_EQ(allocated, 5 * sizeof(int));
+ v.shrink_to_fit();
+ EXPECT_EQ(allocated, 0);
+ }
+}
+
+TEST(AllocatorSupportTest, SwapBothAllocated) {
+ using MyAlloc = CountingAllocator<int>;
+ using AllocVec = absl::InlinedVector<int, 4, MyAlloc>;
+ int64_t allocated1 = 0;
+ int64_t allocated2 = 0;
+ {
+ const int ia1[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+ const int ia2[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8 };
+ MyAlloc a1(&allocated1);
+ MyAlloc a2(&allocated2);
+ AllocVec v1(ia1, ia1 + ABSL_ARRAYSIZE(ia1), a1);
+ AllocVec v2(ia2, ia2 + ABSL_ARRAYSIZE(ia2), a2);
+ EXPECT_LT(v1.capacity(), v2.capacity());
+ EXPECT_THAT(allocated1, v1.capacity() * sizeof(int));
+ EXPECT_THAT(allocated2, v2.capacity() * sizeof(int));
+ v1.swap(v2);
+ EXPECT_THAT(v1, ElementsAreArray(ia2));
+ EXPECT_THAT(v2, ElementsAreArray(ia1));
+ EXPECT_THAT(allocated1, v2.capacity() * sizeof(int));
+ EXPECT_THAT(allocated2, v1.capacity() * sizeof(int));
+ }
+ EXPECT_THAT(allocated1, 0);
+ EXPECT_THAT(allocated2, 0);
+}
+
+TEST(AllocatorSupportTest, SwapOneAllocated) {
+ using MyAlloc = CountingAllocator<int>;
+ using AllocVec = absl::InlinedVector<int, 4, MyAlloc>;
+ int64_t allocated1 = 0;
+ int64_t allocated2 = 0;
+ {
+ const int ia1[] = { 0, 1, 2, 3, 4, 5, 6, 7 };
+ const int ia2[] = { 0, 1, 2, 3 };
+ MyAlloc a1(&allocated1);
+ MyAlloc a2(&allocated2);
+ AllocVec v1(ia1, ia1 + ABSL_ARRAYSIZE(ia1), a1);
+ AllocVec v2(ia2, ia2 + ABSL_ARRAYSIZE(ia2), a2);
+ EXPECT_THAT(allocated1, v1.capacity() * sizeof(int));
+ EXPECT_THAT(allocated2, 0);
+ v1.swap(v2);
+ EXPECT_THAT(v1, ElementsAreArray(ia2));
+ EXPECT_THAT(v2, ElementsAreArray(ia1));
+ EXPECT_THAT(allocated1, v2.capacity() * sizeof(int));
+ EXPECT_THAT(allocated2, 0);
+ EXPECT_TRUE(v2.get_allocator() == a1);
+ EXPECT_TRUE(v1.get_allocator() == a2);
+ }
+ EXPECT_THAT(allocated1, 0);
+ EXPECT_THAT(allocated2, 0);
+}
+
+TEST(AllocatorSupportTest, ScopedAllocatorWorks) {
+ using StdVector = std::vector<int, CountingAllocator<int>>;
+ using MyAlloc =
+ std::scoped_allocator_adaptor<CountingAllocator<StdVector>>;
+ using AllocVec = absl::InlinedVector<StdVector, 4, MyAlloc>;
+
+ int64_t allocated = 0;
+ AllocVec vec(MyAlloc{CountingAllocator<StdVector>{&allocated}});
+ EXPECT_EQ(allocated, 0);
+
+ // This default constructs a vector<int>, but the allocator should pass itself
+ // into the vector<int>.
+ // The absl::InlinedVector does not allocate any memory.
+ // The vector<int> does not allocate any memory.
+ vec.resize(1);
+ EXPECT_EQ(allocated, 0);
+
+ // We make vector<int> allocate memory.
+ // It must go through the allocator even though we didn't construct the
+ // vector directly.
+ vec[0].push_back(1);
+ EXPECT_EQ(allocated, sizeof(int) * 1);
+
+ // Another allocating vector.
+ vec.push_back(vec[0]);
+ EXPECT_EQ(allocated, sizeof(int) * 2);
+
+ // Overflow the inlined memory.
+ // The absl::InlinedVector will now allocate.
+ vec.resize(5);
+ EXPECT_EQ(allocated, sizeof(int) * 2 + sizeof(StdVector) * 8);
+
+ // Adding one more in external mode should also work.
+ vec.push_back(vec[0]);
+ EXPECT_EQ(allocated, sizeof(int) * 3 + sizeof(StdVector) * 8);
+
+ // And extending these should still work.
+ vec[0].push_back(1);
+ EXPECT_EQ(allocated, sizeof(int) * 4 + sizeof(StdVector) * 8);
+
+ vec.clear();
+ EXPECT_EQ(allocated, 0);
+}
+
+} // anonymous namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker.cc
new file mode 100644
index 0000000..fe00aca
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker.cc
@@ -0,0 +1,26 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/container/internal/test_instance_tracker.h"
+
+namespace absl {
+namespace test_internal {
+int BaseCountedInstance::num_instances_ = 0;
+int BaseCountedInstance::num_live_instances_ = 0;
+int BaseCountedInstance::num_moves_ = 0;
+int BaseCountedInstance::num_copies_ = 0;
+int BaseCountedInstance::num_swaps_ = 0;
+
+} // namespace test_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker.h b/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker.h
new file mode 100644
index 0000000..cf8f3a5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker.h
@@ -0,0 +1,220 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
+#define ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
+
+#include <cstdlib>
+#include <ostream>
+
+namespace absl {
+namespace test_internal {
+
+// A type that counts number of occurences of the type, the live occurrences of
+// the type, as well as the number of copies, moves, and swaps that have
+// occurred on the type. This is used as a base class for the copyable,
+// copyable+movable, and movable types below that are used in actual tests. Use
+// InstanceTracker in tests to track the number of instances.
+class BaseCountedInstance {
+ public:
+ explicit BaseCountedInstance(int x) : value_(x) {
+ ++num_instances_;
+ ++num_live_instances_;
+ }
+ BaseCountedInstance(const BaseCountedInstance& x)
+ : value_(x.value_), is_live_(x.is_live_) {
+ ++num_instances_;
+ if (is_live_) ++num_live_instances_;
+ ++num_copies_;
+ }
+ BaseCountedInstance(BaseCountedInstance&& x)
+ : value_(x.value_), is_live_(x.is_live_) {
+ x.is_live_ = false;
+ ++num_instances_;
+ ++num_moves_;
+ }
+ ~BaseCountedInstance() {
+ --num_instances_;
+ if (is_live_) --num_live_instances_;
+ }
+
+ BaseCountedInstance& operator=(const BaseCountedInstance& x) {
+ value_ = x.value_;
+ if (is_live_) --num_live_instances_;
+ is_live_ = x.is_live_;
+ if (is_live_) ++num_live_instances_;
+ ++num_copies_;
+ return *this;
+ }
+ BaseCountedInstance& operator=(BaseCountedInstance&& x) {
+ value_ = x.value_;
+ if (is_live_) --num_live_instances_;
+ is_live_ = x.is_live_;
+ x.is_live_ = false;
+ ++num_moves_;
+ return *this;
+ }
+
+ int value() const {
+ if (!is_live_) std::abort();
+ return value_;
+ }
+
+ friend std::ostream& operator<<(std::ostream& o,
+ const BaseCountedInstance& v) {
+ return o << "[value:" << v.value() << "]";
+ }
+
+ // Implementation of efficient swap() that counts swaps.
+ static void SwapImpl(
+ BaseCountedInstance& lhs, // NOLINT(runtime/references)
+ BaseCountedInstance& rhs) { // NOLINT(runtime/references)
+ using std::swap;
+ swap(lhs.value_, rhs.value_);
+ swap(lhs.is_live_, rhs.is_live_);
+ ++BaseCountedInstance::num_swaps_;
+ }
+
+ private:
+ friend class InstanceTracker;
+
+ int value_;
+
+ // Indicates if the value is live, ie it hasn't been moved away from.
+ bool is_live_ = true;
+
+ // Number of instances.
+ static int num_instances_;
+
+ // Number of live instances (those that have not been moved away from.)
+ static int num_live_instances_;
+
+ // Number of times that BaseCountedInstance objects were moved.
+ static int num_moves_;
+
+ // Number of times that BaseCountedInstance objects were copied.
+ static int num_copies_;
+
+ // Number of times that BaseCountedInstance objects were swapped.
+ static int num_swaps_;
+};
+
+// Helper to track the BaseCountedInstance instance counters. Expects that the
+// number of instances and live_instances are the same when it is constructed
+// and when it is destructed.
+class InstanceTracker {
+ public:
+ InstanceTracker()
+ : start_instances_(BaseCountedInstance::num_instances_),
+ start_live_instances_(BaseCountedInstance::num_live_instances_) {
+ ResetCopiesMovesSwaps();
+ }
+ ~InstanceTracker() {
+ if (instances() != 0) std::abort();
+ if (live_instances() != 0) std::abort();
+ }
+
+ // Returns the number of BaseCountedInstance instances both containing valid
+ // values and those moved away from compared to when the InstanceTracker was
+ // constructed
+ int instances() const {
+ return BaseCountedInstance::num_instances_ - start_instances_;
+ }
+
+ // Returns the number of live BaseCountedInstance instances compared to when
+ // the InstanceTracker was constructed
+ int live_instances() const {
+ return BaseCountedInstance::num_live_instances_ - start_live_instances_;
+ }
+
+ // Returns the number of moves on BaseCountedInstance objects since
+ // construction or since the last call to ResetCopiesMovesSwaps().
+ int moves() const { return BaseCountedInstance::num_moves_ - start_moves_; }
+
+ // Returns the number of copies on BaseCountedInstance objects since
+ // construction or the last call to ResetCopiesMovesSwaps().
+ int copies() const {
+ return BaseCountedInstance::num_copies_ - start_copies_;
+ }
+
+ // Returns the number of swaps on BaseCountedInstance objects since
+ // construction or the last call to ResetCopiesMovesSwaps().
+ int swaps() const { return BaseCountedInstance::num_swaps_ - start_swaps_; }
+
+ // Resets the base values for moves, copies and swaps to the current values,
+ // so that subsequent Get*() calls for moves, copies and swaps will compare to
+ // the situation at the point of this call.
+ void ResetCopiesMovesSwaps() {
+ start_moves_ = BaseCountedInstance::num_moves_;
+ start_copies_ = BaseCountedInstance::num_copies_;
+ start_swaps_ = BaseCountedInstance::num_swaps_;
+ }
+
+ private:
+ int start_instances_;
+ int start_live_instances_;
+ int start_moves_;
+ int start_copies_;
+ int start_swaps_;
+};
+
+// Copyable, not movable.
+class CopyableOnlyInstance : public BaseCountedInstance {
+ public:
+ explicit CopyableOnlyInstance(int x) : BaseCountedInstance(x) {}
+ CopyableOnlyInstance(const CopyableOnlyInstance& rhs) = default;
+ CopyableOnlyInstance& operator=(const CopyableOnlyInstance& rhs) = default;
+
+ friend void swap(CopyableOnlyInstance& lhs, CopyableOnlyInstance& rhs) {
+ BaseCountedInstance::SwapImpl(lhs, rhs);
+ }
+
+ static bool supports_move() { return false; }
+};
+
+// Copyable and movable.
+class CopyableMovableInstance : public BaseCountedInstance {
+ public:
+ explicit CopyableMovableInstance(int x) : BaseCountedInstance(x) {}
+ CopyableMovableInstance(const CopyableMovableInstance& rhs) = default;
+ CopyableMovableInstance(CopyableMovableInstance&& rhs) = default;
+ CopyableMovableInstance& operator=(const CopyableMovableInstance& rhs) =
+ default;
+ CopyableMovableInstance& operator=(CopyableMovableInstance&& rhs) = default;
+
+ friend void swap(CopyableMovableInstance& lhs, CopyableMovableInstance& rhs) {
+ BaseCountedInstance::SwapImpl(lhs, rhs);
+ }
+
+ static bool supports_move() { return true; }
+};
+
+// Only movable, not default-constructible.
+class MovableOnlyInstance : public BaseCountedInstance {
+ public:
+ explicit MovableOnlyInstance(int x) : BaseCountedInstance(x) {}
+ MovableOnlyInstance(MovableOnlyInstance&& other) = default;
+ MovableOnlyInstance& operator=(MovableOnlyInstance&& other) = default;
+
+ friend void swap(MovableOnlyInstance& lhs, MovableOnlyInstance& rhs) {
+ BaseCountedInstance::SwapImpl(lhs, rhs);
+ }
+
+ static bool supports_move() { return true; }
+};
+
+} // namespace test_internal
+} // namespace absl
+
+#endif // ABSL_CONTAINER_INTERNAL_TEST_INSTANCE_TRACKER_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker_test.cc
new file mode 100644
index 0000000..9efb677
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/container/internal/test_instance_tracker_test.cc
@@ -0,0 +1,160 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/container/internal/test_instance_tracker.h"
+
+#include "gtest/gtest.h"
+
+namespace {
+
+using absl::test_internal::CopyableMovableInstance;
+using absl::test_internal::CopyableOnlyInstance;
+using absl::test_internal::InstanceTracker;
+using absl::test_internal::MovableOnlyInstance;
+
+TEST(TestInstanceTracker, CopyableMovable) {
+ InstanceTracker tracker;
+ CopyableMovableInstance src(1);
+ EXPECT_EQ(1, src.value()) << src;
+ CopyableMovableInstance copy(src);
+ CopyableMovableInstance move(std::move(src));
+ EXPECT_EQ(1, tracker.copies());
+ EXPECT_EQ(1, tracker.moves());
+ EXPECT_EQ(0, tracker.swaps());
+ EXPECT_EQ(3, tracker.instances());
+ EXPECT_EQ(2, tracker.live_instances());
+ tracker.ResetCopiesMovesSwaps();
+
+ CopyableMovableInstance copy_assign(1);
+ copy_assign = copy;
+ CopyableMovableInstance move_assign(1);
+ move_assign = std::move(move);
+ EXPECT_EQ(1, tracker.copies());
+ EXPECT_EQ(1, tracker.moves());
+ EXPECT_EQ(0, tracker.swaps());
+ EXPECT_EQ(5, tracker.instances());
+ EXPECT_EQ(3, tracker.live_instances());
+ tracker.ResetCopiesMovesSwaps();
+
+ {
+ using std::swap;
+ swap(move_assign, copy);
+ swap(copy, move_assign);
+ EXPECT_EQ(2, tracker.swaps());
+ EXPECT_EQ(0, tracker.copies());
+ EXPECT_EQ(0, tracker.moves());
+ EXPECT_EQ(5, tracker.instances());
+ EXPECT_EQ(3, tracker.live_instances());
+ }
+}
+
+TEST(TestInstanceTracker, CopyableOnly) {
+ InstanceTracker tracker;
+ CopyableOnlyInstance src(1);
+ EXPECT_EQ(1, src.value()) << src;
+ CopyableOnlyInstance copy(src);
+ CopyableOnlyInstance copy2(std::move(src)); // NOLINT
+ EXPECT_EQ(2, tracker.copies());
+ EXPECT_EQ(0, tracker.moves());
+ EXPECT_EQ(3, tracker.instances());
+ EXPECT_EQ(3, tracker.live_instances());
+ tracker.ResetCopiesMovesSwaps();
+
+ CopyableOnlyInstance copy_assign(1);
+ copy_assign = copy;
+ CopyableOnlyInstance copy_assign2(1);
+ copy_assign2 = std::move(copy2); // NOLINT
+ EXPECT_EQ(2, tracker.copies());
+ EXPECT_EQ(0, tracker.moves());
+ EXPECT_EQ(5, tracker.instances());
+ EXPECT_EQ(5, tracker.live_instances());
+ tracker.ResetCopiesMovesSwaps();
+
+ {
+ using std::swap;
+ swap(src, copy);
+ swap(copy, src);
+ EXPECT_EQ(2, tracker.swaps());
+ EXPECT_EQ(0, tracker.copies());
+ EXPECT_EQ(0, tracker.moves());
+ EXPECT_EQ(5, tracker.instances());
+ EXPECT_EQ(5, tracker.live_instances());
+ }
+}
+
+TEST(TestInstanceTracker, MovableOnly) {
+ InstanceTracker tracker;
+ MovableOnlyInstance src(1);
+ EXPECT_EQ(1, src.value()) << src;
+ MovableOnlyInstance move(std::move(src));
+ MovableOnlyInstance move_assign(2);
+ move_assign = std::move(move);
+ EXPECT_EQ(3, tracker.instances());
+ EXPECT_EQ(1, tracker.live_instances());
+ EXPECT_EQ(2, tracker.moves());
+ EXPECT_EQ(0, tracker.copies());
+ tracker.ResetCopiesMovesSwaps();
+
+ {
+ using std::swap;
+ MovableOnlyInstance other(2);
+ swap(move_assign, other);
+ swap(other, move_assign);
+ EXPECT_EQ(2, tracker.swaps());
+ EXPECT_EQ(0, tracker.copies());
+ EXPECT_EQ(0, tracker.moves());
+ EXPECT_EQ(4, tracker.instances());
+ EXPECT_EQ(2, tracker.live_instances());
+ }
+}
+
+TEST(TestInstanceTracker, ExistingInstances) {
+ CopyableMovableInstance uncounted_instance(1);
+ CopyableMovableInstance uncounted_live_instance(
+ std::move(uncounted_instance));
+ InstanceTracker tracker;
+ EXPECT_EQ(0, tracker.instances());
+ EXPECT_EQ(0, tracker.live_instances());
+ EXPECT_EQ(0, tracker.copies());
+ {
+ CopyableMovableInstance instance1(1);
+ EXPECT_EQ(1, tracker.instances());
+ EXPECT_EQ(1, tracker.live_instances());
+ EXPECT_EQ(0, tracker.copies());
+ EXPECT_EQ(0, tracker.moves());
+ {
+ InstanceTracker tracker2;
+ CopyableMovableInstance instance2(instance1);
+ CopyableMovableInstance instance3(std::move(instance2));
+ EXPECT_EQ(3, tracker.instances());
+ EXPECT_EQ(2, tracker.live_instances());
+ EXPECT_EQ(1, tracker.copies());
+ EXPECT_EQ(1, tracker.moves());
+ EXPECT_EQ(2, tracker2.instances());
+ EXPECT_EQ(1, tracker2.live_instances());
+ EXPECT_EQ(1, tracker2.copies());
+ EXPECT_EQ(1, tracker2.moves());
+ }
+ EXPECT_EQ(1, tracker.instances());
+ EXPECT_EQ(1, tracker.live_instances());
+ EXPECT_EQ(1, tracker.copies());
+ EXPECT_EQ(1, tracker.moves());
+ }
+ EXPECT_EQ(0, tracker.instances());
+ EXPECT_EQ(0, tracker.live_instances());
+ EXPECT_EQ(1, tracker.copies());
+ EXPECT_EQ(1, tracker.moves());
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/copts.bzl
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/copts.bzl b/libraries/ostrich/backend/3rdparty/abseil/absl/copts.bzl
new file mode 100644
index 0000000..20c9b61
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/copts.bzl
@@ -0,0 +1,155 @@
+"""absl specific copts.
+
+Flags specified here must not impact ABI. Code compiled with and without these
+opts will be linked together, and in some cases headers compiled with and
+without these options will be part of the same program.
+"""
+GCC_FLAGS = [
+ "-Wall",
+ "-Wextra",
+ "-Wcast-qual",
+ "-Wconversion-null",
+ "-Wmissing-declarations",
+ "-Woverlength-strings",
+ "-Wpointer-arith",
+ "-Wunused-local-typedefs",
+ "-Wunused-result",
+ "-Wvarargs",
+ "-Wvla", # variable-length array
+ "-Wwrite-strings",
+ # Google style does not use unsigned integers, though STL containers
+ # have unsigned types.
+ "-Wno-sign-compare",
+]
+
+GCC_TEST_FLAGS = [
+ "-Wno-conversion-null",
+ "-Wno-missing-declarations",
+ "-Wno-sign-compare",
+ "-Wno-unused-function",
+ "-Wno-unused-parameter",
+ "-Wno-unused-private-field",
+]
+
+
+# Docs on single flags is preceded by a comment.
+# Docs on groups of flags is preceded by ###.
+
+LLVM_FLAGS = [
+ # All warnings are treated as errors by implicit -Werror flag
+ "-Wall",
+ "-Wextra",
+ "-Weverything",
+ # Abseil does not support C++98
+ "-Wno-c++98-compat-pedantic",
+ # Turns off all implicit conversion warnings. Most are re-enabled below.
+ "-Wno-conversion",
+ "-Wno-covered-switch-default",
+ "-Wno-deprecated",
+ "-Wno-disabled-macro-expansion",
+ "-Wno-double-promotion",
+ ###
+ # Turned off as they include valid C++ code.
+ "-Wno-comma",
+ "-Wno-extra-semi",
+ "-Wno-packed",
+ "-Wno-padded",
+ ###
+ "-Wno-float-conversion",
+ "-Wno-float-equal",
+ "-Wno-format-nonliteral",
+ # Too aggressive: warns on Clang extensions enclosed in Clang-only
+ # compilation paths.
+ "-Wno-gcc-compat",
+ ###
+ # Some internal globals are necessary. Don't do this at home.
+ "-Wno-global-constructors",
+ "-Wno-exit-time-destructors",
+ ###
+ "-Wno-nested-anon-types",
+ "-Wno-non-modular-include-in-module",
+ "-Wno-old-style-cast",
+ # Warns on preferred usage of non-POD types such as string_view
+ "-Wno-range-loop-analysis",
+ "-Wno-reserved-id-macro",
+ "-Wno-shorten-64-to-32",
+ "-Wno-switch-enum",
+ "-Wno-thread-safety-negative",
+ "-Wno-undef",
+ "-Wno-unknown-warning-option",
+ "-Wno-unreachable-code",
+ # Causes warnings on include guards
+ "-Wno-unused-macros",
+ "-Wno-weak-vtables",
+ ###
+ # Implicit conversion warnings turned off by -Wno-conversion
+ # which are re-enabled below.
+ "-Wbitfield-enum-conversion",
+ "-Wbool-conversion",
+ "-Wconstant-conversion",
+ "-Wenum-conversion",
+ "-Wint-conversion",
+ "-Wliteral-conversion",
+ "-Wnon-literal-null-conversion",
+ "-Wnull-conversion",
+ "-Wobjc-literal-conversion",
+ "-Wno-sign-conversion",
+ "-Wstring-conversion",
+ ###
+]
+
+LLVM_TEST_FLAGS = [
+ "-Wno-c99-extensions",
+ "-Wno-missing-noreturn",
+ "-Wno-missing-prototypes",
+ "-Wno-null-conversion",
+ "-Wno-shadow",
+ "-Wno-shift-sign-overflow",
+ "-Wno-sign-compare",
+ "-Wno-unused-function",
+ "-Wno-unused-member-function",
+ "-Wno-unused-parameter",
+ "-Wno-unused-private-field",
+ "-Wno-unused-template",
+ "-Wno-used-but-marked-unused",
+ "-Wno-zero-as-null-pointer-constant",
+]
+
+MSVC_FLAGS = [
+ "/W3",
+ "/WX",
+ "/wd4005", # macro-redefinition
+ "/wd4068", # unknown pragma
+ "/wd4244", # conversion from 'type1' to 'type2', possible loss of data
+ "/wd4267", # conversion from 'size_t' to 'type', possible loss of data
+ "/wd4800", # forcing value to bool 'true' or 'false' (performance warning)
+ "/DNOMINMAX", # Don't define min and max macros (windows.h)
+ "/DWIN32_LEAN_AND_MEAN", # Don't bloat namespace with incompatible winsock versions.
+ "/D_CRT_SECURE_NO_WARNINGS", # Don't warn about usage of insecure C functions
+]
+
+MSVC_TEST_FLAGS = [
+ "/wd4018", # signed/unsigned mismatch
+ "/wd4101", # unreferenced local variable
+ "/wd4503", # decorated name length exceeded, name was truncated
+]
+
+# /Wall with msvc includes unhelpful warnings such as C4711, C4710, ...
+ABSL_DEFAULT_COPTS = select({
+ "//absl:windows": MSVC_FLAGS,
+ "//absl:llvm_compiler": LLVM_FLAGS,
+ "//conditions:default": GCC_FLAGS,
+})
+
+# in absence of modules (--compiler=gcc or -c opt), cc_tests leak their copts
+# to their (included header) dependencies and fail to build outside absl
+ABSL_TEST_COPTS = ABSL_DEFAULT_COPTS + select({
+ "//absl:windows": MSVC_TEST_FLAGS,
+ "//absl:llvm_compiler": LLVM_TEST_FLAGS,
+ "//conditions:default": GCC_TEST_FLAGS,
+})
+
+ABSL_EXCEPTIONS_FLAG = select({
+ "//absl:windows": ["/U_HAS_EXCEPTIONS", "/D_HAS_EXCEPTIONS=1", "/EHsc"],
+ "//conditions:default": ["-fexceptions"],
+})
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/BUILD.bazel
new file mode 100644
index 0000000..e1e7fce
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/BUILD.bazel
@@ -0,0 +1,305 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+)
+
+package(
+ default_visibility = ["//visibility:public"],
+)
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "stacktrace",
+ srcs = [
+ "stacktrace.cc",
+ ],
+ hdrs = ["stacktrace.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":debugging_internal",
+ "//absl/base",
+ "//absl/base:core_headers",
+ ],
+)
+
+cc_library(
+ name = "symbolize",
+ srcs = [
+ "symbolize.cc",
+ "symbolize_elf.inc",
+ "symbolize_unimplemented.inc",
+ "symbolize_win32.inc",
+ ],
+ hdrs = [
+ "internal/symbolize.h",
+ "symbolize.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":debugging_internal",
+ ":demangle_internal",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "//absl/base:malloc_internal",
+ ],
+)
+
+cc_test(
+ name = "symbolize_test",
+ srcs = ["symbolize_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":stack_consumption",
+ ":symbolize",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "//absl/memory",
+ "@com_google_googletest//:gtest",
+ ],
+)
+
+cc_library(
+ name = "examine_stack",
+ srcs = [
+ "internal/examine_stack.cc",
+ ],
+ hdrs = [
+ "internal/examine_stack.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":stacktrace",
+ ":symbolize",
+ "//absl/base",
+ "//absl/base:core_headers",
+ ],
+)
+
+cc_library(
+ name = "failure_signal_handler",
+ srcs = ["failure_signal_handler.cc"],
+ hdrs = ["failure_signal_handler.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":examine_stack",
+ ":stacktrace",
+ "//absl/base",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ ],
+)
+
+cc_test(
+ name = "failure_signal_handler_test",
+ srcs = ["failure_signal_handler_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ linkopts = select({
+ "//absl:windows": [],
+ "//conditions:default": ["-pthread"],
+ }),
+ deps = [
+ ":failure_signal_handler",
+ ":stacktrace",
+ ":symbolize",
+ "//absl/base",
+ "//absl/strings",
+ "@com_google_googletest//:gtest",
+ ],
+)
+
+cc_library(
+ name = "debugging_internal",
+ srcs = [
+ "internal/address_is_readable.cc",
+ "internal/elf_mem_image.cc",
+ "internal/vdso_support.cc",
+ ],
+ hdrs = [
+ "internal/address_is_readable.h",
+ "internal/elf_mem_image.h",
+ "internal/stacktrace_aarch64-inl.inc",
+ "internal/stacktrace_arm-inl.inc",
+ "internal/stacktrace_config.h",
+ "internal/stacktrace_generic-inl.inc",
+ "internal/stacktrace_powerpc-inl.inc",
+ "internal/stacktrace_unimplemented-inl.inc",
+ "internal/stacktrace_win32-inl.inc",
+ "internal/stacktrace_x86-inl.inc",
+ "internal/vdso_support.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/base",
+ "//absl/base:dynamic_annotations",
+ ],
+)
+
+cc_library(
+ name = "demangle_internal",
+ srcs = ["internal/demangle.cc"],
+ hdrs = ["internal/demangle.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/base",
+ "//absl/base:core_headers",
+ ],
+)
+
+cc_test(
+ name = "demangle_test",
+ srcs = ["internal/demangle_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":demangle_internal",
+ ":stack_consumption",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "//absl/memory",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "leak_check",
+ srcs = select({
+ # The leak checking interface depends on weak function
+ # declarations that may not necessarily have definitions.
+ # Windows doesn't support this, and ios requires
+ # guaranteed definitions for weak symbols.
+ "//absl:ios": [],
+ "//absl:windows": [],
+ "//conditions:default": [
+ "leak_check.cc",
+ ],
+ }),
+ hdrs = select({
+ "//absl:ios": [],
+ "//absl:windows": [],
+ "//conditions:default": ["leak_check.h"],
+ }),
+ deps = ["//absl/base:core_headers"],
+)
+
+# Adding a dependency to leak_check_disable will disable
+# sanitizer leak checking (asan/lsan) in a test without
+# the need to mess around with build features.
+cc_library(
+ name = "leak_check_disable",
+ srcs = ["leak_check_disable.cc"],
+ linkstatic = 1,
+ alwayslink = 1,
+)
+
+# These targets exists for use in tests only, explicitly configuring the
+# LEAK_SANITIZER macro. It must be linked with -fsanitize=leak for lsan.
+ABSL_LSAN_LINKOPTS = select({
+ "//absl:llvm_compiler": ["-fsanitize=leak"],
+ "//conditions:default": [],
+})
+
+cc_library(
+ name = "leak_check_api_enabled_for_testing",
+ testonly = 1,
+ srcs = ["leak_check.cc"],
+ hdrs = ["leak_check.h"],
+ copts = select({
+ "//absl:llvm_compiler": ["-DLEAK_SANITIZER"],
+ "//conditions:default": [],
+ }),
+ visibility = ["//visibility:private"],
+)
+
+cc_library(
+ name = "leak_check_api_disabled_for_testing",
+ testonly = 1,
+ srcs = ["leak_check.cc"],
+ hdrs = ["leak_check.h"],
+ copts = ["-ULEAK_SANITIZER"],
+ visibility = ["//visibility:private"],
+)
+
+cc_test(
+ name = "leak_check_test",
+ srcs = ["leak_check_test.cc"],
+ copts = select({
+ "//absl:llvm_compiler": ["-DABSL_EXPECT_LEAK_SANITIZER"],
+ "//conditions:default": [],
+ }),
+ linkopts = ABSL_LSAN_LINKOPTS,
+ deps = [
+ ":leak_check_api_enabled_for_testing",
+ "//absl/base",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "leak_check_no_lsan_test",
+ srcs = ["leak_check_test.cc"],
+ copts = ["-UABSL_EXPECT_LEAK_SANITIZER"],
+ deps = [
+ ":leak_check_api_disabled_for_testing",
+ "//absl/base", # for raw_logging
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+# Test that leak checking is skipped when lsan is enabled but
+# ":leak_check_disable" is linked in.
+#
+# This test should fail in the absence of a dependency on ":leak_check_disable"
+cc_test(
+ name = "disabled_leak_check_test",
+ srcs = ["leak_check_fail_test.cc"],
+ linkopts = ABSL_LSAN_LINKOPTS,
+ deps = [
+ ":leak_check_api_enabled_for_testing",
+ ":leak_check_disable",
+ "//absl/base",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "stack_consumption",
+ testonly = 1,
+ srcs = ["internal/stack_consumption.cc"],
+ hdrs = ["internal/stack_consumption.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ "//absl/base",
+ "//absl/base:core_headers",
+ ],
+)
+
+cc_test(
+ name = "stack_consumption_test",
+ srcs = ["internal/stack_consumption_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":stack_consumption",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
[53/62] [abbrv] marmotta git commit: Remove some more unnecessary code
Posted by ja...@apache.org.
Remove some more unnecessary code
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/310ce408
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/310ce408
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/310ce408
Branch: refs/heads/master
Commit: 310ce40824c33a2286094cef7244892710f0df40
Parents: 1e9b2b1
Author: Sebastian Schaffert <ss...@apache.org>
Authored: Sun Apr 29 22:06:52 2018 +0200
Committer: Sebastian Schaffert <ss...@apache.org>
Committed: Sun Apr 29 22:06:52 2018 +0200
----------------------------------------------------------------------
libraries/ostrich/backend/ldpath/CMakeLists.txt | 6 -
.../ostrich/backend/ldpath/ldpath_model.cc | 26 --
libraries/ostrich/backend/ldpath/ldpath_model.h | 46 ---
libraries/ostrich/backend/ldpath/parser_base.cc | 5 -
libraries/ostrich/backend/ldpath/parser_base.h | 304 -------------------
5 files changed, 387 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/marmotta/blob/310ce408/libraries/ostrich/backend/ldpath/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/ldpath/CMakeLists.txt b/libraries/ostrich/backend/ldpath/CMakeLists.txt
deleted file mode 100644
index 65e33f7..0000000
--- a/libraries/ostrich/backend/ldpath/CMakeLists.txt
+++ /dev/null
@@ -1,6 +0,0 @@
-include_directories(.. ${CMAKE_CURRENT_BINARY_DIR}/..)
-
-add_library(marmotta_ldpath
- ldpath_model.h ldpath_model.cc
- parser_base.h parser_base.cc)
-target_link_libraries(marmotta_ldpath ${CMAKE_THREAD_LIBS_INIT})
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/marmotta/blob/310ce408/libraries/ostrich/backend/ldpath/ldpath_model.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/ldpath/ldpath_model.cc b/libraries/ostrich/backend/ldpath/ldpath_model.cc
deleted file mode 100644
index 17d7721..0000000
--- a/libraries/ostrich/backend/ldpath/ldpath_model.cc
+++ /dev/null
@@ -1,26 +0,0 @@
-//
-// Created by wastl on 15.02.16.
-//
-
-#include "ldpath_model.h"
-
-namespace marmotta {
-namespace ldpath {
-namespace model {
-
-std::vector<rdf::Value> PropertySelector::select(
- const RDFBackend *backend, const rdf::Value &context) const {
- return backend->listObjects(context, property);
-}
-
-std::string PropertySelector::getPathExpression() const {
- std::string s = "<";
- s += property.getUri();
- s += ">";
- return s;
-}
-
-}
-}
-}
-
http://git-wip-us.apache.org/repos/asf/marmotta/blob/310ce408/libraries/ostrich/backend/ldpath/ldpath_model.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/ldpath/ldpath_model.h b/libraries/ostrich/backend/ldpath/ldpath_model.h
deleted file mode 100644
index 6275033..0000000
--- a/libraries/ostrich/backend/ldpath/ldpath_model.h
+++ /dev/null
@@ -1,46 +0,0 @@
-//
-// Created by wastl on 15.02.16.
-//
-
-#ifndef MARMOTTA_LDPATH_MODEL_H
-#define MARMOTTA_LDPATH_MODEL_H
-
-#include <vector>
-#include <string>
-
-#include "model/rdf_model.h"
-
-namespace marmotta {
-namespace ldpath {
-namespace model {
-
-class RDFBackend {
- public:
- virtual std::vector<rdf::Value> listObjects(const rdf::Value& subject, const rdf::Value& property) const = 0;
-
- virtual std::vector<rdf::Value> listSubjects(const rdf::Value& property, const rdf::Value& object) const = 0;
-};
-
-
-class NodeSelector {
- public:
- virtual std::vector<rdf::Value> select(const RDFBackend* backend, const rdf::Value& context) const = 0;
-
- virtual std::string getPathExpression() const = 0;
-};
-
-class PropertySelector : public NodeSelector {
- public:
- PropertySelector(const rdf::URI& property) : property(property) {}
-
- std::vector<rdf::Value> select(const RDFBackend* backend, const rdf::Value& context) const override;
- std::string getPathExpression() const override;
-
- private:
- rdf::URI property;
-};
-}
-}
-}
-
-#endif //MARMOTTA_LDPATH_MODEL_H
http://git-wip-us.apache.org/repos/asf/marmotta/blob/310ce408/libraries/ostrich/backend/ldpath/parser_base.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/ldpath/parser_base.cc b/libraries/ostrich/backend/ldpath/parser_base.cc
deleted file mode 100644
index 089bcf4..0000000
--- a/libraries/ostrich/backend/ldpath/parser_base.cc
+++ /dev/null
@@ -1,5 +0,0 @@
-//
-// Created by wastl on 15.02.16.
-//
-
-#include "parser_base.h"
http://git-wip-us.apache.org/repos/asf/marmotta/blob/310ce408/libraries/ostrich/backend/ldpath/parser_base.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/ldpath/parser_base.h b/libraries/ostrich/backend/ldpath/parser_base.h
deleted file mode 100644
index ba415de..0000000
--- a/libraries/ostrich/backend/ldpath/parser_base.h
+++ /dev/null
@@ -1,304 +0,0 @@
-//
-// Created by wastl on 15.02.16.
-//
-
-#ifndef MARMOTTA_PARSER_BASE_H
-#define MARMOTTA_PARSER_BASE_H
-
-#include <utility>
-#include <map>
-#include <string>
-
-#include <model/rdf_model.h>
-
-namespace marmotta {
-namespace ldpath {
-namespace parser {
-
-template<Node>
-class LdPathParser<Node> {
-
- private:
- enum Mode { RULE, SELECTOR, TEST, PROGRAM, PREFIX };
-
- /**
- * A map mapping from namespace prefix to namespace URI
- */
- std::map<std::string,std::string> namespaces;
-
- Mode mode;
-
- public:
- LdPathParser(NodeBackend<Node> backend, Reader in) {
- this(backend,null,in);
- }
-
- public LdPathParser(NodeBackend<Node> backend, Configuration config, Reader in) {
- this(in);
- this.backend = backend;
- if(config == null) {
- this.config = new DefaultConfiguration();
- } else {
- this.config = config;
- }
-
- initialise();
- }
-
- public LdPathParser(NodeBackend<Node> backend, InputStream in) {
- this(backend,null,in);
- }
-
- public LdPathParser(NodeBackend<Node> backend, Configuration config, InputStream in) {
- this(in);
- this.backend = backend;
- if(config == null) {
- this.config = new DefaultConfiguration();
- } else {
- this.config = config;
- }
-
- initialise();
- }
-
- public LdPathParser(NodeBackend<Node> backend, InputStream in, String encoding) {
- this(backend,null,in,encoding);
- }
-
- public LdPathParser(NodeBackend<Node> backend, Configuration config, InputStream in, String encoding) {
- this(in,encoding);
- this.backend = backend;
- if(config == null) {
- this.config = new DefaultConfiguration();
- } else {
- this.config = config;
- }
-
- initialise();
- }
-
- public Program<Node> parseProgram() throws ParseException {
- namespaces.clear();
- namespaces.putAll(config.getNamespaces());
-
- mode = Mode.PROGRAM;
- try {
- return Program();
- } catch(TokenMgrError error){
- throw new ParseException("Unable to parse Program: (Message: "+error.getMessage()+")");
- }
- }
-
- public Entry<String, String> parsePrefix() throws ParseException {
- namespaces.clear();
- namespaces.putAll(config.getNamespaces());
- mode = Mode.PREFIX;
- try {
- return Namespace();
- } catch (TokenMgrError error) {
- throw new ParseException("Unable to parse Prefix: (Message: "+ error.getMessage()+")");
- }
- }
-
- public Map<String, String> parsePrefixes() throws ParseException {
- namespaces.clear();
- namespaces.putAll(config.getNamespaces());
- mode = Mode.PREFIX;
- try {
- return Namespaces();
- } catch (TokenMgrError error) {
- throw new ParseException("Unable to parse Prefixes: (Message: "+ error.getMessage()+")");
- }
- }
-
-
- public NodeSelector<Node> parseSelector(Map<String,String> ctxNamespaces) throws ParseException {
- namespaces.clear();
- namespaces.putAll(config.getNamespaces());
- if(ctxNamespaces != null) {
- namespaces.putAll(ctxNamespaces);
- }
-
- mode = Mode.SELECTOR;
-
- try {
- return Selector();
- } catch(TokenMgrError error){
- throw new ParseException("Unable to parse Selector: (Message: "+error.getMessage()+")");
- }
- }
-
- public NodeTest<Node> parseTest(Map<String, String> ctxNamespaces) throws ParseException {
- namespaces.clear();
- namespaces.putAll(config.getNamespaces());
- if (ctxNamespaces != null) {
- namespaces.putAll(ctxNamespaces);
- }
- mode = Mode.TEST;
- try {
- return NodeTest();
- } catch (TokenMgrError error) {
- throw new ParseException("Unable to parse Test: (Message: "+ error.getMessage()+")");
- }
- }
-
- public <T> FieldMapping<T,Node> parseRule(Map<String,String> ctxNamespaces) throws ParseException {
- namespaces.clear();
- namespaces.putAll(config.getNamespaces());
- if(ctxNamespaces != null) {
- namespaces.putAll(ctxNamespaces);
- }
-
- mode = Mode.RULE;
-
- try {
- return Rule();
- } catch(TokenMgrError error){
- throw new ParseException("Unable to parse Rule: (Message: "+error.getMessage()+")");
- }
- }
-
- public Node resolveURI(URI uri) {
- return backend.createURI(uri.toString());
- }
-
- public Node resolveResource(String uri) throws ParseException {
- return backend.createURI(uri);
- }
-
- public Node resolveResource(String prefix, String local) throws ParseException {
- return resolveResource(resolveNamespace(prefix)+local);
- }
-
-
- public String resolveNamespace(String prefix) throws ParseException {
- String uri = namespaces.get(prefix);
- if(uri == null) {
- throw new ParseException("Namespace "+prefix+" not defined!");
- }
- return uri;
- }
-
-
- public SelectorFunction<Node> getFunction(String uri) throws ParseException {
- if(xsdNodeFunctionMap.get(uri) != null) {
- return xsdNodeFunctionMap.get(uri);
- } else {
- throw new ParseException("function with URI "+uri+" does not exist");
- }
- }
-
- public TestFunction<Node> getTestFunction(String uri) throws ParseException {
- if (xsdNodeTestMap.get(uri) != null) {
- return xsdNodeTestMap.get(uri);
- } else {
- throw new ParseException("test function with URI "+uri+" does not exist");
- }
- }
-
- public NodeTransformer<?,Node> getTransformer(URI type) throws ParseException {
- return getTransformer(type.toString());
- }
-
- public NodeTransformer<?,Node> getTransformer(Node node) throws ParseException {
- return getTransformer(backend.stringValue(node));
- }
-
- public NodeTransformer<?,Node> getTransformer(String uri) throws ParseException {
- if(xsdNodeTransformerMap.get(uri) != null) {
- return xsdNodeTransformerMap.get(uri);
- } else {
- throw new ParseException("transformer with URI "+uri+" does not exist");
- }
- }
-
-
- private void initialise() {
- initTransformerMappings();
- initFunctionMappings();
- }
-
- /**
- * Register the function passed as argument in this parser's function map.
- */
- public void registerFunction(SelectorFunction<Node> function) {
- registerFunction(xsdNodeFunctionMap,function);
- }
-
- public void registerFunction(TestFunction<Node> test) {
- registerTest(xsdNodeTestMap, test);
- }
-
- /**
- * Register the result transformer passed as argument for the given type uri.
- */
- public void registerTransformer(String typeUri, NodeTransformer<?,Node> transformer) {
- xsdNodeTransformerMap.put(typeUri,transformer);
- }
-
-
- /**
- * A map mapping from XSD types to node transformers.
- */
- private Map<String, NodeTransformer<?,Node>> xsdNodeTransformerMap;
- private void initTransformerMappings() {
- Map<String, NodeTransformer<?,Node>> transformerMap = new HashMap<String, NodeTransformer<?,Node>>();
-
- transformerMap.putAll(config.getTransformers());
-
- xsdNodeTransformerMap = transformerMap;
- }
-
-
- private Map<String, SelectorFunction<Node>> xsdNodeFunctionMap;
- private Map<String, TestFunction<Node>> xsdNodeTestMap;
- private void initFunctionMappings() {
- Map<String, SelectorFunction<Node>> functionMap = new HashMap<String, SelectorFunction<Node>>();
-
- functionMap.putAll(config.getFunctions());
-
- xsdNodeFunctionMap = functionMap;
-
- Map<String, TestFunction<Node>> testMap = new HashMap<String, TestFunction<Node>>();
- testMap.putAll(config.getTestFunctions());
- xsdNodeTestMap = testMap;
- }
-
- private void registerFunction(Map<String, SelectorFunction<Node>> register, final SelectorFunction<Node> function) {
- register.put(NS_LMF_FUNCS + function.getPathExpression(backend), function);
- }
-
- private void registerTest(Map<String, TestFunction<Node>> register, final TestFunction<Node> test) {
- register.put(NS_LMF_FUNCS + test.getLocalName(), test);
- }
-
- private class Namespace implements Entry<String, String> {
- private String key, val;
- public Namespace(String key, String val) {
- this.key = key;
- this.val = val;
- }
- @Override
- public String getKey() {
- return key;
- }
- @Override
- public String getValue() {
- return val;
- }
- @Override
- public String setValue(String value) {
- String oV = val;
- val = value;
- return oV;
- }
- }
-
-}
-
-}
-}
-}
-
-
-#endif //MARMOTTA_PARSER_BASE_H
[34/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/meta/type_traits_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/meta/type_traits_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/meta/type_traits_test.cc
new file mode 100644
index 0000000..c44d1c5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/meta/type_traits_test.cc
@@ -0,0 +1,799 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/meta/type_traits.h"
+
+#include <cstdint>
+#include <string>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+using ::testing::StaticAssertTypeEq;
+
+template <class T, class U>
+struct simple_pair {
+ T first;
+ U second;
+};
+
+struct Dummy {};
+
+TEST(VoidTTest, BasicUsage) {
+ StaticAssertTypeEq<void, absl::void_t<Dummy>>();
+ StaticAssertTypeEq<void, absl::void_t<Dummy, Dummy, Dummy>>();
+}
+
+TEST(ConjunctionTest, BasicBooleanLogic) {
+ EXPECT_TRUE(absl::conjunction<>::value);
+ EXPECT_TRUE(absl::conjunction<std::true_type>::value);
+ EXPECT_TRUE((absl::conjunction<std::true_type, std::true_type>::value));
+ EXPECT_FALSE((absl::conjunction<std::true_type, std::false_type>::value));
+ EXPECT_FALSE((absl::conjunction<std::false_type, std::true_type>::value));
+ EXPECT_FALSE((absl::conjunction<std::false_type, std::false_type>::value));
+}
+
+struct MyTrueType {
+ static constexpr bool value = true;
+};
+
+struct MyFalseType {
+ static constexpr bool value = false;
+};
+
+TEST(ConjunctionTest, ShortCircuiting) {
+ EXPECT_FALSE(
+ (absl::conjunction<std::true_type, std::false_type, Dummy>::value));
+ EXPECT_TRUE((std::is_base_of<MyFalseType,
+ absl::conjunction<std::true_type, MyFalseType,
+ std::false_type>>::value));
+ EXPECT_TRUE(
+ (std::is_base_of<MyTrueType,
+ absl::conjunction<std::true_type, MyTrueType>>::value));
+}
+
+TEST(DisjunctionTest, BasicBooleanLogic) {
+ EXPECT_FALSE(absl::disjunction<>::value);
+ EXPECT_FALSE(absl::disjunction<std::false_type>::value);
+ EXPECT_TRUE((absl::disjunction<std::true_type, std::true_type>::value));
+ EXPECT_TRUE((absl::disjunction<std::true_type, std::false_type>::value));
+ EXPECT_TRUE((absl::disjunction<std::false_type, std::true_type>::value));
+ EXPECT_FALSE((absl::disjunction<std::false_type, std::false_type>::value));
+}
+
+TEST(DisjunctionTest, ShortCircuiting) {
+ EXPECT_TRUE(
+ (absl::disjunction<std::false_type, std::true_type, Dummy>::value));
+ EXPECT_TRUE((
+ std::is_base_of<MyTrueType, absl::disjunction<std::false_type, MyTrueType,
+ std::true_type>>::value));
+ EXPECT_TRUE((
+ std::is_base_of<MyFalseType,
+ absl::disjunction<std::false_type, MyFalseType>>::value));
+}
+
+TEST(NegationTest, BasicBooleanLogic) {
+ EXPECT_FALSE(absl::negation<std::true_type>::value);
+ EXPECT_FALSE(absl::negation<MyTrueType>::value);
+ EXPECT_TRUE(absl::negation<std::false_type>::value);
+ EXPECT_TRUE(absl::negation<MyFalseType>::value);
+}
+
+// all member functions are trivial
+class Trivial {
+ int n_;
+};
+
+struct TrivialDestructor {
+ ~TrivialDestructor() = default;
+};
+
+struct NontrivialDestructor {
+ ~NontrivialDestructor() {}
+};
+
+struct DeletedDestructor {
+ ~DeletedDestructor() = delete;
+};
+
+class TrivialDefaultCtor {
+ public:
+ TrivialDefaultCtor() = default;
+ explicit TrivialDefaultCtor(int n) : n_(n) {}
+
+ private:
+ int n_;
+};
+
+class NontrivialDefaultCtor {
+ public:
+ NontrivialDefaultCtor() : n_(1) {}
+
+ private:
+ int n_;
+};
+
+class DeletedDefaultCtor {
+ public:
+ DeletedDefaultCtor() = delete;
+ explicit DeletedDefaultCtor(int n) : n_(n) {}
+
+ private:
+ int n_;
+};
+
+class TrivialCopyCtor {
+ public:
+ explicit TrivialCopyCtor(int n) : n_(n) {}
+ TrivialCopyCtor(const TrivialCopyCtor&) = default;
+ TrivialCopyCtor& operator=(const TrivialCopyCtor& t) {
+ n_ = t.n_;
+ return *this;
+ }
+
+ private:
+ int n_;
+};
+
+class NontrivialCopyCtor {
+ public:
+ explicit NontrivialCopyCtor(int n) : n_(n) {}
+ NontrivialCopyCtor(const NontrivialCopyCtor& t) : n_(t.n_) {}
+ NontrivialCopyCtor& operator=(const NontrivialCopyCtor&) = default;
+
+ private:
+ int n_;
+};
+
+class DeletedCopyCtor {
+ public:
+ explicit DeletedCopyCtor(int n) : n_(n) {}
+ DeletedCopyCtor(const DeletedCopyCtor&) = delete;
+ DeletedCopyCtor& operator=(const DeletedCopyCtor&) = default;
+
+ private:
+ int n_;
+};
+
+class TrivialCopyAssign {
+ public:
+ explicit TrivialCopyAssign(int n) : n_(n) {}
+ TrivialCopyAssign(const TrivialCopyAssign& t) : n_(t.n_) {}
+ TrivialCopyAssign& operator=(const TrivialCopyAssign& t) = default;
+ ~TrivialCopyAssign() {} // can have nontrivial destructor
+ private:
+ int n_;
+};
+
+class NontrivialCopyAssign {
+ public:
+ explicit NontrivialCopyAssign(int n) : n_(n) {}
+ NontrivialCopyAssign(const NontrivialCopyAssign&) = default;
+ NontrivialCopyAssign& operator=(const NontrivialCopyAssign& t) {
+ n_ = t.n_;
+ return *this;
+ }
+
+ private:
+ int n_;
+};
+
+class DeletedCopyAssign {
+ public:
+ explicit DeletedCopyAssign(int n) : n_(n) {}
+ DeletedCopyAssign(const DeletedCopyAssign&) = default;
+ DeletedCopyAssign& operator=(const DeletedCopyAssign&) = delete;
+
+ private:
+ int n_;
+};
+
+struct NonCopyable {
+ NonCopyable() = default;
+ NonCopyable(const NonCopyable&) = delete;
+ NonCopyable& operator=(const NonCopyable&) = delete;
+};
+
+class Base {
+ public:
+ virtual ~Base() {}
+};
+
+// In GCC/Clang, std::is_trivially_constructible requires that the destructor is
+// trivial. However, MSVC doesn't require that. This results in different
+// behavior when checking is_trivially_constructible on any type with
+// nontrivial destructor. Since absl::is_trivially_default_constructible and
+// absl::is_trivially_copy_constructible both follows Clang/GCC's interpretation
+// and check is_trivially_destructible, it results in inconsistency with
+// std::is_trivially_xxx_constructible on MSVC. This macro is used to work
+// around this issue in test. In practice, a trivially constructible type
+// should also be trivially destructible.
+// GCC bug 51452: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452
+// LWG issue 2116: http://cplusplus.github.io/LWG/lwg-active.html#2116
+#ifndef _MSC_VER
+#define ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE 1
+#endif
+
+// Old versions of libc++, around Clang 3.5 to 3.6, consider deleted destructors
+// as also being trivial. With the resolution of CWG 1928 and CWG 1734, this
+// is no longer considered true and has thus been amended.
+// Compiler Explorer: https://godbolt.org/g/zT59ZL
+// CWG issue 1734: http://open-std.org/JTC1/SC22/WG21/docs/cwg_defects.html#1734
+// CWG issue 1928: http://open-std.org/JTC1/SC22/WG21/docs/cwg_closed.html#1928
+#if !defined(_LIBCPP_VERSION) || _LIBCPP_VERSION >= 3700
+#define ABSL_TRIVIALLY_DESTRUCTIBLE_CONSIDER_DELETED_DESTRUCTOR_NOT_TRIVIAL 1
+#endif
+
+// As of the moment, GCC versions >5.1 have a problem compiling for
+// std::is_trivially_default_constructible<NontrivialDestructor[10]>, where
+// NontrivialDestructor is a struct with a custom nontrivial destructor. Note
+// that this problem only occurs for arrays of a known size, so something like
+// std::is_trivially_default_constructible<NontrivialDestructor[]> does not
+// have any problems.
+// Compiler Explorer: https://godbolt.org/g/dXRbdK
+// GCC bug 83689: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=83689
+#if defined(__clang__) || defined(_MSC_VER) || \
+ (defined(__GNUC__) && __GNUC__ < 5)
+#define ABSL_GCC_BUG_TRIVIALLY_CONSTRUCTIBLE_ON_ARRAY_OF_NONTRIVIAL 1
+#endif
+
+TEST(TypeTraitsTest, TestTrivialDestructor) {
+ // Verify that arithmetic types and pointers have trivial destructors.
+ EXPECT_TRUE(absl::is_trivially_destructible<bool>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<char>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<unsigned char>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<signed char>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<wchar_t>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<int>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<unsigned int>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<int16_t>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<uint16_t>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<int64_t>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<uint64_t>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<float>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<double>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<long double>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<std::string*>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<Trivial*>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<const std::string*>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<const Trivial*>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<std::string**>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<Trivial**>::value);
+
+ // classes with destructors
+ EXPECT_TRUE(absl::is_trivially_destructible<Trivial>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<TrivialDestructor>::value);
+
+ // Verify that types with a nontrivial or deleted destructor
+ // are marked as such.
+ EXPECT_FALSE(absl::is_trivially_destructible<NontrivialDestructor>::value);
+#ifdef ABSL_TRIVIALLY_DESTRUCTIBLE_CONSIDER_DELETED_DESTRUCTOR_NOT_TRIVIAL
+ EXPECT_FALSE(absl::is_trivially_destructible<DeletedDestructor>::value);
+#endif
+
+ // simple_pair of such types is trivial
+ EXPECT_TRUE((absl::is_trivially_destructible<simple_pair<int, int>>::value));
+ EXPECT_TRUE((absl::is_trivially_destructible<
+ simple_pair<Trivial, TrivialDestructor>>::value));
+
+ // Verify that types without trivial destructors are correctly marked as such.
+ EXPECT_FALSE(absl::is_trivially_destructible<std::string>::value);
+ EXPECT_FALSE(absl::is_trivially_destructible<std::vector<int>>::value);
+
+ // Verify that simple_pairs of types without trivial destructors
+ // are not marked as trivial.
+ EXPECT_FALSE((absl::is_trivially_destructible<
+ simple_pair<int, std::string>>::value));
+ EXPECT_FALSE((absl::is_trivially_destructible<
+ simple_pair<std::string, int>>::value));
+
+ // array of such types is trivial
+ using int10 = int[10];
+ EXPECT_TRUE(absl::is_trivially_destructible<int10>::value);
+ using Trivial10 = Trivial[10];
+ EXPECT_TRUE(absl::is_trivially_destructible<Trivial10>::value);
+ using TrivialDestructor10 = TrivialDestructor[10];
+ EXPECT_TRUE(absl::is_trivially_destructible<TrivialDestructor10>::value);
+
+ // Conversely, the opposite also holds.
+ using NontrivialDestructor10 = NontrivialDestructor[10];
+ EXPECT_FALSE(absl::is_trivially_destructible<NontrivialDestructor10>::value);
+}
+
+TEST(TypeTraitsTest, TestTrivialDefaultCtor) {
+ // arithmetic types and pointers have trivial default constructors.
+ EXPECT_TRUE(absl::is_trivially_default_constructible<bool>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<char>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<unsigned char>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<signed char>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<wchar_t>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<int>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<unsigned int>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<int16_t>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<uint16_t>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<int64_t>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<uint64_t>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<float>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<double>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<long double>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<std::string*>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial*>::value);
+ EXPECT_TRUE(
+ absl::is_trivially_default_constructible<const std::string*>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<const Trivial*>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<std::string**>::value);
+ EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial**>::value);
+
+ // types with compiler generated default ctors
+ EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial>::value);
+ EXPECT_TRUE(
+ absl::is_trivially_default_constructible<TrivialDefaultCtor>::value);
+
+ // Verify that types without them are not.
+ EXPECT_FALSE(
+ absl::is_trivially_default_constructible<NontrivialDefaultCtor>::value);
+ EXPECT_FALSE(
+ absl::is_trivially_default_constructible<DeletedDefaultCtor>::value);
+
+#ifdef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE
+ // types with nontrivial destructor are nontrivial
+ EXPECT_FALSE(
+ absl::is_trivially_default_constructible<NontrivialDestructor>::value);
+#endif
+
+ // types with vtables
+ EXPECT_FALSE(absl::is_trivially_default_constructible<Base>::value);
+
+ // Verify that simple_pair has trivial constructors where applicable.
+ EXPECT_TRUE((absl::is_trivially_default_constructible<
+ simple_pair<int, char*>>::value));
+ EXPECT_TRUE((absl::is_trivially_default_constructible<
+ simple_pair<int, Trivial>>::value));
+ EXPECT_TRUE((absl::is_trivially_default_constructible<
+ simple_pair<int, TrivialDefaultCtor>>::value));
+
+ // Verify that types without trivial constructors are
+ // correctly marked as such.
+ EXPECT_FALSE(absl::is_trivially_default_constructible<std::string>::value);
+ EXPECT_FALSE(
+ absl::is_trivially_default_constructible<std::vector<int>>::value);
+
+ // Verify that simple_pairs of types without trivial constructors
+ // are not marked as trivial.
+ EXPECT_FALSE((absl::is_trivially_default_constructible<
+ simple_pair<int, std::string>>::value));
+ EXPECT_FALSE((absl::is_trivially_default_constructible<
+ simple_pair<std::string, int>>::value));
+
+ // Verify that arrays of such types are trivially default constructible
+ using int10 = int[10];
+ EXPECT_TRUE(absl::is_trivially_default_constructible<int10>::value);
+ using Trivial10 = Trivial[10];
+ EXPECT_TRUE(absl::is_trivially_default_constructible<Trivial10>::value);
+ using TrivialDefaultCtor10 = TrivialDefaultCtor[10];
+ EXPECT_TRUE(
+ absl::is_trivially_default_constructible<TrivialDefaultCtor10>::value);
+
+ // Conversely, the opposite also holds.
+#ifdef ABSL_GCC_BUG_TRIVIALLY_CONSTRUCTIBLE_ON_ARRAY_OF_NONTRIVIAL
+ using NontrivialDefaultCtor10 = NontrivialDefaultCtor[10];
+ EXPECT_FALSE(
+ absl::is_trivially_default_constructible<NontrivialDefaultCtor10>::value);
+#endif
+}
+
+TEST(TypeTraitsTest, TestTrivialCopyCtor) {
+ // Verify that arithmetic types and pointers have trivial copy
+ // constructors.
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<bool>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<char>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<unsigned char>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<signed char>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<wchar_t>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<int>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<unsigned int>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<int16_t>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<uint16_t>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<int64_t>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<uint64_t>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<float>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<double>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<long double>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<std::string*>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<Trivial*>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<const std::string*>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<const Trivial*>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<std::string**>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<Trivial**>::value);
+
+ // types with compiler generated copy ctors
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<Trivial>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<TrivialCopyCtor>::value);
+
+ // Verify that types without them (i.e. nontrivial or deleted) are not.
+ EXPECT_FALSE(
+ absl::is_trivially_copy_constructible<NontrivialCopyCtor>::value);
+ EXPECT_FALSE(absl::is_trivially_copy_constructible<DeletedCopyCtor>::value);
+ EXPECT_FALSE(
+ absl::is_trivially_copy_constructible<NonCopyable>::value);
+
+#ifdef ABSL_TRIVIALLY_CONSTRUCTIBLE_VERIFY_TRIVIALLY_DESTRUCTIBLE
+ // type with nontrivial destructor are nontrivial copy construbtible
+ EXPECT_FALSE(
+ absl::is_trivially_copy_constructible<NontrivialDestructor>::value);
+#endif
+
+ // types with vtables
+ EXPECT_FALSE(absl::is_trivially_copy_constructible<Base>::value);
+
+ // Verify that simple_pair of such types is trivially copy constructible
+ EXPECT_TRUE(
+ (absl::is_trivially_copy_constructible<simple_pair<int, char*>>::value));
+ EXPECT_TRUE((
+ absl::is_trivially_copy_constructible<simple_pair<int, Trivial>>::value));
+ EXPECT_TRUE((absl::is_trivially_copy_constructible<
+ simple_pair<int, TrivialCopyCtor>>::value));
+
+ // Verify that types without trivial copy constructors are
+ // correctly marked as such.
+ EXPECT_FALSE(absl::is_trivially_copy_constructible<std::string>::value);
+ EXPECT_FALSE(absl::is_trivially_copy_constructible<std::vector<int>>::value);
+
+ // Verify that simple_pairs of types without trivial copy constructors
+ // are not marked as trivial.
+ EXPECT_FALSE((absl::is_trivially_copy_constructible<
+ simple_pair<int, std::string>>::value));
+ EXPECT_FALSE((absl::is_trivially_copy_constructible<
+ simple_pair<std::string, int>>::value));
+
+ // Verify that arrays are not
+ using int10 = int[10];
+ EXPECT_FALSE(absl::is_trivially_copy_constructible<int10>::value);
+}
+
+TEST(TypeTraitsTest, TestTrivialCopyAssign) {
+ // Verify that arithmetic types and pointers have trivial copy
+ // assignment operators.
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<bool>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<char>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<unsigned char>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<signed char>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<wchar_t>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<int>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<unsigned int>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<int16_t>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<uint16_t>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<int64_t>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<uint64_t>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<float>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<double>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<long double>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<std::string*>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial*>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<const std::string*>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<const Trivial*>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<std::string**>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial**>::value);
+
+ // const qualified types are not assignable
+ EXPECT_FALSE(absl::is_trivially_copy_assignable<const int>::value);
+
+ // types with compiler generated copy assignment
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<Trivial>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<TrivialCopyAssign>::value);
+
+ // Verify that types without them (i.e. nontrivial or deleted) are not.
+ EXPECT_FALSE(absl::is_trivially_copy_assignable<NontrivialCopyAssign>::value);
+ EXPECT_FALSE(absl::is_trivially_copy_assignable<DeletedCopyAssign>::value);
+ EXPECT_FALSE(absl::is_trivially_copy_assignable<NonCopyable>::value);
+
+ // types with vtables
+ EXPECT_FALSE(absl::is_trivially_copy_assignable<Base>::value);
+
+ // Verify that simple_pair is trivially assignable
+ EXPECT_TRUE(
+ (absl::is_trivially_copy_assignable<simple_pair<int, char*>>::value));
+ EXPECT_TRUE(
+ (absl::is_trivially_copy_assignable<simple_pair<int, Trivial>>::value));
+ EXPECT_TRUE((absl::is_trivially_copy_assignable<
+ simple_pair<int, TrivialCopyAssign>>::value));
+
+ // Verify that types not trivially copy assignable are
+ // correctly marked as such.
+ EXPECT_FALSE(absl::is_trivially_copy_assignable<std::string>::value);
+ EXPECT_FALSE(absl::is_trivially_copy_assignable<std::vector<int>>::value);
+
+ // Verify that simple_pairs of types not trivially copy assignable
+ // are not marked as trivial.
+ EXPECT_FALSE((absl::is_trivially_copy_assignable<
+ simple_pair<int, std::string>>::value));
+ EXPECT_FALSE((absl::is_trivially_copy_assignable<
+ simple_pair<std::string, int>>::value));
+
+ // Verify that arrays are not trivially copy assignable
+ using int10 = int[10];
+ EXPECT_FALSE(absl::is_trivially_copy_assignable<int10>::value);
+}
+
+#define ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(trait_name, ...) \
+ EXPECT_TRUE((std::is_same<typename std::trait_name<__VA_ARGS__>::type, \
+ absl::trait_name##_t<__VA_ARGS__>>::value))
+
+TEST(TypeTraitsTest, TestRemoveCVAliases) {
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, const int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_cv, const volatile int);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, const int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_const, const volatile int);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, const int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_volatile, const volatile int);
+}
+
+TEST(TypeTraitsTest, TestAddCVAliases) {
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, const int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_cv, const volatile int);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, const int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_const, const volatile int);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, const int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_volatile, const volatile int);
+}
+
+TEST(TypeTraitsTest, TestReferenceAliases) {
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, volatile int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, int&&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_reference, volatile int&&);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, volatile int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, int&&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_lvalue_reference, volatile int&&);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, volatile int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, int&&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_rvalue_reference, volatile int&&);
+}
+
+TEST(TypeTraitsTest, TestPointerAliases) {
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_pointer, int*);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_pointer, volatile int*);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_pointer, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(add_pointer, volatile int);
+}
+
+TEST(TypeTraitsTest, TestSignednessAliases) {
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, unsigned);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_signed, volatile unsigned);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, unsigned);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(make_unsigned, volatile unsigned);
+}
+
+TEST(TypeTraitsTest, TestExtentAliases) {
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[]);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[1]);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[1][1]);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_extent, int[][1]);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[]);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[1]);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[1][1]);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(remove_all_extents, int[][1]);
+}
+
+TEST(TypeTraitsTest, TestAlignedStorageAlias) {
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 1);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 2);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 3);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 4);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 5);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 6);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 7);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 8);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 9);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 10);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 11);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 12);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 13);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 14);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 15);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 16);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 17);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 18);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 19);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 20);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 21);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 22);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 23);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 24);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 25);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 26);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 27);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 28);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 29);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 30);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 31);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 32);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 33);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 1, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 2, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 3, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 4, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 5, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 6, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 7, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 8, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 9, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 10, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 11, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 12, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 13, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 14, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 15, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 16, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 17, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 18, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 19, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 20, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 21, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 22, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 23, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 24, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 25, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 26, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 27, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 28, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 29, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 30, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 31, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 32, 128);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(aligned_storage, 33, 128);
+}
+
+TEST(TypeTraitsTest, TestDecay) {
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, volatile int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const volatile int);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, volatile int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const volatile int&);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, volatile int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, const volatile int&);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int[1]);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int[1][1]);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int[][1]);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int());
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int(float));
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(decay, int(char, ...));
+}
+
+struct TypeA {};
+struct TypeB {};
+struct TypeC {};
+struct TypeD {};
+
+template <typename T>
+struct Wrap {};
+
+enum class TypeEnum { A, B, C, D };
+
+struct GetTypeT {
+ template <typename T,
+ absl::enable_if_t<std::is_same<T, TypeA>::value, int> = 0>
+ TypeEnum operator()(Wrap<T>) const {
+ return TypeEnum::A;
+ }
+
+ template <typename T,
+ absl::enable_if_t<std::is_same<T, TypeB>::value, int> = 0>
+ TypeEnum operator()(Wrap<T>) const {
+ return TypeEnum::B;
+ }
+
+ template <typename T,
+ absl::enable_if_t<std::is_same<T, TypeC>::value, int> = 0>
+ TypeEnum operator()(Wrap<T>) const {
+ return TypeEnum::C;
+ }
+
+ // NOTE: TypeD is intentionally not handled
+} constexpr GetType = {};
+
+TEST(TypeTraitsTest, TestEnableIf) {
+ EXPECT_EQ(TypeEnum::A, GetType(Wrap<TypeA>()));
+ EXPECT_EQ(TypeEnum::B, GetType(Wrap<TypeB>()));
+ EXPECT_EQ(TypeEnum::C, GetType(Wrap<TypeC>()));
+}
+
+TEST(TypeTraitsTest, TestConditional) {
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(conditional, true, int, char);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(conditional, false, int, char);
+}
+
+// TODO(calabrese) Check with specialized std::common_type
+TEST(TypeTraitsTest, TestCommonType) {
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char, int);
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char&);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(common_type, int, char, int&);
+}
+
+TEST(TypeTraitsTest, TestUnderlyingType) {
+ enum class enum_char : char {};
+ enum class enum_long_long : long long {}; // NOLINT(runtime/int)
+
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(underlying_type, enum_char);
+ ABSL_INTERNAL_EXPECT_ALIAS_EQUIVALENCE(underlying_type, enum_long_long);
+}
+
+struct GetTypeExtT {
+ template <typename T>
+ absl::result_of_t<const GetTypeT&(T)> operator()(T&& arg) const {
+ return GetType(std::forward<T>(arg));
+ }
+
+ TypeEnum operator()(Wrap<TypeD>) const { return TypeEnum::D; }
+} constexpr GetTypeExt = {};
+
+TEST(TypeTraitsTest, TestResultOf) {
+ EXPECT_EQ(TypeEnum::A, GetTypeExt(Wrap<TypeA>()));
+ EXPECT_EQ(TypeEnum::B, GetTypeExt(Wrap<TypeB>()));
+ EXPECT_EQ(TypeEnum::C, GetTypeExt(Wrap<TypeC>()));
+ EXPECT_EQ(TypeEnum::D, GetTypeExt(Wrap<TypeD>()));
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/BUILD.bazel
new file mode 100644
index 0000000..4a24a87
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/BUILD.bazel
@@ -0,0 +1,41 @@
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "int128",
+ srcs = [
+ "int128.cc",
+ "int128_have_intrinsic.inc",
+ "int128_no_intrinsic.inc",
+ ],
+ hdrs = ["int128.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ ],
+)
+
+cc_test(
+ name = "int128_test",
+ size = "small",
+ srcs = [
+ "int128_stream_test.cc",
+ "int128_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":int128",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "//absl/meta:type_traits",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/CMakeLists.txt
new file mode 100644
index 0000000..3360b2e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/CMakeLists.txt
@@ -0,0 +1,62 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+list(APPEND NUMERIC_PUBLIC_HEADERS
+ "int128.h"
+)
+
+
+# library 128
+list(APPEND INT128_SRC
+ "int128.cc"
+ ${NUMERIC_PUBLIC_HEADERS}
+)
+absl_library(
+ TARGET
+ absl_int128
+ SOURCES
+ ${INT128_SRC}
+ PUBLIC_LIBRARIES
+ ${INT128_PUBLIC_LIBRARIES}
+ EXPORT_NAME
+ int128
+)
+
+
+absl_header_library(
+ TARGET
+ absl_numeric
+ PUBLIC_LIBRARIES
+ absl::int128
+ EXPORT_NAME
+ numeric
+)
+
+# test int128_test
+set(INT128_TEST_SRC "int128_test.cc")
+set(INT128_TEST_PUBLIC_LIBRARIES absl::numeric absl::base)
+
+absl_test(
+ TARGET
+ int128_test
+ SOURCES
+ ${INT128_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${INT128_TEST_PUBLIC_LIBRARIES}
+)
+
+
+
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128.cc
new file mode 100644
index 0000000..3688e5e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128.cc
@@ -0,0 +1,225 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/numeric/int128.h"
+
+#include <stddef.h>
+#include <cassert>
+#include <iomanip>
+#include <iostream> // NOLINT(readability/streams)
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+namespace absl {
+
+const uint128 kuint128max = MakeUint128(std::numeric_limits<uint64_t>::max(),
+ std::numeric_limits<uint64_t>::max());
+
+namespace {
+
+// Returns the 0-based position of the last set bit (i.e., most significant bit)
+// in the given uint64_t. The argument may not be 0.
+//
+// For example:
+// Given: 5 (decimal) == 101 (binary)
+// Returns: 2
+#define STEP(T, n, pos, sh) \
+ do { \
+ if ((n) >= (static_cast<T>(1) << (sh))) { \
+ (n) = (n) >> (sh); \
+ (pos) |= (sh); \
+ } \
+ } while (0)
+static inline int Fls64(uint64_t n) {
+ assert(n != 0);
+ int pos = 0;
+ STEP(uint64_t, n, pos, 0x20);
+ uint32_t n32 = static_cast<uint32_t>(n);
+ STEP(uint32_t, n32, pos, 0x10);
+ STEP(uint32_t, n32, pos, 0x08);
+ STEP(uint32_t, n32, pos, 0x04);
+ return pos + ((uint64_t{0x3333333322221100} >> (n32 << 2)) & 0x3);
+}
+#undef STEP
+
+// Like Fls64() above, but returns the 0-based position of the last set bit
+// (i.e., most significant bit) in the given uint128. The argument may not be 0.
+static inline int Fls128(uint128 n) {
+ if (uint64_t hi = Uint128High64(n)) {
+ return Fls64(hi) + 64;
+ }
+ return Fls64(Uint128Low64(n));
+}
+
+// Long division/modulo for uint128 implemented using the shift-subtract
+// division algorithm adapted from:
+// http://stackoverflow.com/questions/5386377/division-without-using
+void DivModImpl(uint128 dividend, uint128 divisor, uint128* quotient_ret,
+ uint128* remainder_ret) {
+ assert(divisor != 0);
+
+ if (divisor > dividend) {
+ *quotient_ret = 0;
+ *remainder_ret = dividend;
+ return;
+ }
+
+ if (divisor == dividend) {
+ *quotient_ret = 1;
+ *remainder_ret = 0;
+ return;
+ }
+
+ uint128 denominator = divisor;
+ uint128 quotient = 0;
+
+ // Left aligns the MSB of the denominator and the dividend.
+ const int shift = Fls128(dividend) - Fls128(denominator);
+ denominator <<= shift;
+
+ // Uses shift-subtract algorithm to divide dividend by denominator. The
+ // remainder will be left in dividend.
+ for (int i = 0; i <= shift; ++i) {
+ quotient <<= 1;
+ if (dividend >= denominator) {
+ dividend -= denominator;
+ quotient |= 1;
+ }
+ denominator >>= 1;
+ }
+
+ *quotient_ret = quotient;
+ *remainder_ret = dividend;
+}
+
+template <typename T>
+uint128 MakeUint128FromFloat(T v) {
+ static_assert(std::is_floating_point<T>::value, "");
+
+ // Rounding behavior is towards zero, same as for built-in types.
+
+ // Undefined behavior if v is NaN or cannot fit into uint128.
+ assert(std::isfinite(v) && v > -1 &&
+ (std::numeric_limits<T>::max_exponent <= 128 ||
+ v < std::ldexp(static_cast<T>(1), 128)));
+
+ if (v >= std::ldexp(static_cast<T>(1), 64)) {
+ uint64_t hi = static_cast<uint64_t>(std::ldexp(v, -64));
+ uint64_t lo = static_cast<uint64_t>(v - std::ldexp(static_cast<T>(hi), 64));
+ return MakeUint128(hi, lo);
+ }
+
+ return MakeUint128(0, static_cast<uint64_t>(v));
+}
+} // namespace
+
+uint128::uint128(float v) : uint128(MakeUint128FromFloat(v)) {}
+uint128::uint128(double v) : uint128(MakeUint128FromFloat(v)) {}
+uint128::uint128(long double v) : uint128(MakeUint128FromFloat(v)) {}
+
+uint128 operator/(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+ return static_cast<unsigned __int128>(lhs) /
+ static_cast<unsigned __int128>(rhs);
+#else // ABSL_HAVE_INTRINSIC_INT128
+ uint128 quotient = 0;
+ uint128 remainder = 0;
+ DivModImpl(lhs, rhs, "ient, &remainder);
+ return quotient;
+#endif // ABSL_HAVE_INTRINSIC_INT128
+}
+uint128 operator%(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+ return static_cast<unsigned __int128>(lhs) %
+ static_cast<unsigned __int128>(rhs);
+#else // ABSL_HAVE_INTRINSIC_INT128
+ uint128 quotient = 0;
+ uint128 remainder = 0;
+ DivModImpl(lhs, rhs, "ient, &remainder);
+ return remainder;
+#endif // ABSL_HAVE_INTRINSIC_INT128
+}
+
+namespace {
+
+std::string Uint128ToFormattedString(uint128 v, std::ios_base::fmtflags flags) {
+ // Select a divisor which is the largest power of the base < 2^64.
+ uint128 div;
+ int div_base_log;
+ switch (flags & std::ios::basefield) {
+ case std::ios::hex:
+ div = 0x1000000000000000; // 16^15
+ div_base_log = 15;
+ break;
+ case std::ios::oct:
+ div = 01000000000000000000000; // 8^21
+ div_base_log = 21;
+ break;
+ default: // std::ios::dec
+ div = 10000000000000000000u; // 10^19
+ div_base_log = 19;
+ break;
+ }
+
+ // Now piece together the uint128 representation from three chunks of the
+ // original value, each less than "div" and therefore representable as a
+ // uint64_t.
+ std::ostringstream os;
+ std::ios_base::fmtflags copy_mask =
+ std::ios::basefield | std::ios::showbase | std::ios::uppercase;
+ os.setf(flags & copy_mask, copy_mask);
+ uint128 high = v;
+ uint128 low;
+ DivModImpl(high, div, &high, &low);
+ uint128 mid;
+ DivModImpl(high, div, &high, &mid);
+ if (Uint128Low64(high) != 0) {
+ os << Uint128Low64(high);
+ os << std::noshowbase << std::setfill('0') << std::setw(div_base_log);
+ os << Uint128Low64(mid);
+ os << std::setw(div_base_log);
+ } else if (Uint128Low64(mid) != 0) {
+ os << Uint128Low64(mid);
+ os << std::noshowbase << std::setfill('0') << std::setw(div_base_log);
+ }
+ os << Uint128Low64(low);
+ return os.str();
+}
+
+} // namespace
+
+std::ostream& operator<<(std::ostream& os, uint128 v) {
+ std::ios_base::fmtflags flags = os.flags();
+ std::string rep = Uint128ToFormattedString(v, flags);
+
+ // Add the requisite padding.
+ std::streamsize width = os.width(0);
+ if (static_cast<size_t>(width) > rep.size()) {
+ std::ios::fmtflags adjustfield = flags & std::ios::adjustfield;
+ if (adjustfield == std::ios::left) {
+ rep.append(width - rep.size(), os.fill());
+ } else if (adjustfield == std::ios::internal &&
+ (flags & std::ios::showbase) &&
+ (flags & std::ios::basefield) == std::ios::hex && v != 0) {
+ rep.insert(2, width - rep.size(), os.fill());
+ } else {
+ rep.insert(0, width - rep.size(), os.fill());
+ }
+ }
+
+ return os << rep;
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128.h b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128.h
new file mode 100644
index 0000000..bc7dbb4
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128.h
@@ -0,0 +1,656 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: int128.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines 128-bit integer types.
+//
+// Currently, this file defines `uint128`, an unsigned 128-bit integer; a signed
+// 128-bit integer is forthcoming.
+
+#ifndef ABSL_NUMERIC_INT128_H_
+#define ABSL_NUMERIC_INT128_H_
+
+#include <cassert>
+#include <cmath>
+#include <cstdint>
+#include <cstring>
+#include <iosfwd>
+#include <limits>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+
+namespace absl {
+
+
+// uint128
+//
+// An unsigned 128-bit integer type. The API is meant to mimic an intrinsic type
+// as closely as is practical, including exhibiting undefined behavior in
+// analogous cases (e.g. division by zero). This type is intended to be a
+// drop-in replacement once C++ supports an intrinsic `uint128_t` type; when
+// that occurs, existing well-behaved uses of `uint128` will continue to work
+// using that new type.
+//
+// Note: code written with this type will continue to compile once `uint128_t`
+// is introduced, provided the replacement helper functions
+// `Uint128(Low|High)64()` and `MakeUint128()` are made.
+//
+// A `uint128` supports the following:
+//
+// * Implicit construction from integral types
+// * Explicit conversion to integral types
+//
+// Additionally, if your compiler supports `__int128`, `uint128` is
+// interoperable with that type. (Abseil checks for this compatibility through
+// the `ABSL_HAVE_INTRINSIC_INT128` macro.)
+//
+// However, a `uint128` differs from intrinsic integral types in the following
+// ways:
+//
+// * Errors on implicit conversions that do not preserve value (such as
+// loss of precision when converting to float values).
+// * Requires explicit construction from and conversion to floating point
+// types.
+// * Conversion to integral types requires an explicit static_cast() to
+// mimic use of the `-Wnarrowing` compiler flag.
+// * The alignment requirement of `uint128` may differ from that of an
+// intrinsic 128-bit integer type depending on platform and build
+// configuration.
+//
+// Example:
+//
+// float y = absl::Uint128Max(); // Error. uint128 cannot be implicitly
+// // converted to float.
+//
+// absl::uint128 v;
+// uint64_t i = v; // Error
+// uint64_t i = static_cast<uint64_t>(v); // OK
+//
+class
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+ alignas(unsigned __int128)
+#endif // ABSL_HAVE_INTRINSIC_INT128
+ uint128 {
+ public:
+ uint128() = default;
+
+ // Constructors from arithmetic types
+ constexpr uint128(int v); // NOLINT(runtime/explicit)
+ constexpr uint128(unsigned int v); // NOLINT(runtime/explicit)
+ constexpr uint128(long v); // NOLINT(runtime/int)
+ constexpr uint128(unsigned long v); // NOLINT(runtime/int)
+ constexpr uint128(long long v); // NOLINT(runtime/int)
+ constexpr uint128(unsigned long long v); // NOLINT(runtime/int)
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+ constexpr uint128(__int128 v); // NOLINT(runtime/explicit)
+ constexpr uint128(unsigned __int128 v); // NOLINT(runtime/explicit)
+#endif // ABSL_HAVE_INTRINSIC_INT128
+ explicit uint128(float v);
+ explicit uint128(double v);
+ explicit uint128(long double v);
+
+ // Assignment operators from arithmetic types
+ uint128& operator=(int v);
+ uint128& operator=(unsigned int v);
+ uint128& operator=(long v); // NOLINT(runtime/int)
+ uint128& operator=(unsigned long v); // NOLINT(runtime/int)
+ uint128& operator=(long long v); // NOLINT(runtime/int)
+ uint128& operator=(unsigned long long v); // NOLINT(runtime/int)
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+ uint128& operator=(__int128 v);
+ uint128& operator=(unsigned __int128 v);
+#endif // ABSL_HAVE_INTRINSIC_INT128
+
+ // Conversion operators to other arithmetic types
+ constexpr explicit operator bool() const;
+ constexpr explicit operator char() const;
+ constexpr explicit operator signed char() const;
+ constexpr explicit operator unsigned char() const;
+ constexpr explicit operator char16_t() const;
+ constexpr explicit operator char32_t() const;
+ constexpr explicit operator wchar_t() const;
+ constexpr explicit operator short() const; // NOLINT(runtime/int)
+ // NOLINTNEXTLINE(runtime/int)
+ constexpr explicit operator unsigned short() const;
+ constexpr explicit operator int() const;
+ constexpr explicit operator unsigned int() const;
+ constexpr explicit operator long() const; // NOLINT(runtime/int)
+ // NOLINTNEXTLINE(runtime/int)
+ constexpr explicit operator unsigned long() const;
+ // NOLINTNEXTLINE(runtime/int)
+ constexpr explicit operator long long() const;
+ // NOLINTNEXTLINE(runtime/int)
+ constexpr explicit operator unsigned long long() const;
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+ constexpr explicit operator __int128() const;
+ constexpr explicit operator unsigned __int128() const;
+#endif // ABSL_HAVE_INTRINSIC_INT128
+ explicit operator float() const;
+ explicit operator double() const;
+ explicit operator long double() const;
+
+ // Trivial copy constructor, assignment operator and destructor.
+
+ // Arithmetic operators.
+ uint128& operator+=(uint128 other);
+ uint128& operator-=(uint128 other);
+ uint128& operator*=(uint128 other);
+ // Long division/modulo for uint128.
+ uint128& operator/=(uint128 other);
+ uint128& operator%=(uint128 other);
+ uint128 operator++(int);
+ uint128 operator--(int);
+ uint128& operator<<=(int);
+ uint128& operator>>=(int);
+ uint128& operator&=(uint128 other);
+ uint128& operator|=(uint128 other);
+ uint128& operator^=(uint128 other);
+ uint128& operator++();
+ uint128& operator--();
+
+ // Uint128Low64()
+ //
+ // Returns the lower 64-bit value of a `uint128` value.
+ friend constexpr uint64_t Uint128Low64(uint128 v);
+
+ // Uint128High64()
+ //
+ // Returns the higher 64-bit value of a `uint128` value.
+ friend constexpr uint64_t Uint128High64(uint128 v);
+
+ // MakeUInt128()
+ //
+ // Constructs a `uint128` numeric value from two 64-bit unsigned integers.
+ // Note that this factory function is the only way to construct a `uint128`
+ // from integer values greater than 2^64.
+ //
+ // Example:
+ //
+ // absl::uint128 big = absl::MakeUint128(1, 0);
+ friend constexpr uint128 MakeUint128(uint64_t high, uint64_t low);
+
+ // Uint128Max()
+ //
+ // Returns the highest value for a 128-bit unsigned integer.
+ friend constexpr uint128 Uint128Max();
+
+ private:
+ constexpr uint128(uint64_t high, uint64_t low);
+
+ // TODO(strel) Update implementation to use __int128 once all users of
+ // uint128 are fixed to not depend on alignof(uint128) == 8. Also add
+ // alignas(16) to class definition to keep alignment consistent across
+ // platforms.
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+ uint64_t lo_;
+ uint64_t hi_;
+#elif defined(ABSL_IS_BIG_ENDIAN)
+ uint64_t hi_;
+ uint64_t lo_;
+#else // byte order
+#error "Unsupported byte order: must be little-endian or big-endian."
+#endif // byte order
+};
+
+// Prefer to use the constexpr `Uint128Max()`.
+//
+// TODO(absl-team) deprecate kuint128max once migration tool is released.
+extern const uint128 kuint128max;
+
+// allow uint128 to be logged
+std::ostream& operator<<(std::ostream& os, uint128 v);
+
+// TODO(strel) add operator>>(std::istream&, uint128)
+
+// TODO(absl-team): Implement signed 128-bit type
+
+// --------------------------------------------------------------------------
+// Implementation details follow
+// --------------------------------------------------------------------------
+
+constexpr uint128 MakeUint128(uint64_t high, uint64_t low) {
+ return uint128(high, low);
+}
+
+constexpr uint128 Uint128Max() {
+ return uint128(std::numeric_limits<uint64_t>::max(),
+ std::numeric_limits<uint64_t>::max());
+}
+
+// Assignment from integer types.
+
+inline uint128& uint128::operator=(int v) { return *this = uint128(v); }
+
+inline uint128& uint128::operator=(unsigned int v) {
+ return *this = uint128(v);
+}
+
+inline uint128& uint128::operator=(long v) { // NOLINT(runtime/int)
+ return *this = uint128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline uint128& uint128::operator=(unsigned long v) {
+ return *this = uint128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline uint128& uint128::operator=(long long v) {
+ return *this = uint128(v);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+inline uint128& uint128::operator=(unsigned long long v) {
+ return *this = uint128(v);
+}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+inline uint128& uint128::operator=(__int128 v) {
+ return *this = uint128(v);
+}
+
+inline uint128& uint128::operator=(unsigned __int128 v) {
+ return *this = uint128(v);
+}
+#endif // ABSL_HAVE_INTRINSIC_INT128
+
+// Arithmetic operators.
+
+uint128 operator<<(uint128 lhs, int amount);
+uint128 operator>>(uint128 lhs, int amount);
+uint128 operator+(uint128 lhs, uint128 rhs);
+uint128 operator-(uint128 lhs, uint128 rhs);
+uint128 operator*(uint128 lhs, uint128 rhs);
+uint128 operator/(uint128 lhs, uint128 rhs);
+uint128 operator%(uint128 lhs, uint128 rhs);
+
+inline uint128& uint128::operator<<=(int amount) {
+ *this = *this << amount;
+ return *this;
+}
+
+inline uint128& uint128::operator>>=(int amount) {
+ *this = *this >> amount;
+ return *this;
+}
+
+inline uint128& uint128::operator+=(uint128 other) {
+ *this = *this + other;
+ return *this;
+}
+
+inline uint128& uint128::operator-=(uint128 other) {
+ *this = *this - other;
+ return *this;
+}
+
+inline uint128& uint128::operator*=(uint128 other) {
+ *this = *this * other;
+ return *this;
+}
+
+inline uint128& uint128::operator/=(uint128 other) {
+ *this = *this / other;
+ return *this;
+}
+
+inline uint128& uint128::operator%=(uint128 other) {
+ *this = *this % other;
+ return *this;
+}
+
+constexpr uint64_t Uint128Low64(uint128 v) { return v.lo_; }
+
+constexpr uint64_t Uint128High64(uint128 v) { return v.hi_; }
+
+// Constructors from integer types.
+
+#if defined(ABSL_IS_LITTLE_ENDIAN)
+
+constexpr uint128::uint128(uint64_t high, uint64_t low)
+ : lo_{low}, hi_{high} {}
+
+constexpr uint128::uint128(int v)
+ : lo_{static_cast<uint64_t>(v)},
+ hi_{v < 0 ? std::numeric_limits<uint64_t>::max() : 0} {}
+constexpr uint128::uint128(long v) // NOLINT(runtime/int)
+ : lo_{static_cast<uint64_t>(v)},
+ hi_{v < 0 ? std::numeric_limits<uint64_t>::max() : 0} {}
+constexpr uint128::uint128(long long v) // NOLINT(runtime/int)
+ : lo_{static_cast<uint64_t>(v)},
+ hi_{v < 0 ? std::numeric_limits<uint64_t>::max() : 0} {}
+
+constexpr uint128::uint128(unsigned int v) : lo_{v}, hi_{0} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long v) : lo_{v}, hi_{0} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long long v) : lo_{v}, hi_{0} {}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+constexpr uint128::uint128(__int128 v)
+ : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
+ hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)} {}
+constexpr uint128::uint128(unsigned __int128 v)
+ : lo_{static_cast<uint64_t>(v & ~uint64_t{0})},
+ hi_{static_cast<uint64_t>(v >> 64)} {}
+#endif // ABSL_HAVE_INTRINSIC_INT128
+
+#elif defined(ABSL_IS_BIG_ENDIAN)
+
+constexpr uint128::uint128(uint64_t high, uint64_t low)
+ : hi_{high}, lo_{low} {}
+
+constexpr uint128::uint128(int v)
+ : hi_{v < 0 ? std::numeric_limits<uint64_t>::max() : 0},
+ lo_{static_cast<uint64_t>(v)} {}
+constexpr uint128::uint128(long v) // NOLINT(runtime/int)
+ : hi_{v < 0 ? std::numeric_limits<uint64_t>::max() : 0},
+ lo_{static_cast<uint64_t>(v)} {}
+constexpr uint128::uint128(long long v) // NOLINT(runtime/int)
+ : hi_{v < 0 ? std::numeric_limits<uint64_t>::max() : 0},
+ lo_{static_cast<uint64_t>(v)} {}
+
+constexpr uint128::uint128(unsigned int v) : hi_{0}, lo_{v} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long v) : hi_{0}, lo_{v} {}
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::uint128(unsigned long long v) : hi_{0}, lo_{v} {}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+constexpr uint128::uint128(__int128 v)
+ : hi_{static_cast<uint64_t>(static_cast<unsigned __int128>(v) >> 64)},
+ lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
+constexpr uint128::uint128(unsigned __int128 v)
+ : hi_{static_cast<uint64_t>(v >> 64)},
+ lo_{static_cast<uint64_t>(v & ~uint64_t{0})} {}
+#endif // ABSL_HAVE_INTRINSIC_INT128
+
+#else // byte order
+#error "Unsupported byte order: must be little-endian or big-endian."
+#endif // byte order
+
+// Conversion operators to integer types.
+
+constexpr uint128::operator bool() const { return lo_ || hi_; }
+
+constexpr uint128::operator char() const { return static_cast<char>(lo_); }
+
+constexpr uint128::operator signed char() const {
+ return static_cast<signed char>(lo_);
+}
+
+constexpr uint128::operator unsigned char() const {
+ return static_cast<unsigned char>(lo_);
+}
+
+constexpr uint128::operator char16_t() const {
+ return static_cast<char16_t>(lo_);
+}
+
+constexpr uint128::operator char32_t() const {
+ return static_cast<char32_t>(lo_);
+}
+
+constexpr uint128::operator wchar_t() const {
+ return static_cast<wchar_t>(lo_);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::operator short() const { return static_cast<short>(lo_); }
+
+constexpr uint128::operator unsigned short() const { // NOLINT(runtime/int)
+ return static_cast<unsigned short>(lo_); // NOLINT(runtime/int)
+}
+
+constexpr uint128::operator int() const { return static_cast<int>(lo_); }
+
+constexpr uint128::operator unsigned int() const {
+ return static_cast<unsigned int>(lo_);
+}
+
+// NOLINTNEXTLINE(runtime/int)
+constexpr uint128::operator long() const { return static_cast<long>(lo_); }
+
+constexpr uint128::operator unsigned long() const { // NOLINT(runtime/int)
+ return static_cast<unsigned long>(lo_); // NOLINT(runtime/int)
+}
+
+constexpr uint128::operator long long() const { // NOLINT(runtime/int)
+ return static_cast<long long>(lo_); // NOLINT(runtime/int)
+}
+
+constexpr uint128::operator unsigned long long() const { // NOLINT(runtime/int)
+ return static_cast<unsigned long long>(lo_); // NOLINT(runtime/int)
+}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+constexpr uint128::operator __int128() const {
+ return (static_cast<__int128>(hi_) << 64) + lo_;
+}
+
+constexpr uint128::operator unsigned __int128() const {
+ return (static_cast<unsigned __int128>(hi_) << 64) + lo_;
+}
+#endif // ABSL_HAVE_INTRINSIC_INT128
+
+// Conversion operators to floating point types.
+
+inline uint128::operator float() const {
+ return static_cast<float>(lo_) + std::ldexp(static_cast<float>(hi_), 64);
+}
+
+inline uint128::operator double() const {
+ return static_cast<double>(lo_) + std::ldexp(static_cast<double>(hi_), 64);
+}
+
+inline uint128::operator long double() const {
+ return static_cast<long double>(lo_) +
+ std::ldexp(static_cast<long double>(hi_), 64);
+}
+
+// Comparison operators.
+
+inline bool operator==(uint128 lhs, uint128 rhs) {
+ return (Uint128Low64(lhs) == Uint128Low64(rhs) &&
+ Uint128High64(lhs) == Uint128High64(rhs));
+}
+
+inline bool operator!=(uint128 lhs, uint128 rhs) {
+ return !(lhs == rhs);
+}
+
+inline bool operator<(uint128 lhs, uint128 rhs) {
+ return (Uint128High64(lhs) == Uint128High64(rhs))
+ ? (Uint128Low64(lhs) < Uint128Low64(rhs))
+ : (Uint128High64(lhs) < Uint128High64(rhs));
+}
+
+inline bool operator>(uint128 lhs, uint128 rhs) {
+ return (Uint128High64(lhs) == Uint128High64(rhs))
+ ? (Uint128Low64(lhs) > Uint128Low64(rhs))
+ : (Uint128High64(lhs) > Uint128High64(rhs));
+}
+
+inline bool operator<=(uint128 lhs, uint128 rhs) {
+ return (Uint128High64(lhs) == Uint128High64(rhs))
+ ? (Uint128Low64(lhs) <= Uint128Low64(rhs))
+ : (Uint128High64(lhs) <= Uint128High64(rhs));
+}
+
+inline bool operator>=(uint128 lhs, uint128 rhs) {
+ return (Uint128High64(lhs) == Uint128High64(rhs))
+ ? (Uint128Low64(lhs) >= Uint128Low64(rhs))
+ : (Uint128High64(lhs) >= Uint128High64(rhs));
+}
+
+// Unary operators.
+
+inline uint128 operator-(uint128 val) {
+ uint64_t hi = ~Uint128High64(val);
+ uint64_t lo = ~Uint128Low64(val) + 1;
+ if (lo == 0) ++hi; // carry
+ return MakeUint128(hi, lo);
+}
+
+inline bool operator!(uint128 val) {
+ return !Uint128High64(val) && !Uint128Low64(val);
+}
+
+// Logical operators.
+
+inline uint128 operator~(uint128 val) {
+ return MakeUint128(~Uint128High64(val), ~Uint128Low64(val));
+}
+
+inline uint128 operator|(uint128 lhs, uint128 rhs) {
+ return MakeUint128(Uint128High64(lhs) | Uint128High64(rhs),
+ Uint128Low64(lhs) | Uint128Low64(rhs));
+}
+
+inline uint128 operator&(uint128 lhs, uint128 rhs) {
+ return MakeUint128(Uint128High64(lhs) & Uint128High64(rhs),
+ Uint128Low64(lhs) & Uint128Low64(rhs));
+}
+
+inline uint128 operator^(uint128 lhs, uint128 rhs) {
+ return MakeUint128(Uint128High64(lhs) ^ Uint128High64(rhs),
+ Uint128Low64(lhs) ^ Uint128Low64(rhs));
+}
+
+inline uint128& uint128::operator|=(uint128 other) {
+ hi_ |= other.hi_;
+ lo_ |= other.lo_;
+ return *this;
+}
+
+inline uint128& uint128::operator&=(uint128 other) {
+ hi_ &= other.hi_;
+ lo_ &= other.lo_;
+ return *this;
+}
+
+inline uint128& uint128::operator^=(uint128 other) {
+ hi_ ^= other.hi_;
+ lo_ ^= other.lo_;
+ return *this;
+}
+
+// Arithmetic operators.
+
+inline uint128 operator<<(uint128 lhs, int amount) {
+ // uint64_t shifts of >= 64 are undefined, so we will need some
+ // special-casing.
+ if (amount < 64) {
+ if (amount != 0) {
+ return MakeUint128(
+ (Uint128High64(lhs) << amount) | (Uint128Low64(lhs) >> (64 - amount)),
+ Uint128Low64(lhs) << amount);
+ }
+ return lhs;
+ }
+ return MakeUint128(Uint128Low64(lhs) << (amount - 64), 0);
+}
+
+inline uint128 operator>>(uint128 lhs, int amount) {
+ // uint64_t shifts of >= 64 are undefined, so we will need some
+ // special-casing.
+ if (amount < 64) {
+ if (amount != 0) {
+ return MakeUint128(Uint128High64(lhs) >> amount,
+ (Uint128Low64(lhs) >> amount) |
+ (Uint128High64(lhs) << (64 - amount)));
+ }
+ return lhs;
+ }
+ return MakeUint128(0, Uint128High64(lhs) >> (amount - 64));
+}
+
+inline uint128 operator+(uint128 lhs, uint128 rhs) {
+ uint128 result = MakeUint128(Uint128High64(lhs) + Uint128High64(rhs),
+ Uint128Low64(lhs) + Uint128Low64(rhs));
+ if (Uint128Low64(result) < Uint128Low64(lhs)) { // check for carry
+ return MakeUint128(Uint128High64(result) + 1, Uint128Low64(result));
+ }
+ return result;
+}
+
+inline uint128 operator-(uint128 lhs, uint128 rhs) {
+ uint128 result = MakeUint128(Uint128High64(lhs) - Uint128High64(rhs),
+ Uint128Low64(lhs) - Uint128Low64(rhs));
+ if (Uint128Low64(lhs) < Uint128Low64(rhs)) { // check for carry
+ return MakeUint128(Uint128High64(result) - 1, Uint128Low64(result));
+ }
+ return result;
+}
+
+inline uint128 operator*(uint128 lhs, uint128 rhs) {
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+ // TODO(strel) Remove once alignment issues are resolved and unsigned __int128
+ // can be used for uint128 storage.
+ return static_cast<unsigned __int128>(lhs) *
+ static_cast<unsigned __int128>(rhs);
+#else // ABSL_HAVE_INTRINSIC128
+ uint64_t a32 = Uint128Low64(lhs) >> 32;
+ uint64_t a00 = Uint128Low64(lhs) & 0xffffffff;
+ uint64_t b32 = Uint128Low64(rhs) >> 32;
+ uint64_t b00 = Uint128Low64(rhs) & 0xffffffff;
+ uint128 result =
+ MakeUint128(Uint128High64(lhs) * Uint128Low64(rhs) +
+ Uint128Low64(lhs) * Uint128High64(rhs) + a32 * b32,
+ a00 * b00);
+ result += uint128(a32 * b00) << 32;
+ result += uint128(a00 * b32) << 32;
+ return result;
+#endif // ABSL_HAVE_INTRINSIC128
+}
+
+// Increment/decrement operators.
+
+inline uint128 uint128::operator++(int) {
+ uint128 tmp(*this);
+ *this += 1;
+ return tmp;
+}
+
+inline uint128 uint128::operator--(int) {
+ uint128 tmp(*this);
+ *this -= 1;
+ return tmp;
+}
+
+inline uint128& uint128::operator++() {
+ *this += 1;
+ return *this;
+}
+
+inline uint128& uint128::operator--() {
+ *this -= 1;
+ return *this;
+}
+
+#if defined(ABSL_HAVE_INTRINSIC_INT128)
+#include "absl/numeric/int128_have_intrinsic.inc"
+#else // ABSL_HAVE_INTRINSIC_INT128
+#include "absl/numeric/int128_no_intrinsic.inc"
+#endif // ABSL_HAVE_INTRINSIC_INT128
+
+} // namespace absl
+
+#endif // ABSL_NUMERIC_INT128_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_have_intrinsic.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_have_intrinsic.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_have_intrinsic.inc
new file mode 100644
index 0000000..ee2a093
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_have_intrinsic.inc
@@ -0,0 +1,18 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains :int128 implementation details that depend on internal
+// representation when ABSL_HAVE_INTRINSIC_INT128 is defined. This file is
+// included by int128.h.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_no_intrinsic.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_no_intrinsic.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_no_intrinsic.inc
new file mode 100644
index 0000000..0d0b3cf
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_no_intrinsic.inc
@@ -0,0 +1,18 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains :int128 implementation details that depend on internal
+// representation when ABSL_HAVE_INTRINSIC_INT128 is *not* defined. This file
+// is included by int128.h.
[26/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view_test.cc
new file mode 100644
index 0000000..bb149d5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/string_view_test.cc
@@ -0,0 +1,1136 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/string_view.h"
+
+#include <stdlib.h>
+#include <iomanip>
+#include <iterator>
+#include <limits>
+#include <map>
+#include <sstream>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/base/dynamic_annotations.h"
+
+namespace {
+
+// A minimal allocator that uses malloc().
+template <typename T>
+struct Mallocator {
+ typedef T value_type;
+ typedef size_t size_type;
+ typedef ptrdiff_t difference_type;
+ typedef T* pointer;
+ typedef const T* const_pointer;
+ typedef T& reference;
+ typedef const T& const_reference;
+
+ size_type max_size() const {
+ return size_t(std::numeric_limits<size_type>::max()) / sizeof(value_type);
+ }
+ template <typename U>
+ struct rebind {
+ typedef Mallocator<U> other;
+ };
+ Mallocator() = default;
+ template <class U>
+ Mallocator(const Mallocator<U>&) {} // NOLINT(runtime/explicit)
+
+ T* allocate(size_t n) { return static_cast<T*>(std::malloc(n * sizeof(T))); }
+ void deallocate(T* p, size_t) { std::free(p); }
+};
+template <typename T, typename U>
+bool operator==(const Mallocator<T>&, const Mallocator<U>&) {
+ return true;
+}
+template <typename T, typename U>
+bool operator!=(const Mallocator<T>&, const Mallocator<U>&) {
+ return false;
+}
+
+TEST(StringViewTest, Ctor) {
+ {
+ // Null.
+ absl::string_view s10;
+ EXPECT_TRUE(s10.data() == nullptr);
+ EXPECT_EQ(0, s10.length());
+ }
+
+ {
+ // const char* without length.
+ const char* hello = "hello";
+ absl::string_view s20(hello);
+ EXPECT_TRUE(s20.data() == hello);
+ EXPECT_EQ(5, s20.length());
+
+ // const char* with length.
+ absl::string_view s21(hello, 4);
+ EXPECT_TRUE(s21.data() == hello);
+ EXPECT_EQ(4, s21.length());
+
+ // Not recommended, but valid C++
+ absl::string_view s22(hello, 6);
+ EXPECT_TRUE(s22.data() == hello);
+ EXPECT_EQ(6, s22.length());
+ }
+
+ {
+ // std::string.
+ std::string hola = "hola";
+ absl::string_view s30(hola);
+ EXPECT_TRUE(s30.data() == hola.data());
+ EXPECT_EQ(4, s30.length());
+
+ // std::string with embedded '\0'.
+ hola.push_back('\0');
+ hola.append("h2");
+ hola.push_back('\0');
+ absl::string_view s31(hola);
+ EXPECT_TRUE(s31.data() == hola.data());
+ EXPECT_EQ(8, s31.length());
+ }
+
+ {
+ using mstring =
+ std::basic_string<char, std::char_traits<char>, Mallocator<char>>;
+ mstring str1("BUNGIE-JUMPING!");
+ const mstring str2("SLEEPING!");
+
+ absl::string_view s1(str1);
+ s1.remove_prefix(strlen("BUNGIE-JUM"));
+
+ absl::string_view s2(str2);
+ s2.remove_prefix(strlen("SLEE"));
+
+ EXPECT_EQ(s1, s2);
+ EXPECT_EQ(s1, "PING!");
+ }
+
+ // TODO(mec): absl::string_view(const absl::string_view&);
+}
+
+TEST(StringViewTest, Swap) {
+ absl::string_view a("a");
+ absl::string_view b("bbb");
+ EXPECT_TRUE(noexcept(a.swap(b)));
+ a.swap(b);
+ EXPECT_EQ(a, "bbb");
+ EXPECT_EQ(b, "a");
+ a.swap(b);
+ EXPECT_EQ(a, "a");
+ EXPECT_EQ(b, "bbb");
+}
+
+TEST(StringViewTest, STLComparator) {
+ std::string s1("foo");
+ std::string s2("bar");
+ std::string s3("baz");
+
+ absl::string_view p1(s1);
+ absl::string_view p2(s2);
+ absl::string_view p3(s3);
+
+ typedef std::map<absl::string_view, int> TestMap;
+ TestMap map;
+
+ map.insert(std::make_pair(p1, 0));
+ map.insert(std::make_pair(p2, 1));
+ map.insert(std::make_pair(p3, 2));
+ EXPECT_EQ(map.size(), 3);
+
+ TestMap::const_iterator iter = map.begin();
+ EXPECT_EQ(iter->second, 1);
+ ++iter;
+ EXPECT_EQ(iter->second, 2);
+ ++iter;
+ EXPECT_EQ(iter->second, 0);
+ ++iter;
+ EXPECT_TRUE(iter == map.end());
+
+ TestMap::iterator new_iter = map.find("zot");
+ EXPECT_TRUE(new_iter == map.end());
+
+ new_iter = map.find("bar");
+ EXPECT_TRUE(new_iter != map.end());
+
+ map.erase(new_iter);
+ EXPECT_EQ(map.size(), 2);
+
+ iter = map.begin();
+ EXPECT_EQ(iter->second, 2);
+ ++iter;
+ EXPECT_EQ(iter->second, 0);
+ ++iter;
+ EXPECT_TRUE(iter == map.end());
+}
+
+#define COMPARE(result, op, x, y) \
+ EXPECT_EQ(result, absl::string_view((x)) op absl::string_view((y))); \
+ EXPECT_EQ(result, absl::string_view((x)).compare(absl::string_view((y))) op 0)
+
+TEST(StringViewTest, ComparisonOperators) {
+ COMPARE(true, ==, "", "");
+ COMPARE(true, ==, "", absl::string_view());
+ COMPARE(true, ==, absl::string_view(), "");
+ COMPARE(true, ==, "a", "a");
+ COMPARE(true, ==, "aa", "aa");
+ COMPARE(false, ==, "a", "");
+ COMPARE(false, ==, "", "a");
+ COMPARE(false, ==, "a", "b");
+ COMPARE(false, ==, "a", "aa");
+ COMPARE(false, ==, "aa", "a");
+
+ COMPARE(false, !=, "", "");
+ COMPARE(false, !=, "a", "a");
+ COMPARE(false, !=, "aa", "aa");
+ COMPARE(true, !=, "a", "");
+ COMPARE(true, !=, "", "a");
+ COMPARE(true, !=, "a", "b");
+ COMPARE(true, !=, "a", "aa");
+ COMPARE(true, !=, "aa", "a");
+
+ COMPARE(true, <, "a", "b");
+ COMPARE(true, <, "a", "aa");
+ COMPARE(true, <, "aa", "b");
+ COMPARE(true, <, "aa", "bb");
+ COMPARE(false, <, "a", "a");
+ COMPARE(false, <, "b", "a");
+ COMPARE(false, <, "aa", "a");
+ COMPARE(false, <, "b", "aa");
+ COMPARE(false, <, "bb", "aa");
+
+ COMPARE(true, <=, "a", "a");
+ COMPARE(true, <=, "a", "b");
+ COMPARE(true, <=, "a", "aa");
+ COMPARE(true, <=, "aa", "b");
+ COMPARE(true, <=, "aa", "bb");
+ COMPARE(false, <=, "b", "a");
+ COMPARE(false, <=, "aa", "a");
+ COMPARE(false, <=, "b", "aa");
+ COMPARE(false, <=, "bb", "aa");
+
+ COMPARE(false, >=, "a", "b");
+ COMPARE(false, >=, "a", "aa");
+ COMPARE(false, >=, "aa", "b");
+ COMPARE(false, >=, "aa", "bb");
+ COMPARE(true, >=, "a", "a");
+ COMPARE(true, >=, "b", "a");
+ COMPARE(true, >=, "aa", "a");
+ COMPARE(true, >=, "b", "aa");
+ COMPARE(true, >=, "bb", "aa");
+
+ COMPARE(false, >, "a", "a");
+ COMPARE(false, >, "a", "b");
+ COMPARE(false, >, "a", "aa");
+ COMPARE(false, >, "aa", "b");
+ COMPARE(false, >, "aa", "bb");
+ COMPARE(true, >, "b", "a");
+ COMPARE(true, >, "aa", "a");
+ COMPARE(true, >, "b", "aa");
+ COMPARE(true, >, "bb", "aa");
+}
+
+TEST(StringViewTest, ComparisonOperatorsByCharacterPosition) {
+ std::string x;
+ for (int i = 0; i < 256; i++) {
+ x += 'a';
+ std::string y = x;
+ COMPARE(true, ==, x, y);
+ for (int j = 0; j < i; j++) {
+ std::string z = x;
+ z[j] = 'b'; // Differs in position 'j'
+ COMPARE(false, ==, x, z);
+ COMPARE(true, <, x, z);
+ COMPARE(true, >, z, x);
+ if (j + 1 < i) {
+ z[j + 1] = 'A'; // Differs in position 'j+1' as well
+ COMPARE(false, ==, x, z);
+ COMPARE(true, <, x, z);
+ COMPARE(true, >, z, x);
+ z[j + 1] = 'z'; // Differs in position 'j+1' as well
+ COMPARE(false, ==, x, z);
+ COMPARE(true, <, x, z);
+ COMPARE(true, >, z, x);
+ }
+ }
+ }
+}
+#undef COMPARE
+
+// Sadly, our users often confuse std::string::npos with absl::string_view::npos;
+// So much so that we test here that they are the same. They need to
+// both be unsigned, and both be the maximum-valued integer of their type.
+
+template <typename T>
+struct is_type {
+ template <typename U>
+ static bool same(U) {
+ return false;
+ }
+ static bool same(T) { return true; }
+};
+
+TEST(StringViewTest, NposMatchesStdStringView) {
+ EXPECT_EQ(absl::string_view::npos, std::string::npos);
+
+ EXPECT_TRUE(is_type<size_t>::same(absl::string_view::npos));
+ EXPECT_FALSE(is_type<size_t>::same(""));
+
+ // Make sure absl::string_view::npos continues to be a header constant.
+ char test[absl::string_view::npos & 1] = {0};
+ EXPECT_EQ(0, test[0]);
+}
+
+TEST(StringViewTest, STL1) {
+ const absl::string_view a("abcdefghijklmnopqrstuvwxyz");
+ const absl::string_view b("abc");
+ const absl::string_view c("xyz");
+ const absl::string_view d("foobar");
+ const absl::string_view e;
+ std::string temp("123");
+ temp += '\0';
+ temp += "456";
+ const absl::string_view f(temp);
+
+ EXPECT_EQ(a[6], 'g');
+ EXPECT_EQ(b[0], 'a');
+ EXPECT_EQ(c[2], 'z');
+ EXPECT_EQ(f[3], '\0');
+ EXPECT_EQ(f[5], '5');
+
+ EXPECT_EQ(*d.data(), 'f');
+ EXPECT_EQ(d.data()[5], 'r');
+ EXPECT_TRUE(e.data() == nullptr);
+
+ EXPECT_EQ(*a.begin(), 'a');
+ EXPECT_EQ(*(b.begin() + 2), 'c');
+ EXPECT_EQ(*(c.end() - 1), 'z');
+
+ EXPECT_EQ(*a.rbegin(), 'z');
+ EXPECT_EQ(*(b.rbegin() + 2), 'a');
+ EXPECT_EQ(*(c.rend() - 1), 'x');
+ EXPECT_TRUE(a.rbegin() + 26 == a.rend());
+
+ EXPECT_EQ(a.size(), 26);
+ EXPECT_EQ(b.size(), 3);
+ EXPECT_EQ(c.size(), 3);
+ EXPECT_EQ(d.size(), 6);
+ EXPECT_EQ(e.size(), 0);
+ EXPECT_EQ(f.size(), 7);
+
+ EXPECT_TRUE(!d.empty());
+ EXPECT_TRUE(d.begin() != d.end());
+ EXPECT_TRUE(d.begin() + 6 == d.end());
+
+ EXPECT_TRUE(e.empty());
+ EXPECT_TRUE(e.begin() == e.end());
+
+ char buf[4] = { '%', '%', '%', '%' };
+ EXPECT_EQ(a.copy(buf, 4), 4);
+ EXPECT_EQ(buf[0], a[0]);
+ EXPECT_EQ(buf[1], a[1]);
+ EXPECT_EQ(buf[2], a[2]);
+ EXPECT_EQ(buf[3], a[3]);
+ EXPECT_EQ(a.copy(buf, 3, 7), 3);
+ EXPECT_EQ(buf[0], a[7]);
+ EXPECT_EQ(buf[1], a[8]);
+ EXPECT_EQ(buf[2], a[9]);
+ EXPECT_EQ(buf[3], a[3]);
+ EXPECT_EQ(c.copy(buf, 99), 3);
+ EXPECT_EQ(buf[0], c[0]);
+ EXPECT_EQ(buf[1], c[1]);
+ EXPECT_EQ(buf[2], c[2]);
+ EXPECT_EQ(buf[3], a[3]);
+}
+
+// Separated from STL1() because some compilers produce an overly
+// large stack frame for the combined function.
+TEST(StringViewTest, STL2) {
+ const absl::string_view a("abcdefghijklmnopqrstuvwxyz");
+ const absl::string_view b("abc");
+ const absl::string_view c("xyz");
+ absl::string_view d("foobar");
+ const absl::string_view e;
+ const absl::string_view f(
+ "123"
+ "\0"
+ "456",
+ 7);
+
+ d = absl::string_view();
+ EXPECT_EQ(d.size(), 0);
+ EXPECT_TRUE(d.empty());
+ EXPECT_TRUE(d.data() == nullptr);
+ EXPECT_TRUE(d.begin() == d.end());
+
+ EXPECT_EQ(a.find(b), 0);
+ EXPECT_EQ(a.find(b, 1), absl::string_view::npos);
+ EXPECT_EQ(a.find(c), 23);
+ EXPECT_EQ(a.find(c, 9), 23);
+ EXPECT_EQ(a.find(c, absl::string_view::npos), absl::string_view::npos);
+ EXPECT_EQ(b.find(c), absl::string_view::npos);
+ EXPECT_EQ(b.find(c, absl::string_view::npos), absl::string_view::npos);
+ EXPECT_EQ(a.find(d), 0);
+ EXPECT_EQ(a.find(e), 0);
+ EXPECT_EQ(a.find(d, 12), 12);
+ EXPECT_EQ(a.find(e, 17), 17);
+ absl::string_view g("xx not found bb");
+ EXPECT_EQ(a.find(g), absl::string_view::npos);
+ // empty std::string nonsense
+ EXPECT_EQ(d.find(b), absl::string_view::npos);
+ EXPECT_EQ(e.find(b), absl::string_view::npos);
+ EXPECT_EQ(d.find(b, 4), absl::string_view::npos);
+ EXPECT_EQ(e.find(b, 7), absl::string_view::npos);
+
+ size_t empty_search_pos = std::string().find(std::string());
+ EXPECT_EQ(d.find(d), empty_search_pos);
+ EXPECT_EQ(d.find(e), empty_search_pos);
+ EXPECT_EQ(e.find(d), empty_search_pos);
+ EXPECT_EQ(e.find(e), empty_search_pos);
+ EXPECT_EQ(d.find(d, 4), std::string().find(std::string(), 4));
+ EXPECT_EQ(d.find(e, 4), std::string().find(std::string(), 4));
+ EXPECT_EQ(e.find(d, 4), std::string().find(std::string(), 4));
+ EXPECT_EQ(e.find(e, 4), std::string().find(std::string(), 4));
+
+ EXPECT_EQ(a.find('a'), 0);
+ EXPECT_EQ(a.find('c'), 2);
+ EXPECT_EQ(a.find('z'), 25);
+ EXPECT_EQ(a.find('$'), absl::string_view::npos);
+ EXPECT_EQ(a.find('\0'), absl::string_view::npos);
+ EXPECT_EQ(f.find('\0'), 3);
+ EXPECT_EQ(f.find('3'), 2);
+ EXPECT_EQ(f.find('5'), 5);
+ EXPECT_EQ(g.find('o'), 4);
+ EXPECT_EQ(g.find('o', 4), 4);
+ EXPECT_EQ(g.find('o', 5), 8);
+ EXPECT_EQ(a.find('b', 5), absl::string_view::npos);
+ // empty std::string nonsense
+ EXPECT_EQ(d.find('\0'), absl::string_view::npos);
+ EXPECT_EQ(e.find('\0'), absl::string_view::npos);
+ EXPECT_EQ(d.find('\0', 4), absl::string_view::npos);
+ EXPECT_EQ(e.find('\0', 7), absl::string_view::npos);
+ EXPECT_EQ(d.find('x'), absl::string_view::npos);
+ EXPECT_EQ(e.find('x'), absl::string_view::npos);
+ EXPECT_EQ(d.find('x', 4), absl::string_view::npos);
+ EXPECT_EQ(e.find('x', 7), absl::string_view::npos);
+
+ EXPECT_EQ(a.rfind(b), 0);
+ EXPECT_EQ(a.rfind(b, 1), 0);
+ EXPECT_EQ(a.rfind(c), 23);
+ EXPECT_EQ(a.rfind(c, 22), absl::string_view::npos);
+ EXPECT_EQ(a.rfind(c, 1), absl::string_view::npos);
+ EXPECT_EQ(a.rfind(c, 0), absl::string_view::npos);
+ EXPECT_EQ(b.rfind(c), absl::string_view::npos);
+ EXPECT_EQ(b.rfind(c, 0), absl::string_view::npos);
+ EXPECT_EQ(a.rfind(d), std::string(a).rfind(std::string()));
+ EXPECT_EQ(a.rfind(e), std::string(a).rfind(std::string()));
+ EXPECT_EQ(a.rfind(d, 12), 12);
+ EXPECT_EQ(a.rfind(e, 17), 17);
+ EXPECT_EQ(a.rfind(g), absl::string_view::npos);
+ EXPECT_EQ(d.rfind(b), absl::string_view::npos);
+ EXPECT_EQ(e.rfind(b), absl::string_view::npos);
+ EXPECT_EQ(d.rfind(b, 4), absl::string_view::npos);
+ EXPECT_EQ(e.rfind(b, 7), absl::string_view::npos);
+ // empty std::string nonsense
+ EXPECT_EQ(d.rfind(d, 4), std::string().rfind(std::string()));
+ EXPECT_EQ(e.rfind(d, 7), std::string().rfind(std::string()));
+ EXPECT_EQ(d.rfind(e, 4), std::string().rfind(std::string()));
+ EXPECT_EQ(e.rfind(e, 7), std::string().rfind(std::string()));
+ EXPECT_EQ(d.rfind(d), std::string().rfind(std::string()));
+ EXPECT_EQ(e.rfind(d), std::string().rfind(std::string()));
+ EXPECT_EQ(d.rfind(e), std::string().rfind(std::string()));
+ EXPECT_EQ(e.rfind(e), std::string().rfind(std::string()));
+
+ EXPECT_EQ(g.rfind('o'), 8);
+ EXPECT_EQ(g.rfind('q'), absl::string_view::npos);
+ EXPECT_EQ(g.rfind('o', 8), 8);
+ EXPECT_EQ(g.rfind('o', 7), 4);
+ EXPECT_EQ(g.rfind('o', 3), absl::string_view::npos);
+ EXPECT_EQ(f.rfind('\0'), 3);
+ EXPECT_EQ(f.rfind('\0', 12), 3);
+ EXPECT_EQ(f.rfind('3'), 2);
+ EXPECT_EQ(f.rfind('5'), 5);
+ // empty std::string nonsense
+ EXPECT_EQ(d.rfind('o'), absl::string_view::npos);
+ EXPECT_EQ(e.rfind('o'), absl::string_view::npos);
+ EXPECT_EQ(d.rfind('o', 4), absl::string_view::npos);
+ EXPECT_EQ(e.rfind('o', 7), absl::string_view::npos);
+}
+
+// Continued from STL2
+TEST(StringViewTest, STL2FindFirst) {
+ const absl::string_view a("abcdefghijklmnopqrstuvwxyz");
+ const absl::string_view b("abc");
+ const absl::string_view c("xyz");
+ absl::string_view d("foobar");
+ const absl::string_view e;
+ const absl::string_view f(
+ "123"
+ "\0"
+ "456",
+ 7);
+ absl::string_view g("xx not found bb");
+
+ d = absl::string_view();
+ EXPECT_EQ(a.find_first_of(b), 0);
+ EXPECT_EQ(a.find_first_of(b, 0), 0);
+ EXPECT_EQ(a.find_first_of(b, 1), 1);
+ EXPECT_EQ(a.find_first_of(b, 2), 2);
+ EXPECT_EQ(a.find_first_of(b, 3), absl::string_view::npos);
+ EXPECT_EQ(a.find_first_of(c), 23);
+ EXPECT_EQ(a.find_first_of(c, 23), 23);
+ EXPECT_EQ(a.find_first_of(c, 24), 24);
+ EXPECT_EQ(a.find_first_of(c, 25), 25);
+ EXPECT_EQ(a.find_first_of(c, 26), absl::string_view::npos);
+ EXPECT_EQ(g.find_first_of(b), 13);
+ EXPECT_EQ(g.find_first_of(c), 0);
+ EXPECT_EQ(a.find_first_of(f), absl::string_view::npos);
+ EXPECT_EQ(f.find_first_of(a), absl::string_view::npos);
+ // empty std::string nonsense
+ EXPECT_EQ(a.find_first_of(d), absl::string_view::npos);
+ EXPECT_EQ(a.find_first_of(e), absl::string_view::npos);
+ EXPECT_EQ(d.find_first_of(b), absl::string_view::npos);
+ EXPECT_EQ(e.find_first_of(b), absl::string_view::npos);
+ EXPECT_EQ(d.find_first_of(d), absl::string_view::npos);
+ EXPECT_EQ(e.find_first_of(d), absl::string_view::npos);
+ EXPECT_EQ(d.find_first_of(e), absl::string_view::npos);
+ EXPECT_EQ(e.find_first_of(e), absl::string_view::npos);
+
+ EXPECT_EQ(a.find_first_not_of(b), 3);
+ EXPECT_EQ(a.find_first_not_of(c), 0);
+ EXPECT_EQ(b.find_first_not_of(a), absl::string_view::npos);
+ EXPECT_EQ(c.find_first_not_of(a), absl::string_view::npos);
+ EXPECT_EQ(f.find_first_not_of(a), 0);
+ EXPECT_EQ(a.find_first_not_of(f), 0);
+ EXPECT_EQ(a.find_first_not_of(d), 0);
+ EXPECT_EQ(a.find_first_not_of(e), 0);
+ // empty std::string nonsense
+ EXPECT_EQ(a.find_first_not_of(d), 0);
+ EXPECT_EQ(a.find_first_not_of(e), 0);
+ EXPECT_EQ(a.find_first_not_of(d, 1), 1);
+ EXPECT_EQ(a.find_first_not_of(e, 1), 1);
+ EXPECT_EQ(a.find_first_not_of(d, a.size() - 1), a.size() - 1);
+ EXPECT_EQ(a.find_first_not_of(e, a.size() - 1), a.size() - 1);
+ EXPECT_EQ(a.find_first_not_of(d, a.size()), absl::string_view::npos);
+ EXPECT_EQ(a.find_first_not_of(e, a.size()), absl::string_view::npos);
+ EXPECT_EQ(a.find_first_not_of(d, absl::string_view::npos),
+ absl::string_view::npos);
+ EXPECT_EQ(a.find_first_not_of(e, absl::string_view::npos),
+ absl::string_view::npos);
+ EXPECT_EQ(d.find_first_not_of(a), absl::string_view::npos);
+ EXPECT_EQ(e.find_first_not_of(a), absl::string_view::npos);
+ EXPECT_EQ(d.find_first_not_of(d), absl::string_view::npos);
+ EXPECT_EQ(e.find_first_not_of(d), absl::string_view::npos);
+ EXPECT_EQ(d.find_first_not_of(e), absl::string_view::npos);
+ EXPECT_EQ(e.find_first_not_of(e), absl::string_view::npos);
+
+ absl::string_view h("====");
+ EXPECT_EQ(h.find_first_not_of('='), absl::string_view::npos);
+ EXPECT_EQ(h.find_first_not_of('=', 3), absl::string_view::npos);
+ EXPECT_EQ(h.find_first_not_of('\0'), 0);
+ EXPECT_EQ(g.find_first_not_of('x'), 2);
+ EXPECT_EQ(f.find_first_not_of('\0'), 0);
+ EXPECT_EQ(f.find_first_not_of('\0', 3), 4);
+ EXPECT_EQ(f.find_first_not_of('\0', 2), 2);
+ // empty std::string nonsense
+ EXPECT_EQ(d.find_first_not_of('x'), absl::string_view::npos);
+ EXPECT_EQ(e.find_first_not_of('x'), absl::string_view::npos);
+ EXPECT_EQ(d.find_first_not_of('\0'), absl::string_view::npos);
+ EXPECT_EQ(e.find_first_not_of('\0'), absl::string_view::npos);
+}
+
+// Continued from STL2
+TEST(StringViewTest, STL2FindLast) {
+ const absl::string_view a("abcdefghijklmnopqrstuvwxyz");
+ const absl::string_view b("abc");
+ const absl::string_view c("xyz");
+ absl::string_view d("foobar");
+ const absl::string_view e;
+ const absl::string_view f(
+ "123"
+ "\0"
+ "456",
+ 7);
+ absl::string_view g("xx not found bb");
+ absl::string_view h("====");
+ absl::string_view i("56");
+
+ d = absl::string_view();
+ EXPECT_EQ(h.find_last_of(a), absl::string_view::npos);
+ EXPECT_EQ(g.find_last_of(a), g.size()-1);
+ EXPECT_EQ(a.find_last_of(b), 2);
+ EXPECT_EQ(a.find_last_of(c), a.size()-1);
+ EXPECT_EQ(f.find_last_of(i), 6);
+ EXPECT_EQ(a.find_last_of('a'), 0);
+ EXPECT_EQ(a.find_last_of('b'), 1);
+ EXPECT_EQ(a.find_last_of('z'), 25);
+ EXPECT_EQ(a.find_last_of('a', 5), 0);
+ EXPECT_EQ(a.find_last_of('b', 5), 1);
+ EXPECT_EQ(a.find_last_of('b', 0), absl::string_view::npos);
+ EXPECT_EQ(a.find_last_of('z', 25), 25);
+ EXPECT_EQ(a.find_last_of('z', 24), absl::string_view::npos);
+ EXPECT_EQ(f.find_last_of(i, 5), 5);
+ EXPECT_EQ(f.find_last_of(i, 6), 6);
+ EXPECT_EQ(f.find_last_of(a, 4), absl::string_view::npos);
+ // empty std::string nonsense
+ EXPECT_EQ(f.find_last_of(d), absl::string_view::npos);
+ EXPECT_EQ(f.find_last_of(e), absl::string_view::npos);
+ EXPECT_EQ(f.find_last_of(d, 4), absl::string_view::npos);
+ EXPECT_EQ(f.find_last_of(e, 4), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_of(d), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_of(e), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_of(d), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_of(e), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_of(f), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_of(f), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_of(d, 4), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_of(e, 4), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_of(d, 4), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_of(e, 4), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_of(f, 4), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_of(f, 4), absl::string_view::npos);
+
+ EXPECT_EQ(a.find_last_not_of(b), a.size()-1);
+ EXPECT_EQ(a.find_last_not_of(c), 22);
+ EXPECT_EQ(b.find_last_not_of(a), absl::string_view::npos);
+ EXPECT_EQ(b.find_last_not_of(b), absl::string_view::npos);
+ EXPECT_EQ(f.find_last_not_of(i), 4);
+ EXPECT_EQ(a.find_last_not_of(c, 24), 22);
+ EXPECT_EQ(a.find_last_not_of(b, 3), 3);
+ EXPECT_EQ(a.find_last_not_of(b, 2), absl::string_view::npos);
+ // empty std::string nonsense
+ EXPECT_EQ(f.find_last_not_of(d), f.size()-1);
+ EXPECT_EQ(f.find_last_not_of(e), f.size()-1);
+ EXPECT_EQ(f.find_last_not_of(d, 4), 4);
+ EXPECT_EQ(f.find_last_not_of(e, 4), 4);
+ EXPECT_EQ(d.find_last_not_of(d), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_not_of(e), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_not_of(d), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_not_of(e), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_not_of(f), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_not_of(f), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_not_of(d, 4), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_not_of(e, 4), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_not_of(d, 4), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_not_of(e, 4), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_not_of(f, 4), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_not_of(f, 4), absl::string_view::npos);
+
+ EXPECT_EQ(h.find_last_not_of('x'), h.size() - 1);
+ EXPECT_EQ(h.find_last_not_of('='), absl::string_view::npos);
+ EXPECT_EQ(b.find_last_not_of('c'), 1);
+ EXPECT_EQ(h.find_last_not_of('x', 2), 2);
+ EXPECT_EQ(h.find_last_not_of('=', 2), absl::string_view::npos);
+ EXPECT_EQ(b.find_last_not_of('b', 1), 0);
+ // empty std::string nonsense
+ EXPECT_EQ(d.find_last_not_of('x'), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_not_of('x'), absl::string_view::npos);
+ EXPECT_EQ(d.find_last_not_of('\0'), absl::string_view::npos);
+ EXPECT_EQ(e.find_last_not_of('\0'), absl::string_view::npos);
+}
+
+// Continued from STL2
+TEST(StringViewTest, STL2Substr) {
+ const absl::string_view a("abcdefghijklmnopqrstuvwxyz");
+ const absl::string_view b("abc");
+ const absl::string_view c("xyz");
+ absl::string_view d("foobar");
+ const absl::string_view e;
+
+ d = absl::string_view();
+ EXPECT_EQ(a.substr(0, 3), b);
+ EXPECT_EQ(a.substr(23), c);
+ EXPECT_EQ(a.substr(23, 3), c);
+ EXPECT_EQ(a.substr(23, 99), c);
+ EXPECT_EQ(a.substr(0), a);
+ EXPECT_EQ(a.substr(3, 2), "de");
+ // empty std::string nonsense
+ EXPECT_EQ(d.substr(0, 99), e);
+ // use of npos
+ EXPECT_EQ(a.substr(0, absl::string_view::npos), a);
+ EXPECT_EQ(a.substr(23, absl::string_view::npos), c);
+ // throw exception
+#ifdef ABSL_HAVE_EXCEPTIONS
+ EXPECT_THROW(a.substr(99, 2), std::out_of_range);
+#else
+ EXPECT_DEATH(a.substr(99, 2), "absl::string_view::substr");
+#endif
+}
+
+TEST(StringViewTest, TruncSubstr) {
+ const absl::string_view hi("hi");
+ EXPECT_EQ("", absl::ClippedSubstr(hi, 0, 0));
+ EXPECT_EQ("h", absl::ClippedSubstr(hi, 0, 1));
+ EXPECT_EQ("hi", absl::ClippedSubstr(hi, 0));
+ EXPECT_EQ("i", absl::ClippedSubstr(hi, 1));
+ EXPECT_EQ("", absl::ClippedSubstr(hi, 2));
+ EXPECT_EQ("", absl::ClippedSubstr(hi, 3)); // truncation
+ EXPECT_EQ("", absl::ClippedSubstr(hi, 3, 2)); // truncation
+}
+
+TEST(StringViewTest, UTF8) {
+ std::string utf8 = "\u00E1";
+ std::string utf8_twice = utf8 + " " + utf8;
+ int utf8_len = strlen(utf8.data());
+ EXPECT_EQ(utf8_len, absl::string_view(utf8_twice).find_first_of(" "));
+ EXPECT_EQ(utf8_len, absl::string_view(utf8_twice).find_first_of(" \t"));
+}
+
+TEST(StringViewTest, FindConformance) {
+ struct {
+ std::string haystack;
+ std::string needle;
+ } specs[] = {
+ {"", ""},
+ {"", "a"},
+ {"a", ""},
+ {"a", "a"},
+ {"a", "b"},
+ {"aa", ""},
+ {"aa", "a"},
+ {"aa", "b"},
+ {"ab", "a"},
+ {"ab", "b"},
+ {"abcd", ""},
+ {"abcd", "a"},
+ {"abcd", "d"},
+ {"abcd", "ab"},
+ {"abcd", "bc"},
+ {"abcd", "cd"},
+ {"abcd", "abcd"},
+ };
+ for (const auto& s : specs) {
+ SCOPED_TRACE(s.haystack);
+ SCOPED_TRACE(s.needle);
+ std::string st = s.haystack;
+ absl::string_view sp = s.haystack;
+ for (size_t i = 0; i <= sp.size(); ++i) {
+ size_t pos = (i == sp.size()) ? absl::string_view::npos : i;
+ SCOPED_TRACE(pos);
+ EXPECT_EQ(sp.find(s.needle, pos),
+ st.find(s.needle, pos));
+ EXPECT_EQ(sp.rfind(s.needle, pos),
+ st.rfind(s.needle, pos));
+ EXPECT_EQ(sp.find_first_of(s.needle, pos),
+ st.find_first_of(s.needle, pos));
+ EXPECT_EQ(sp.find_first_not_of(s.needle, pos),
+ st.find_first_not_of(s.needle, pos));
+ EXPECT_EQ(sp.find_last_of(s.needle, pos),
+ st.find_last_of(s.needle, pos));
+ EXPECT_EQ(sp.find_last_not_of(s.needle, pos),
+ st.find_last_not_of(s.needle, pos));
+ }
+ }
+}
+
+TEST(StringViewTest, Remove) {
+ absl::string_view a("foobar");
+ std::string s1("123");
+ s1 += '\0';
+ s1 += "456";
+ absl::string_view b(s1);
+ absl::string_view e;
+ std::string s2;
+
+ // remove_prefix
+ absl::string_view c(a);
+ c.remove_prefix(3);
+ EXPECT_EQ(c, "bar");
+ c = a;
+ c.remove_prefix(0);
+ EXPECT_EQ(c, a);
+ c.remove_prefix(c.size());
+ EXPECT_EQ(c, e);
+
+ // remove_suffix
+ c = a;
+ c.remove_suffix(3);
+ EXPECT_EQ(c, "foo");
+ c = a;
+ c.remove_suffix(0);
+ EXPECT_EQ(c, a);
+ c.remove_suffix(c.size());
+ EXPECT_EQ(c, e);
+}
+
+TEST(StringViewTest, Set) {
+ absl::string_view a("foobar");
+ absl::string_view empty;
+ absl::string_view b;
+
+ // set
+ b = absl::string_view("foobar", 6);
+ EXPECT_EQ(b, a);
+ b = absl::string_view("foobar", 0);
+ EXPECT_EQ(b, empty);
+ b = absl::string_view("foobar", 7);
+ EXPECT_NE(b, a);
+
+ b = absl::string_view("foobar");
+ EXPECT_EQ(b, a);
+}
+
+TEST(StringViewTest, FrontBack) {
+ static const char arr[] = "abcd";
+ const absl::string_view csp(arr, 4);
+ EXPECT_EQ(&arr[0], &csp.front());
+ EXPECT_EQ(&arr[3], &csp.back());
+}
+
+TEST(StringViewTest, FrontBackSingleChar) {
+ static const char c = 'a';
+ const absl::string_view csp(&c, 1);
+ EXPECT_EQ(&c, &csp.front());
+ EXPECT_EQ(&c, &csp.back());
+}
+
+// `std::string_view::string_view(const char*)` calls
+// `std::char_traits<char>::length(const char*)` to get the std::string length. In
+// libc++, it doesn't allow `nullptr` in the constexpr context, with the error
+// "read of dereferenced null pointer is not allowed in a constant expression".
+// At run time, the behavior of `std::char_traits::length()` on `nullptr` is
+// undefined by the standard and usually results in crash with libc++. This
+// conforms to the standard, but `absl::string_view` implements a different
+// behavior for historical reasons. We work around tests that construct
+// `string_view` from `nullptr` when using libc++.
+#if !defined(ABSL_HAVE_STD_STRING_VIEW) || !defined(_LIBCPP_VERSION)
+#define ABSL_HAVE_STRING_VIEW_FROM_NULLPTR 1
+#endif // !defined(ABSL_HAVE_STD_STRING_VIEW) || !defined(_LIBCPP_VERSION)
+
+TEST(StringViewTest, NULLInput) {
+ absl::string_view s;
+ EXPECT_EQ(s.data(), nullptr);
+ EXPECT_EQ(s.size(), 0);
+
+#ifdef ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
+ s = absl::string_view(nullptr);
+ EXPECT_EQ(s.data(), nullptr);
+ EXPECT_EQ(s.size(), 0);
+
+ // .ToString() on a absl::string_view with nullptr should produce the empty
+ // std::string.
+ EXPECT_EQ("", std::string(s));
+#endif // ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
+}
+
+TEST(StringViewTest, Comparisons2) {
+ // The `compare` member has 6 overloads (v: string_view, s: const char*):
+ // (1) compare(v)
+ // (2) compare(pos1, count1, v)
+ // (3) compare(pos1, count1, v, pos2, count2)
+ // (4) compare(s)
+ // (5) compare(pos1, count1, s)
+ // (6) compare(pos1, count1, s, count2)
+
+ absl::string_view abc("abcdefghijklmnopqrstuvwxyz");
+
+ // check comparison operations on strings longer than 4 bytes.
+ EXPECT_EQ(abc, absl::string_view("abcdefghijklmnopqrstuvwxyz"));
+ EXPECT_EQ(abc.compare(absl::string_view("abcdefghijklmnopqrstuvwxyz")), 0);
+
+ EXPECT_LT(abc, absl::string_view("abcdefghijklmnopqrstuvwxzz"));
+ EXPECT_LT(abc.compare(absl::string_view("abcdefghijklmnopqrstuvwxzz")), 0);
+
+ EXPECT_GT(abc, absl::string_view("abcdefghijklmnopqrstuvwxyy"));
+ EXPECT_GT(abc.compare(absl::string_view("abcdefghijklmnopqrstuvwxyy")), 0);
+
+ // The "substr" variants of `compare`.
+ absl::string_view digits("0123456789");
+ auto npos = absl::string_view::npos;
+
+ // Taking string_view
+ EXPECT_EQ(digits.compare(3, npos, absl::string_view("3456789")), 0); // 2
+ EXPECT_EQ(digits.compare(3, 4, absl::string_view("3456")), 0); // 2
+ EXPECT_EQ(digits.compare(10, 0, absl::string_view()), 0); // 2
+ EXPECT_EQ(digits.compare(3, 4, absl::string_view("0123456789"), 3, 4),
+ 0); // 3
+ EXPECT_LT(digits.compare(3, 4, absl::string_view("0123456789"), 3, 5),
+ 0); // 3
+ EXPECT_LT(digits.compare(0, npos, absl::string_view("0123456789"), 3, 5),
+ 0); // 3
+ // Taking const char*
+ EXPECT_EQ(digits.compare(3, 4, "3456"), 0); // 5
+ EXPECT_EQ(digits.compare(3, npos, "3456789"), 0); // 5
+ EXPECT_EQ(digits.compare(10, 0, ""), 0); // 5
+ EXPECT_EQ(digits.compare(3, 4, "0123456789", 3, 4), 0); // 6
+ EXPECT_LT(digits.compare(3, 4, "0123456789", 3, 5), 0); // 6
+ EXPECT_LT(digits.compare(0, npos, "0123456789", 3, 5), 0); // 6
+}
+
+struct MyCharAlloc : std::allocator<char> {};
+
+TEST(StringViewTest, ExplicitConversionOperator) {
+ absl::string_view sp = "hi";
+ EXPECT_EQ(sp, std::string(sp));
+}
+
+TEST(StringViewTest, NullSafeStringView) {
+ {
+ absl::string_view s = absl::NullSafeStringView(nullptr);
+ EXPECT_EQ(nullptr, s.data());
+ EXPECT_EQ(0, s.size());
+ EXPECT_EQ(absl::string_view(), s);
+ }
+ {
+ static const char kHi[] = "hi";
+ absl::string_view s = absl::NullSafeStringView(kHi);
+ EXPECT_EQ(kHi, s.data());
+ EXPECT_EQ(strlen(kHi), s.size());
+ EXPECT_EQ(absl::string_view("hi"), s);
+ }
+}
+
+TEST(StringViewTest, ConstexprCompiles) {
+ constexpr absl::string_view sp;
+#ifdef ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
+ constexpr absl::string_view cstr(nullptr);
+#endif
+ constexpr absl::string_view cstr_len("cstr", 4);
+
+#if defined(ABSL_HAVE_STD_STRING_VIEW)
+ // In libstdc++ (as of 7.2), `std::string_view::string_view(const char*)`
+ // calls `std::char_traits<char>::length(const char*)` to get the std::string
+ // length, but it is not marked constexpr yet. See GCC bug:
+ // https://gcc.gnu.org/bugzilla/show_bug.cgi?id=78156
+ // Also, there is a LWG issue that adds constexpr to length() which was just
+ // resolved 2017-06-02. See
+ // http://www.open-std.org/jtc1/sc22/wg21/docs/lwg-defects.html#2232
+ // TODO(zhangxy): Update the condition when libstdc++ adopts the constexpr
+ // length().
+#if !defined(__GLIBCXX__)
+#define ABSL_HAVE_CONSTEXPR_STRING_VIEW_FROM_CSTR 1
+#endif // !__GLIBCXX__
+
+#else // ABSL_HAVE_STD_STRING_VIEW
+
+// This duplicates the check for __builtin_strlen in the header.
+#if ABSL_HAVE_BUILTIN(__builtin_strlen) || \
+ (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_HAVE_CONSTEXPR_STRING_VIEW_FROM_CSTR 1
+#elif defined(__GNUC__) // GCC or clang
+#error GCC/clang should have constexpr string_view.
+#endif
+
+#endif // ABSL_HAVE_STD_STRING_VIEW
+
+#ifdef ABSL_HAVE_CONSTEXPR_STRING_VIEW_FROM_CSTR
+ constexpr absl::string_view cstr_strlen("foo");
+ EXPECT_EQ(cstr_strlen.length(), 3);
+ constexpr absl::string_view cstr_strlen2 = "bar";
+ EXPECT_EQ(cstr_strlen2, "bar");
+#endif
+
+#if !defined(__clang__) || 3 < __clang_major__ || \
+ (3 == __clang_major__ && 4 < __clang_minor__)
+ // older clang versions (< 3.5) complain that:
+ // "cannot perform pointer arithmetic on null pointer"
+ constexpr absl::string_view::iterator const_begin_empty = sp.begin();
+ constexpr absl::string_view::iterator const_end_empty = sp.end();
+ EXPECT_EQ(const_begin_empty, const_end_empty);
+
+#ifdef ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
+ constexpr absl::string_view::iterator const_begin_nullptr = cstr.begin();
+ constexpr absl::string_view::iterator const_end_nullptr = cstr.end();
+ EXPECT_EQ(const_begin_nullptr, const_end_nullptr);
+#endif // ABSL_HAVE_STRING_VIEW_FROM_NULLPTR
+#endif // !defined(__clang__) || ...
+
+ constexpr absl::string_view::iterator const_begin = cstr_len.begin();
+ constexpr absl::string_view::iterator const_end = cstr_len.end();
+ constexpr absl::string_view::size_type const_size = cstr_len.size();
+ constexpr absl::string_view::size_type const_length = cstr_len.length();
+ EXPECT_EQ(const_begin + const_size, const_end);
+ EXPECT_EQ(const_begin + const_length, const_end);
+
+ constexpr bool isempty = sp.empty();
+ EXPECT_TRUE(isempty);
+
+ constexpr const char c = cstr_len[2];
+ EXPECT_EQ(c, 't');
+
+ constexpr const char cfront = cstr_len.front();
+ constexpr const char cback = cstr_len.back();
+ EXPECT_EQ(cfront, 'c');
+ EXPECT_EQ(cback, 'r');
+
+ constexpr const char* np = sp.data();
+ constexpr const char* cstr_ptr = cstr_len.data();
+ EXPECT_EQ(np, nullptr);
+ EXPECT_NE(cstr_ptr, nullptr);
+
+ constexpr size_t sp_npos = sp.npos;
+ EXPECT_EQ(sp_npos, -1);
+}
+
+TEST(StringViewTest, Noexcept) {
+ EXPECT_TRUE((std::is_nothrow_constructible<absl::string_view,
+ const std::string&>::value));
+ EXPECT_TRUE(
+ (std::is_nothrow_constructible<absl::string_view, const std::string&>::value));
+ EXPECT_TRUE(std::is_nothrow_constructible<absl::string_view>::value);
+ constexpr absl::string_view sp;
+ EXPECT_TRUE(noexcept(sp.begin()));
+ EXPECT_TRUE(noexcept(sp.end()));
+ EXPECT_TRUE(noexcept(sp.cbegin()));
+ EXPECT_TRUE(noexcept(sp.cend()));
+ EXPECT_TRUE(noexcept(sp.rbegin()));
+ EXPECT_TRUE(noexcept(sp.rend()));
+ EXPECT_TRUE(noexcept(sp.crbegin()));
+ EXPECT_TRUE(noexcept(sp.crend()));
+ EXPECT_TRUE(noexcept(sp.size()));
+ EXPECT_TRUE(noexcept(sp.length()));
+ EXPECT_TRUE(noexcept(sp.empty()));
+ EXPECT_TRUE(noexcept(sp.data()));
+ EXPECT_TRUE(noexcept(sp.compare(sp)));
+ EXPECT_TRUE(noexcept(sp.find(sp)));
+ EXPECT_TRUE(noexcept(sp.find('f')));
+ EXPECT_TRUE(noexcept(sp.rfind(sp)));
+ EXPECT_TRUE(noexcept(sp.rfind('f')));
+ EXPECT_TRUE(noexcept(sp.find_first_of(sp)));
+ EXPECT_TRUE(noexcept(sp.find_first_of('f')));
+ EXPECT_TRUE(noexcept(sp.find_last_of(sp)));
+ EXPECT_TRUE(noexcept(sp.find_last_of('f')));
+ EXPECT_TRUE(noexcept(sp.find_first_not_of(sp)));
+ EXPECT_TRUE(noexcept(sp.find_first_not_of('f')));
+ EXPECT_TRUE(noexcept(sp.find_last_not_of(sp)));
+ EXPECT_TRUE(noexcept(sp.find_last_not_of('f')));
+}
+
+TEST(ComparisonOpsTest, StringCompareNotAmbiguous) {
+ EXPECT_EQ("hello", std::string("hello"));
+ EXPECT_LT("hello", std::string("world"));
+}
+
+TEST(ComparisonOpsTest, HeterogenousStringViewEquals) {
+ EXPECT_EQ(absl::string_view("hello"), std::string("hello"));
+ EXPECT_EQ("hello", absl::string_view("hello"));
+}
+
+TEST(FindOneCharTest, EdgeCases) {
+ absl::string_view a("xxyyyxx");
+
+ // Set a = "xyyyx".
+ a.remove_prefix(1);
+ a.remove_suffix(1);
+
+ EXPECT_EQ(0, a.find('x'));
+ EXPECT_EQ(0, a.find('x', 0));
+ EXPECT_EQ(4, a.find('x', 1));
+ EXPECT_EQ(4, a.find('x', 4));
+ EXPECT_EQ(absl::string_view::npos, a.find('x', 5));
+
+ EXPECT_EQ(4, a.rfind('x'));
+ EXPECT_EQ(4, a.rfind('x', 5));
+ EXPECT_EQ(4, a.rfind('x', 4));
+ EXPECT_EQ(0, a.rfind('x', 3));
+ EXPECT_EQ(0, a.rfind('x', 0));
+
+ // Set a = "yyy".
+ a.remove_prefix(1);
+ a.remove_suffix(1);
+
+ EXPECT_EQ(absl::string_view::npos, a.find('x'));
+ EXPECT_EQ(absl::string_view::npos, a.rfind('x'));
+}
+
+#ifndef THREAD_SANITIZER // Allocates too much memory for tsan.
+TEST(HugeStringView, TwoPointTwoGB) {
+ if (sizeof(size_t) <= 4 || RunningOnValgrind())
+ return;
+ // Try a huge std::string piece.
+ const size_t size = size_t{2200} * 1000 * 1000;
+ std::string s(size, 'a');
+ absl::string_view sp(s);
+ EXPECT_EQ(size, sp.length());
+ sp.remove_prefix(1);
+ EXPECT_EQ(size - 1, sp.length());
+ sp.remove_suffix(2);
+ EXPECT_EQ(size - 1 - 2, sp.length());
+}
+#endif // THREAD_SANITIZER
+
+#if !defined(NDEBUG) && !defined(ABSL_HAVE_STD_STRING_VIEW)
+TEST(NonNegativeLenTest, NonNegativeLen) {
+ EXPECT_DEATH_IF_SUPPORTED(absl::string_view("xyz", -1), "len <= kMaxSize");
+}
+
+TEST(LenExceedsMaxSizeTest, LenExceedsMaxSize) {
+ auto max_size = absl::string_view().max_size();
+
+ // This should construct ok (although the view itself is obviously invalid).
+ absl::string_view ok_view("", max_size);
+
+ // Adding one to the max should trigger an assertion.
+ EXPECT_DEATH_IF_SUPPORTED(absl::string_view("", max_size + 1),
+ "len <= kMaxSize");
+}
+#endif // !defined(NDEBUG) && !defined(ABSL_HAVE_STD_STRING_VIEW)
+
+class StringViewStreamTest : public ::testing::Test {
+ public:
+ // Set negative 'width' for right justification.
+ template <typename T>
+ std::string Pad(const T& s, int width, char fill = 0) {
+ std::ostringstream oss;
+ if (fill != 0) {
+ oss << std::setfill(fill);
+ }
+ if (width < 0) {
+ width = -width;
+ oss << std::right;
+ }
+ oss << std::setw(width) << s;
+ return oss.str();
+ }
+};
+
+TEST_F(StringViewStreamTest, Padding) {
+ std::string s("hello");
+ absl::string_view sp(s);
+ for (int w = -64; w < 64; ++w) {
+ SCOPED_TRACE(w);
+ EXPECT_EQ(Pad(s, w), Pad(sp, w));
+ }
+ for (int w = -64; w < 64; ++w) {
+ SCOPED_TRACE(w);
+ EXPECT_EQ(Pad(s, w, '#'), Pad(sp, w, '#'));
+ }
+}
+
+TEST_F(StringViewStreamTest, ResetsWidth) {
+ // Width should reset after one formatted write.
+ // If we weren't resetting width after formatting the string_view,
+ // we'd have width=5 carrying over to the printing of the "]",
+ // creating "[###hi####]".
+ std::string s = "hi";
+ absl::string_view sp = s;
+ {
+ std::ostringstream oss;
+ oss << "[" << std::setfill('#') << std::setw(5) << s << "]";
+ ASSERT_EQ("[###hi]", oss.str());
+ }
+ {
+ std::ostringstream oss;
+ oss << "[" << std::setfill('#') << std::setw(5) << sp << "]";
+ EXPECT_EQ("[###hi]", oss.str());
+ }
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/strip.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/strip.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/strip.h
new file mode 100644
index 0000000..2f8d21f
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/strip.h
@@ -0,0 +1,89 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: strip.h
+// -----------------------------------------------------------------------------
+//
+// This file contains various functions for stripping substrings from a std::string.
+#ifndef ABSL_STRINGS_STRIP_H_
+#define ABSL_STRINGS_STRIP_H_
+
+#include <cstddef>
+#include <string>
+
+#include "absl/base/macros.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/match.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+
+// ConsumePrefix()
+//
+// Strips the `expected` prefix from the start of the given std::string, returning
+// `true` if the strip operation succeeded or false otherwise.
+//
+// Example:
+//
+// absl::string_view input("abc");
+// EXPECT_TRUE(absl::ConsumePrefix(&input, "a"));
+// EXPECT_EQ(input, "bc");
+inline bool ConsumePrefix(absl::string_view* str, absl::string_view expected) {
+ if (!absl::StartsWith(*str, expected)) return false;
+ str->remove_prefix(expected.size());
+ return true;
+}
+// ConsumeSuffix()
+//
+// Strips the `expected` suffix from the end of the given std::string, returning
+// `true` if the strip operation succeeded or false otherwise.
+//
+// Example:
+//
+// absl::string_view input("abcdef");
+// EXPECT_TRUE(absl::ConsumeSuffix(&input, "def"));
+// EXPECT_EQ(input, "abc");
+inline bool ConsumeSuffix(absl::string_view* str, absl::string_view expected) {
+ if (!absl::EndsWith(*str, expected)) return false;
+ str->remove_suffix(expected.size());
+ return true;
+}
+
+// StripPrefix()
+//
+// Returns a view into the input std::string 'str' with the given 'prefix' removed,
+// but leaving the original std::string intact. If the prefix does not match at the
+// start of the std::string, returns the original std::string instead.
+ABSL_MUST_USE_RESULT inline absl::string_view StripPrefix(
+ absl::string_view str, absl::string_view prefix) {
+ if (absl::StartsWith(str, prefix)) str.remove_prefix(prefix.size());
+ return str;
+}
+
+// StripSuffix()
+//
+// Returns a view into the input std::string 'str' with the given 'suffix' removed,
+// but leaving the original std::string intact. If the suffix does not match at the
+// end of the std::string, returns the original std::string instead.
+ABSL_MUST_USE_RESULT inline absl::string_view StripSuffix(
+ absl::string_view str, absl::string_view suffix) {
+ if (absl::EndsWith(str, suffix)) str.remove_suffix(suffix.size());
+ return str;
+}
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_STRIP_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/strip_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/strip_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/strip_test.cc
new file mode 100644
index 0000000..205c160
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/strip_test.cc
@@ -0,0 +1,201 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains functions that remove a defined part from the std::string,
+// i.e., strip the std::string.
+
+#include "absl/strings/strip.h"
+
+#include <cassert>
+#include <cstdio>
+#include <cstring>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/strings/string_view.h"
+
+namespace {
+
+using testing::ElementsAre;
+using testing::IsEmpty;
+
+TEST(Strip, ConsumePrefixOneChar) {
+ absl::string_view input("abc");
+ EXPECT_TRUE(absl::ConsumePrefix(&input, "a"));
+ EXPECT_EQ(input, "bc");
+
+ EXPECT_FALSE(absl::ConsumePrefix(&input, "x"));
+ EXPECT_EQ(input, "bc");
+
+ EXPECT_TRUE(absl::ConsumePrefix(&input, "b"));
+ EXPECT_EQ(input, "c");
+
+ EXPECT_TRUE(absl::ConsumePrefix(&input, "c"));
+ EXPECT_EQ(input, "");
+
+ EXPECT_FALSE(absl::ConsumePrefix(&input, "a"));
+ EXPECT_EQ(input, "");
+}
+
+TEST(Strip, ConsumePrefix) {
+ absl::string_view input("abcdef");
+ EXPECT_FALSE(absl::ConsumePrefix(&input, "abcdefg"));
+ EXPECT_EQ(input, "abcdef");
+
+ EXPECT_FALSE(absl::ConsumePrefix(&input, "abce"));
+ EXPECT_EQ(input, "abcdef");
+
+ EXPECT_TRUE(absl::ConsumePrefix(&input, ""));
+ EXPECT_EQ(input, "abcdef");
+
+ EXPECT_FALSE(absl::ConsumePrefix(&input, "abcdeg"));
+ EXPECT_EQ(input, "abcdef");
+
+ EXPECT_TRUE(absl::ConsumePrefix(&input, "abcdef"));
+ EXPECT_EQ(input, "");
+
+ input = "abcdef";
+ EXPECT_TRUE(absl::ConsumePrefix(&input, "abcde"));
+ EXPECT_EQ(input, "f");
+}
+
+TEST(Strip, ConsumeSuffix) {
+ absl::string_view input("abcdef");
+ EXPECT_FALSE(absl::ConsumeSuffix(&input, "abcdefg"));
+ EXPECT_EQ(input, "abcdef");
+
+ EXPECT_TRUE(absl::ConsumeSuffix(&input, ""));
+ EXPECT_EQ(input, "abcdef");
+
+ EXPECT_TRUE(absl::ConsumeSuffix(&input, "def"));
+ EXPECT_EQ(input, "abc");
+
+ input = "abcdef";
+ EXPECT_FALSE(absl::ConsumeSuffix(&input, "abcdeg"));
+ EXPECT_EQ(input, "abcdef");
+
+ EXPECT_TRUE(absl::ConsumeSuffix(&input, "f"));
+ EXPECT_EQ(input, "abcde");
+
+ EXPECT_TRUE(absl::ConsumeSuffix(&input, "abcde"));
+ EXPECT_EQ(input, "");
+}
+
+TEST(Strip, StripPrefix) {
+ const absl::string_view null_str;
+
+ EXPECT_EQ(absl::StripPrefix("foobar", "foo"), "bar");
+ EXPECT_EQ(absl::StripPrefix("foobar", ""), "foobar");
+ EXPECT_EQ(absl::StripPrefix("foobar", null_str), "foobar");
+ EXPECT_EQ(absl::StripPrefix("foobar", "foobar"), "");
+ EXPECT_EQ(absl::StripPrefix("foobar", "bar"), "foobar");
+ EXPECT_EQ(absl::StripPrefix("foobar", "foobarr"), "foobar");
+ EXPECT_EQ(absl::StripPrefix("", ""), "");
+}
+
+TEST(Strip, StripSuffix) {
+ const absl::string_view null_str;
+
+ EXPECT_EQ(absl::StripSuffix("foobar", "bar"), "foo");
+ EXPECT_EQ(absl::StripSuffix("foobar", ""), "foobar");
+ EXPECT_EQ(absl::StripSuffix("foobar", null_str), "foobar");
+ EXPECT_EQ(absl::StripSuffix("foobar", "foobar"), "");
+ EXPECT_EQ(absl::StripSuffix("foobar", "foo"), "foobar");
+ EXPECT_EQ(absl::StripSuffix("foobar", "ffoobar"), "foobar");
+ EXPECT_EQ(absl::StripSuffix("", ""), "");
+}
+
+TEST(Strip, RemoveExtraAsciiWhitespace) {
+ const char* inputs[] = {
+ "No extra space",
+ " Leading whitespace",
+ "Trailing whitespace ",
+ " Leading and trailing ",
+ " Whitespace \t in\v middle ",
+ "'Eeeeep! \n Newlines!\n",
+ "nospaces",
+ };
+ const char* outputs[] = {
+ "No extra space",
+ "Leading whitespace",
+ "Trailing whitespace",
+ "Leading and trailing",
+ "Whitespace in middle",
+ "'Eeeeep! Newlines!",
+ "nospaces",
+ };
+ int NUM_TESTS = 7;
+
+ for (int i = 0; i < NUM_TESTS; i++) {
+ std::string s(inputs[i]);
+ absl::RemoveExtraAsciiWhitespace(&s);
+ EXPECT_STREQ(outputs[i], s.c_str());
+ }
+
+ // Test that absl::RemoveExtraAsciiWhitespace returns immediately for empty
+ // strings (It was adding the \0 character to the C++ std::string, which broke
+ // tests involving empty())
+ std::string zero_string = "";
+ assert(zero_string.empty());
+ absl::RemoveExtraAsciiWhitespace(&zero_string);
+ EXPECT_EQ(zero_string.size(), 0);
+ EXPECT_TRUE(zero_string.empty());
+}
+
+TEST(Strip, StripTrailingAsciiWhitespace) {
+ std::string test = "foo ";
+ absl::StripTrailingAsciiWhitespace(&test);
+ EXPECT_EQ(test, "foo");
+
+ test = " ";
+ absl::StripTrailingAsciiWhitespace(&test);
+ EXPECT_EQ(test, "");
+
+ test = "";
+ absl::StripTrailingAsciiWhitespace(&test);
+ EXPECT_EQ(test, "");
+
+ test = " abc\t";
+ absl::StripTrailingAsciiWhitespace(&test);
+ EXPECT_EQ(test, " abc");
+}
+
+TEST(String, StripLeadingAsciiWhitespace) {
+ absl::string_view orig = "\t \n\f\r\n\vfoo";
+ EXPECT_EQ("foo", absl::StripLeadingAsciiWhitespace(orig));
+ orig = "\t \n\f\r\v\n\t \n\f\r\v\n";
+ EXPECT_EQ(absl::string_view(), absl::StripLeadingAsciiWhitespace(orig));
+}
+
+TEST(Strip, StripAsciiWhitespace) {
+ std::string test2 = "\t \f\r\n\vfoo \t\f\r\v\n";
+ absl::StripAsciiWhitespace(&test2);
+ EXPECT_EQ(test2, "foo");
+ std::string test3 = "bar";
+ absl::StripAsciiWhitespace(&test3);
+ EXPECT_EQ(test3, "bar");
+ std::string test4 = "\t \f\r\n\vfoo";
+ absl::StripAsciiWhitespace(&test4);
+ EXPECT_EQ(test4, "foo");
+ std::string test5 = "foo \t\f\r\v\n";
+ absl::StripAsciiWhitespace(&test5);
+ EXPECT_EQ(test5, "foo");
+ absl::string_view test6("\t \f\r\n\vfoo \t\f\r\v\n");
+ test6 = absl::StripAsciiWhitespace(test6);
+ EXPECT_EQ(test6, "foo");
+ test6 = absl::StripAsciiWhitespace(test6);
+ EXPECT_EQ(test6, "foo"); // already stripped
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute.cc
new file mode 100644
index 0000000..3b20059
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute.cc
@@ -0,0 +1,170 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/substitute.h"
+
+#include <algorithm>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/internal/resize_uninitialized.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+namespace substitute_internal {
+
+void SubstituteAndAppendArray(std::string* output, absl::string_view format,
+ const absl::string_view* args_array,
+ size_t num_args) {
+ // Determine total size needed.
+ size_t size = 0;
+ for (size_t i = 0; i < format.size(); i++) {
+ if (format[i] == '$') {
+ if (i + 1 >= format.size()) {
+#ifndef NDEBUG
+ ABSL_RAW_LOG(FATAL,
+ "Invalid strings::Substitute() format std::string: \"%s\".",
+ absl::CEscape(format).c_str());
+#endif
+ return;
+ } else if (absl::ascii_isdigit(format[i + 1])) {
+ int index = format[i + 1] - '0';
+ if (static_cast<size_t>(index) >= num_args) {
+#ifndef NDEBUG
+ ABSL_RAW_LOG(
+ FATAL,
+ "Invalid strings::Substitute() format std::string: asked for \"$"
+ "%d\", but only %d args were given. Full format std::string was: "
+ "\"%s\".",
+ index, static_cast<int>(num_args), absl::CEscape(format).c_str());
+#endif
+ return;
+ }
+ size += args_array[index].size();
+ ++i; // Skip next char.
+ } else if (format[i + 1] == '$') {
+ ++size;
+ ++i; // Skip next char.
+ } else {
+#ifndef NDEBUG
+ ABSL_RAW_LOG(FATAL,
+ "Invalid strings::Substitute() format std::string: \"%s\".",
+ absl::CEscape(format).c_str());
+#endif
+ return;
+ }
+ } else {
+ ++size;
+ }
+ }
+
+ if (size == 0) return;
+
+ // Build the std::string.
+ size_t original_size = output->size();
+ strings_internal::STLStringResizeUninitialized(output, original_size + size);
+ char* target = &(*output)[original_size];
+ for (size_t i = 0; i < format.size(); i++) {
+ if (format[i] == '$') {
+ if (absl::ascii_isdigit(format[i + 1])) {
+ const absl::string_view src = args_array[format[i + 1] - '0'];
+ target = std::copy(src.begin(), src.end(), target);
+ ++i; // Skip next char.
+ } else if (format[i + 1] == '$') {
+ *target++ = '$';
+ ++i; // Skip next char.
+ }
+ } else {
+ *target++ = format[i];
+ }
+ }
+
+ assert(target == output->data() + output->size());
+}
+
+static const char kHexDigits[] = "0123456789abcdef";
+Arg::Arg(const void* value) {
+ static_assert(sizeof(scratch_) >= sizeof(value) * 2 + 2,
+ "fix sizeof(scratch_)");
+ if (value == nullptr) {
+ piece_ = "NULL";
+ } else {
+ char* ptr = scratch_ + sizeof(scratch_);
+ uintptr_t num = reinterpret_cast<uintptr_t>(value);
+ do {
+ *--ptr = kHexDigits[num & 0xf];
+ num >>= 4;
+ } while (num != 0);
+ *--ptr = 'x';
+ *--ptr = '0';
+ piece_ = absl::string_view(ptr, scratch_ + sizeof(scratch_) - ptr);
+ }
+}
+
+// TODO(jorg): Don't duplicate so much code between here and str_cat.cc
+Arg::Arg(Hex hex) {
+ char* const end = &scratch_[numbers_internal::kFastToBufferSize];
+ char* writer = end;
+ uint64_t value = hex.value;
+ do {
+ *--writer = kHexDigits[value & 0xF];
+ value >>= 4;
+ } while (value != 0);
+
+ char* beg;
+ if (end - writer < hex.width) {
+ beg = end - hex.width;
+ std::fill_n(beg, writer - beg, hex.fill);
+ } else {
+ beg = writer;
+ }
+
+ piece_ = absl::string_view(beg, end - beg);
+}
+
+// TODO(jorg): Don't duplicate so much code between here and str_cat.cc
+Arg::Arg(Dec dec) {
+ assert(dec.width <= numbers_internal::kFastToBufferSize);
+ char* const end = &scratch_[numbers_internal::kFastToBufferSize];
+ char* const minfill = end - dec.width;
+ char* writer = end;
+ uint64_t value = dec.value;
+ bool neg = dec.neg;
+ while (value > 9) {
+ *--writer = '0' + (value % 10);
+ value /= 10;
+ }
+ *--writer = '0' + value;
+ if (neg) *--writer = '-';
+
+ ptrdiff_t fillers = writer - minfill;
+ if (fillers > 0) {
+ // Tricky: if the fill character is ' ', then it's <fill><+/-><digits>
+ // But...: if the fill character is '0', then it's <+/-><fill><digits>
+ bool add_sign_again = false;
+ if (neg && dec.fill == '0') { // If filling with '0',
+ ++writer; // ignore the sign we just added
+ add_sign_again = true; // and re-add the sign later.
+ }
+ writer -= fillers;
+ std::fill_n(writer, fillers, dec.fill);
+ if (add_sign_again) *--writer = '-';
+ }
+
+ piece_ = absl::string_view(writer, end - writer);
+}
+
+} // namespace substitute_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute.h
new file mode 100644
index 0000000..5747d38
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute.h
@@ -0,0 +1,668 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: substitute.h
+// -----------------------------------------------------------------------------
+//
+// This package contains functions for efficiently performing std::string
+// substitutions using a format std::string with positional notation:
+// `Substitute()` and `SubstituteAndAppend()`.
+//
+// Unlike printf-style format specifiers, `Substitute()` functions do not need
+// to specify the type of the substitution arguments. Supported arguments
+// following the format std::string, such as strings, string_views, ints,
+// floats, and bools, are automatically converted to strings during the
+// substitution process. (See below for a full list of supported types.)
+//
+// `Substitute()` does not allow you to specify *how* to format a value, beyond
+// the default conversion to std::string. For example, you cannot format an integer
+// in hex.
+//
+// The format std::string uses positional identifiers indicated by a dollar sign ($)
+// and single digit positional ids to indicate which substitution arguments to
+// use at that location within the format std::string.
+//
+// Example 1:
+// std::string s = Substitute("$1 purchased $0 $2. Thanks $1!",
+// 5, "Bob", "Apples");
+// EXPECT_EQ("Bob purchased 5 Apples. Thanks Bob!", s);
+//
+// Example 2:
+// std::string s = "Hi. ";
+// SubstituteAndAppend(&s, "My name is $0 and I am $1 years old.", "Bob", 5);
+// EXPECT_EQ("Hi. My name is Bob and I am 5 years old.", s);
+//
+//
+// Supported types:
+// * absl::string_view, std::string, const char* (null is equivalent to "")
+// * int32_t, int64_t, uint32_t, uint64
+// * float, double
+// * bool (Printed as "true" or "false")
+// * pointer types other than char* (Printed as "0x<lower case hex std::string>",
+// except that null is printed as "NULL")
+//
+// If an invalid format std::string is provided, Substitute returns an empty std::string
+// and SubstituteAndAppend does not change the provided output std::string.
+// A format std::string is invalid if it:
+// * ends in an unescaped $ character,
+// e.g. "Hello $", or
+// * calls for a position argument which is not provided,
+// e.g. Substitute("Hello $2", "world"), or
+// * specifies a non-digit, non-$ character after an unescaped $ character,
+// e.g. "Hello $f".
+// In debug mode, i.e. #ifndef NDEBUG, such errors terminate the program.
+
+#ifndef ABSL_STRINGS_SUBSTITUTE_H_
+#define ABSL_STRINGS_SUBSTITUTE_H_
+
+#include <cstring>
+#include <string>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/escaping.h"
+#include "absl/strings/numbers.h"
+#include "absl/strings/str_cat.h"
+#include "absl/strings/str_split.h"
+#include "absl/strings/string_view.h"
+#include "absl/strings/strip.h"
+
+namespace absl {
+namespace substitute_internal {
+
+// Arg
+//
+// This class provides an argument type for `absl::Substitute()` and
+// `absl::SubstituteAndAppend()`. `Arg` handles implicit conversion of various
+// types to a std::string. (`Arg` is very similar to the `AlphaNum` class in
+// `StrCat()`.)
+//
+// This class has implicit constructors.
+class Arg {
+ public:
+ // Overloads for std::string-y things
+ //
+ // Explicitly overload `const char*` so the compiler doesn't cast to `bool`.
+ Arg(const char* value) // NOLINT(runtime/explicit)
+ : piece_(absl::NullSafeStringView(value)) {}
+ Arg(const std::string& value) // NOLINT(runtime/explicit)
+ : piece_(value) {}
+ Arg(absl::string_view value) // NOLINT(runtime/explicit)
+ : piece_(value) {}
+
+ // Overloads for primitives
+ //
+ // No overloads are available for signed and unsigned char because if people
+ // are explicitly declaring their chars as signed or unsigned then they are
+ // probably using them as 8-bit integers and would probably prefer an integer
+ // representation. However, we can't really know, so we make the caller decide
+ // what to do.
+ Arg(char value) // NOLINT(runtime/explicit)
+ : piece_(scratch_, 1) { scratch_[0] = value; }
+ Arg(short value) // NOLINT(*)
+ : piece_(scratch_,
+ numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+ Arg(unsigned short value) // NOLINT(*)
+ : piece_(scratch_,
+ numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+ Arg(int value) // NOLINT(runtime/explicit)
+ : piece_(scratch_,
+ numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+ Arg(unsigned int value) // NOLINT(runtime/explicit)
+ : piece_(scratch_,
+ numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+ Arg(long value) // NOLINT(*)
+ : piece_(scratch_,
+ numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+ Arg(unsigned long value) // NOLINT(*)
+ : piece_(scratch_,
+ numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+ Arg(long long value) // NOLINT(*)
+ : piece_(scratch_,
+ numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+ Arg(unsigned long long value) // NOLINT(*)
+ : piece_(scratch_,
+ numbers_internal::FastIntToBuffer(value, scratch_) - scratch_) {}
+ Arg(float value) // NOLINT(runtime/explicit)
+ : piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_)) {
+ }
+ Arg(double value) // NOLINT(runtime/explicit)
+ : piece_(scratch_, numbers_internal::SixDigitsToBuffer(value, scratch_)) {
+ }
+ Arg(bool value) // NOLINT(runtime/explicit)
+ : piece_(value ? "true" : "false") {}
+
+ Arg(Hex hex); // NOLINT(runtime/explicit)
+ Arg(Dec dec); // NOLINT(runtime/explicit)
+
+ // `void*` values, with the exception of `char*`, are printed as
+ // "0x<hex value>". However, in the case of `nullptr`, "NULL" is printed.
+ Arg(const void* value); // NOLINT(runtime/explicit)
+
+ Arg(const Arg&) = delete;
+ Arg& operator=(const Arg&) = delete;
+
+ absl::string_view piece() const { return piece_; }
+
+ private:
+ absl::string_view piece_;
+ char scratch_[numbers_internal::kFastToBufferSize];
+};
+
+// Internal helper function. Don't call this from outside this implementation.
+// This interface may change without notice.
+void SubstituteAndAppendArray(std::string* output, absl::string_view format,
+ const absl::string_view* args_array,
+ size_t num_args);
+
+#if defined(ABSL_BAD_CALL_IF)
+constexpr int CalculateOneBit(const char* format) {
+ return (*format < '0' || *format > '9') ? 0 : (1 << (*format - '0'));
+}
+
+constexpr const char* SkipNumber(const char* format) {
+ return !*format ? format : (format + 1);
+}
+
+constexpr int PlaceholderBitmask(const char* format) {
+ return !*format ? 0 : *format != '$'
+ ? PlaceholderBitmask(format + 1)
+ : (CalculateOneBit(format + 1) |
+ PlaceholderBitmask(SkipNumber(format + 1)));
+}
+#endif // ABSL_BAD_CALL_IF
+
+} // namespace substitute_internal
+
+//
+// PUBLIC API
+//
+
+// SubstituteAndAppend()
+//
+// Substitutes variables into a given format std::string and appends to a given
+// output std::string. See file comments above for usage.
+//
+// The declarations of `SubstituteAndAppend()` below consist of overloads
+// for passing 0 to 10 arguments, respectively.
+//
+// NOTE: A zero-argument `SubstituteAndAppend()` may be used within variadic
+// templates to allow a variable number of arguments.
+//
+// Example:
+// template <typename... Args>
+// void VarMsg(std::string* boilerplate, absl::string_view format,
+// const Args&... args) {
+// absl::SubstituteAndAppend(boilerplate, format, args...);
+// }
+//
+inline void SubstituteAndAppend(std::string* output, absl::string_view format) {
+ substitute_internal::SubstituteAndAppendArray(output, format, nullptr, 0);
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+ const substitute_internal::Arg& a0) {
+ const absl::string_view args[] = {a0.piece()};
+ substitute_internal::SubstituteAndAppendArray(output, format, args,
+ ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1) {
+ const absl::string_view args[] = {a0.piece(), a1.piece()};
+ substitute_internal::SubstituteAndAppendArray(output, format, args,
+ ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2) {
+ const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece()};
+ substitute_internal::SubstituteAndAppendArray(output, format, args,
+ ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3) {
+ const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+ a3.piece()};
+ substitute_internal::SubstituteAndAppendArray(output, format, args,
+ ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4) {
+ const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+ a3.piece(), a4.piece()};
+ substitute_internal::SubstituteAndAppendArray(output, format, args,
+ ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5) {
+ const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+ a3.piece(), a4.piece(), a5.piece()};
+ substitute_internal::SubstituteAndAppendArray(output, format, args,
+ ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(std::string* output, absl::string_view format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5,
+ const substitute_internal::Arg& a6) {
+ const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+ a3.piece(), a4.piece(), a5.piece(),
+ a6.piece()};
+ substitute_internal::SubstituteAndAppendArray(output, format, args,
+ ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(
+ std::string* output, absl::string_view format,
+ const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
+ const substitute_internal::Arg& a6, const substitute_internal::Arg& a7) {
+ const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+ a3.piece(), a4.piece(), a5.piece(),
+ a6.piece(), a7.piece()};
+ substitute_internal::SubstituteAndAppendArray(output, format, args,
+ ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(
+ std::string* output, absl::string_view format,
+ const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
+ const substitute_internal::Arg& a6, const substitute_internal::Arg& a7,
+ const substitute_internal::Arg& a8) {
+ const absl::string_view args[] = {a0.piece(), a1.piece(), a2.piece(),
+ a3.piece(), a4.piece(), a5.piece(),
+ a6.piece(), a7.piece(), a8.piece()};
+ substitute_internal::SubstituteAndAppendArray(output, format, args,
+ ABSL_ARRAYSIZE(args));
+}
+
+inline void SubstituteAndAppend(
+ std::string* output, absl::string_view format,
+ const substitute_internal::Arg& a0, const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2, const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4, const substitute_internal::Arg& a5,
+ const substitute_internal::Arg& a6, const substitute_internal::Arg& a7,
+ const substitute_internal::Arg& a8, const substitute_internal::Arg& a9) {
+ const absl::string_view args[] = {
+ a0.piece(), a1.piece(), a2.piece(), a3.piece(), a4.piece(),
+ a5.piece(), a6.piece(), a7.piece(), a8.piece(), a9.piece()};
+ substitute_internal::SubstituteAndAppendArray(output, format, args,
+ ABSL_ARRAYSIZE(args));
+}
+
+#if defined(ABSL_BAD_CALL_IF)
+// This body of functions catches cases where the number of placeholders
+// doesn't match the number of data arguments.
+void SubstituteAndAppend(std::string* output, const char* format)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 0,
+ "There were no substitution arguments "
+ "but this format std::string has a $[0-9] in it");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+ const substitute_internal::Arg& a0)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1,
+ "There was 1 substitution argument given, but "
+ "this format std::string is either missing its $0, or "
+ "contains one of $1-$9");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 3,
+ "There were 2 substitution arguments given, but "
+ "this format std::string is either missing its $0/$1, or "
+ "contains one of $2-$9");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 7,
+ "There were 3 substitution arguments given, but "
+ "this format std::string is either missing its $0/$1/$2, or "
+ "contains one of $3-$9");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 15,
+ "There were 4 substitution arguments given, but "
+ "this format std::string is either missing its $0-$3, or "
+ "contains one of $4-$9");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 31,
+ "There were 5 substitution arguments given, but "
+ "this format std::string is either missing its $0-$4, or "
+ "contains one of $5-$9");
+
+void SubstituteAndAppend(std::string* output, const char* format,
+ const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 63,
+ "There were 6 substitution arguments given, but "
+ "this format std::string is either missing its $0-$5, or "
+ "contains one of $6-$9");
+
+void SubstituteAndAppend(
+ std::string* output, const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5, const substitute_internal::Arg& a6)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 127,
+ "There were 7 substitution arguments given, but "
+ "this format std::string is either missing its $0-$6, or "
+ "contains one of $7-$9");
+
+void SubstituteAndAppend(
+ std::string* output, const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+ const substitute_internal::Arg& a7)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 255,
+ "There were 8 substitution arguments given, but "
+ "this format std::string is either missing its $0-$7, or "
+ "contains one of $8-$9");
+
+void SubstituteAndAppend(
+ std::string* output, const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+ const substitute_internal::Arg& a7, const substitute_internal::Arg& a8)
+ ABSL_BAD_CALL_IF(
+ substitute_internal::PlaceholderBitmask(format) != 511,
+ "There were 9 substitution arguments given, but "
+ "this format std::string is either missing its $0-$8, or contains a $9");
+
+void SubstituteAndAppend(
+ std::string* output, const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+ const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
+ const substitute_internal::Arg& a9)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1023,
+ "There were 10 substitution arguments given, but this "
+ "format std::string doesn't contain all of $0 through $9");
+#endif // ABSL_BAD_CALL_IF
+
+// Substitute()
+//
+// Substitutes variables into a given format std::string. See file comments above
+// for usage.
+//
+// The declarations of `Substitute()` below consist of overloads for passing 0
+// to 10 arguments, respectively.
+//
+// NOTE: A zero-argument `Substitute()` may be used within variadic templates to
+// allow a variable number of arguments.
+//
+// Example:
+// template <typename... Args>
+// void VarMsg(absl::string_view format, const Args&... args) {
+// std::string s = absl::Substitute(format, args...);
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(absl::string_view format) {
+ std::string result;
+ SubstituteAndAppend(&result, format);
+ return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+ absl::string_view format, const substitute_internal::Arg& a0) {
+ std::string result;
+ SubstituteAndAppend(&result, format, a0);
+ return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+ absl::string_view format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1) {
+ std::string result;
+ SubstituteAndAppend(&result, format, a0, a1);
+ return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+ absl::string_view format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2) {
+ std::string result;
+ SubstituteAndAppend(&result, format, a0, a1, a2);
+ return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+ absl::string_view format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3) {
+ std::string result;
+ SubstituteAndAppend(&result, format, a0, a1, a2, a3);
+ return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+ absl::string_view format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4) {
+ std::string result;
+ SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4);
+ return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+ absl::string_view format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5) {
+ std::string result;
+ SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5);
+ return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+ absl::string_view format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5, const substitute_internal::Arg& a6) {
+ std::string result;
+ SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6);
+ return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+ absl::string_view format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+ const substitute_internal::Arg& a7) {
+ std::string result;
+ SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7);
+ return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+ absl::string_view format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+ const substitute_internal::Arg& a7, const substitute_internal::Arg& a8) {
+ std::string result;
+ SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8);
+ return result;
+}
+
+ABSL_MUST_USE_RESULT inline std::string Substitute(
+ absl::string_view format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+ const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
+ const substitute_internal::Arg& a9) {
+ std::string result;
+ SubstituteAndAppend(&result, format, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9);
+ return result;
+}
+
+#if defined(ABSL_BAD_CALL_IF)
+// This body of functions catches cases where the number of placeholders
+// doesn't match the number of data arguments.
+std::string Substitute(const char* format)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 0,
+ "There were no substitution arguments "
+ "but this format std::string has a $[0-9] in it");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1,
+ "There was 1 substitution argument given, but "
+ "this format std::string is either missing its $0, or "
+ "contains one of $1-$9");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 3,
+ "There were 2 substitution arguments given, but "
+ "this format std::string is either missing its $0/$1, or "
+ "contains one of $2-$9");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 7,
+ "There were 3 substitution arguments given, but "
+ "this format std::string is either missing its $0/$1/$2, or "
+ "contains one of $3-$9");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 15,
+ "There were 4 substitution arguments given, but "
+ "this format std::string is either missing its $0-$3, or "
+ "contains one of $4-$9");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 31,
+ "There were 5 substitution arguments given, but "
+ "this format std::string is either missing its $0-$4, or "
+ "contains one of $5-$9");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 63,
+ "There were 6 substitution arguments given, but "
+ "this format std::string is either missing its $0-$5, or "
+ "contains one of $6-$9");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5,
+ const substitute_internal::Arg& a6)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 127,
+ "There were 7 substitution arguments given, but "
+ "this format std::string is either missing its $0-$6, or "
+ "contains one of $7-$9");
+
+std::string Substitute(const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1,
+ const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3,
+ const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5,
+ const substitute_internal::Arg& a6,
+ const substitute_internal::Arg& a7)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 255,
+ "There were 8 substitution arguments given, but "
+ "this format std::string is either missing its $0-$7, or "
+ "contains one of $8-$9");
+
+std::string Substitute(
+ const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+ const substitute_internal::Arg& a7, const substitute_internal::Arg& a8)
+ ABSL_BAD_CALL_IF(
+ substitute_internal::PlaceholderBitmask(format) != 511,
+ "There were 9 substitution arguments given, but "
+ "this format std::string is either missing its $0-$8, or contains a $9");
+
+std::string Substitute(
+ const char* format, const substitute_internal::Arg& a0,
+ const substitute_internal::Arg& a1, const substitute_internal::Arg& a2,
+ const substitute_internal::Arg& a3, const substitute_internal::Arg& a4,
+ const substitute_internal::Arg& a5, const substitute_internal::Arg& a6,
+ const substitute_internal::Arg& a7, const substitute_internal::Arg& a8,
+ const substitute_internal::Arg& a9)
+ ABSL_BAD_CALL_IF(substitute_internal::PlaceholderBitmask(format) != 1023,
+ "There were 10 substitution arguments given, but this "
+ "format std::string doesn't contain all of $0 through $9");
+#endif // ABSL_BAD_CALL_IF
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_SUBSTITUTE_H_
[43/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/macros.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/macros.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/macros.h
new file mode 100644
index 0000000..114a7be
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/macros.h
@@ -0,0 +1,202 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: macros.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the set of language macros used within Abseil code.
+// For the set of macros used to determine supported compilers and platforms,
+// see absl/base/config.h instead.
+//
+// This code is compiled directly on many platforms, including client
+// platforms like Windows, Mac, and embedded systems. Before making
+// any changes here, make sure that you're not breaking any platforms.
+//
+
+#ifndef ABSL_BASE_MACROS_H_
+#define ABSL_BASE_MACROS_H_
+
+#include <cassert>
+#include <cstddef>
+
+#include "absl/base/port.h"
+
+// ABSL_ARRAYSIZE()
+//
+// Returns the # of elements in an array as a compile-time constant, which can
+// be used in defining new arrays. If you use this macro on a pointer by
+// mistake, you will get a compile-time error.
+//
+// Note: this template function declaration is used in defining arraysize.
+// Note that the function doesn't need an implementation, as we only
+// use its type.
+namespace absl {
+namespace macros_internal {
+template <typename T, size_t N>
+auto ArraySizeHelper(const T (&array)[N]) -> char (&)[N];
+} // namespace macros_internal
+} // namespace absl
+#define ABSL_ARRAYSIZE(array) \
+ (sizeof(::absl::macros_internal::ArraySizeHelper(array)))
+
+// kLinkerInitialized
+//
+// An enum used only as a constructor argument to indicate that a variable has
+// static storage duration, and that the constructor should do nothing to its
+// state. Use of this macro indicates to the reader that it is legal to
+// declare a static instance of the class, provided the constructor is given
+// the absl::base_internal::kLinkerInitialized argument.
+//
+// Normally, it is unsafe to declare a static variable that has a constructor or
+// a destructor because invocation order is undefined. However, if the type can
+// be zero-initialized (which the loader does for static variables) into a valid
+// state and the type's destructor does not affect storage, then a constructor
+// for static initialization can be declared.
+//
+// Example:
+// // Declaration
+// explicit MyClass(absl::base_internal:LinkerInitialized x) {}
+//
+// // Invocation
+// static MyClass my_global(absl::base_internal::kLinkerInitialized);
+namespace absl {
+namespace base_internal {
+enum LinkerInitialized {
+ kLinkerInitialized = 0,
+};
+} // namespace base_internal
+} // namespace absl
+
+// ABSL_FALLTHROUGH_INTENDED
+//
+// Annotates implicit fall-through between switch labels, allowing a case to
+// indicate intentional fallthrough and turn off warnings about any lack of a
+// `break` statement. The ABSL_FALLTHROUGH_INTENDED macro should be followed by
+// a semicolon and can be used in most places where `break` can, provided that
+// no statements exist between it and the next switch label.
+//
+// Example:
+//
+// switch (x) {
+// case 40:
+// case 41:
+// if (truth_is_out_there) {
+// ++x;
+// ABSL_FALLTHROUGH_INTENDED; // Use instead of/along with annotations
+// // in comments
+// } else {
+// return x;
+// }
+// case 42:
+// ...
+//
+// Notes: when compiled with clang in C++11 mode, the ABSL_FALLTHROUGH_INTENDED
+// macro is expanded to the [[clang::fallthrough]] attribute, which is analysed
+// when performing switch labels fall-through diagnostic
+// (`-Wimplicit-fallthrough`). See clang documentation on language extensions
+// for details:
+// http://clang.llvm.org/docs/AttributeReference.html#fallthrough-clang-fallthrough
+//
+// When used with unsupported compilers, the ABSL_FALLTHROUGH_INTENDED macro
+// has no effect on diagnostics. In any case this macro has no effect on runtime
+// behavior and performance of code.
+#ifdef ABSL_FALLTHROUGH_INTENDED
+#error "ABSL_FALLTHROUGH_INTENDED should not be defined."
+#endif
+
+// TODO(zhangxy): Use c++17 standard [[fallthrough]] macro, when supported.
+#if defined(__clang__) && defined(__has_warning)
+#if __has_feature(cxx_attributes) && __has_warning("-Wimplicit-fallthrough")
+#define ABSL_FALLTHROUGH_INTENDED [[clang::fallthrough]]
+#endif
+#elif defined(__GNUC__) && __GNUC__ >= 7
+#define ABSL_FALLTHROUGH_INTENDED [[gnu::fallthrough]]
+#endif
+
+#ifndef ABSL_FALLTHROUGH_INTENDED
+#define ABSL_FALLTHROUGH_INTENDED \
+ do { \
+ } while (0)
+#endif
+
+// ABSL_DEPRECATED()
+//
+// Marks a deprecated class, struct, enum, function, method and variable
+// declarations. The macro argument is used as a custom diagnostic message (e.g.
+// suggestion of a better alternative).
+//
+// Example:
+//
+// class ABSL_DEPRECATED("Use Bar instead") Foo {...};
+// ABSL_DEPRECATED("Use Baz instead") void Bar() {...}
+//
+// Every usage of a deprecated entity will trigger a warning when compiled with
+// clang's `-Wdeprecated-declarations` option. This option is turned off by
+// default, but the warnings will be reported by clang-tidy.
+#if defined(__clang__) && __cplusplus >= 201103L
+#define ABSL_DEPRECATED(message) __attribute__((deprecated(message)))
+#endif
+
+#ifndef ABSL_DEPRECATED
+#define ABSL_DEPRECATED(message)
+#endif
+
+// ABSL_BAD_CALL_IF()
+//
+// Used on a function overload to trap bad calls: any call that matches the
+// overload will cause a compile-time error. This macro uses a clang-specific
+// "enable_if" attribute, as described at
+// http://clang.llvm.org/docs/AttributeReference.html#enable-if
+//
+// Overloads which use this macro should be bracketed by
+// `#ifdef ABSL_BAD_CALL_IF`.
+//
+// Example:
+//
+// int isdigit(int c);
+// #ifdef ABSL_BAD_CALL_IF
+// int isdigit(int c)
+// ABSL_BAD_CALL_IF(c <= -1 || c > 255,
+// "'c' must have the value of an unsigned char or EOF");
+// #endif // ABSL_BAD_CALL_IF
+
+#if defined(__clang__)
+# if __has_attribute(enable_if)
+# define ABSL_BAD_CALL_IF(expr, msg) \
+ __attribute__((enable_if(expr, "Bad call trap"), unavailable(msg)))
+# endif
+#endif
+
+// ABSL_ASSERT()
+//
+// In C++11, `assert` can't be used portably within constexpr functions.
+// ABSL_ASSERT functions as a runtime assert but works in C++11 constexpr
+// functions. Example:
+//
+// constexpr double Divide(double a, double b) {
+// return ABSL_ASSERT(b != 0), a / b;
+// }
+//
+// This macro is inspired by
+// https://akrzemi1.wordpress.com/2017/05/18/asserts-in-constexpr-functions/
+#if defined(NDEBUG)
+#define ABSL_ASSERT(expr) (false ? (void)(expr) : (void)0)
+#else
+#define ABSL_ASSERT(expr) \
+ (ABSL_PREDICT_TRUE((expr)) ? (void)0 : [] { assert(false && #expr); }())
+#endif
+
+#endif // ABSL_BASE_MACROS_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/optimization.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/optimization.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/optimization.h
new file mode 100644
index 0000000..aaaffa4
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/optimization.h
@@ -0,0 +1,165 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: optimization.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines portable macros for performance optimization.
+
+#ifndef ABSL_BASE_OPTIMIZATION_H_
+#define ABSL_BASE_OPTIMIZATION_H_
+
+#include "absl/base/config.h"
+
+// ABSL_BLOCK_TAIL_CALL_OPTIMIZATION
+//
+// Instructs the compiler to avoid optimizing tail-call recursion. Use of this
+// macro is useful when you wish to preserve the existing function order within
+// a stack trace for logging, debugging, or profiling purposes.
+//
+// Example:
+//
+// int f() {
+// int result = g();
+// ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+// return result;
+// }
+#if defined(__pnacl__)
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#elif defined(__clang__)
+// Clang will not tail call given inline volatile assembly.
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
+#elif defined(__GNUC__)
+// GCC will not tail call given inline volatile assembly.
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __asm__ __volatile__("")
+#elif defined(_MSC_VER)
+#include <intrin.h>
+// The __nop() intrinsic blocks the optimisation.
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() __nop()
+#else
+#define ABSL_BLOCK_TAIL_CALL_OPTIMIZATION() if (volatile int x = 0) { (void)x; }
+#endif
+
+// ABSL_CACHELINE_SIZE
+//
+// Explicitly defines the size of the L1 cache for purposes of alignment.
+// Setting the cacheline size allows you to specify that certain objects be
+// aligned on a cacheline boundary with `ABSL_CACHELINE_ALIGNED` declarations.
+// (See below.)
+//
+// NOTE: this macro should be replaced with the following C++17 features, when
+// those are generally available:
+//
+// * `std::hardware_constructive_interference_size`
+// * `std::hardware_destructive_interference_size`
+//
+// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0154r1.html
+// for more information.
+#if defined(__GNUC__)
+// Cache line alignment
+#if defined(__i386__) || defined(__x86_64__)
+#define ABSL_CACHELINE_SIZE 64
+#elif defined(__powerpc64__)
+#define ABSL_CACHELINE_SIZE 128
+#elif defined(__aarch64__)
+// We would need to read special register ctr_el0 to find out L1 dcache size.
+// This value is a good estimate based on a real aarch64 machine.
+#define ABSL_CACHELINE_SIZE 64
+#elif defined(__arm__)
+// Cache line sizes for ARM: These values are not strictly correct since
+// cache line sizes depend on implementations, not architectures. There
+// are even implementations with cache line sizes configurable at boot
+// time.
+#if defined(__ARM_ARCH_5T__)
+#define ABSL_CACHELINE_SIZE 32
+#elif defined(__ARM_ARCH_7A__)
+#define ABSL_CACHELINE_SIZE 64
+#endif
+#endif
+
+#ifndef ABSL_CACHELINE_SIZE
+// A reasonable default guess. Note that overestimates tend to waste more
+// space, while underestimates tend to waste more time.
+#define ABSL_CACHELINE_SIZE 64
+#endif
+
+// ABSL_CACHELINE_ALIGNED
+//
+// Indicates that the declared object be cache aligned using
+// `ABSL_CACHELINE_SIZE` (see above). Cacheline aligning objects allows you to
+// load a set of related objects in the L1 cache for performance improvements.
+// Cacheline aligning objects properly allows constructive memory sharing and
+// prevents destructive (or "false") memory sharing.
+//
+// NOTE: this macro should be replaced with usage of `alignas()` using
+// `std::hardware_constructive_interference_size` and/or
+// `std::hardware_destructive_interference_size` when available within C++17.
+//
+// See http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0154r1.html
+// for more information.
+//
+// On some compilers, `ABSL_CACHELINE_ALIGNED` expands to
+// `__attribute__((aligned(ABSL_CACHELINE_SIZE)))`. For compilers where this is
+// not known to work, the macro expands to nothing.
+//
+// No further guarantees are made here. The result of applying the macro
+// to variables and types is always implementation-defined.
+//
+// WARNING: It is easy to use this attribute incorrectly, even to the point
+// of causing bugs that are difficult to diagnose, crash, etc. It does not
+// of itself guarantee that objects are aligned to a cache line.
+//
+// Recommendations:
+//
+// 1) Consult compiler documentation; this comment is not kept in sync as
+// toolchains evolve.
+// 2) Verify your use has the intended effect. This often requires inspecting
+// the generated machine code.
+// 3) Prefer applying this attribute to individual variables. Avoid
+// applying it to types. This tends to localize the effect.
+#define ABSL_CACHELINE_ALIGNED __attribute__((aligned(ABSL_CACHELINE_SIZE)))
+
+#else // not GCC
+#define ABSL_CACHELINE_SIZE 64
+#define ABSL_CACHELINE_ALIGNED
+#endif
+
+// ABSL_PREDICT_TRUE, ABSL_PREDICT_FALSE
+//
+// Enables the compiler to prioritize compilation using static analysis for
+// likely paths within a boolean branch.
+//
+// Example:
+//
+// if (ABSL_PREDICT_TRUE(expression)) {
+// return result; // Faster if more likely
+// } else {
+// return 0;
+// }
+//
+// Compilers can use the information that a certain branch is not likely to be
+// taken (for instance, a CHECK failure) to optimize for the common case in
+// the absence of better information (ie. compiling gcc with `-fprofile-arcs`).
+#if ABSL_HAVE_BUILTIN(__builtin_expect) || \
+ (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_PREDICT_FALSE(x) (__builtin_expect(x, 0))
+#define ABSL_PREDICT_TRUE(x) (__builtin_expect(!!(x), 1))
+#else
+#define ABSL_PREDICT_FALSE(x) x
+#define ABSL_PREDICT_TRUE(x) x
+#endif
+
+#endif // ABSL_BASE_OPTIMIZATION_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/policy_checks.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/policy_checks.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/policy_checks.h
new file mode 100644
index 0000000..d634dac
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/policy_checks.h
@@ -0,0 +1,121 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: policy_checks.h
+// -----------------------------------------------------------------------------
+//
+// This header enforces a minimum set of policies at build time, such as the
+// supported compiler and library versions. Unsupported configurations are
+// reported with `#error`. This enforcement is best effort, so successfully
+// compiling this header does not guarantee a supported configuration.
+
+#ifndef ABSL_BASE_POLICY_CHECKS_H_
+#define ABSL_BASE_POLICY_CHECKS_H_
+
+// Included for the __GLIBC_PREREQ macro used below.
+#include <limits.h>
+
+// Included for the _STLPORT_VERSION macro used below.
+#if defined(__cplusplus)
+#include <cstddef>
+#endif
+
+// -----------------------------------------------------------------------------
+// Operating System Check
+// -----------------------------------------------------------------------------
+
+#if defined(__CYGWIN__)
+#error "Cygwin is not supported."
+#endif
+
+// -----------------------------------------------------------------------------
+// Compiler Check
+// -----------------------------------------------------------------------------
+
+// We support MSVC++ 14.0 update 2 and later.
+// This minimum will go up.
+#if defined(_MSC_FULL_VER) && _MSC_FULL_VER < 190023918 && !defined(__clang__)
+#error "This package requires Visual Studio 2015 Update 2 or higher."
+#endif
+
+// We support gcc 4.7 and later.
+// This minimum will go up.
+#if defined(__GNUC__) && !defined(__clang__)
+#if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 7)
+#error "This package requires gcc 4.7 or higher."
+#endif
+#endif
+
+// We support Apple Xcode clang 4.2.1 (version 421.11.65) and later.
+// This corresponds to Apple Xcode version 4.5.
+// This minimum will go up.
+#if defined(__apple_build_version__) && __apple_build_version__ < 4211165
+#error "This package requires __apple_build_version__ of 4211165 or higher."
+#endif
+
+// -----------------------------------------------------------------------------
+// C++ Version Check
+// -----------------------------------------------------------------------------
+
+// Enforce C++11 as the minimum. Note that Visual Studio has not
+// advanced __cplusplus despite being good enough for our purposes, so
+// so we exempt it from the check.
+#if defined(__cplusplus) && !defined(_MSC_VER)
+#if __cplusplus < 201103L
+#error "C++ versions less than C++11 are not supported."
+#endif
+#endif
+
+// -----------------------------------------------------------------------------
+// Standard Library Check
+// -----------------------------------------------------------------------------
+
+// We have chosen glibc 2.12 as the minimum as it was tagged for release
+// in May, 2010 and includes some functionality used in Google software
+// (for instance pthread_setname_np):
+// https://sourceware.org/ml/libc-alpha/2010-05/msg00000.html
+#ifdef __GLIBC_PREREQ
+#if !__GLIBC_PREREQ(2, 12)
+#error "Minimum required version of glibc is 2.12."
+#endif
+#endif
+
+#if defined(_STLPORT_VERSION)
+#error "STLPort is not supported."
+#endif
+
+// -----------------------------------------------------------------------------
+// `char` Size Check
+// -----------------------------------------------------------------------------
+
+// Abseil currently assumes CHAR_BIT == 8. If you would like to use Abseil on a
+// platform where this is not the case, please provide us with the details about
+// your platform so we can consider relaxing this requirement.
+#if CHAR_BIT != 8
+#error "Abseil assumes CHAR_BIT == 8."
+#endif
+
+// -----------------------------------------------------------------------------
+// `int` Size Check
+// -----------------------------------------------------------------------------
+
+// Abseil currently assumes that an int is 4 bytes. If you would like to use
+// Abseil on a platform where this is not the case, please provide us with the
+// details about your platform so we can consider relaxing this requirement.
+#if INT_MAX < 2147483647
+#error "Abseil assumes that int is at least 4 bytes. "
+#endif
+
+#endif // ABSL_BASE_POLICY_CHECKS_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/port.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/port.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/port.h
new file mode 100644
index 0000000..1c67257
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/port.h
@@ -0,0 +1,26 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This files is a forwarding header for other headers containing various
+// portability macros and functions.
+// This file is used for both C and C++!
+
+#ifndef ABSL_BASE_PORT_H_
+#define ABSL_BASE_PORT_H_
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/optimization.h"
+
+#endif // ABSL_BASE_PORT_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/raw_logging_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/raw_logging_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/raw_logging_test.cc
new file mode 100644
index 0000000..dae4b35
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/raw_logging_test.cc
@@ -0,0 +1,50 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This test serves primarily as a compilation test for base/raw_logging.h.
+// Raw logging testing is covered by logging_unittest.cc, which is not as
+// portable as this test.
+
+#include "absl/base/internal/raw_logging.h"
+
+#include "gtest/gtest.h"
+
+namespace {
+
+TEST(RawLoggingCompilationTest, Log) {
+ ABSL_RAW_LOG(INFO, "RAW INFO: %d", 1);
+ ABSL_RAW_LOG(ERROR, "RAW ERROR: %d", 1);
+}
+
+TEST(RawLoggingCompilationTest, PassingCheck) {
+ ABSL_RAW_CHECK(true, "RAW CHECK");
+}
+
+// Not all platforms support output from raw log, so we don't verify any
+// particular output for RAW check failures (expecting the empty std::string
+// accomplishes this). This test is primarily a compilation test, but we
+// are verifying process death when EXPECT_DEATH works for a platform.
+const char kExpectedDeathOutput[] = "";
+
+TEST(RawLoggingDeathTest, FailingCheck) {
+ EXPECT_DEATH_IF_SUPPORTED(ABSL_RAW_CHECK(1 == 0, "explanation"),
+ kExpectedDeathOutput);
+}
+
+TEST(RawLoggingDeathTest, LogFatal) {
+ EXPECT_DEATH_IF_SUPPORTED(ABSL_RAW_LOG(FATAL, "my dog has fleas"),
+ kExpectedDeathOutput);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/spinlock_test_common.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/spinlock_test_common.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/spinlock_test_common.cc
new file mode 100644
index 0000000..1b50884
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/spinlock_test_common.cc
@@ -0,0 +1,266 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// A bunch of threads repeatedly hash an array of ints protected by a
+// spinlock. If the spinlock is working properly, all elements of the
+// array should be equal at the end of the test.
+
+#include <cstdint>
+#include <limits>
+#include <random>
+#include <thread> // NOLINT(build/c++11)
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/attributes.h"
+#include "absl/base/internal/low_level_scheduling.h"
+#include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/internal/spinlock.h"
+#include "absl/base/internal/sysinfo.h"
+#include "absl/base/macros.h"
+#include "absl/synchronization/blocking_counter.h"
+#include "absl/synchronization/notification.h"
+
+constexpr int32_t kNumThreads = 10;
+constexpr int32_t kIters = 1000;
+
+namespace absl {
+namespace base_internal {
+
+// This is defined outside of anonymous namespace so that it can be
+// a friend of SpinLock to access protected methods for testing.
+struct SpinLockTest {
+ static uint32_t EncodeWaitCycles(int64_t wait_start_time,
+ int64_t wait_end_time) {
+ return SpinLock::EncodeWaitCycles(wait_start_time, wait_end_time);
+ }
+ static uint64_t DecodeWaitCycles(uint32_t lock_value) {
+ return SpinLock::DecodeWaitCycles(lock_value);
+ }
+};
+
+namespace {
+
+static constexpr int kArrayLength = 10;
+static uint32_t values[kArrayLength];
+static SpinLock static_spinlock(base_internal::kLinkerInitialized);
+static SpinLock static_cooperative_spinlock(
+ base_internal::kLinkerInitialized,
+ base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL);
+static SpinLock static_noncooperative_spinlock(
+ base_internal::kLinkerInitialized, base_internal::SCHEDULE_KERNEL_ONLY);
+
+
+// Simple integer hash function based on the public domain lookup2 hash.
+// http://burtleburtle.net/bob/c/lookup2.c
+static uint32_t Hash32(uint32_t a, uint32_t c) {
+ uint32_t b = 0x9e3779b9UL; // The golden ratio; an arbitrary value.
+ a -= b; a -= c; a ^= (c >> 13);
+ b -= c; b -= a; b ^= (a << 8);
+ c -= a; c -= b; c ^= (b >> 13);
+ a -= b; a -= c; a ^= (c >> 12);
+ b -= c; b -= a; b ^= (a << 16);
+ c -= a; c -= b; c ^= (b >> 5);
+ a -= b; a -= c; a ^= (c >> 3);
+ b -= c; b -= a; b ^= (a << 10);
+ c -= a; c -= b; c ^= (b >> 15);
+ return c;
+}
+
+static void TestFunction(int thread_salt, SpinLock* spinlock) {
+ for (int i = 0; i < kIters; i++) {
+ SpinLockHolder h(spinlock);
+ for (int j = 0; j < kArrayLength; j++) {
+ const int index = (j + thread_salt) % kArrayLength;
+ values[index] = Hash32(values[index], thread_salt);
+ std::this_thread::yield();
+ }
+ }
+}
+
+static void ThreadedTest(SpinLock* spinlock) {
+ std::vector<std::thread> threads;
+ for (int i = 0; i < kNumThreads; ++i) {
+ threads.push_back(std::thread(TestFunction, i, spinlock));
+ }
+ for (auto& thread : threads) {
+ thread.join();
+ }
+
+ SpinLockHolder h(spinlock);
+ for (int i = 1; i < kArrayLength; i++) {
+ EXPECT_EQ(values[0], values[i]);
+ }
+}
+
+TEST(SpinLock, StackNonCooperativeDisablesScheduling) {
+ SpinLock spinlock(base_internal::SCHEDULE_KERNEL_ONLY);
+ spinlock.Lock();
+ EXPECT_FALSE(base_internal::SchedulingGuard::ReschedulingIsAllowed());
+ spinlock.Unlock();
+}
+
+TEST(SpinLock, StaticNonCooperativeDisablesScheduling) {
+ static_noncooperative_spinlock.Lock();
+ EXPECT_FALSE(base_internal::SchedulingGuard::ReschedulingIsAllowed());
+ static_noncooperative_spinlock.Unlock();
+}
+
+TEST(SpinLock, WaitCyclesEncoding) {
+ // These are implementation details not exported by SpinLock.
+ const int kProfileTimestampShift = 7;
+ const int kLockwordReservedShift = 3;
+ const uint32_t kSpinLockSleeper = 8;
+
+ // We should be able to encode up to (1^kMaxCycleBits - 1) without clamping
+ // but the lower kProfileTimestampShift will be dropped.
+ const int kMaxCyclesShift =
+ 32 - kLockwordReservedShift + kProfileTimestampShift;
+ const uint64_t kMaxCycles = (int64_t{1} << kMaxCyclesShift) - 1;
+
+ // These bits should be zero after encoding.
+ const uint32_t kLockwordReservedMask = (1 << kLockwordReservedShift) - 1;
+
+ // These bits are dropped when wait cycles are encoded.
+ const uint64_t kProfileTimestampMask = (1 << kProfileTimestampShift) - 1;
+
+ // Test a bunch of random values
+ std::default_random_engine generator;
+ // Shift to avoid overflow below.
+ std::uniform_int_distribution<uint64_t> time_distribution(
+ 0, std::numeric_limits<uint64_t>::max() >> 4);
+ std::uniform_int_distribution<uint64_t> cycle_distribution(0, kMaxCycles);
+
+ for (int i = 0; i < 100; i++) {
+ int64_t start_time = time_distribution(generator);
+ int64_t cycles = cycle_distribution(generator);
+ int64_t end_time = start_time + cycles;
+ uint32_t lock_value = SpinLockTest::EncodeWaitCycles(start_time, end_time);
+ EXPECT_EQ(0, lock_value & kLockwordReservedMask);
+ uint64_t decoded = SpinLockTest::DecodeWaitCycles(lock_value);
+ EXPECT_EQ(0, decoded & kProfileTimestampMask);
+ EXPECT_EQ(cycles & ~kProfileTimestampMask, decoded);
+ }
+
+ // Test corner cases
+ int64_t start_time = time_distribution(generator);
+ EXPECT_EQ(0, SpinLockTest::EncodeWaitCycles(start_time, start_time));
+ EXPECT_EQ(0, SpinLockTest::DecodeWaitCycles(0));
+ EXPECT_EQ(0, SpinLockTest::DecodeWaitCycles(kLockwordReservedMask));
+ EXPECT_EQ(kMaxCycles & ~kProfileTimestampMask,
+ SpinLockTest::DecodeWaitCycles(~kLockwordReservedMask));
+
+ // Check that we cannot produce kSpinLockSleeper during encoding.
+ int64_t sleeper_cycles =
+ kSpinLockSleeper << (kProfileTimestampShift - kLockwordReservedShift);
+ uint32_t sleeper_value =
+ SpinLockTest::EncodeWaitCycles(start_time, start_time + sleeper_cycles);
+ EXPECT_NE(sleeper_value, kSpinLockSleeper);
+
+ // Test clamping
+ uint32_t max_value =
+ SpinLockTest::EncodeWaitCycles(start_time, start_time + kMaxCycles);
+ uint64_t max_value_decoded = SpinLockTest::DecodeWaitCycles(max_value);
+ uint64_t expected_max_value_decoded = kMaxCycles & ~kProfileTimestampMask;
+ EXPECT_EQ(expected_max_value_decoded, max_value_decoded);
+
+ const int64_t step = (1 << kProfileTimestampShift);
+ uint32_t after_max_value =
+ SpinLockTest::EncodeWaitCycles(start_time, start_time + kMaxCycles + step);
+ uint64_t after_max_value_decoded =
+ SpinLockTest::DecodeWaitCycles(after_max_value);
+ EXPECT_EQ(expected_max_value_decoded, after_max_value_decoded);
+
+ uint32_t before_max_value = SpinLockTest::EncodeWaitCycles(
+ start_time, start_time + kMaxCycles - step);
+ uint64_t before_max_value_decoded =
+ SpinLockTest::DecodeWaitCycles(before_max_value);
+ EXPECT_GT(expected_max_value_decoded, before_max_value_decoded);
+}
+TEST(SpinLockWithThreads, StaticSpinLock) {
+ ThreadedTest(&static_spinlock);
+}
+TEST(SpinLockWithThreads, StackSpinLock) {
+ SpinLock spinlock;
+ ThreadedTest(&spinlock);
+}
+
+TEST(SpinLockWithThreads, StackCooperativeSpinLock) {
+ SpinLock spinlock(base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL);
+ ThreadedTest(&spinlock);
+}
+
+TEST(SpinLockWithThreads, StackNonCooperativeSpinLock) {
+ SpinLock spinlock(base_internal::SCHEDULE_KERNEL_ONLY);
+ ThreadedTest(&spinlock);
+}
+
+TEST(SpinLockWithThreads, StaticCooperativeSpinLock) {
+ ThreadedTest(&static_cooperative_spinlock);
+}
+
+TEST(SpinLockWithThreads, StaticNonCooperativeSpinLock) {
+ ThreadedTest(&static_noncooperative_spinlock);
+}
+
+TEST(SpinLockWithThreads, DoesNotDeadlock) {
+ struct Helper {
+ static void NotifyThenLock(Notification* locked, SpinLock* spinlock,
+ BlockingCounter* b) {
+ locked->WaitForNotification(); // Wait for LockThenWait() to hold "s".
+ b->DecrementCount();
+ SpinLockHolder l(spinlock);
+ }
+
+ static void LockThenWait(Notification* locked, SpinLock* spinlock,
+ BlockingCounter* b) {
+ SpinLockHolder l(spinlock);
+ locked->Notify();
+ b->Wait();
+ }
+
+ static void DeadlockTest(SpinLock* spinlock, int num_spinners) {
+ Notification locked;
+ BlockingCounter counter(num_spinners);
+ std::vector<std::thread> threads;
+
+ threads.push_back(
+ std::thread(Helper::LockThenWait, &locked, spinlock, &counter));
+ for (int i = 0; i < num_spinners; ++i) {
+ threads.push_back(
+ std::thread(Helper::NotifyThenLock, &locked, spinlock, &counter));
+ }
+
+ for (auto& thread : threads) {
+ thread.join();
+ }
+ }
+ };
+
+ SpinLock stack_cooperative_spinlock(
+ base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL);
+ SpinLock stack_noncooperative_spinlock(base_internal::SCHEDULE_KERNEL_ONLY);
+ Helper::DeadlockTest(&stack_cooperative_spinlock,
+ base_internal::NumCPUs() * 2);
+ Helper::DeadlockTest(&stack_noncooperative_spinlock,
+ base_internal::NumCPUs() * 2);
+ Helper::DeadlockTest(&static_cooperative_spinlock,
+ base_internal::NumCPUs() * 2);
+ Helper::DeadlockTest(&static_noncooperative_spinlock,
+ base_internal::NumCPUs() * 2);
+}
+
+} // namespace
+} // namespace base_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/thread_annotations.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/thread_annotations.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/thread_annotations.h
new file mode 100644
index 0000000..8d30b93
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/thread_annotations.h
@@ -0,0 +1,258 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: thread_annotations.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains macro definitions for thread safety annotations
+// that allow developers to document the locking policies of multi-threaded
+// code. The annotations can also help program analysis tools to identify
+// potential thread safety issues.
+//
+//
+// These annotations are implemented using compiler attributes. Using the macros
+// defined here instead of raw attributes allow for portability and future
+// compatibility.
+//
+// When referring to mutexes in the arguments of the attributes, you should
+// use variable names or more complex expressions (e.g. my_object->mutex_)
+// that evaluate to a concrete mutex object whenever possible. If the mutex
+// you want to refer to is not in scope, you may use a member pointer
+// (e.g. &MyClass::mutex_) to refer to a mutex in some (unknown) object.
+//
+
+#ifndef ABSL_BASE_THREAD_ANNOTATIONS_H_
+#define ABSL_BASE_THREAD_ANNOTATIONS_H_
+#if defined(__clang__)
+#define THREAD_ANNOTATION_ATTRIBUTE__(x) __attribute__((x))
+#else
+#define THREAD_ANNOTATION_ATTRIBUTE__(x) // no-op
+#endif
+
+// GUARDED_BY()
+//
+// Documents if a shared field or global variable needs to be protected by a
+// mutex. GUARDED_BY() allows the user to specify a particular mutex that
+// should be held when accessing the annotated variable.
+//
+// Although this annotation (and PT_GUARDED_BY, below) cannot be applied to
+// local variables, a local variable and its associated mutex can often be
+// combined into a small class or struct, thereby allowing the annotation.
+//
+// Example:
+//
+// class Foo {
+// Mutex mu_;
+// int p1_ GUARDED_BY(mu_);
+// ...
+// };
+#define GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(guarded_by(x))
+
+// PT_GUARDED_BY()
+//
+// Documents if the memory location pointed to by a pointer should be guarded
+// by a mutex when dereferencing the pointer.
+//
+// Example:
+// class Foo {
+// Mutex mu_;
+// int *p1_ PT_GUARDED_BY(mu_);
+// ...
+// };
+//
+// Note that a pointer variable to a shared memory location could itself be a
+// shared variable.
+//
+// Example:
+//
+// // `q_`, guarded by `mu1_`, points to a shared memory location that is
+// // guarded by `mu2_`:
+// int *q_ GUARDED_BY(mu1_) PT_GUARDED_BY(mu2_);
+#define PT_GUARDED_BY(x) THREAD_ANNOTATION_ATTRIBUTE__(pt_guarded_by(x))
+
+// ACQUIRED_AFTER() / ACQUIRED_BEFORE()
+//
+// Documents the acquisition order between locks that can be held
+// simultaneously by a thread. For any two locks that need to be annotated
+// to establish an acquisition order, only one of them needs the annotation.
+// (i.e. You don't have to annotate both locks with both ACQUIRED_AFTER
+// and ACQUIRED_BEFORE.)
+//
+// As with GUARDED_BY, this is only applicable to mutexes that are shared
+// fields or global variables.
+//
+// Example:
+//
+// Mutex m1_;
+// Mutex m2_ ACQUIRED_AFTER(m1_);
+#define ACQUIRED_AFTER(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(acquired_after(__VA_ARGS__))
+
+#define ACQUIRED_BEFORE(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(acquired_before(__VA_ARGS__))
+
+// EXCLUSIVE_LOCKS_REQUIRED() / SHARED_LOCKS_REQUIRED()
+//
+// Documents a function that expects a mutex to be held prior to entry.
+// The mutex is expected to be held both on entry to, and exit from, the
+// function.
+//
+// Example:
+//
+// Mutex mu1, mu2;
+// int a GUARDED_BY(mu1);
+// int b GUARDED_BY(mu2);
+//
+// void foo() EXCLUSIVE_LOCKS_REQUIRED(mu1, mu2) { ... };
+#define EXCLUSIVE_LOCKS_REQUIRED(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(exclusive_locks_required(__VA_ARGS__))
+
+#define SHARED_LOCKS_REQUIRED(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(shared_locks_required(__VA_ARGS__))
+
+// LOCKS_EXCLUDED()
+//
+// Documents the locks acquired in the body of the function. These locks
+// cannot be held when calling this function (as Abseil's `Mutex` locks are
+// non-reentrant).
+#define LOCKS_EXCLUDED(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(locks_excluded(__VA_ARGS__))
+
+// LOCK_RETURNED()
+//
+// Documents a function that returns a mutex without acquiring it. For example,
+// a public getter method that returns a pointer to a private mutex should
+// be annotated with LOCK_RETURNED.
+#define LOCK_RETURNED(x) \
+ THREAD_ANNOTATION_ATTRIBUTE__(lock_returned(x))
+
+// LOCKABLE
+//
+// Documents if a class/type is a lockable type (such as the `Mutex` class).
+#define LOCKABLE \
+ THREAD_ANNOTATION_ATTRIBUTE__(lockable)
+
+// SCOPED_LOCKABLE
+//
+// Documents if a class does RAII locking (such as the `MutexLock` class).
+// The constructor should use `LOCK_FUNCTION()` to specify the mutex that is
+// acquired, and the destructor should use `UNLOCK_FUNCTION()` with no
+// arguments; the analysis will assume that the destructor unlocks whatever the
+// constructor locked.
+#define SCOPED_LOCKABLE \
+ THREAD_ANNOTATION_ATTRIBUTE__(scoped_lockable)
+
+// EXCLUSIVE_LOCK_FUNCTION()
+//
+// Documents functions that acquire a lock in the body of a function, and do
+// not release it.
+#define EXCLUSIVE_LOCK_FUNCTION(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(exclusive_lock_function(__VA_ARGS__))
+
+// SHARED_LOCK_FUNCTION()
+//
+// Documents functions that acquire a shared (reader) lock in the body of a
+// function, and do not release it.
+#define SHARED_LOCK_FUNCTION(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(shared_lock_function(__VA_ARGS__))
+
+// UNLOCK_FUNCTION()
+//
+// Documents functions that expect a lock to be held on entry to the function,
+// and release it in the body of the function.
+#define UNLOCK_FUNCTION(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(unlock_function(__VA_ARGS__))
+
+// EXCLUSIVE_TRYLOCK_FUNCTION() / SHARED_TRYLOCK_FUNCTION()
+//
+// Documents functions that try to acquire a lock, and return success or failure
+// (or a non-boolean value that can be interpreted as a boolean).
+// The first argument should be `true` for functions that return `true` on
+// success, or `false` for functions that return `false` on success. The second
+// argument specifies the mutex that is locked on success. If unspecified, this
+// mutex is assumed to be `this`.
+#define EXCLUSIVE_TRYLOCK_FUNCTION(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(exclusive_trylock_function(__VA_ARGS__))
+
+#define SHARED_TRYLOCK_FUNCTION(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(shared_trylock_function(__VA_ARGS__))
+
+// ASSERT_EXCLUSIVE_LOCK() / ASSERT_SHARED_LOCK()
+//
+// Documents functions that dynamically check to see if a lock is held, and fail
+// if it is not held.
+#define ASSERT_EXCLUSIVE_LOCK(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(assert_exclusive_lock(__VA_ARGS__))
+
+#define ASSERT_SHARED_LOCK(...) \
+ THREAD_ANNOTATION_ATTRIBUTE__(assert_shared_lock(__VA_ARGS__))
+
+// NO_THREAD_SAFETY_ANALYSIS
+//
+// Turns off thread safety checking within the body of a particular function.
+// This annotation is used to mark functions that are known to be correct, but
+// the locking behavior is more complicated than the analyzer can handle.
+#define NO_THREAD_SAFETY_ANALYSIS \
+ THREAD_ANNOTATION_ATTRIBUTE__(no_thread_safety_analysis)
+
+//------------------------------------------------------------------------------
+// Tool-Supplied Annotations
+//------------------------------------------------------------------------------
+
+// TS_UNCHECKED should be placed around lock expressions that are not valid
+// C++ syntax, but which are present for documentation purposes. These
+// annotations will be ignored by the analysis.
+#define TS_UNCHECKED(x) ""
+
+// TS_FIXME is used to mark lock expressions that are not valid C++ syntax.
+// It is used by automated tools to mark and disable invalid expressions.
+// The annotation should either be fixed, or changed to TS_UNCHECKED.
+#define TS_FIXME(x) ""
+
+// Like NO_THREAD_SAFETY_ANALYSIS, this turns off checking within the body of
+// a particular function. However, this attribute is used to mark functions
+// that are incorrect and need to be fixed. It is used by automated tools to
+// avoid breaking the build when the analysis is updated.
+// Code owners are expected to eventually fix the routine.
+#define NO_THREAD_SAFETY_ANALYSIS_FIXME NO_THREAD_SAFETY_ANALYSIS
+
+// Similar to NO_THREAD_SAFETY_ANALYSIS_FIXME, this macro marks a GUARDED_BY
+// annotation that needs to be fixed, because it is producing thread safety
+// warning. It disables the GUARDED_BY.
+#define GUARDED_BY_FIXME(x)
+
+// Disables warnings for a single read operation. This can be used to avoid
+// warnings when it is known that the read is not actually involved in a race,
+// but the compiler cannot confirm that.
+#define TS_UNCHECKED_READ(x) thread_safety_analysis::ts_unchecked_read(x)
+
+
+namespace thread_safety_analysis {
+
+// Takes a reference to a guarded data member, and returns an unguarded
+// reference.
+template <typename T>
+inline const T& ts_unchecked_read(const T& v) NO_THREAD_SAFETY_ANALYSIS {
+ return v;
+}
+
+template <typename T>
+inline T& ts_unchecked_read(T& v) NO_THREAD_SAFETY_ANALYSIS {
+ return v;
+}
+
+} // namespace thread_safety_analysis
+
+#endif // ABSL_BASE_THREAD_ANNOTATIONS_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/throw_delegate_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/throw_delegate_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/throw_delegate_test.cc
new file mode 100644
index 0000000..0f15df0
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/throw_delegate_test.cc
@@ -0,0 +1,94 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/throw_delegate.h"
+
+#include <functional>
+#include <new>
+#include <stdexcept>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+using absl::base_internal::ThrowStdLogicError;
+using absl::base_internal::ThrowStdInvalidArgument;
+using absl::base_internal::ThrowStdDomainError;
+using absl::base_internal::ThrowStdLengthError;
+using absl::base_internal::ThrowStdOutOfRange;
+using absl::base_internal::ThrowStdRuntimeError;
+using absl::base_internal::ThrowStdRangeError;
+using absl::base_internal::ThrowStdOverflowError;
+using absl::base_internal::ThrowStdUnderflowError;
+using absl::base_internal::ThrowStdBadFunctionCall;
+using absl::base_internal::ThrowStdBadAlloc;
+
+constexpr const char* what_arg = "The quick brown fox jumps over the lazy dog";
+
+template <typename E>
+void ExpectThrowChar(void (*f)(const char*)) {
+ try {
+ f(what_arg);
+ FAIL() << "Didn't throw";
+ } catch (const E& e) {
+ EXPECT_STREQ(e.what(), what_arg);
+ }
+}
+
+template <typename E>
+void ExpectThrowString(void (*f)(const std::string&)) {
+ try {
+ f(what_arg);
+ FAIL() << "Didn't throw";
+ } catch (const E& e) {
+ EXPECT_STREQ(e.what(), what_arg);
+ }
+}
+
+template <typename E>
+void ExpectThrowNoWhat(void (*f)()) {
+ try {
+ f();
+ FAIL() << "Didn't throw";
+ } catch (const E& e) {
+ }
+}
+
+TEST(ThrowHelper, Test) {
+ // Not using EXPECT_THROW because we want to check the .what() message too.
+ ExpectThrowChar<std::logic_error>(ThrowStdLogicError);
+ ExpectThrowChar<std::invalid_argument>(ThrowStdInvalidArgument);
+ ExpectThrowChar<std::domain_error>(ThrowStdDomainError);
+ ExpectThrowChar<std::length_error>(ThrowStdLengthError);
+ ExpectThrowChar<std::out_of_range>(ThrowStdOutOfRange);
+ ExpectThrowChar<std::runtime_error>(ThrowStdRuntimeError);
+ ExpectThrowChar<std::range_error>(ThrowStdRangeError);
+ ExpectThrowChar<std::overflow_error>(ThrowStdOverflowError);
+ ExpectThrowChar<std::underflow_error>(ThrowStdUnderflowError);
+
+ ExpectThrowString<std::logic_error>(ThrowStdLogicError);
+ ExpectThrowString<std::invalid_argument>(ThrowStdInvalidArgument);
+ ExpectThrowString<std::domain_error>(ThrowStdDomainError);
+ ExpectThrowString<std::length_error>(ThrowStdLengthError);
+ ExpectThrowString<std::out_of_range>(ThrowStdOutOfRange);
+ ExpectThrowString<std::runtime_error>(ThrowStdRuntimeError);
+ ExpectThrowString<std::range_error>(ThrowStdRangeError);
+ ExpectThrowString<std::overflow_error>(ThrowStdOverflowError);
+ ExpectThrowString<std::underflow_error>(ThrowStdUnderflowError);
+
+ ExpectThrowNoWhat<std::bad_function_call>(ThrowStdBadFunctionCall);
+ ExpectThrowNoWhat<std::bad_alloc>(ThrowStdBadAlloc);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/container/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/container/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/container/BUILD.bazel
new file mode 100644
index 0000000..8bdf631
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/container/BUILD.bazel
@@ -0,0 +1,128 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+ "ABSL_EXCEPTIONS_FLAG",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "fixed_array",
+ hdrs = ["fixed_array.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/algorithm",
+ "//absl/base:core_headers",
+ "//absl/base:dynamic_annotations",
+ "//absl/base:throw_delegate",
+ "//absl/memory",
+ ],
+)
+
+cc_test(
+ name = "fixed_array_test",
+ srcs = ["fixed_array_test.cc"],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":fixed_array",
+ "//absl/base:exception_testing",
+ "//absl/memory",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "fixed_array_test_noexceptions",
+ srcs = ["fixed_array_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":fixed_array",
+ "//absl/base:exception_testing",
+ "//absl/memory",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "inlined_vector",
+ hdrs = ["inlined_vector.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/algorithm",
+ "//absl/base:core_headers",
+ "//absl/base:throw_delegate",
+ "//absl/memory",
+ ],
+)
+
+cc_test(
+ name = "inlined_vector_test",
+ srcs = ["inlined_vector_test.cc"],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":inlined_vector",
+ ":test_instance_tracker",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "//absl/base:exception_testing",
+ "//absl/memory",
+ "//absl/strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "inlined_vector_test_noexceptions",
+ srcs = ["inlined_vector_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":inlined_vector",
+ ":test_instance_tracker",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "//absl/base:exception_testing",
+ "//absl/memory",
+ "//absl/strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "test_instance_tracker",
+ testonly = 1,
+ srcs = ["internal/test_instance_tracker.cc"],
+ hdrs = ["internal/test_instance_tracker.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ visibility = [
+ "//absl:__subpackages__",
+ ],
+)
+
+cc_test(
+ name = "test_instance_tracker_test",
+ srcs = ["internal/test_instance_tracker_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":test_instance_tracker",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/container/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/container/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/container/CMakeLists.txt
new file mode 100644
index 0000000..f56ce92
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/container/CMakeLists.txt
@@ -0,0 +1,126 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+list(APPEND CONTAINER_PUBLIC_HEADERS
+ "fixed_array.h"
+ "inlined_vector.h"
+)
+
+
+list(APPEND CONTAINER_INTERNAL_HEADERS
+ "internal/test_instance_tracker.h"
+)
+
+
+absl_header_library(
+ TARGET
+ absl_container
+ EXPORT_NAME
+ container
+)
+
+
+#
+## TESTS
+#
+
+list(APPEND TEST_INSTANCE_TRACKER_LIB_SRC
+ "internal/test_instance_tracker.cc"
+ ${CONTAINER_PUBLIC_HEADERS}
+ ${CONTAINER_INTERNAL_HEADERS}
+)
+
+
+absl_library(
+ TARGET
+ test_instance_tracker_lib
+ SOURCES
+ ${TEST_INSTANCE_TRACKER_LIB_SRC}
+ PUBLIC_LIBRARIES
+ absl::container
+ DISABLE_INSTALL
+)
+
+
+
+# test fixed_array_test
+set(FIXED_ARRAY_TEST_SRC "fixed_array_test.cc")
+set(FIXED_ARRAY_TEST_PUBLIC_LIBRARIES absl::base absl_throw_delegate test_instance_tracker_lib)
+
+absl_test(
+ TARGET
+ fixed_array_test
+ SOURCES
+ ${FIXED_ARRAY_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${FIXED_ARRAY_TEST_PUBLIC_LIBRARIES}
+ PRIVATE_COMPILE_FLAGS
+ ${ABSL_EXCEPTIONS_FLAG}
+)
+
+
+
+absl_test(
+ TARGET
+ fixed_array_test_noexceptions
+ SOURCES
+ ${FIXED_ARRAY_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${FIXED_ARRAY_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test inlined_vector_test
+set(INLINED_VECTOR_TEST_SRC "inlined_vector_test.cc")
+set(INLINED_VECTOR_TEST_PUBLIC_LIBRARIES absl::base absl_throw_delegate test_instance_tracker_lib)
+
+absl_test(
+ TARGET
+ inlined_vector_test
+ SOURCES
+ ${INLINED_VECTOR_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${INLINED_VECTOR_TEST_PUBLIC_LIBRARIES}
+)
+
+absl_test(
+ TARGET
+ inlined_vector_test_noexceptions
+ SOURCES
+ ${INLINED_VECTOR_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${INLINED_VECTOR_TEST_PUBLIC_LIBRARIES}
+ PRIVATE_COMPILE_FLAGS
+ ${ABSL_NOEXCEPTION_CXXFLAGS}
+)
+
+
+# test test_instance_tracker_test
+set(TEST_INSTANCE_TRACKER_TEST_SRC "internal/test_instance_tracker_test.cc")
+set(TEST_INSTANCE_TRACKER_TEST_PUBLIC_LIBRARIES absl::base absl_throw_delegate test_instance_tracker_lib)
+
+
+absl_test(
+ TARGET
+ test_instance_tracker_test
+ SOURCES
+ ${TEST_INSTANCE_TRACKER_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${TEST_INSTANCE_TRACKER_TEST_PUBLIC_LIBRARIES}
+)
+
+
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/container/fixed_array.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/container/fixed_array.h b/libraries/ostrich/backend/3rdparty/abseil/absl/container/fixed_array.h
new file mode 100644
index 0000000..06bc800
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/container/fixed_array.h
@@ -0,0 +1,498 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: fixed_array.h
+// -----------------------------------------------------------------------------
+//
+// A `FixedArray<T>` represents a non-resizable array of `T` where the length of
+// the array can be determined at run-time. It is a good replacement for
+// non-standard and deprecated uses of `alloca()` and variable length arrays
+// within the GCC extension. (See
+// https://gcc.gnu.org/onlinedocs/gcc/Variable-Length.html).
+//
+// `FixedArray` allocates small arrays inline, keeping performance fast by
+// avoiding heap operations. It also helps reduce the chances of
+// accidentally overflowing your stack if large input is passed to
+// your function.
+
+#ifndef ABSL_CONTAINER_FIXED_ARRAY_H_
+#define ABSL_CONTAINER_FIXED_ARRAY_H_
+
+#include <algorithm>
+#include <array>
+#include <cassert>
+#include <cstddef>
+#include <initializer_list>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <new>
+#include <type_traits>
+
+#include "absl/algorithm/algorithm.h"
+#include "absl/base/dynamic_annotations.h"
+#include "absl/base/internal/throw_delegate.h"
+#include "absl/base/macros.h"
+#include "absl/base/optimization.h"
+#include "absl/base/port.h"
+#include "absl/memory/memory.h"
+
+namespace absl {
+
+constexpr static auto kFixedArrayUseDefault = static_cast<size_t>(-1);
+
+// -----------------------------------------------------------------------------
+// FixedArray
+// -----------------------------------------------------------------------------
+//
+// A `FixedArray` provides a run-time fixed-size array, allocating small arrays
+// inline for efficiency and correctness.
+//
+// Most users should not specify an `inline_elements` argument and let
+// `FixedArray<>` automatically determine the number of elements
+// to store inline based on `sizeof(T)`. If `inline_elements` is specified, the
+// `FixedArray<>` implementation will inline arrays of
+// length <= `inline_elements`.
+//
+// Note that a `FixedArray` constructed with a `size_type` argument will
+// default-initialize its values by leaving trivially constructible types
+// uninitialized (e.g. int, int[4], double), and others default-constructed.
+// This matches the behavior of c-style arrays and `std::array`, but not
+// `std::vector`.
+//
+// Note that `FixedArray` does not provide a public allocator; if it requires a
+// heap allocation, it will do so with global `::operator new[]()` and
+// `::operator delete[]()`, even if T provides class-scope overrides for these
+// operators.
+template <typename T, size_t inlined = kFixedArrayUseDefault>
+class FixedArray {
+ static constexpr size_t kInlineBytesDefault = 256;
+
+ // std::iterator_traits isn't guaranteed to be SFINAE-friendly until C++17,
+ // but this seems to be mostly pedantic.
+ template <typename Iter>
+ using EnableIfForwardIterator = typename std::enable_if<
+ std::is_convertible<
+ typename std::iterator_traits<Iter>::iterator_category,
+ std::forward_iterator_tag>::value,
+ int>::type;
+
+ public:
+ // For playing nicely with stl:
+ using value_type = T;
+ using iterator = T*;
+ using const_iterator = const T*;
+ using reverse_iterator = std::reverse_iterator<iterator>;
+ using const_reverse_iterator = std::reverse_iterator<const_iterator>;
+ using reference = T&;
+ using const_reference = const T&;
+ using pointer = T*;
+ using const_pointer = const T*;
+ using difference_type = ptrdiff_t;
+ using size_type = size_t;
+
+ static constexpr size_type inline_elements =
+ inlined == kFixedArrayUseDefault
+ ? kInlineBytesDefault / sizeof(value_type)
+ : inlined;
+
+ FixedArray(const FixedArray& other) : rep_(other.begin(), other.end()) {}
+ FixedArray(FixedArray&& other) noexcept(
+ // clang-format off
+ absl::allocator_is_nothrow<std::allocator<value_type>>::value &&
+ // clang-format on
+ std::is_nothrow_move_constructible<value_type>::value)
+ : rep_(std::make_move_iterator(other.begin()),
+ std::make_move_iterator(other.end())) {}
+
+ // Creates an array object that can store `n` elements.
+ // Note that trivially constructible elements will be uninitialized.
+ explicit FixedArray(size_type n) : rep_(n) {}
+
+ // Creates an array initialized with `n` copies of `val`.
+ FixedArray(size_type n, const value_type& val) : rep_(n, val) {}
+
+ // Creates an array initialized with the elements from the input
+ // range. The array's size will always be `std::distance(first, last)`.
+ // REQUIRES: Iter must be a forward_iterator or better.
+ template <typename Iter, EnableIfForwardIterator<Iter> = 0>
+ FixedArray(Iter first, Iter last) : rep_(first, last) {}
+
+ // Creates the array from an initializer_list.
+ FixedArray(std::initializer_list<T> init_list)
+ : FixedArray(init_list.begin(), init_list.end()) {}
+
+ ~FixedArray() {}
+
+ // Assignments are deleted because they break the invariant that the size of a
+ // `FixedArray` never changes.
+ void operator=(FixedArray&&) = delete;
+ void operator=(const FixedArray&) = delete;
+
+ // FixedArray::size()
+ //
+ // Returns the length of the fixed array.
+ size_type size() const { return rep_.size(); }
+
+ // FixedArray::max_size()
+ //
+ // Returns the largest possible value of `std::distance(begin(), end())` for a
+ // `FixedArray<T>`. This is equivalent to the most possible addressable bytes
+ // over the number of bytes taken by T.
+ constexpr size_type max_size() const {
+ return std::numeric_limits<difference_type>::max() / sizeof(value_type);
+ }
+
+ // FixedArray::empty()
+ //
+ // Returns whether or not the fixed array is empty.
+ bool empty() const { return size() == 0; }
+
+ // FixedArray::memsize()
+ //
+ // Returns the memory size of the fixed array in bytes.
+ size_t memsize() const { return size() * sizeof(value_type); }
+
+ // FixedArray::data()
+ //
+ // Returns a const T* pointer to elements of the `FixedArray`. This pointer
+ // can be used to access (but not modify) the contained elements.
+ const_pointer data() const { return AsValue(rep_.begin()); }
+
+ // Overload of FixedArray::data() to return a T* pointer to elements of the
+ // fixed array. This pointer can be used to access and modify the contained
+ // elements.
+ pointer data() { return AsValue(rep_.begin()); }
+
+ // FixedArray::operator[]
+ //
+ // Returns a reference the ith element of the fixed array.
+ // REQUIRES: 0 <= i < size()
+ reference operator[](size_type i) {
+ assert(i < size());
+ return data()[i];
+ }
+
+ // Overload of FixedArray::operator()[] to return a const reference to the
+ // ith element of the fixed array.
+ // REQUIRES: 0 <= i < size()
+ const_reference operator[](size_type i) const {
+ assert(i < size());
+ return data()[i];
+ }
+
+ // FixedArray::at
+ //
+ // Bounds-checked access. Returns a reference to the ith element of the
+ // fiexed array, or throws std::out_of_range
+ reference at(size_type i) {
+ if (ABSL_PREDICT_FALSE(i >= size())) {
+ base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
+ }
+ return data()[i];
+ }
+
+ // Overload of FixedArray::at() to return a const reference to the ith element
+ // of the fixed array.
+ const_reference at(size_type i) const {
+ if (ABSL_PREDICT_FALSE(i >= size())) {
+ base_internal::ThrowStdOutOfRange("FixedArray::at failed bounds check");
+ }
+ return data()[i];
+ }
+
+ // FixedArray::front()
+ //
+ // Returns a reference to the first element of the fixed array.
+ reference front() { return *begin(); }
+
+ // Overload of FixedArray::front() to return a reference to the first element
+ // of a fixed array of const values.
+ const_reference front() const { return *begin(); }
+
+ // FixedArray::back()
+ //
+ // Returns a reference to the last element of the fixed array.
+ reference back() { return *(end() - 1); }
+
+ // Overload of FixedArray::back() to return a reference to the last element
+ // of a fixed array of const values.
+ const_reference back() const { return *(end() - 1); }
+
+ // FixedArray::begin()
+ //
+ // Returns an iterator to the beginning of the fixed array.
+ iterator begin() { return data(); }
+
+ // Overload of FixedArray::begin() to return a const iterator to the
+ // beginning of the fixed array.
+ const_iterator begin() const { return data(); }
+
+ // FixedArray::cbegin()
+ //
+ // Returns a const iterator to the beginning of the fixed array.
+ const_iterator cbegin() const { return begin(); }
+
+ // FixedArray::end()
+ //
+ // Returns an iterator to the end of the fixed array.
+ iterator end() { return data() + size(); }
+
+ // Overload of FixedArray::end() to return a const iterator to the end of the
+ // fixed array.
+ const_iterator end() const { return data() + size(); }
+
+ // FixedArray::cend()
+ //
+ // Returns a const iterator to the end of the fixed array.
+ const_iterator cend() const { return end(); }
+
+ // FixedArray::rbegin()
+ //
+ // Returns a reverse iterator from the end of the fixed array.
+ reverse_iterator rbegin() { return reverse_iterator(end()); }
+
+ // Overload of FixedArray::rbegin() to return a const reverse iterator from
+ // the end of the fixed array.
+ const_reverse_iterator rbegin() const {
+ return const_reverse_iterator(end());
+ }
+
+ // FixedArray::crbegin()
+ //
+ // Returns a const reverse iterator from the end of the fixed array.
+ const_reverse_iterator crbegin() const { return rbegin(); }
+
+ // FixedArray::rend()
+ //
+ // Returns a reverse iterator from the beginning of the fixed array.
+ reverse_iterator rend() { return reverse_iterator(begin()); }
+
+ // Overload of FixedArray::rend() for returning a const reverse iterator
+ // from the beginning of the fixed array.
+ const_reverse_iterator rend() const {
+ return const_reverse_iterator(begin());
+ }
+
+ // FixedArray::crend()
+ //
+ // Returns a reverse iterator from the beginning of the fixed array.
+ const_reverse_iterator crend() const { return rend(); }
+
+ // FixedArray::fill()
+ //
+ // Assigns the given `value` to all elements in the fixed array.
+ void fill(const T& value) { std::fill(begin(), end(), value); }
+
+ // Relational operators. Equality operators are elementwise using
+ // `operator==`, while order operators order FixedArrays lexicographically.
+ friend bool operator==(const FixedArray& lhs, const FixedArray& rhs) {
+ return absl::equal(lhs.begin(), lhs.end(), rhs.begin(), rhs.end());
+ }
+
+ friend bool operator!=(const FixedArray& lhs, const FixedArray& rhs) {
+ return !(lhs == rhs);
+ }
+
+ friend bool operator<(const FixedArray& lhs, const FixedArray& rhs) {
+ return std::lexicographical_compare(lhs.begin(), lhs.end(), rhs.begin(),
+ rhs.end());
+ }
+
+ friend bool operator>(const FixedArray& lhs, const FixedArray& rhs) {
+ return rhs < lhs;
+ }
+
+ friend bool operator<=(const FixedArray& lhs, const FixedArray& rhs) {
+ return !(rhs < lhs);
+ }
+
+ friend bool operator>=(const FixedArray& lhs, const FixedArray& rhs) {
+ return !(lhs < rhs);
+ }
+
+ private:
+ // HolderTraits
+ //
+ // Wrapper to hold elements of type T for the case where T is an array type.
+ // If 'T' is an array type, HolderTraits::type is a struct with a 'T v;'.
+ // Otherwise, HolderTraits::type is simply 'T'.
+ //
+ // Maintainer's Note: The simpler solution would be to simply wrap T in a
+ // struct whether it's an array or not: 'struct Holder { T v; };', but
+ // that causes some paranoid diagnostics to misfire about uses of data(),
+ // believing that 'data()' (aka '&rep_.begin().v') is a pointer to a single
+ // element, rather than the packed array that it really is.
+ // e.g.:
+ //
+ // FixedArray<char> buf(1);
+ // sprintf(buf.data(), "foo");
+ //
+ // error: call to int __builtin___sprintf_chk(etc...)
+ // will always overflow destination buffer [-Werror]
+ //
+ class HolderTraits {
+ template <typename U>
+ struct SelectImpl {
+ using type = U;
+ static pointer AsValue(type* p) { return p; }
+ };
+
+ // Partial specialization for elements of array type.
+ template <typename U, size_t N>
+ struct SelectImpl<U[N]> {
+ struct Holder { U v[N]; };
+ using type = Holder;
+ static pointer AsValue(type* p) { return &p->v; }
+ };
+ using Impl = SelectImpl<value_type>;
+
+ public:
+ using type = typename Impl::type;
+
+ static pointer AsValue(type *p) { return Impl::AsValue(p); }
+
+ // TODO(billydonahue): fix the type aliasing violation
+ // this assertion hints at.
+ static_assert(sizeof(type) == sizeof(value_type),
+ "Holder must be same size as value_type");
+ };
+
+ using Holder = typename HolderTraits::type;
+ static pointer AsValue(Holder *p) { return HolderTraits::AsValue(p); }
+
+ // InlineSpace
+ //
+ // Allocate some space, not an array of elements of type T, so that we can
+ // skip calling the T constructors and destructors for space we never use.
+ // How many elements should we store inline?
+ // a. If not specified, use a default of kInlineBytesDefault bytes (This is
+ // currently 256 bytes, which seems small enough to not cause stack overflow
+ // or unnecessary stack pollution, while still allowing stack allocation for
+ // reasonably long character arrays).
+ // b. Never use 0 length arrays (not ISO C++)
+ //
+ template <size_type N, typename = void>
+ class InlineSpace {
+ public:
+ Holder* data() { return reinterpret_cast<Holder*>(space_.data()); }
+ void AnnotateConstruct(size_t n) const { Annotate(n, true); }
+ void AnnotateDestruct(size_t n) const { Annotate(n, false); }
+
+ private:
+#ifndef ADDRESS_SANITIZER
+ void Annotate(size_t, bool) const { }
+#else
+ void Annotate(size_t n, bool creating) const {
+ if (!n) return;
+ const void* bot = &left_redzone_;
+ const void* beg = space_.data();
+ const void* end = space_.data() + n;
+ const void* top = &right_redzone_ + 1;
+ // args: (beg, end, old_mid, new_mid)
+ if (creating) {
+ ANNOTATE_CONTIGUOUS_CONTAINER(beg, top, top, end);
+ ANNOTATE_CONTIGUOUS_CONTAINER(bot, beg, beg, bot);
+ } else {
+ ANNOTATE_CONTIGUOUS_CONTAINER(beg, top, end, top);
+ ANNOTATE_CONTIGUOUS_CONTAINER(bot, beg, bot, beg);
+ }
+ }
+#endif // ADDRESS_SANITIZER
+
+ using Buffer =
+ typename std::aligned_storage<sizeof(Holder), alignof(Holder)>::type;
+
+ ADDRESS_SANITIZER_REDZONE(left_redzone_);
+ std::array<Buffer, N> space_;
+ ADDRESS_SANITIZER_REDZONE(right_redzone_);
+ };
+
+ // specialization when N = 0.
+ template <typename U>
+ class InlineSpace<0, U> {
+ public:
+ Holder* data() { return nullptr; }
+ void AnnotateConstruct(size_t) const {}
+ void AnnotateDestruct(size_t) const {}
+ };
+
+ // Rep
+ //
+ // A const Rep object holds FixedArray's size and data pointer.
+ //
+ class Rep : public InlineSpace<inline_elements> {
+ public:
+ Rep(size_type n, const value_type& val) : n_(n), p_(MakeHolder(n)) {
+ std::uninitialized_fill_n(p_, n, val);
+ }
+
+ explicit Rep(size_type n) : n_(n), p_(MakeHolder(n)) {
+ // Loop optimizes to nothing for trivially constructible T.
+ for (Holder* p = p_; p != p_ + n; ++p)
+ // Note: no parens: default init only.
+ // Also note '::' to avoid Holder class placement new operator.
+ ::new (static_cast<void*>(p)) Holder;
+ }
+
+ template <typename Iter>
+ Rep(Iter first, Iter last)
+ : n_(std::distance(first, last)), p_(MakeHolder(n_)) {
+ std::uninitialized_copy(first, last, AsValue(p_));
+ }
+
+ ~Rep() {
+ // Destruction must be in reverse order.
+ // Loop optimizes to nothing for trivially destructible T.
+ for (Holder* p = end(); p != begin();) (--p)->~Holder();
+ if (IsAllocated(size())) {
+ std::allocator<Holder>().deallocate(p_, n_);
+ } else {
+ this->AnnotateDestruct(size());
+ }
+ }
+ Holder* begin() const { return p_; }
+ Holder* end() const { return p_ + n_; }
+ size_type size() const { return n_; }
+
+ private:
+ Holder* MakeHolder(size_type n) {
+ if (IsAllocated(n)) {
+ return std::allocator<Holder>().allocate(n);
+ } else {
+ this->AnnotateConstruct(n);
+ return this->data();
+ }
+ }
+
+ bool IsAllocated(size_type n) const { return n > inline_elements; }
+
+ const size_type n_;
+ Holder* const p_;
+ };
+
+
+ // Data members
+ Rep rep_;
+};
+
+template <typename T, size_t N>
+constexpr size_t FixedArray<T, N>::inline_elements;
+
+template <typename T, size_t N>
+constexpr size_t FixedArray<T, N>::kInlineBytesDefault;
+
+} // namespace absl
+#endif // ABSL_CONTAINER_FIXED_ARRAY_H_
[59/62] [abbrv] marmotta git commit: [maven-release-plugin] prepare
for next development iteration
Posted by ja...@apache.org.
[maven-release-plugin] prepare for next development iteration
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/d7e87707
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/d7e87707
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/d7e87707
Branch: refs/heads/develop
Commit: d7e877073e4d3c92c9f70ae889fe5437d5fd0c42
Parents: b0e5b93
Author: Jakob Frank <ja...@apache.org>
Authored: Tue Jun 12 13:27:28 2018 +0200
Committer: Jakob Frank <ja...@apache.org>
Committed: Tue Jun 12 13:27:28 2018 +0200
----------------------------------------------------------------------
build/archetypes/marmotta-archetype-module/pom.xml | 2 +-
build/archetypes/marmotta-archetype-webapp/pom.xml | 2 +-
build/archetypes/pom.xml | 2 +-
build/checkstyle-resources/pom.xml | 2 +-
build/dependency-resource-supplement/pom.xml | 2 +-
build/plugins/buildinfo-maven-plugin/pom.xml | 2 +-
build/plugins/marmotta-maven-plugin/pom.xml | 2 +-
build/plugins/pom.xml | 2 +-
build/plugins/refpack-maven-plugin/pom.xml | 2 +-
build/plugins/repocheck-maven-plugin/pom.xml | 2 +-
build/pom.xml | 2 +-
client/marmotta-client-java/pom.xml | 2 +-
client/marmotta-client-js-sample-webapp/pom.xml | 2 +-
client/marmotta-client-js/pom.xml | 2 +-
client/pom.xml | 2 +-
commons/marmotta-commons/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml | 2 +-
.../marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml | 2 +-
.../marmotta-sesame-tools/marmotta-sail-transactions/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml | 2 +-
.../marmotta-sesame-tools/marmotta-util-tripletable/pom.xml | 2 +-
commons/marmotta-sesame-tools/pom.xml | 2 +-
commons/pom.xml | 2 +-
extras/pom.xml | 2 +-
extras/webjars/codemirror/pom.xml | 2 +-
extras/webjars/pom.xml | 2 +-
extras/webjars/strftime/pom.xml | 2 +-
launchers/marmotta-installer/pom.xml | 2 +-
launchers/marmotta-splash/pom.xml | 2 +-
launchers/marmotta-webapp/pom.xml | 2 +-
launchers/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-ehcache/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-hazelcast/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-infinispan/pom.xml | 2 +-
libraries/kiwi/kiwi-loader/pom.xml | 2 +-
libraries/kiwi/kiwi-reasoner/pom.xml | 2 +-
libraries/kiwi/kiwi-sparql/pom.xml | 2 +-
libraries/kiwi/kiwi-triplestore/pom.xml | 2 +-
libraries/kiwi/kiwi-versioning/pom.xml | 2 +-
libraries/kiwi/pom.xml | 2 +-
libraries/ldcache/ldcache-api/pom.xml | 2 +-
libraries/ldcache/ldcache-backend-file/pom.xml | 2 +-
libraries/ldcache/ldcache-backend-infinispan/pom.xml | 2 +-
libraries/ldcache/ldcache-backend-kiwi/pom.xml | 2 +-
libraries/ldcache/ldcache-core/pom.xml | 2 +-
libraries/ldcache/ldcache-sail-generic/pom.xml | 2 +-
libraries/ldcache/ldcache-sail-kiwi/pom.xml | 2 +-
libraries/ldcache/pom.xml | 2 +-
libraries/ldclient/ldclient-api/pom.xml | 2 +-
libraries/ldclient/ldclient-core/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-facebook/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-html/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-ldap/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-mediawiki/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-phpbb/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-rdf/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-rdfa/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-vimeo/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-xml/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-youtube/pom.xml | 2 +-
libraries/ldclient/pom.xml | 2 +-
libraries/ldpath/ldpath-api/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-file/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-jena/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-linkeddata/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-sesame/pom.xml | 2 +-
libraries/ldpath/ldpath-core-bundle/pom.xml | 2 +-
libraries/ldpath/ldpath-core/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-collections/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-date/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-html/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-json/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-math/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-text/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-xml/pom.xml | 2 +-
libraries/ldpath/ldpath-ldquery-cli/pom.xml | 2 +-
libraries/ldpath/ldpath-template-linkeddata/pom.xml | 2 +-
libraries/ldpath/ldpath-template/pom.xml | 2 +-
libraries/ldpath/pom.xml | 2 +-
libraries/pom.xml | 2 +-
loader/marmotta-loader-berkeley/pom.xml | 2 +-
loader/marmotta-loader-core/pom.xml | 2 +-
loader/marmotta-loader-hbase/pom.xml | 2 +-
loader/marmotta-loader-kiwi/pom.xml | 2 +-
loader/marmotta-loader-titan/pom.xml | 2 +-
loader/pom.xml | 2 +-
parent/pom.xml | 6 +-----
platform/backends/marmotta-backend-accumulograph/pom.xml | 2 +-
platform/backends/marmotta-backend-kiwi/pom.xml | 2 +-
platform/backends/marmotta-backend-memory/pom.xml | 2 +-
platform/backends/marmotta-backend-native/pom.xml | 2 +-
platform/backends/marmotta-backend-titan/pom.xml | 2 +-
platform/backends/pom.xml | 2 +-
platform/ldcache/marmotta-ldcache-common/pom.xml | 2 +-
platform/ldcache/marmotta-ldcache-file/pom.xml | 2 +-
platform/ldcache/marmotta-ldcache-kiwi/pom.xml | 2 +-
platform/ldcache/pom.xml | 2 +-
platform/marmotta-core/pom.xml | 2 +-
platform/marmotta-ldp/pom.xml | 2 +-
platform/marmotta-ldpath/pom.xml | 2 +-
platform/marmotta-reasoner-kiwi/pom.xml | 2 +-
platform/marmotta-security/pom.xml | 2 +-
platform/marmotta-sparql/pom.xml | 2 +-
platform/marmotta-user/pom.xml | 2 +-
platform/marmotta-versioning-common/pom.xml | 2 +-
platform/marmotta-versioning-kiwi/pom.xml | 2 +-
platform/marmotta-zookeeper/pom.xml | 2 +-
platform/pom.xml | 2 +-
pom.xml | 4 ++--
116 files changed, 117 insertions(+), 121 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/archetypes/marmotta-archetype-module/pom.xml
----------------------------------------------------------------------
diff --git a/build/archetypes/marmotta-archetype-module/pom.xml b/build/archetypes/marmotta-archetype-module/pom.xml
index 2a00be0..cec6dee 100644
--- a/build/archetypes/marmotta-archetype-module/pom.xml
+++ b/build/archetypes/marmotta-archetype-module/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/archetypes/marmotta-archetype-webapp/pom.xml
----------------------------------------------------------------------
diff --git a/build/archetypes/marmotta-archetype-webapp/pom.xml b/build/archetypes/marmotta-archetype-webapp/pom.xml
index 087135f..d1fea1d 100644
--- a/build/archetypes/marmotta-archetype-webapp/pom.xml
+++ b/build/archetypes/marmotta-archetype-webapp/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/archetypes/pom.xml
----------------------------------------------------------------------
diff --git a/build/archetypes/pom.xml b/build/archetypes/pom.xml
index 2338f04..80bc146 100644
--- a/build/archetypes/pom.xml
+++ b/build/archetypes/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
<artifactId>archetypes-reactor</artifactId>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/checkstyle-resources/pom.xml
----------------------------------------------------------------------
diff --git a/build/checkstyle-resources/pom.xml b/build/checkstyle-resources/pom.xml
index e1ccbb7..62ef34d 100644
--- a/build/checkstyle-resources/pom.xml
+++ b/build/checkstyle-resources/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/dependency-resource-supplement/pom.xml
----------------------------------------------------------------------
diff --git a/build/dependency-resource-supplement/pom.xml b/build/dependency-resource-supplement/pom.xml
index 7e0ec1b..51065c5 100644
--- a/build/dependency-resource-supplement/pom.xml
+++ b/build/dependency-resource-supplement/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/plugins/buildinfo-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/buildinfo-maven-plugin/pom.xml b/build/plugins/buildinfo-maven-plugin/pom.xml
index eee29df..adfa014 100644
--- a/build/plugins/buildinfo-maven-plugin/pom.xml
+++ b/build/plugins/buildinfo-maven-plugin/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/plugins/marmotta-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/marmotta-maven-plugin/pom.xml b/build/plugins/marmotta-maven-plugin/pom.xml
index c0ce8e9..60f6417 100644
--- a/build/plugins/marmotta-maven-plugin/pom.xml
+++ b/build/plugins/marmotta-maven-plugin/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../</relativePath>
<artifactId>plugins-reactor</artifactId>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/plugins/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/pom.xml b/build/plugins/pom.xml
index ba775ac..7eaca87 100644
--- a/build/plugins/pom.xml
+++ b/build/plugins/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/plugins/refpack-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/refpack-maven-plugin/pom.xml b/build/plugins/refpack-maven-plugin/pom.xml
index f1fe33c..b6baf6f 100644
--- a/build/plugins/refpack-maven-plugin/pom.xml
+++ b/build/plugins/refpack-maven-plugin/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<artifactId>plugins-reactor</artifactId>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/plugins/repocheck-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/repocheck-maven-plugin/pom.xml b/build/plugins/repocheck-maven-plugin/pom.xml
index c1beb9e..c5a03e1 100644
--- a/build/plugins/repocheck-maven-plugin/pom.xml
+++ b/build/plugins/repocheck-maven-plugin/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>plugins-reactor</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../</relativePath>
<!-- <artifactId>maven-plugins</artifactId> <groupId>org.apache.maven.plugins</groupId>
<version>23</version> <relativePath /> -->
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/build/pom.xml
----------------------------------------------------------------------
diff --git a/build/pom.xml b/build/pom.xml
index 0bebd2e..34146d8 100644
--- a/build/pom.xml
+++ b/build/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/client/marmotta-client-java/pom.xml
----------------------------------------------------------------------
diff --git a/client/marmotta-client-java/pom.xml b/client/marmotta-client-java/pom.xml
index 6a38fb2..3a26298 100644
--- a/client/marmotta-client-java/pom.xml
+++ b/client/marmotta-client-java/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/client/marmotta-client-js-sample-webapp/pom.xml
----------------------------------------------------------------------
diff --git a/client/marmotta-client-js-sample-webapp/pom.xml b/client/marmotta-client-js-sample-webapp/pom.xml
index 584251d..6b58414 100644
--- a/client/marmotta-client-js-sample-webapp/pom.xml
+++ b/client/marmotta-client-js-sample-webapp/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent/pom.xml</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/client/marmotta-client-js/pom.xml
----------------------------------------------------------------------
diff --git a/client/marmotta-client-js/pom.xml b/client/marmotta-client-js/pom.xml
index 8245b8c..8ecfadc 100644
--- a/client/marmotta-client-js/pom.xml
+++ b/client/marmotta-client-js/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent/pom.xml</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/client/pom.xml
----------------------------------------------------------------------
diff --git a/client/pom.xml b/client/pom.xml
index 9dc1dd7..b3be40e 100644
--- a/client/pom.xml
+++ b/client/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-commons/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-commons/pom.xml b/commons/marmotta-commons/pom.xml
index 39c0de3..042deac 100644
--- a/commons/marmotta-commons/pom.xml
+++ b/commons/marmotta-commons/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml b/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
index c0a38bb..ec8a24c 100644
--- a/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
index be494cc..6ef5808 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
index f10b42b..0c424e6 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
index ebdb353..d5be402 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
index b6cc99f..0915563 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml b/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
index 1aa196d..db31a7b 100644
--- a/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml b/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
index 85e0071..7d978f3 100644
--- a/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml b/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
index f9ec969..7971ba3 100644
--- a/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
index 9a41a0d..5fab0e1 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
index f840141..db1ce95 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
index 01c6c85..862df53 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
index e556426..5a455d0 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/marmotta-sesame-tools/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/pom.xml b/commons/marmotta-sesame-tools/pom.xml
index f0a1af9..073a227 100644
--- a/commons/marmotta-sesame-tools/pom.xml
+++ b/commons/marmotta-sesame-tools/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/commons/pom.xml
----------------------------------------------------------------------
diff --git a/commons/pom.xml b/commons/pom.xml
index 3697ca3..2b20596 100644
--- a/commons/pom.xml
+++ b/commons/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/extras/pom.xml
----------------------------------------------------------------------
diff --git a/extras/pom.xml b/extras/pom.xml
index 50aafd5..4eefed7 100644
--- a/extras/pom.xml
+++ b/extras/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/extras/webjars/codemirror/pom.xml
----------------------------------------------------------------------
diff --git a/extras/webjars/codemirror/pom.xml b/extras/webjars/codemirror/pom.xml
index 24057c6..db9ee9e 100644
--- a/extras/webjars/codemirror/pom.xml
+++ b/extras/webjars/codemirror/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/extras/webjars/pom.xml
----------------------------------------------------------------------
diff --git a/extras/webjars/pom.xml b/extras/webjars/pom.xml
index 1407c83..020e1e9 100644
--- a/extras/webjars/pom.xml
+++ b/extras/webjars/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/extras/webjars/strftime/pom.xml
----------------------------------------------------------------------
diff --git a/extras/webjars/strftime/pom.xml b/extras/webjars/strftime/pom.xml
index 2ebb335..94a0083 100644
--- a/extras/webjars/strftime/pom.xml
+++ b/extras/webjars/strftime/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/launchers/marmotta-installer/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/marmotta-installer/pom.xml b/launchers/marmotta-installer/pom.xml
index 045adb8..90b3a3d 100644
--- a/launchers/marmotta-installer/pom.xml
+++ b/launchers/marmotta-installer/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/launchers/marmotta-splash/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/marmotta-splash/pom.xml b/launchers/marmotta-splash/pom.xml
index e464ee3..b153c37 100644
--- a/launchers/marmotta-splash/pom.xml
+++ b/launchers/marmotta-splash/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/launchers/marmotta-webapp/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/marmotta-webapp/pom.xml b/launchers/marmotta-webapp/pom.xml
index 3718b17..fcd9a77 100644
--- a/launchers/marmotta-webapp/pom.xml
+++ b/launchers/marmotta-webapp/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/launchers/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/pom.xml b/launchers/pom.xml
index 0df37e6..d923697 100644
--- a/launchers/pom.xml
+++ b/launchers/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/kiwi/kiwi-caching-ehcache/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-caching-ehcache/pom.xml b/libraries/kiwi/kiwi-caching-ehcache/pom.xml
index 8e0dbf2..50d8f7c 100644
--- a/libraries/kiwi/kiwi-caching-ehcache/pom.xml
+++ b/libraries/kiwi/kiwi-caching-ehcache/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-caching-hazelcast/pom.xml b/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
index 8b19a26..403e2f2 100644
--- a/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
+++ b/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/kiwi/kiwi-caching-infinispan/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-caching-infinispan/pom.xml b/libraries/kiwi/kiwi-caching-infinispan/pom.xml
index 833c4a9..ddfff18 100644
--- a/libraries/kiwi/kiwi-caching-infinispan/pom.xml
+++ b/libraries/kiwi/kiwi-caching-infinispan/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/kiwi/kiwi-loader/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-loader/pom.xml b/libraries/kiwi/kiwi-loader/pom.xml
index c0df08e..33ea006 100644
--- a/libraries/kiwi/kiwi-loader/pom.xml
+++ b/libraries/kiwi/kiwi-loader/pom.xml
@@ -14,7 +14,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
</parent>
<artifactId>kiwi-loader</artifactId>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/kiwi/kiwi-reasoner/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-reasoner/pom.xml b/libraries/kiwi/kiwi-reasoner/pom.xml
index 7432004..09273f2 100644
--- a/libraries/kiwi/kiwi-reasoner/pom.xml
+++ b/libraries/kiwi/kiwi-reasoner/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/kiwi/kiwi-sparql/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-sparql/pom.xml b/libraries/kiwi/kiwi-sparql/pom.xml
index 782277c..1483551 100644
--- a/libraries/kiwi/kiwi-sparql/pom.xml
+++ b/libraries/kiwi/kiwi-sparql/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/kiwi/kiwi-triplestore/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-triplestore/pom.xml b/libraries/kiwi/kiwi-triplestore/pom.xml
index 9c98c20..148b5e6 100644
--- a/libraries/kiwi/kiwi-triplestore/pom.xml
+++ b/libraries/kiwi/kiwi-triplestore/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/kiwi/kiwi-versioning/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-versioning/pom.xml b/libraries/kiwi/kiwi-versioning/pom.xml
index 6ce814c..3def9a5 100644
--- a/libraries/kiwi/kiwi-versioning/pom.xml
+++ b/libraries/kiwi/kiwi-versioning/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/pom.xml b/libraries/kiwi/pom.xml
index a6a7a58..0642f1a 100644
--- a/libraries/kiwi/pom.xml
+++ b/libraries/kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldcache/ldcache-api/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-api/pom.xml b/libraries/ldcache/ldcache-api/pom.xml
index cf1634b..1655db9 100644
--- a/libraries/ldcache/ldcache-api/pom.xml
+++ b/libraries/ldcache/ldcache-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldcache/ldcache-backend-file/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-backend-file/pom.xml b/libraries/ldcache/ldcache-backend-file/pom.xml
index ba8b274..0e47bf7 100644
--- a/libraries/ldcache/ldcache-backend-file/pom.xml
+++ b/libraries/ldcache/ldcache-backend-file/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldcache/ldcache-backend-infinispan/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-backend-infinispan/pom.xml b/libraries/ldcache/ldcache-backend-infinispan/pom.xml
index 41aaf9f..92694ab 100644
--- a/libraries/ldcache/ldcache-backend-infinispan/pom.xml
+++ b/libraries/ldcache/ldcache-backend-infinispan/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldcache/ldcache-backend-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-backend-kiwi/pom.xml b/libraries/ldcache/ldcache-backend-kiwi/pom.xml
index b227eab..1806ba8 100644
--- a/libraries/ldcache/ldcache-backend-kiwi/pom.xml
+++ b/libraries/ldcache/ldcache-backend-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldcache/ldcache-core/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-core/pom.xml b/libraries/ldcache/ldcache-core/pom.xml
index 21997b9..ff17878 100644
--- a/libraries/ldcache/ldcache-core/pom.xml
+++ b/libraries/ldcache/ldcache-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldcache/ldcache-sail-generic/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-sail-generic/pom.xml b/libraries/ldcache/ldcache-sail-generic/pom.xml
index 4a0e6f4..382b38a 100644
--- a/libraries/ldcache/ldcache-sail-generic/pom.xml
+++ b/libraries/ldcache/ldcache-sail-generic/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldcache/ldcache-sail-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-sail-kiwi/pom.xml b/libraries/ldcache/ldcache-sail-kiwi/pom.xml
index a844934..9a5ba84 100644
--- a/libraries/ldcache/ldcache-sail-kiwi/pom.xml
+++ b/libraries/ldcache/ldcache-sail-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldcache/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/pom.xml b/libraries/ldcache/pom.xml
index 2874143..d011c63 100644
--- a/libraries/ldcache/pom.xml
+++ b/libraries/ldcache/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-api/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-api/pom.xml b/libraries/ldclient/ldclient-api/pom.xml
index 1634c79..fd76ce0 100644
--- a/libraries/ldclient/ldclient-api/pom.xml
+++ b/libraries/ldclient/ldclient-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-core/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-core/pom.xml b/libraries/ldclient/ldclient-core/pom.xml
index d350020..7669cdb 100644
--- a/libraries/ldclient/ldclient-core/pom.xml
+++ b/libraries/ldclient/ldclient-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-provider-facebook/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-facebook/pom.xml b/libraries/ldclient/ldclient-provider-facebook/pom.xml
index 7ab6d44..b1fe28d 100644
--- a/libraries/ldclient/ldclient-provider-facebook/pom.xml
+++ b/libraries/ldclient/ldclient-provider-facebook/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-provider-html/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-html/pom.xml b/libraries/ldclient/ldclient-provider-html/pom.xml
index 3c7c6a3..371c3e2 100644
--- a/libraries/ldclient/ldclient-provider-html/pom.xml
+++ b/libraries/ldclient/ldclient-provider-html/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-provider-ldap/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-ldap/pom.xml b/libraries/ldclient/ldclient-provider-ldap/pom.xml
index 5697646..e37405e 100644
--- a/libraries/ldclient/ldclient-provider-ldap/pom.xml
+++ b/libraries/ldclient/ldclient-provider-ldap/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-mediawiki/pom.xml b/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
index 636c533..e41e73d 100644
--- a/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
+++ b/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-provider-phpbb/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-phpbb/pom.xml b/libraries/ldclient/ldclient-provider-phpbb/pom.xml
index b73f601..6c9e394 100644
--- a/libraries/ldclient/ldclient-provider-phpbb/pom.xml
+++ b/libraries/ldclient/ldclient-provider-phpbb/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-provider-rdf/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-rdf/pom.xml b/libraries/ldclient/ldclient-provider-rdf/pom.xml
index fbbd3be..37e00a9 100644
--- a/libraries/ldclient/ldclient-provider-rdf/pom.xml
+++ b/libraries/ldclient/ldclient-provider-rdf/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-provider-rdfa/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-rdfa/pom.xml b/libraries/ldclient/ldclient-provider-rdfa/pom.xml
index e3c4020..45098b9 100644
--- a/libraries/ldclient/ldclient-provider-rdfa/pom.xml
+++ b/libraries/ldclient/ldclient-provider-rdfa/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-provider-vimeo/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-vimeo/pom.xml b/libraries/ldclient/ldclient-provider-vimeo/pom.xml
index dd6eb6b..a69ed66 100644
--- a/libraries/ldclient/ldclient-provider-vimeo/pom.xml
+++ b/libraries/ldclient/ldclient-provider-vimeo/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-provider-xml/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-xml/pom.xml b/libraries/ldclient/ldclient-provider-xml/pom.xml
index 1146025..87ab907 100644
--- a/libraries/ldclient/ldclient-provider-xml/pom.xml
+++ b/libraries/ldclient/ldclient-provider-xml/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/ldclient-provider-youtube/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-youtube/pom.xml b/libraries/ldclient/ldclient-provider-youtube/pom.xml
index d49b755..04efea4 100644
--- a/libraries/ldclient/ldclient-provider-youtube/pom.xml
+++ b/libraries/ldclient/ldclient-provider-youtube/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldclient/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/pom.xml b/libraries/ldclient/pom.xml
index c66058b..9db23f5 100644
--- a/libraries/ldclient/pom.xml
+++ b/libraries/ldclient/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-api/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-api/pom.xml b/libraries/ldpath/ldpath-api/pom.xml
index 8bacad0..9d5fa36 100644
--- a/libraries/ldpath/ldpath-api/pom.xml
+++ b/libraries/ldpath/ldpath-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-backend-file/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-file/pom.xml b/libraries/ldpath/ldpath-backend-file/pom.xml
index 0584f0d..f1b4a5e 100644
--- a/libraries/ldpath/ldpath-backend-file/pom.xml
+++ b/libraries/ldpath/ldpath-backend-file/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-backend-jena/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-jena/pom.xml b/libraries/ldpath/ldpath-backend-jena/pom.xml
index 1b83d2f..2f85a97 100644
--- a/libraries/ldpath/ldpath-backend-jena/pom.xml
+++ b/libraries/ldpath/ldpath-backend-jena/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-linkeddata/pom.xml b/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
index fbb5388..4a30941 100644
--- a/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
+++ b/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-backend-sesame/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-sesame/pom.xml b/libraries/ldpath/ldpath-backend-sesame/pom.xml
index 4de5163..699a8de 100644
--- a/libraries/ldpath/ldpath-backend-sesame/pom.xml
+++ b/libraries/ldpath/ldpath-backend-sesame/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-core-bundle/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-core-bundle/pom.xml b/libraries/ldpath/ldpath-core-bundle/pom.xml
index 0797860..5eb24ca 100644
--- a/libraries/ldpath/ldpath-core-bundle/pom.xml
+++ b/libraries/ldpath/ldpath-core-bundle/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-core/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-core/pom.xml b/libraries/ldpath/ldpath-core/pom.xml
index 085d86c..2d59f62 100644
--- a/libraries/ldpath/ldpath-core/pom.xml
+++ b/libraries/ldpath/ldpath-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-functions-collections/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-collections/pom.xml b/libraries/ldpath/ldpath-functions-collections/pom.xml
index 3644308..0506544 100644
--- a/libraries/ldpath/ldpath-functions-collections/pom.xml
+++ b/libraries/ldpath/ldpath-functions-collections/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-functions-date/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-date/pom.xml b/libraries/ldpath/ldpath-functions-date/pom.xml
index bdbd631..e89c170 100644
--- a/libraries/ldpath/ldpath-functions-date/pom.xml
+++ b/libraries/ldpath/ldpath-functions-date/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-functions-html/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-html/pom.xml b/libraries/ldpath/ldpath-functions-html/pom.xml
index d2c2de9..89c4c59 100644
--- a/libraries/ldpath/ldpath-functions-html/pom.xml
+++ b/libraries/ldpath/ldpath-functions-html/pom.xml
@@ -19,7 +19,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-functions-json/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-json/pom.xml b/libraries/ldpath/ldpath-functions-json/pom.xml
index 89569c6..dad271a 100644
--- a/libraries/ldpath/ldpath-functions-json/pom.xml
+++ b/libraries/ldpath/ldpath-functions-json/pom.xml
@@ -19,7 +19,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-functions-math/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-math/pom.xml b/libraries/ldpath/ldpath-functions-math/pom.xml
index b726355..8b8b006 100644
--- a/libraries/ldpath/ldpath-functions-math/pom.xml
+++ b/libraries/ldpath/ldpath-functions-math/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-functions-text/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-text/pom.xml b/libraries/ldpath/ldpath-functions-text/pom.xml
index 962035f..288aa49 100644
--- a/libraries/ldpath/ldpath-functions-text/pom.xml
+++ b/libraries/ldpath/ldpath-functions-text/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-functions-xml/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-xml/pom.xml b/libraries/ldpath/ldpath-functions-xml/pom.xml
index 859ab99..6c6df30 100644
--- a/libraries/ldpath/ldpath-functions-xml/pom.xml
+++ b/libraries/ldpath/ldpath-functions-xml/pom.xml
@@ -19,7 +19,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-ldquery-cli/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-ldquery-cli/pom.xml b/libraries/ldpath/ldpath-ldquery-cli/pom.xml
index 4237db3..7ef8e8b 100644
--- a/libraries/ldpath/ldpath-ldquery-cli/pom.xml
+++ b/libraries/ldpath/ldpath-ldquery-cli/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-template-linkeddata/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-template-linkeddata/pom.xml b/libraries/ldpath/ldpath-template-linkeddata/pom.xml
index 29e3d42..353d491 100644
--- a/libraries/ldpath/ldpath-template-linkeddata/pom.xml
+++ b/libraries/ldpath/ldpath-template-linkeddata/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/ldpath-template/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-template/pom.xml b/libraries/ldpath/ldpath-template/pom.xml
index 5ba307b..8748701 100644
--- a/libraries/ldpath/ldpath-template/pom.xml
+++ b/libraries/ldpath/ldpath-template/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/ldpath/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/pom.xml b/libraries/ldpath/pom.xml
index b2a4f48..fb8b703 100644
--- a/libraries/ldpath/pom.xml
+++ b/libraries/ldpath/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/libraries/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/pom.xml b/libraries/pom.xml
index e130fe8..8a62c86 100644
--- a/libraries/pom.xml
+++ b/libraries/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/loader/marmotta-loader-berkeley/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-berkeley/pom.xml b/loader/marmotta-loader-berkeley/pom.xml
index b684f49..c666832 100644
--- a/loader/marmotta-loader-berkeley/pom.xml
+++ b/loader/marmotta-loader-berkeley/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/loader/marmotta-loader-core/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-core/pom.xml b/loader/marmotta-loader-core/pom.xml
index 4a903a9..67e0bc9 100644
--- a/loader/marmotta-loader-core/pom.xml
+++ b/loader/marmotta-loader-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/loader/marmotta-loader-hbase/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-hbase/pom.xml b/loader/marmotta-loader-hbase/pom.xml
index 0a8b525..2eb82b3 100644
--- a/loader/marmotta-loader-hbase/pom.xml
+++ b/loader/marmotta-loader-hbase/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/loader/marmotta-loader-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-kiwi/pom.xml b/loader/marmotta-loader-kiwi/pom.xml
index f2bf1bc..690539a 100644
--- a/loader/marmotta-loader-kiwi/pom.xml
+++ b/loader/marmotta-loader-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/loader/marmotta-loader-titan/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-titan/pom.xml b/loader/marmotta-loader-titan/pom.xml
index dc60e45..d39ea07 100644
--- a/loader/marmotta-loader-titan/pom.xml
+++ b/loader/marmotta-loader-titan/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/loader/pom.xml
----------------------------------------------------------------------
diff --git a/loader/pom.xml b/loader/pom.xml
index 78ebc16..142757e 100644
--- a/loader/pom.xml
+++ b/loader/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/parent/pom.xml
----------------------------------------------------------------------
diff --git a/parent/pom.xml b/parent/pom.xml
index 62dafff..e3dc660 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -29,7 +29,7 @@
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
<packaging>pom</packaging>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<name>Apache Marmotta Parent</name>
<description>Parent POM for the Apache Marmotta project</description>
@@ -1841,8 +1841,4 @@
</properties>
</profile>
</profiles>
-
- <scm>
- <tag>3.4.0</tag>
- </scm>
</project>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/backends/marmotta-backend-accumulograph/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-accumulograph/pom.xml b/platform/backends/marmotta-backend-accumulograph/pom.xml
index ede3aa9..cd033a8 100644
--- a/platform/backends/marmotta-backend-accumulograph/pom.xml
+++ b/platform/backends/marmotta-backend-accumulograph/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/backends/marmotta-backend-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-kiwi/pom.xml b/platform/backends/marmotta-backend-kiwi/pom.xml
index 9a28ed6..8b18f04 100644
--- a/platform/backends/marmotta-backend-kiwi/pom.xml
+++ b/platform/backends/marmotta-backend-kiwi/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/backends/marmotta-backend-memory/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-memory/pom.xml b/platform/backends/marmotta-backend-memory/pom.xml
index c29b8c0..8945eb9 100644
--- a/platform/backends/marmotta-backend-memory/pom.xml
+++ b/platform/backends/marmotta-backend-memory/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/backends/marmotta-backend-native/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-native/pom.xml b/platform/backends/marmotta-backend-native/pom.xml
index 7c4657c..9d8421a 100644
--- a/platform/backends/marmotta-backend-native/pom.xml
+++ b/platform/backends/marmotta-backend-native/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/backends/marmotta-backend-titan/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-titan/pom.xml b/platform/backends/marmotta-backend-titan/pom.xml
index e726410..c84c507 100644
--- a/platform/backends/marmotta-backend-titan/pom.xml
+++ b/platform/backends/marmotta-backend-titan/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent/pom.xml</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/backends/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/pom.xml b/platform/backends/pom.xml
index 519bf64..3fea0d0 100644
--- a/platform/backends/pom.xml
+++ b/platform/backends/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/ldcache/marmotta-ldcache-common/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/marmotta-ldcache-common/pom.xml b/platform/ldcache/marmotta-ldcache-common/pom.xml
index 784db15..2f0ebdd 100644
--- a/platform/ldcache/marmotta-ldcache-common/pom.xml
+++ b/platform/ldcache/marmotta-ldcache-common/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/ldcache/marmotta-ldcache-file/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/marmotta-ldcache-file/pom.xml b/platform/ldcache/marmotta-ldcache-file/pom.xml
index 48b185b..f868bc2 100644
--- a/platform/ldcache/marmotta-ldcache-file/pom.xml
+++ b/platform/ldcache/marmotta-ldcache-file/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/marmotta-ldcache-kiwi/pom.xml b/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
index c6bf7b2..fca36b6 100644
--- a/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
+++ b/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/ldcache/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/pom.xml b/platform/ldcache/pom.xml
index 484097a..625a6ab 100644
--- a/platform/ldcache/pom.xml
+++ b/platform/ldcache/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/marmotta-core/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-core/pom.xml b/platform/marmotta-core/pom.xml
index 6e85133..fe5f739 100644
--- a/platform/marmotta-core/pom.xml
+++ b/platform/marmotta-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/marmotta-ldp/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-ldp/pom.xml b/platform/marmotta-ldp/pom.xml
index c0ed328..c67d990 100644
--- a/platform/marmotta-ldp/pom.xml
+++ b/platform/marmotta-ldp/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/marmotta-ldpath/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-ldpath/pom.xml b/platform/marmotta-ldpath/pom.xml
index 9d5c986..e72f47b 100644
--- a/platform/marmotta-ldpath/pom.xml
+++ b/platform/marmotta-ldpath/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/marmotta-reasoner-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-reasoner-kiwi/pom.xml b/platform/marmotta-reasoner-kiwi/pom.xml
index c253b67..0d6fc75 100644
--- a/platform/marmotta-reasoner-kiwi/pom.xml
+++ b/platform/marmotta-reasoner-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/marmotta-security/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-security/pom.xml b/platform/marmotta-security/pom.xml
index 845721e..2f628fa 100644
--- a/platform/marmotta-security/pom.xml
+++ b/platform/marmotta-security/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/marmotta-sparql/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-sparql/pom.xml b/platform/marmotta-sparql/pom.xml
index 1123ab8..77c8aa5 100644
--- a/platform/marmotta-sparql/pom.xml
+++ b/platform/marmotta-sparql/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/marmotta-user/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-user/pom.xml b/platform/marmotta-user/pom.xml
index 4ee022f..ecc00e5 100644
--- a/platform/marmotta-user/pom.xml
+++ b/platform/marmotta-user/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/marmotta-versioning-common/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-versioning-common/pom.xml b/platform/marmotta-versioning-common/pom.xml
index 6da4aa0..a59ca03 100644
--- a/platform/marmotta-versioning-common/pom.xml
+++ b/platform/marmotta-versioning-common/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/marmotta-versioning-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-versioning-kiwi/pom.xml b/platform/marmotta-versioning-kiwi/pom.xml
index f979e58..79b93b8 100644
--- a/platform/marmotta-versioning-kiwi/pom.xml
+++ b/platform/marmotta-versioning-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/marmotta-zookeeper/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-zookeeper/pom.xml b/platform/marmotta-zookeeper/pom.xml
index 53513f7..8c2ab97 100644
--- a/platform/marmotta-zookeeper/pom.xml
+++ b/platform/marmotta-zookeeper/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/platform/pom.xml
----------------------------------------------------------------------
diff --git a/platform/pom.xml b/platform/pom.xml
index 2adc9b6..303d257 100644
--- a/platform/pom.xml
+++ b/platform/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/d7e87707/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 089c6eb..6914adf 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0</version>
+ <version>3.5.0-SNAPSHOT</version>
<relativePath>parent</relativePath>
</parent>
@@ -145,7 +145,7 @@
<url>https://git-wip-us.apache.org/repos/asf/marmotta.git</url>
<connection>scm:git:https://git-wip-us.apache.org/repos/asf/marmotta.git</connection>
<developerConnection>scm:git:https://git-wip-us.apache.org/repos/asf/marmotta.git</developerConnection>
- <tag>3.4.0</tag>
+ <tag>HEAD</tag>
</scm>
<issueManagement>
[06/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/any_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/any_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/types/any_test.cc
new file mode 100644
index 0000000..115e78d
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/any_test.cc
@@ -0,0 +1,724 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/types/any.h"
+
+#include <initializer_list>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/exception_testing.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/container/internal/test_instance_tracker.h"
+
+namespace {
+using absl::test_internal::CopyableOnlyInstance;
+using absl::test_internal::InstanceTracker;
+
+template <typename T>
+const T& AsConst(const T& t) {
+ return t;
+}
+
+struct MoveOnly {
+ MoveOnly() = default;
+ explicit MoveOnly(int value) : value(value) {}
+ MoveOnly(MoveOnly&&) = default;
+ MoveOnly& operator=(MoveOnly&&) = default;
+
+ int value = 0;
+};
+
+struct CopyOnly {
+ CopyOnly() = default;
+ explicit CopyOnly(int value) : value(value) {}
+ CopyOnly(CopyOnly&&) = delete;
+ CopyOnly& operator=(CopyOnly&&) = delete;
+ CopyOnly(const CopyOnly&) = default;
+ CopyOnly& operator=(const CopyOnly&) = default;
+
+ int value = 0;
+};
+
+struct MoveOnlyWithListConstructor {
+ MoveOnlyWithListConstructor() = default;
+ explicit MoveOnlyWithListConstructor(std::initializer_list<int> /*ilist*/,
+ int value)
+ : value(value) {}
+ MoveOnlyWithListConstructor(MoveOnlyWithListConstructor&&) = default;
+ MoveOnlyWithListConstructor& operator=(MoveOnlyWithListConstructor&&) =
+ default;
+
+ int value = 0;
+};
+
+struct IntMoveOnlyCopyOnly {
+ IntMoveOnlyCopyOnly(int value, MoveOnly /*move_only*/, CopyOnly /*copy_only*/)
+ : value(value) {}
+
+ int value;
+};
+
+struct ListMoveOnlyCopyOnly {
+ ListMoveOnlyCopyOnly(std::initializer_list<int> ilist, MoveOnly /*move_only*/,
+ CopyOnly /*copy_only*/)
+ : values(ilist) {}
+
+ std::vector<int> values;
+};
+
+using FunctionType = void();
+void FunctionToEmplace() {}
+
+using ArrayType = int[2];
+using DecayedArray = absl::decay_t<ArrayType>;
+
+TEST(AnyTest, Noexcept) {
+ static_assert(std::is_nothrow_default_constructible<absl::any>(), "");
+ static_assert(std::is_nothrow_move_constructible<absl::any>(), "");
+ static_assert(std::is_nothrow_move_assignable<absl::any>(), "");
+ static_assert(noexcept(std::declval<absl::any&>().has_value()), "");
+ static_assert(noexcept(std::declval<absl::any&>().type()), "");
+ static_assert(noexcept(absl::any_cast<int>(std::declval<absl::any*>())), "");
+ static_assert(
+ noexcept(std::declval<absl::any&>().swap(std::declval<absl::any&>())),
+ "");
+
+ using std::swap;
+ static_assert(
+ noexcept(swap(std::declval<absl::any&>(), std::declval<absl::any&>())),
+ "");
+}
+
+TEST(AnyTest, HasValue) {
+ absl::any o;
+ EXPECT_FALSE(o.has_value());
+ o.emplace<int>();
+ EXPECT_TRUE(o.has_value());
+ o.reset();
+ EXPECT_FALSE(o.has_value());
+}
+
+TEST(AnyTest, Type) {
+ absl::any o;
+ EXPECT_EQ(typeid(void), o.type());
+ o.emplace<int>(5);
+ EXPECT_EQ(typeid(int), o.type());
+ o.emplace<float>(5.f);
+ EXPECT_EQ(typeid(float), o.type());
+ o.reset();
+ EXPECT_EQ(typeid(void), o.type());
+}
+
+TEST(AnyTest, EmptyPointerCast) {
+ // pointer-to-unqualified overload
+ {
+ absl::any o;
+ EXPECT_EQ(nullptr, absl::any_cast<int>(&o));
+ o.emplace<int>();
+ EXPECT_NE(nullptr, absl::any_cast<int>(&o));
+ o.reset();
+ EXPECT_EQ(nullptr, absl::any_cast<int>(&o));
+ }
+
+ // pointer-to-const overload
+ {
+ absl::any o;
+ EXPECT_EQ(nullptr, absl::any_cast<int>(&AsConst(o)));
+ o.emplace<int>();
+ EXPECT_NE(nullptr, absl::any_cast<int>(&AsConst(o)));
+ o.reset();
+ EXPECT_EQ(nullptr, absl::any_cast<int>(&AsConst(o)));
+ }
+}
+
+TEST(AnyTest, InPlaceConstruction) {
+ const CopyOnly copy_only{};
+ absl::any o(absl::in_place_type_t<IntMoveOnlyCopyOnly>(), 5, MoveOnly(),
+ copy_only);
+ IntMoveOnlyCopyOnly& v = absl::any_cast<IntMoveOnlyCopyOnly&>(o);
+ EXPECT_EQ(5, v.value);
+}
+
+TEST(AnyTest, InPlaceConstructionWithCV) {
+ const CopyOnly copy_only{};
+ absl::any o(absl::in_place_type_t<const volatile IntMoveOnlyCopyOnly>(), 5,
+ MoveOnly(), copy_only);
+ IntMoveOnlyCopyOnly& v = absl::any_cast<IntMoveOnlyCopyOnly&>(o);
+ EXPECT_EQ(5, v.value);
+}
+
+TEST(AnyTest, InPlaceConstructionWithFunction) {
+ absl::any o(absl::in_place_type_t<FunctionType>(), FunctionToEmplace);
+ FunctionType*& construction_result = absl::any_cast<FunctionType*&>(o);
+ EXPECT_EQ(&FunctionToEmplace, construction_result);
+}
+
+TEST(AnyTest, InPlaceConstructionWithArray) {
+ ArrayType ar = {5, 42};
+ absl::any o(absl::in_place_type_t<ArrayType>(), ar);
+ DecayedArray& construction_result = absl::any_cast<DecayedArray&>(o);
+ EXPECT_EQ(&ar[0], construction_result);
+}
+
+TEST(AnyTest, InPlaceConstructionIlist) {
+ const CopyOnly copy_only{};
+ absl::any o(absl::in_place_type_t<ListMoveOnlyCopyOnly>(), {1, 2, 3, 4},
+ MoveOnly(), copy_only);
+ ListMoveOnlyCopyOnly& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
+ std::vector<int> expected_values = {1, 2, 3, 4};
+ EXPECT_EQ(expected_values, v.values);
+}
+
+TEST(AnyTest, InPlaceConstructionIlistWithCV) {
+ const CopyOnly copy_only{};
+ absl::any o(absl::in_place_type_t<const volatile ListMoveOnlyCopyOnly>(),
+ {1, 2, 3, 4}, MoveOnly(), copy_only);
+ ListMoveOnlyCopyOnly& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
+ std::vector<int> expected_values = {1, 2, 3, 4};
+ EXPECT_EQ(expected_values, v.values);
+}
+
+TEST(AnyTest, InPlaceNoArgs) {
+ absl::any o(absl::in_place_type_t<int>{});
+ EXPECT_EQ(0, absl::any_cast<int&>(o));
+}
+
+template <typename Enabler, typename T, typename... Args>
+struct CanEmplaceAnyImpl : std::false_type {};
+
+template <typename T, typename... Args>
+struct CanEmplaceAnyImpl<
+ absl::void_t<decltype(
+ std::declval<absl::any&>().emplace<T>(std::declval<Args>()...))>,
+ T, Args...> : std::true_type {};
+
+template <typename T, typename... Args>
+using CanEmplaceAny = CanEmplaceAnyImpl<void, T, Args...>;
+
+TEST(AnyTest, Emplace) {
+ const CopyOnly copy_only{};
+ absl::any o;
+ EXPECT_TRUE((std::is_same<decltype(o.emplace<IntMoveOnlyCopyOnly>(
+ 5, MoveOnly(), copy_only)),
+ IntMoveOnlyCopyOnly&>::value));
+ IntMoveOnlyCopyOnly& emplace_result =
+ o.emplace<IntMoveOnlyCopyOnly>(5, MoveOnly(), copy_only);
+ EXPECT_EQ(5, emplace_result.value);
+ IntMoveOnlyCopyOnly& v = absl::any_cast<IntMoveOnlyCopyOnly&>(o);
+ EXPECT_EQ(5, v.value);
+ EXPECT_EQ(&emplace_result, &v);
+
+ static_assert(!CanEmplaceAny<int, int, int>::value, "");
+ static_assert(!CanEmplaceAny<MoveOnly, MoveOnly>::value, "");
+}
+
+TEST(AnyTest, EmplaceWithCV) {
+ const CopyOnly copy_only{};
+ absl::any o;
+ EXPECT_TRUE(
+ (std::is_same<decltype(o.emplace<const volatile IntMoveOnlyCopyOnly>(
+ 5, MoveOnly(), copy_only)),
+ IntMoveOnlyCopyOnly&>::value));
+ IntMoveOnlyCopyOnly& emplace_result =
+ o.emplace<const volatile IntMoveOnlyCopyOnly>(5, MoveOnly(), copy_only);
+ EXPECT_EQ(5, emplace_result.value);
+ IntMoveOnlyCopyOnly& v = absl::any_cast<IntMoveOnlyCopyOnly&>(o);
+ EXPECT_EQ(5, v.value);
+ EXPECT_EQ(&emplace_result, &v);
+}
+
+TEST(AnyTest, EmplaceWithFunction) {
+ absl::any o;
+ EXPECT_TRUE(
+ (std::is_same<decltype(o.emplace<FunctionType>(FunctionToEmplace)),
+ FunctionType*&>::value));
+ FunctionType*& emplace_result = o.emplace<FunctionType>(FunctionToEmplace);
+ EXPECT_EQ(&FunctionToEmplace, emplace_result);
+}
+
+TEST(AnyTest, EmplaceWithArray) {
+ absl::any o;
+ ArrayType ar = {5, 42};
+ EXPECT_TRUE(
+ (std::is_same<decltype(o.emplace<ArrayType>(ar)), DecayedArray&>::value));
+ DecayedArray& emplace_result = o.emplace<ArrayType>(ar);
+ EXPECT_EQ(&ar[0], emplace_result);
+}
+
+TEST(AnyTest, EmplaceIlist) {
+ const CopyOnly copy_only{};
+ absl::any o;
+ EXPECT_TRUE((std::is_same<decltype(o.emplace<ListMoveOnlyCopyOnly>(
+ {1, 2, 3, 4}, MoveOnly(), copy_only)),
+ ListMoveOnlyCopyOnly&>::value));
+ ListMoveOnlyCopyOnly& emplace_result =
+ o.emplace<ListMoveOnlyCopyOnly>({1, 2, 3, 4}, MoveOnly(), copy_only);
+ ListMoveOnlyCopyOnly& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
+ EXPECT_EQ(&v, &emplace_result);
+ std::vector<int> expected_values = {1, 2, 3, 4};
+ EXPECT_EQ(expected_values, v.values);
+
+ static_assert(!CanEmplaceAny<int, std::initializer_list<int>>::value, "");
+ static_assert(!CanEmplaceAny<MoveOnlyWithListConstructor,
+ std::initializer_list<int>, int>::value,
+ "");
+}
+
+TEST(AnyTest, EmplaceIlistWithCV) {
+ const CopyOnly copy_only{};
+ absl::any o;
+ EXPECT_TRUE(
+ (std::is_same<decltype(o.emplace<const volatile ListMoveOnlyCopyOnly>(
+ {1, 2, 3, 4}, MoveOnly(), copy_only)),
+ ListMoveOnlyCopyOnly&>::value));
+ ListMoveOnlyCopyOnly& emplace_result =
+ o.emplace<const volatile ListMoveOnlyCopyOnly>({1, 2, 3, 4}, MoveOnly(),
+ copy_only);
+ ListMoveOnlyCopyOnly& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
+ EXPECT_EQ(&v, &emplace_result);
+ std::vector<int> expected_values = {1, 2, 3, 4};
+ EXPECT_EQ(expected_values, v.values);
+}
+
+TEST(AnyTest, EmplaceNoArgs) {
+ absl::any o;
+ o.emplace<int>();
+ EXPECT_EQ(0, absl::any_cast<int>(o));
+}
+
+TEST(AnyTest, ConversionConstruction) {
+ {
+ absl::any o = 5;
+ EXPECT_EQ(5, absl::any_cast<int>(o));
+ }
+
+ {
+ const CopyOnly copy_only(5);
+ absl::any o = copy_only;
+ EXPECT_EQ(5, absl::any_cast<CopyOnly&>(o).value);
+ }
+
+ static_assert(!std::is_convertible<MoveOnly, absl::any>::value, "");
+}
+
+TEST(AnyTest, ConversionAssignment) {
+ {
+ absl::any o;
+ o = 5;
+ EXPECT_EQ(5, absl::any_cast<int>(o));
+ }
+
+ {
+ const CopyOnly copy_only(5);
+ absl::any o;
+ o = copy_only;
+ EXPECT_EQ(5, absl::any_cast<CopyOnly&>(o).value);
+ }
+
+ static_assert(!std::is_assignable<MoveOnly, absl::any>::value, "");
+}
+
+// Suppress MSVC warnings.
+// 4521: multiple copy constructors specified
+// We wrote multiple of them to test that the correct overloads are selected.
+#ifdef _MSC_VER
+#pragma warning( push )
+#pragma warning( disable : 4521)
+#endif
+
+// Weird type for testing, only used to make sure we "properly" perfect-forward
+// when being placed into an absl::any (use the l-value constructor if given an
+// l-value rather than use the copy constructor).
+struct WeirdConstructor42 {
+ explicit WeirdConstructor42(int value) : value(value) {}
+
+ // Copy-constructor
+ WeirdConstructor42(const WeirdConstructor42& other) : value(other.value) {}
+
+ // L-value "weird" constructor (used when given an l-value)
+ WeirdConstructor42(
+ WeirdConstructor42& /*other*/) // NOLINT(runtime/references)
+ : value(42) {}
+
+ int value;
+};
+#ifdef _MSC_VER
+#pragma warning( pop )
+#endif
+
+TEST(AnyTest, WeirdConversionConstruction) {
+ {
+ const WeirdConstructor42 source(5);
+ absl::any o = source; // Actual copy
+ EXPECT_EQ(5, absl::any_cast<WeirdConstructor42&>(o).value);
+ }
+
+ {
+ WeirdConstructor42 source(5);
+ absl::any o = source; // Weird "conversion"
+ EXPECT_EQ(42, absl::any_cast<WeirdConstructor42&>(o).value);
+ }
+}
+
+TEST(AnyTest, WeirdConversionAssignment) {
+ {
+ const WeirdConstructor42 source(5);
+ absl::any o;
+ o = source; // Actual copy
+ EXPECT_EQ(5, absl::any_cast<WeirdConstructor42&>(o).value);
+ }
+
+ {
+ WeirdConstructor42 source(5);
+ absl::any o;
+ o = source; // Weird "conversion"
+ EXPECT_EQ(42, absl::any_cast<WeirdConstructor42&>(o).value);
+ }
+}
+
+struct Value {};
+
+TEST(AnyTest, AnyCastValue) {
+ {
+ absl::any o;
+ o.emplace<int>(5);
+ EXPECT_EQ(5, absl::any_cast<int>(o));
+ EXPECT_EQ(5, absl::any_cast<int>(AsConst(o)));
+ static_assert(
+ std::is_same<decltype(absl::any_cast<Value>(o)), Value>::value, "");
+ }
+
+ {
+ absl::any o;
+ o.emplace<int>(5);
+ EXPECT_EQ(5, absl::any_cast<const int>(o));
+ EXPECT_EQ(5, absl::any_cast<const int>(AsConst(o)));
+ static_assert(std::is_same<decltype(absl::any_cast<const Value>(o)),
+ const Value>::value,
+ "");
+ }
+}
+
+TEST(AnyTest, AnyCastReference) {
+ {
+ absl::any o;
+ o.emplace<int>(5);
+ EXPECT_EQ(5, absl::any_cast<int&>(o));
+ EXPECT_EQ(5, absl::any_cast<const int&>(AsConst(o)));
+ static_assert(
+ std::is_same<decltype(absl::any_cast<Value&>(o)), Value&>::value, "");
+ }
+
+ {
+ absl::any o;
+ o.emplace<int>(5);
+ EXPECT_EQ(5, absl::any_cast<const int>(o));
+ EXPECT_EQ(5, absl::any_cast<const int>(AsConst(o)));
+ static_assert(std::is_same<decltype(absl::any_cast<const Value&>(o)),
+ const Value&>::value,
+ "");
+ }
+
+ {
+ absl::any o;
+ o.emplace<int>(5);
+ EXPECT_EQ(5, absl::any_cast<int&&>(std::move(o)));
+ static_assert(std::is_same<decltype(absl::any_cast<Value&&>(std::move(o))),
+ Value&&>::value,
+ "");
+ }
+
+ {
+ absl::any o;
+ o.emplace<int>(5);
+ EXPECT_EQ(5, absl::any_cast<const int>(std::move(o)));
+ static_assert(
+ std::is_same<decltype(absl::any_cast<const Value&&>(std::move(o))),
+ const Value&&>::value,
+ "");
+ }
+}
+
+TEST(AnyTest, AnyCastPointer) {
+ {
+ absl::any o;
+ EXPECT_EQ(nullptr, absl::any_cast<char>(&o));
+ o.emplace<int>(5);
+ EXPECT_EQ(nullptr, absl::any_cast<char>(&o));
+ o.emplace<char>('a');
+ EXPECT_EQ('a', *absl::any_cast<char>(&o));
+ static_assert(
+ std::is_same<decltype(absl::any_cast<Value>(&o)), Value*>::value, "");
+ }
+
+ {
+ absl::any o;
+ EXPECT_EQ(nullptr, absl::any_cast<const char>(&o));
+ o.emplace<int>(5);
+ EXPECT_EQ(nullptr, absl::any_cast<const char>(&o));
+ o.emplace<char>('a');
+ EXPECT_EQ('a', *absl::any_cast<const char>(&o));
+ static_assert(std::is_same<decltype(absl::any_cast<const Value>(&o)),
+ const Value*>::value,
+ "");
+ }
+}
+
+TEST(AnyTest, MakeAny) {
+ const CopyOnly copy_only{};
+ auto o = absl::make_any<IntMoveOnlyCopyOnly>(5, MoveOnly(), copy_only);
+ static_assert(std::is_same<decltype(o), absl::any>::value, "");
+ EXPECT_EQ(5, absl::any_cast<IntMoveOnlyCopyOnly&>(o).value);
+}
+
+TEST(AnyTest, MakeAnyIList) {
+ const CopyOnly copy_only{};
+ auto o =
+ absl::make_any<ListMoveOnlyCopyOnly>({1, 2, 3}, MoveOnly(), copy_only);
+ static_assert(std::is_same<decltype(o), absl::any>::value, "");
+ ListMoveOnlyCopyOnly& v = absl::any_cast<ListMoveOnlyCopyOnly&>(o);
+ std::vector<int> expected_values = {1, 2, 3};
+ EXPECT_EQ(expected_values, v.values);
+}
+
+// Test the use of copy constructor and operator=
+TEST(AnyTest, Copy) {
+ InstanceTracker tracker_raii;
+
+ {
+ absl::any o(absl::in_place_type_t<CopyableOnlyInstance>{}, 123);
+ CopyableOnlyInstance* f1 = absl::any_cast<CopyableOnlyInstance>(&o);
+
+ absl::any o2(o);
+ const CopyableOnlyInstance* f2 = absl::any_cast<CopyableOnlyInstance>(&o2);
+ EXPECT_EQ(123, f2->value());
+ EXPECT_NE(f1, f2);
+
+ absl::any o3;
+ o3 = o2;
+ const CopyableOnlyInstance* f3 = absl::any_cast<CopyableOnlyInstance>(&o3);
+ EXPECT_EQ(123, f3->value());
+ EXPECT_NE(f2, f3);
+
+ const absl::any o4(4);
+ // copy construct from const lvalue ref.
+ absl::any o5 = o4;
+ EXPECT_EQ(4, absl::any_cast<int>(o4));
+ EXPECT_EQ(4, absl::any_cast<int>(o5));
+
+ // Copy construct from const rvalue ref.
+ absl::any o6 = std::move(o4); // NOLINT
+ EXPECT_EQ(4, absl::any_cast<int>(o4));
+ EXPECT_EQ(4, absl::any_cast<int>(o6));
+ }
+}
+
+TEST(AnyTest, Move) {
+ InstanceTracker tracker_raii;
+
+ absl::any any1;
+ any1.emplace<CopyableOnlyInstance>(5);
+
+ // This is a copy, so copy count increases to 1.
+ absl::any any2 = any1;
+ EXPECT_EQ(5, absl::any_cast<CopyableOnlyInstance&>(any1).value());
+ EXPECT_EQ(5, absl::any_cast<CopyableOnlyInstance&>(any2).value());
+ EXPECT_EQ(1, tracker_raii.copies());
+
+ // This isn't a copy, so copy count doesn't increase.
+ absl::any any3 = std::move(any2);
+ EXPECT_EQ(5, absl::any_cast<CopyableOnlyInstance&>(any3).value());
+ EXPECT_EQ(1, tracker_raii.copies());
+
+ absl::any any4;
+ any4 = std::move(any3);
+ EXPECT_EQ(5, absl::any_cast<CopyableOnlyInstance&>(any4).value());
+ EXPECT_EQ(1, tracker_raii.copies());
+
+ absl::any tmp4(4);
+ absl::any o4(std::move(tmp4)); // move construct
+ EXPECT_EQ(4, absl::any_cast<int>(o4));
+ o4 = *&o4; // self assign
+ EXPECT_EQ(4, absl::any_cast<int>(o4));
+ EXPECT_TRUE(o4.has_value());
+
+ absl::any o5;
+ absl::any tmp5(5);
+ o5 = std::move(tmp5); // move assign
+ EXPECT_EQ(5, absl::any_cast<int>(o5));
+}
+
+// Reset the ObjectOwner with an object of a different type
+TEST(AnyTest, Reset) {
+ absl::any o;
+ o.emplace<int>();
+
+ o.reset();
+ EXPECT_FALSE(o.has_value());
+
+ o.emplace<char>();
+ EXPECT_TRUE(o.has_value());
+}
+
+TEST(AnyTest, ConversionConstructionCausesOneCopy) {
+ InstanceTracker tracker_raii;
+ CopyableOnlyInstance counter(5);
+ absl::any o(counter);
+ EXPECT_EQ(5, absl::any_cast<CopyableOnlyInstance&>(o).value());
+ EXPECT_EQ(1, tracker_raii.copies());
+}
+
+//////////////////////////////////
+// Tests for Exception Behavior //
+//////////////////////////////////
+
+#if defined(ABSL_HAVE_STD_ANY)
+
+// If using a std `any` implementation, we can't check for a specific message.
+#define ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(...) \
+ ABSL_BASE_INTERNAL_EXPECT_FAIL((__VA_ARGS__), absl::bad_any_cast, \
+ "")
+
+#else
+
+// If using the absl `any` implementation, we can rely on a specific message.
+#define ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(...) \
+ ABSL_BASE_INTERNAL_EXPECT_FAIL((__VA_ARGS__), absl::bad_any_cast, \
+ "Bad any cast")
+
+#endif // defined(ABSL_HAVE_STD_ANY)
+
+TEST(AnyTest, ThrowBadAlloc) {
+ {
+ absl::any a;
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<int&>(a));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int&>(a));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<int&&>(absl::any{}));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int&&>(absl::any{}));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<int>(a));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int>(a));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<int>(absl::any{}));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int>(absl::any{}));
+
+ // const absl::any operand
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int&>(AsConst(a)));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<int>(AsConst(a)));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const int>(AsConst(a)));
+ }
+
+ {
+ absl::any a(absl::in_place_type_t<int>{});
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<float&>(a));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const float&>(a));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<float&&>(absl::any{}));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(
+ absl::any_cast<const float&&>(absl::any{}));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<float>(a));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const float>(a));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<float>(absl::any{}));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const float>(absl::any{}));
+
+ // const absl::any operand
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const float&>(AsConst(a)));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<float>(AsConst(a)));
+ ABSL_ANY_TEST_EXPECT_BAD_ANY_CAST(absl::any_cast<const float>(AsConst(a)));
+ }
+}
+
+class BadCopy {};
+
+struct BadCopyable {
+ BadCopyable() = default;
+ BadCopyable(BadCopyable&&) = default;
+ BadCopyable(const BadCopyable&) {
+#ifdef ABSL_HAVE_EXCEPTIONS
+ throw BadCopy();
+#else
+ ABSL_RAW_LOG(FATAL, "Bad copy");
+#endif
+ }
+};
+
+#define ABSL_ANY_TEST_EXPECT_BAD_COPY(...) \
+ ABSL_BASE_INTERNAL_EXPECT_FAIL((__VA_ARGS__), BadCopy, "Bad copy")
+
+// Test the guarantees regarding exceptions in copy/assign.
+TEST(AnyTest, FailedCopy) {
+ {
+ const BadCopyable bad{};
+ ABSL_ANY_TEST_EXPECT_BAD_COPY(absl::any{bad});
+ }
+
+ {
+ absl::any src(absl::in_place_type_t<BadCopyable>{});
+ ABSL_ANY_TEST_EXPECT_BAD_COPY(absl::any{src});
+ }
+
+ {
+ BadCopyable bad;
+ absl::any target;
+ ABSL_ANY_TEST_EXPECT_BAD_COPY(target = bad);
+ }
+
+ {
+ BadCopyable bad;
+ absl::any target(absl::in_place_type_t<BadCopyable>{});
+ ABSL_ANY_TEST_EXPECT_BAD_COPY(target = bad);
+ EXPECT_TRUE(target.has_value());
+ }
+
+ {
+ absl::any src(absl::in_place_type_t<BadCopyable>{});
+ absl::any target;
+ ABSL_ANY_TEST_EXPECT_BAD_COPY(target = src);
+ EXPECT_FALSE(target.has_value());
+ }
+
+ {
+ absl::any src(absl::in_place_type_t<BadCopyable>{});
+ absl::any target(absl::in_place_type_t<BadCopyable>{});
+ ABSL_ANY_TEST_EXPECT_BAD_COPY(target = src);
+ EXPECT_TRUE(target.has_value());
+ }
+}
+
+// Test the guarantees regarding exceptions in emplace.
+TEST(AnyTest, FailedEmplace) {
+ {
+ BadCopyable bad;
+ absl::any target;
+ ABSL_ANY_TEST_EXPECT_BAD_COPY(target.emplace<BadCopyable>(bad));
+ }
+
+ {
+ BadCopyable bad;
+ absl::any target(absl::in_place_type_t<int>{});
+ ABSL_ANY_TEST_EXPECT_BAD_COPY(target.emplace<BadCopyable>(bad));
+#if defined(ABSL_HAVE_STD_ANY) && defined(__GLIBCXX__)
+ // libstdc++ std::any::emplace() implementation (as of 7.2) has a bug: if an
+ // exception is thrown, *this contains a value.
+#define ABSL_GLIBCXX_ANY_EMPLACE_EXCEPTION_BUG 1
+#endif
+#if defined(ABSL_HAVE_EXCEPTIONS) && \
+ !defined(ABSL_GLIBCXX_ANY_EMPLACE_EXCEPTION_BUG)
+ EXPECT_FALSE(target.has_value());
+#endif
+ }
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_any_cast.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_any_cast.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_any_cast.cc
new file mode 100644
index 0000000..c9b7330
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_any_cast.cc
@@ -0,0 +1,40 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/types/bad_any_cast.h"
+
+#include <cstdlib>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+
+bad_any_cast::~bad_any_cast() = default;
+
+const char* bad_any_cast::what() const noexcept { return "Bad any cast"; }
+
+namespace any_internal {
+
+void ThrowBadAnyCast() {
+#ifdef ABSL_HAVE_EXCEPTIONS
+ throw bad_any_cast();
+#else
+ ABSL_RAW_LOG(FATAL, "Bad any cast");
+ std::abort();
+#endif
+}
+
+} // namespace any_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_any_cast.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_any_cast.h b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_any_cast.h
new file mode 100644
index 0000000..3b96307
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_any_cast.h
@@ -0,0 +1,57 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// bad_any_cast.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::bad_any_cast` type.
+
+#ifndef ABSL_TYPES_BAD_ANY_CAST_H_
+#define ABSL_TYPES_BAD_ANY_CAST_H_
+
+#include <typeinfo>
+
+namespace absl {
+
+// -----------------------------------------------------------------------------
+// bad_any_cast
+// -----------------------------------------------------------------------------
+//
+// An `absl::bad_any_cast` type is an exception type that is thrown when
+// failing to successfully cast the return value of an `absl::any` object.
+//
+// Example:
+//
+// auto a = absl::any(65);
+// absl::any_cast<int>(a); // 65
+// try {
+// absl::any_cast<char>(a);
+// } catch(const absl::bad_any_cast& e) {
+// std::cout << "Bad any cast: " << e.what() << '\n';
+// }
+class bad_any_cast : public std::bad_cast {
+ public:
+ ~bad_any_cast() override;
+ const char* what() const noexcept override;
+};
+
+namespace any_internal {
+
+[[noreturn]] void ThrowBadAnyCast();
+
+} // namespace any_internal
+} // namespace absl
+
+#endif // ABSL_TYPES_BAD_ANY_CAST_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_optional_access.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_optional_access.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_optional_access.cc
new file mode 100644
index 0000000..6bc67df
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_optional_access.cc
@@ -0,0 +1,42 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/types/bad_optional_access.h"
+
+#include <cstdlib>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+
+bad_optional_access::~bad_optional_access() = default;
+
+const char* bad_optional_access::what() const noexcept {
+ return "optional has no value";
+}
+
+namespace optional_internal {
+
+void throw_bad_optional_access() {
+#ifdef ABSL_HAVE_EXCEPTIONS
+ throw bad_optional_access();
+#else
+ ABSL_RAW_LOG(FATAL, "Bad optional access");
+ abort();
+#endif
+}
+
+} // namespace optional_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_optional_access.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_optional_access.h b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_optional_access.h
new file mode 100644
index 0000000..e9aa8b8
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_optional_access.h
@@ -0,0 +1,60 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// bad_optional_access.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::bad_optional_access` type.
+
+#ifndef ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
+#define ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
+
+#include <stdexcept>
+
+namespace absl {
+
+// -----------------------------------------------------------------------------
+// bad_optional_access
+// -----------------------------------------------------------------------------
+//
+// An `absl::bad_optional_access` type is an exception type that is thrown when
+// attempting to access an `absl::optional` object that does not contain a
+// value.
+//
+// Example:
+//
+// absl::optional<int> o;
+//
+// try {
+// int n = o.value();
+// } catch(const absl::bad_optional_access& e) {
+// std::cout << "Bad optional access: " << e.what() << '\n';
+// }
+class bad_optional_access : public std::exception {
+ public:
+ bad_optional_access() = default;
+ ~bad_optional_access() override;
+ const char* what() const noexcept override;
+};
+
+namespace optional_internal {
+
+// throw delegator
+[[noreturn]] void throw_bad_optional_access();
+
+} // namespace optional_internal
+} // namespace absl
+
+#endif // ABSL_TYPES_BAD_OPTIONAL_ACCESS_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_variant_access.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_variant_access.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_variant_access.cc
new file mode 100644
index 0000000..817fd78
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_variant_access.cc
@@ -0,0 +1,58 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/types/bad_variant_access.h"
+
+#include <cstdlib>
+#include <stdexcept>
+
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+
+//////////////////////////
+// [variant.bad.access] //
+//////////////////////////
+
+bad_variant_access::~bad_variant_access() = default;
+
+const char* bad_variant_access::what() const noexcept {
+ return "Bad variant access";
+}
+
+namespace variant_internal {
+
+void ThrowBadVariantAccess() {
+#ifdef ABSL_HAVE_EXCEPTIONS
+ throw bad_variant_access();
+#else
+ ABSL_RAW_LOG(FATAL, "Bad variant access");
+ abort(); // TODO(calabrese) Remove once RAW_LOG FATAL is noreturn.
+#endif
+}
+
+void Rethrow() {
+#ifdef ABSL_HAVE_EXCEPTIONS
+ throw;
+#else
+ ABSL_RAW_LOG(FATAL,
+ "Internal error in absl::variant implementation. Attempted to "
+ "rethrow an exception when building with exceptions disabled.");
+ abort(); // TODO(calabrese) Remove once RAW_LOG FATAL is noreturn.
+#endif
+}
+
+} // namespace variant_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_variant_access.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_variant_access.h b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_variant_access.h
new file mode 100644
index 0000000..67abe71
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/bad_variant_access.h
@@ -0,0 +1,64 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// bad_variant_access.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::bad_variant_access` type.
+
+#ifndef ABSL_TYPES_BAD_VARIANT_ACCESS_H_
+#define ABSL_TYPES_BAD_VARIANT_ACCESS_H_
+
+#include <stdexcept>
+
+namespace absl {
+
+// -----------------------------------------------------------------------------
+// bad_variant_access
+// -----------------------------------------------------------------------------
+//
+// An `absl::bad_variant_access` type is an exception type that is thrown in
+// the following cases:
+//
+// * Calling `absl::get(absl::variant) with an index or type that does not
+// match the currently selected alternative type
+// * Calling `absl::visit on an `absl::variant` that is in the
+// `variant::valueless_by_exception` state.
+//
+// Example:
+//
+// absl::variant<int, std::string> v;
+// v = 1;
+// try {
+// absl::get<std::string>(v);
+// } catch(const absl::bad_variant_access& e) {
+// std::cout << "Bad variant access: " << e.what() << '\n';
+// }
+class bad_variant_access : public std::exception {
+ public:
+ bad_variant_access() noexcept = default;
+ ~bad_variant_access() override;
+ const char* what() const noexcept override;
+};
+
+namespace variant_internal {
+
+[[noreturn]] void ThrowBadVariantAccess();
+[[noreturn]] void Rethrow();
+
+} // namespace variant_internal
+} // namespace absl
+
+#endif // ABSL_TYPES_BAD_VARIANT_ACCESS_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/internal/variant.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/internal/variant.h b/libraries/ostrich/backend/3rdparty/abseil/absl/types/internal/variant.h
new file mode 100644
index 0000000..61c56dd
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/internal/variant.h
@@ -0,0 +1,1387 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Implementation details of absl/types/variant.h, pulled into a
+// separate file to avoid cluttering the top of the API header with
+// implementation details.
+
+#ifndef ABSL_TYPES_variant_internal_H_
+#define ABSL_TYPES_variant_internal_H_
+
+#include <cstddef>
+#include <memory>
+#include <stdexcept>
+#include <tuple>
+#include <type_traits>
+
+#include "absl/base/internal/identity.h"
+#include "absl/base/internal/inline_variable.h"
+#include "absl/base/internal/invoke.h"
+#include "absl/base/optimization.h"
+#include "absl/meta/type_traits.h"
+#include "absl/types/bad_variant_access.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+
+template <class... Types>
+class variant;
+
+ABSL_INTERNAL_INLINE_CONSTEXPR(size_t, variant_npos, -1);
+
+template <class T>
+struct variant_size;
+
+template <std::size_t I, class T>
+struct variant_alternative;
+
+namespace variant_internal {
+
+// NOTE: See specializations below for details.
+template <std::size_t I, class T>
+struct VariantAlternativeSfinae {};
+
+// Requires: I < variant_size_v<T>.
+//
+// Value: The Ith type of Types...
+template <std::size_t I, class T0, class... Tn>
+struct VariantAlternativeSfinae<I, variant<T0, Tn...>>
+ : VariantAlternativeSfinae<I - 1, variant<Tn...>> {};
+
+// Value: T0
+template <class T0, class... Ts>
+struct VariantAlternativeSfinae<0, variant<T0, Ts...>> {
+ using type = T0;
+};
+
+template <std::size_t I, class T>
+using VariantAlternativeSfinaeT = typename VariantAlternativeSfinae<I, T>::type;
+
+// NOTE: Requires T to be a reference type.
+template <class T, class U>
+struct GiveQualsTo;
+
+template <class T, class U>
+struct GiveQualsTo<T&, U> {
+ using type = U&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<T&&, U> {
+ using type = U&&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<const T&, U> {
+ using type = const U&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<const T&&, U> {
+ using type = const U&&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<volatile T&, U> {
+ using type = volatile U&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<volatile T&&, U> {
+ using type = volatile U&&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<volatile const T&, U> {
+ using type = volatile const U&;
+};
+
+template <class T, class U>
+struct GiveQualsTo<volatile const T&&, U> {
+ using type = volatile const U&&;
+};
+
+template <class T, class U>
+using GiveQualsToT = typename GiveQualsTo<T, U>::type;
+
+// Convenience alias, since size_t integral_constant is used a lot in this file.
+template <std::size_t I>
+using SizeT = std::integral_constant<std::size_t, I>;
+
+template <class Variant, class T, class = void>
+struct IndexOfConstructedType {};
+
+template <std::size_t I, class Variant>
+struct VariantAccessResultImpl;
+
+template <std::size_t I, template <class...> class Variantemplate, class... T>
+struct VariantAccessResultImpl<I, Variantemplate<T...>&> {
+ using type = typename absl::variant_alternative<I, variant<T...>>::type&;
+};
+
+template <std::size_t I, template <class...> class Variantemplate, class... T>
+struct VariantAccessResultImpl<I, const Variantemplate<T...>&> {
+ using type =
+ const typename absl::variant_alternative<I, variant<T...>>::type&;
+};
+
+template <std::size_t I, template <class...> class Variantemplate, class... T>
+struct VariantAccessResultImpl<I, Variantemplate<T...>&&> {
+ using type = typename absl::variant_alternative<I, variant<T...>>::type&&;
+};
+
+template <std::size_t I, template <class...> class Variantemplate, class... T>
+struct VariantAccessResultImpl<I, const Variantemplate<T...>&&> {
+ using type =
+ const typename absl::variant_alternative<I, variant<T...>>::type&&;
+};
+
+template <std::size_t I, class Variant>
+using VariantAccessResult =
+ typename VariantAccessResultImpl<I, Variant&&>::type;
+
+// NOTE: This is used instead of std::array to reduce instantiation overhead.
+template <class T, std::size_t Size>
+struct SimpleArray {
+ static_assert(Size != 0, "");
+ T value[Size];
+};
+
+template <class T>
+struct AccessedType {
+ using type = T;
+};
+
+template <class T>
+using AccessedTypeT = typename AccessedType<T>::type;
+
+template <class T, std::size_t Size>
+struct AccessedType<SimpleArray<T, Size>> {
+ using type = AccessedTypeT<T>;
+};
+
+template <class T>
+constexpr T AccessSimpleArray(const T& value) {
+ return value;
+}
+
+template <class T, std::size_t Size, class... SizeT>
+constexpr AccessedTypeT<T> AccessSimpleArray(const SimpleArray<T, Size>& table,
+ std::size_t head_index,
+ SizeT... tail_indices) {
+ return AccessSimpleArray(table.value[head_index], tail_indices...);
+}
+
+// Note: Intentionally is an alias.
+template <class T>
+using AlwaysZero = SizeT<0>;
+
+template <class Op, class... Vs>
+struct VisitIndicesResultImpl {
+ using type = absl::result_of_t<Op(AlwaysZero<Vs>...)>;
+};
+
+template <class Op, class... Vs>
+using VisitIndicesResultT = typename VisitIndicesResultImpl<Op, Vs...>::type;
+
+template <class ReturnType, class FunctionObject, class EndIndices,
+ std::size_t... BoundIndices>
+struct MakeVisitationMatrix;
+
+template <class ReturnType, class FunctionObject, std::size_t... Indices>
+constexpr ReturnType call_with_indices(FunctionObject&& function) {
+ static_assert(
+ std::is_same<ReturnType, decltype(std::declval<FunctionObject>()(
+ SizeT<Indices>()...))>::value,
+ "Not all visitation overloads have the same return type.");
+ return absl::forward<FunctionObject>(function)(SizeT<Indices>()...);
+}
+
+template <class ReturnType, class FunctionObject, std::size_t... BoundIndices>
+struct MakeVisitationMatrix<ReturnType, FunctionObject, index_sequence<>,
+ BoundIndices...> {
+ using ResultType = ReturnType (*)(FunctionObject&&);
+ static constexpr ResultType Run() {
+ return &call_with_indices<ReturnType, FunctionObject,
+ (BoundIndices - 1)...>;
+ }
+};
+
+template <class ReturnType, class FunctionObject, class EndIndices,
+ class CurrIndices, std::size_t... BoundIndices>
+struct MakeVisitationMatrixImpl;
+
+template <class ReturnType, class FunctionObject, std::size_t... EndIndices,
+ std::size_t... CurrIndices, std::size_t... BoundIndices>
+struct MakeVisitationMatrixImpl<
+ ReturnType, FunctionObject, index_sequence<EndIndices...>,
+ index_sequence<CurrIndices...>, BoundIndices...> {
+ using ResultType = SimpleArray<
+ typename MakeVisitationMatrix<ReturnType, FunctionObject,
+ index_sequence<EndIndices...>>::ResultType,
+ sizeof...(CurrIndices)>;
+
+ static constexpr ResultType Run() {
+ return {{MakeVisitationMatrix<ReturnType, FunctionObject,
+ index_sequence<EndIndices...>,
+ BoundIndices..., CurrIndices>::Run()...}};
+ }
+};
+
+template <class ReturnType, class FunctionObject, std::size_t HeadEndIndex,
+ std::size_t... TailEndIndices, std::size_t... BoundIndices>
+struct MakeVisitationMatrix<ReturnType, FunctionObject,
+ index_sequence<HeadEndIndex, TailEndIndices...>,
+ BoundIndices...>
+ : MakeVisitationMatrixImpl<
+ ReturnType, FunctionObject, index_sequence<TailEndIndices...>,
+ absl::make_index_sequence<HeadEndIndex>, BoundIndices...> {};
+
+template <std::size_t... EndIndices, class Op, class... SizeT>
+VisitIndicesResultT<Op, SizeT...> visit_indices(Op&& op, SizeT... indices) {
+ return AccessSimpleArray(
+ MakeVisitationMatrix<VisitIndicesResultT<Op, SizeT...>, Op,
+ index_sequence<(EndIndices + 1)...>>::Run(),
+ (indices + 1)...)(absl::forward<Op>(op));
+}
+
+template <class ReturnType>
+[[noreturn]] ReturnType TypedThrowBadVariantAccess() {
+ absl::variant_internal::ThrowBadVariantAccess();
+}
+
+// Suppress bogus warning on MSVC: MSVC complains that the `reinterpret_cast`
+// below is returning the address of a temporary or local object.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4172)
+#endif // _MSC_VER
+
+// TODO(calabrese) std::launder
+// TODO(calabrese) constexpr
+template <class Self, std::size_t I>
+VariantAccessResult<I, Self> AccessUnion(Self&& self, SizeT<I> /*i*/) {
+ return reinterpret_cast<VariantAccessResult<I, Self>>(self);
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+template <class T>
+void DeducedDestroy(T& self) { // NOLINT
+ self.~T();
+}
+
+// NOTE: This type exists as a single entity for variant and its bases to
+// befriend. It contains helper functionality that manipulates the state of the
+// variant, such as the implementation of things like assignment and emplace
+// operations.
+struct VariantCoreAccess {
+ template <class VariantType>
+ static typename VariantType::Variant& Derived(VariantType& self) { // NOLINT
+ return static_cast<typename VariantType::Variant&>(self);
+ }
+
+ template <class VariantType>
+ static const typename VariantType::Variant& Derived(
+ const VariantType& self) { // NOLINT
+ return static_cast<const typename VariantType::Variant&>(self);
+ }
+
+ template <class VariantType>
+ static void Destroy(VariantType& self) { // NOLINT
+ Derived(self).destroy();
+ self.index_ = absl::variant_npos;
+ }
+
+ template <class Variant>
+ static void SetIndex(Variant& self, std::size_t i) { // NOLINT
+ self.index_ = i;
+ }
+
+ template <class Variant>
+ static void InitFrom(Variant& self, Variant&& other) { // NOLINT
+ variant_internal::visit_indices<absl::variant_size<Variant>::value>(
+ InitFromVisitor<Variant, Variant&&>{&self,
+ std::forward<Variant>(other)},
+ other.index());
+ self.index_ = other.index();
+ }
+
+ template <std::size_t I, class Variant>
+ static VariantAccessResult<I, Variant> Access(Variant&& self) {
+ if (ABSL_PREDICT_FALSE(self.index_ != I)) {
+ TypedThrowBadVariantAccess<VariantAccessResult<I, Variant>>();
+ }
+
+ // This cast instead of invocation of AccessUnion with an rvalue is a
+ // workaround for msvc. Without this there is a runtime failure when dealing
+ // with rvalues.
+ // TODO(calabrese) Reduce test case and find a simpler workaround.
+ return static_cast<VariantAccessResult<I, Variant>>(
+ variant_internal::AccessUnion(self.state_, SizeT<I>()));
+ }
+
+ // The implementation of the move-assignment operation for a variant.
+ template <class VType>
+ struct MoveAssignVisitor {
+ using DerivedType = typename VType::Variant;
+ template <std::size_t NewIndex>
+ void operator()(SizeT<NewIndex> /*new_i*/) const {
+ if (left->index_ == NewIndex) {
+ Access<NewIndex>(*left) = std::move(Access<NewIndex>(*right));
+ } else {
+ Derived(*left).template emplace<NewIndex>(
+ std::move(Access<NewIndex>(*right)));
+ }
+ }
+
+ void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
+ Destroy(*left);
+ }
+
+ VType* left;
+ VType* right;
+ };
+
+ template <class VType>
+ static MoveAssignVisitor<VType> MakeMoveAssignVisitor(VType* left,
+ VType* other) {
+ return {left, other};
+ }
+
+ // The implementation of the assignment operation for a variant.
+ template <class VType>
+ struct CopyAssignVisitor {
+ using DerivedType = typename VType::Variant;
+ template <std::size_t NewIndex>
+ void operator()(SizeT<NewIndex> /*new_i*/) const {
+ using New =
+ typename absl::variant_alternative<NewIndex, DerivedType>::type;
+
+ if (left->index_ == NewIndex) {
+ Access<NewIndex>(*left) = Access<NewIndex>(*right);
+ } else if (std::is_nothrow_copy_constructible<New>::value ||
+ !std::is_nothrow_move_constructible<New>::value) {
+ Derived(*left).template emplace<NewIndex>(Access<NewIndex>(*right));
+ } else {
+ Derived(*left) = DerivedType(Derived(*right));
+ }
+ }
+
+ void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
+ Destroy(*left);
+ }
+
+ VType* left;
+ const VType* right;
+ };
+
+ template <class VType>
+ static CopyAssignVisitor<VType> MakeCopyAssignVisitor(VType* left,
+ const VType& other) {
+ return {left, &other};
+ }
+
+ // The implementation of conversion-assignment operations for variant.
+ template <class Left, class QualifiedNew>
+ struct ConversionAssignVisitor {
+ using NewIndex =
+ variant_internal::IndexOfConstructedType<Left, QualifiedNew>;
+
+ void operator()(SizeT<NewIndex::value> /*old_i*/
+ ) const {
+ Access<NewIndex::value>(*left) = absl::forward<QualifiedNew>(other);
+ }
+
+ template <std::size_t OldIndex>
+ void operator()(SizeT<OldIndex> /*old_i*/
+ ) const {
+ using New =
+ typename absl::variant_alternative<NewIndex::value, Left>::type;
+ if (std::is_nothrow_constructible<New, QualifiedNew>::value ||
+ !std::is_nothrow_move_constructible<New>::value) {
+ left->template emplace<NewIndex::value>(
+ absl::forward<QualifiedNew>(other));
+ } else {
+ // the standard says "equivalent to
+ // operator=(variant(std::forward<T>(t)))", but we use `emplace` here
+ // because the variant's move assignment operator could be deleted.
+ left->template emplace<NewIndex::value>(
+ New(absl::forward<QualifiedNew>(other)));
+ }
+ }
+
+ Left* left;
+ QualifiedNew&& other;
+ };
+
+ template <class Left, class QualifiedNew>
+ static ConversionAssignVisitor<Left, QualifiedNew>
+ MakeConversionAssignVisitor(Left* left, QualifiedNew&& qual) {
+ return {left, absl::forward<QualifiedNew>(qual)};
+ }
+
+ // Backend for operations for `emplace()` which destructs `*self` then
+ // construct a new alternative with `Args...`.
+ template <std::size_t NewIndex, class Self, class... Args>
+ static typename absl::variant_alternative<NewIndex, Self>::type& Replace(
+ Self* self, Args&&... args) {
+ Destroy(*self);
+ using New = typename absl::variant_alternative<NewIndex, Self>::type;
+ New* const result = ::new (static_cast<void*>(&self->state_))
+ New(absl::forward<Args>(args)...);
+ self->index_ = NewIndex;
+ return *result;
+ }
+
+ template <class LeftVariant, class QualifiedRightVariant>
+ struct InitFromVisitor {
+ template <std::size_t NewIndex>
+ void operator()(SizeT<NewIndex> /*new_i*/) const {
+ using Alternative =
+ typename variant_alternative<NewIndex, LeftVariant>::type;
+ ::new (static_cast<void*>(&left->state_)) Alternative(
+ Access<NewIndex>(std::forward<QualifiedRightVariant>(right)));
+ }
+
+ void operator()(SizeT<absl::variant_npos> /*new_i*/) const {
+ // This space intentionally left blank.
+ }
+ LeftVariant* left;
+ QualifiedRightVariant&& right;
+ };
+};
+
+template <class Expected, class... T>
+struct IndexOfImpl;
+
+template <class Expected>
+struct IndexOfImpl<Expected> {
+ using IndexFromEnd = SizeT<0>;
+ using MatchedIndexFromEnd = IndexFromEnd;
+ using MultipleMatches = std::false_type;
+};
+
+template <class Expected, class Head, class... Tail>
+struct IndexOfImpl<Expected, Head, Tail...> : IndexOfImpl<Expected, Tail...> {
+ using IndexFromEnd =
+ SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
+};
+
+template <class Expected, class... Tail>
+struct IndexOfImpl<Expected, Expected, Tail...>
+ : IndexOfImpl<Expected, Tail...> {
+ using IndexFromEnd =
+ SizeT<IndexOfImpl<Expected, Tail...>::IndexFromEnd::value + 1>;
+ using MatchedIndexFromEnd = IndexFromEnd;
+ using MultipleMatches = std::integral_constant<
+ bool, IndexOfImpl<Expected, Tail...>::MatchedIndexFromEnd::value != 0>;
+};
+
+template <class Expected, class... Types>
+struct IndexOfMeta {
+ using Results = IndexOfImpl<Expected, Types...>;
+ static_assert(!Results::MultipleMatches::value,
+ "Attempted to access a variant by specifying a type that "
+ "matches more than one alternative.");
+ static_assert(Results::MatchedIndexFromEnd::value != 0,
+ "Attempted to access a variant by specifying a type that does "
+ "not match any alternative.");
+ using type = SizeT<sizeof...(Types) - Results::MatchedIndexFromEnd::value>;
+};
+
+template <class Expected, class... Types>
+using IndexOf = typename IndexOfMeta<Expected, Types...>::type;
+
+template <class Variant, class T, std::size_t CurrIndex>
+struct UnambiguousIndexOfImpl;
+
+// Terminating case encountered once we've checked all of the alternatives
+template <class T, std::size_t CurrIndex>
+struct UnambiguousIndexOfImpl<variant<>, T, CurrIndex> : SizeT<CurrIndex> {};
+
+// Case where T is not Head
+template <class Head, class... Tail, class T, std::size_t CurrIndex>
+struct UnambiguousIndexOfImpl<variant<Head, Tail...>, T, CurrIndex>
+ : UnambiguousIndexOfImpl<variant<Tail...>, T, CurrIndex + 1>::type {};
+
+// Case where T is Head
+template <class Head, class... Tail, std::size_t CurrIndex>
+struct UnambiguousIndexOfImpl<variant<Head, Tail...>, Head, CurrIndex>
+ : SizeT<UnambiguousIndexOfImpl<variant<Tail...>, Head, 0>::value ==
+ sizeof...(Tail)
+ ? CurrIndex
+ : CurrIndex + sizeof...(Tail) + 1> {};
+
+template <class Variant, class T>
+struct UnambiguousIndexOf;
+
+struct NoMatch {
+ struct type {};
+};
+
+template <class... Alts, class T>
+struct UnambiguousIndexOf<variant<Alts...>, T>
+ : std::conditional<UnambiguousIndexOfImpl<variant<Alts...>, T, 0>::value !=
+ sizeof...(Alts),
+ UnambiguousIndexOfImpl<variant<Alts...>, T, 0>,
+ NoMatch>::type::type {};
+
+template <class T, std::size_t /*Dummy*/>
+using UnambiguousTypeOfImpl = T;
+
+template <class Variant, class T>
+using UnambiguousTypeOfT =
+ UnambiguousTypeOfImpl<T, UnambiguousIndexOf<Variant, T>::value>;
+
+template <class H, class... T>
+class VariantStateBase;
+
+// This is an implementation of the "imaginary function" that is described in
+// [variant.ctor]
+// It is used in order to determine which alternative to construct during
+// initialization from some type T.
+template <class Variant, std::size_t I = 0>
+struct ImaginaryFun;
+
+template <std::size_t I>
+struct ImaginaryFun<variant<>, I> {
+ static void Run() = delete;
+};
+
+template <class H, class... T, std::size_t I>
+struct ImaginaryFun<variant<H, T...>, I> : ImaginaryFun<variant<T...>, I + 1> {
+ using ImaginaryFun<variant<T...>, I + 1>::Run;
+
+ // NOTE: const& and && are used instead of by-value due to lack of guaranteed
+ // move elision of C++17. This may have other minor differences, but tests
+ // pass.
+ static SizeT<I> Run(const H&);
+ static SizeT<I> Run(H&&);
+};
+
+// The following metafunctions are used in constructor and assignment
+// constraints.
+template <class Self, class T>
+struct IsNeitherSelfNorInPlace : std::true_type {};
+
+template <class Self>
+struct IsNeitherSelfNorInPlace<Self, Self> : std::false_type {};
+
+template <class Self, class T>
+struct IsNeitherSelfNorInPlace<Self, in_place_type_t<T>> : std::false_type {};
+
+template <class Self, std::size_t I>
+struct IsNeitherSelfNorInPlace<Self, in_place_index_t<I>> : std::false_type {};
+
+template <class Variant, class T, class = void>
+struct ConversionIsPossibleImpl : std::false_type {};
+
+template <class Variant, class T>
+struct ConversionIsPossibleImpl<
+ Variant, T, void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>()))>>
+ : std::true_type {};
+
+template <class Variant, class T>
+struct ConversionIsPossible : ConversionIsPossibleImpl<Variant, T>::type {};
+
+template <class Variant, class T>
+struct IndexOfConstructedType<
+ Variant, T, void_t<decltype(ImaginaryFun<Variant>::Run(std::declval<T>()))>>
+ : decltype(ImaginaryFun<Variant>::Run(std::declval<T>())) {};
+
+template <std::size_t... Is>
+struct ContainsVariantNPos
+ : absl::negation<std::is_same< // NOLINT
+ absl::integer_sequence<bool, 0 <= Is...>,
+ absl::integer_sequence<bool, Is != absl::variant_npos...>>> {};
+
+template <class Op, class... QualifiedVariants>
+using RawVisitResult =
+ absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
+
+// NOTE: The spec requires that all return-paths yield the same type and is not
+// SFINAE-friendly, so we can deduce the return type by examining the first
+// result. If it's not callable, then we get an error, but are compliant and
+// fast to compile.
+// TODO(calabrese) Possibly rewrite in a way that yields better compile errors
+// at the cost of longer compile-times.
+template <class Op, class... QualifiedVariants>
+struct VisitResultImpl {
+ using type =
+ absl::result_of_t<Op(VariantAccessResult<0, QualifiedVariants>...)>;
+};
+
+// Done in two steps intentionally so that we don't cause substitution to fail.
+template <class Op, class... QualifiedVariants>
+using VisitResult = typename VisitResultImpl<Op, QualifiedVariants...>::type;
+
+template <class Op, class... QualifiedVariants>
+struct PerformVisitation {
+ using ReturnType = VisitResult<Op, QualifiedVariants...>;
+
+ template <std::size_t... Is>
+ constexpr ReturnType operator()(SizeT<Is>... indices) const {
+ return Run(typename ContainsVariantNPos<Is...>::type{},
+ absl::index_sequence_for<QualifiedVariants...>(), indices...);
+ }
+
+ template <std::size_t... TupIs, std::size_t... Is>
+ constexpr ReturnType Run(std::false_type /*has_valueless*/,
+ index_sequence<TupIs...>, SizeT<Is>...) const {
+ return absl::base_internal::Invoke(
+ absl::forward<Op>(op),
+ VariantCoreAccess::Access<Is>(
+ absl::forward<QualifiedVariants>(std::get<TupIs>(variant_tup)))...);
+ }
+
+ template <std::size_t... TupIs, std::size_t... Is>
+ [[noreturn]] ReturnType Run(std::true_type /*has_valueless*/,
+ index_sequence<TupIs...>, SizeT<Is>...) const {
+ absl::variant_internal::ThrowBadVariantAccess();
+ }
+
+ // TODO(calabrese) Avoid using a tuple, which causes lots of instantiations
+ // Attempts using lambda variadic captures fail on current GCC.
+ std::tuple<QualifiedVariants&&...> variant_tup;
+ Op&& op;
+};
+
+template <class... T>
+union Union;
+
+// We want to allow for variant<> to be trivial. For that, we need the default
+// constructor to be trivial, which means we can't define it ourselves.
+// Instead, we use a non-default constructor that takes NoopConstructorTag
+// that doesn't affect the triviality of the types.
+struct NoopConstructorTag {};
+
+template <std::size_t I>
+struct EmplaceTag {};
+
+template <>
+union Union<> {
+ constexpr explicit Union(NoopConstructorTag) noexcept {}
+};
+
+// Suppress bogus warning on MSVC: MSVC complains that Union<T...> has a defined
+// deleted destructor from the `std::is_destructible` check below.
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4624)
+#endif // _MSC_VER
+
+template <class Head, class... Tail>
+union Union<Head, Tail...> {
+ using TailUnion = Union<Tail...>;
+
+ explicit constexpr Union(NoopConstructorTag /*tag*/) noexcept
+ : tail(NoopConstructorTag()) {}
+
+ template <class... P>
+ explicit constexpr Union(EmplaceTag<0>, P&&... args)
+ : head(absl::forward<P>(args)...) {}
+
+ template <std::size_t I, class... P>
+ explicit constexpr Union(EmplaceTag<I>, P&&... args)
+ : tail(EmplaceTag<I - 1>{}, absl::forward<P>(args)...) {}
+
+ Head head;
+ TailUnion tail;
+};
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif // _MSC_VER
+
+// TODO(calabrese) Just contain a Union in this union (certain configs fail).
+template <class... T>
+union DestructibleUnionImpl;
+
+template <>
+union DestructibleUnionImpl<> {
+ constexpr explicit DestructibleUnionImpl(NoopConstructorTag) noexcept {}
+};
+
+template <class Head, class... Tail>
+union DestructibleUnionImpl<Head, Tail...> {
+ using TailUnion = DestructibleUnionImpl<Tail...>;
+
+ explicit constexpr DestructibleUnionImpl(NoopConstructorTag /*tag*/) noexcept
+ : tail(NoopConstructorTag()) {}
+
+ template <class... P>
+ explicit constexpr DestructibleUnionImpl(EmplaceTag<0>, P&&... args)
+ : head(absl::forward<P>(args)...) {}
+
+ template <std::size_t I, class... P>
+ explicit constexpr DestructibleUnionImpl(EmplaceTag<I>, P&&... args)
+ : tail(EmplaceTag<I - 1>{}, absl::forward<P>(args)...) {}
+
+ ~DestructibleUnionImpl() {}
+
+ Head head;
+ TailUnion tail;
+};
+
+// This union type is destructible even if one or more T are not trivially
+// destructible. In the case that all T are trivially destructible, then so is
+// this resultant type.
+template <class... T>
+using DestructibleUnion =
+ absl::conditional_t<std::is_destructible<Union<T...>>::value, Union<T...>,
+ DestructibleUnionImpl<T...>>;
+
+// Deepest base, containing the actual union and the discriminator
+template <class H, class... T>
+class VariantStateBase {
+ protected:
+ using Variant = variant<H, T...>;
+
+ template <class LazyH = H,
+ class ConstructibleH = absl::enable_if_t<
+ std::is_default_constructible<LazyH>::value, LazyH>>
+ constexpr VariantStateBase() noexcept(
+ std::is_nothrow_default_constructible<ConstructibleH>::value)
+ : state_(EmplaceTag<0>()), index_(0) {}
+
+ template <std::size_t I, class... P>
+ explicit constexpr VariantStateBase(EmplaceTag<I> tag, P&&... args)
+ : state_(tag, absl::forward<P>(args)...), index_(I) {}
+
+ explicit constexpr VariantStateBase(NoopConstructorTag)
+ : state_(NoopConstructorTag()), index_(variant_npos) {}
+
+ void destroy() {} // Does nothing (shadowed in child if non-trivial)
+
+ DestructibleUnion<H, T...> state_;
+ std::size_t index_;
+};
+
+using absl::internal::identity;
+
+// OverloadSet::Overload() is a unary function which is overloaded to
+// take any of the element types of the variant, by reference-to-const.
+// The return type of the overload on T is identity<T>, so that you
+// can statically determine which overload was called.
+//
+// Overload() is not defined, so it can only be called in unevaluated
+// contexts.
+template <typename... Ts>
+struct OverloadSet;
+
+template <typename T, typename... Ts>
+struct OverloadSet<T, Ts...> : OverloadSet<Ts...> {
+ using Base = OverloadSet<Ts...>;
+ static identity<T> Overload(const T&);
+ using Base::Overload;
+};
+
+template <>
+struct OverloadSet<> {
+ // For any case not handled above.
+ static void Overload(...);
+};
+
+////////////////////////////////
+// Library Fundamentals V2 TS //
+////////////////////////////////
+
+// TODO(calabrese): Consider moving this to absl/meta/type_traits.h
+
+// The following is a rough implementation of parts of the detection idiom.
+// It is used for the comparison operator checks.
+
+template <class Enabler, class To, template <class...> class Op, class... Args>
+struct is_detected_convertible_impl {
+ using type = std::false_type;
+};
+
+template <class To, template <class...> class Op, class... Args>
+struct is_detected_convertible_impl<
+ absl::enable_if_t<std::is_convertible<Op<Args...>, To>::value>, To, Op,
+ Args...> {
+ using type = std::true_type;
+};
+
+// NOTE: This differs from library fundamentals by being lazy.
+template <class To, template <class...> class Op, class... Args>
+struct is_detected_convertible
+ : is_detected_convertible_impl<void, To, Op, Args...>::type {};
+
+template <class T>
+using LessThanResult = decltype(std::declval<T>() < std::declval<T>());
+
+template <class T>
+using GreaterThanResult = decltype(std::declval<T>() > std::declval<T>());
+
+template <class T>
+using LessThanOrEqualResult = decltype(std::declval<T>() <= std::declval<T>());
+
+template <class T>
+using GreaterThanOrEqualResult =
+ decltype(std::declval<T>() >= std::declval<T>());
+
+template <class T>
+using EqualResult = decltype(std::declval<T>() == std::declval<T>());
+
+template <class T>
+using NotEqualResult = decltype(std::declval<T>() != std::declval<T>());
+
+template <class T>
+using HasLessThan = is_detected_convertible<bool, LessThanResult, T>;
+
+template <class T>
+using HasGreaterThan = is_detected_convertible<bool, GreaterThanResult, T>;
+
+template <class T>
+using HasLessThanOrEqual =
+ is_detected_convertible<bool, LessThanOrEqualResult, T>;
+
+template <class T>
+using HasGreaterThanOrEqual =
+ is_detected_convertible<bool, GreaterThanOrEqualResult, T>;
+
+template <class T>
+using HasEqual = is_detected_convertible<bool, EqualResult, T>;
+
+template <class T>
+using HasNotEqual = is_detected_convertible<bool, NotEqualResult, T>;
+
+template <class... T>
+using RequireAllHaveEqualT =
+ absl::enable_if_t<absl::conjunction<HasEqual<T>...>::value, bool>;
+
+template <class... T>
+using RequireAllHaveNotEqualT =
+ absl::enable_if_t<absl::conjunction<HasEqual<T>...>::value, bool>;
+
+template <class... T>
+using RequireAllHaveLessThanT =
+ absl::enable_if_t<absl::conjunction<HasLessThan<T>...>::value, bool>;
+
+template <class... T>
+using RequireAllHaveLessThanOrEqualT =
+ absl::enable_if_t<absl::conjunction<HasLessThan<T>...>::value, bool>;
+
+template <class... T>
+using RequireAllHaveGreaterThanOrEqualT =
+ absl::enable_if_t<absl::conjunction<HasLessThan<T>...>::value, bool>;
+
+template <class... T>
+using RequireAllHaveGreaterThanT =
+ absl::enable_if_t<absl::conjunction<HasLessThan<T>...>::value, bool>;
+
+// Helper template containing implementations details of variant that can't go
+// in the private section. For convenience, this takes the variant type as a
+// single template parameter.
+template <typename T>
+struct VariantHelper;
+
+template <typename... Ts>
+struct VariantHelper<variant<Ts...>> {
+ // Type metafunction which returns the element type selected if
+ // OverloadSet::Overload() is well-formed when called with argument type U.
+ template <typename U>
+ using BestMatch = decltype(
+ variant_internal::OverloadSet<Ts...>::Overload(std::declval<U>()));
+
+ // Type metafunction which returns true if OverloadSet::Overload() is
+ // well-formed when called with argument type U.
+ // CanAccept can't be just an alias because there is a MSVC bug on parameter
+ // pack expansion involving decltype.
+ template <typename U>
+ struct CanAccept :
+ std::integral_constant<bool, !std::is_void<BestMatch<U>>::value> {};
+
+ // Type metafunction which returns true if Other is an instantiation of
+ // variant, and variants's converting constructor from Other will be
+ // well-formed. We will use this to remove constructors that would be
+ // ill-formed from the overload set.
+ template <typename Other>
+ struct CanConvertFrom;
+
+ template <typename... Us>
+ struct CanConvertFrom<variant<Us...>>
+ : public absl::conjunction<CanAccept<Us>...> {};
+};
+
+// A type with nontrivial copy ctor and trivial move ctor.
+struct TrivialMoveOnly {
+ TrivialMoveOnly(TrivialMoveOnly&&) = default;
+};
+
+// Trait class to detect whether a type is trivially move constructible.
+// A union's defaulted copy/move constructor is deleted if any variant member's
+// copy/move constructor is nontrivial.
+template <typename T>
+struct IsTriviallyMoveConstructible:
+ std::is_move_constructible<Union<T, TrivialMoveOnly>> {};
+
+// To guarantee triviality of all special-member functions that can be trivial,
+// we use a chain of conditional bases for each one.
+// The order of inheritance of bases from child to base are logically:
+//
+// variant
+// VariantCopyAssignBase
+// VariantMoveAssignBase
+// VariantCopyBase
+// VariantMoveBase
+// VariantStateBaseDestructor
+// VariantStateBase
+//
+// Note that there is a separate branch at each base that is dependent on
+// whether or not that corresponding special-member-function can be trivial in
+// the resultant variant type.
+
+template <class... T>
+class VariantStateBaseDestructorNontrivial;
+
+template <class... T>
+class VariantMoveBaseNontrivial;
+
+template <class... T>
+class VariantCopyBaseNontrivial;
+
+template <class... T>
+class VariantMoveAssignBaseNontrivial;
+
+template <class... T>
+class VariantCopyAssignBaseNontrivial;
+
+// Base that is dependent on whether or not the destructor can be trivial.
+template <class... T>
+using VariantStateBaseDestructor =
+ absl::conditional_t<std::is_destructible<Union<T...>>::value,
+ VariantStateBase<T...>,
+ VariantStateBaseDestructorNontrivial<T...>>;
+
+// Base that is dependent on whether or not the move-constructor can be
+// implicitly generated by the compiler (trivial or deleted).
+// Previously we were using `std::is_move_constructible<Union<T...>>` to check
+// whether all Ts have trivial move constructor, but it ran into a GCC bug:
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=84866
+// So we have to use a different approach (i.e. `HasTrivialMoveConstructor`) to
+// work around the bug.
+template <class... T>
+using VariantMoveBase = absl::conditional_t<
+ absl::disjunction<
+ absl::negation<absl::conjunction<std::is_move_constructible<T>...>>,
+ absl::conjunction<IsTriviallyMoveConstructible<T>...>>::value,
+ VariantStateBaseDestructor<T...>, VariantMoveBaseNontrivial<T...>>;
+
+// Base that is dependent on whether or not the copy-constructor can be trivial.
+template <class... T>
+using VariantCopyBase = absl::conditional_t<
+ absl::disjunction<
+ absl::negation<absl::conjunction<std::is_copy_constructible<T>...>>,
+ std::is_copy_constructible<Union<T...>>>::value,
+ VariantMoveBase<T...>, VariantCopyBaseNontrivial<T...>>;
+
+// Base that is dependent on whether or not the move-assign can be trivial.
+template <class... T>
+using VariantMoveAssignBase = absl::conditional_t<
+ absl::disjunction<absl::conjunction<std::is_move_assignable<Union<T...>>,
+ std::is_move_constructible<Union<T...>>,
+ std::is_destructible<Union<T...>>>,
+ absl::negation<absl::conjunction<
+ std::is_move_constructible<T>...,
+ std::is_move_assignable<T>...>>>::value,
+ VariantCopyBase<T...>, VariantMoveAssignBaseNontrivial<T...>>;
+
+// Base that is dependent on whether or not the copy-assign can be trivial.
+template <class... T>
+using VariantCopyAssignBase = absl::conditional_t<
+ absl::disjunction<absl::conjunction<std::is_copy_assignable<Union<T...>>,
+ std::is_copy_constructible<Union<T...>>,
+ std::is_destructible<Union<T...>>>,
+ absl::negation<absl::conjunction<
+ std::is_copy_constructible<T>...,
+ std::is_copy_assignable<T>...>>>::value,
+ VariantMoveAssignBase<T...>, VariantCopyAssignBaseNontrivial<T...>>;
+
+template <class... T>
+using VariantBase = VariantCopyAssignBase<T...>;
+
+template <class... T>
+class VariantStateBaseDestructorNontrivial : protected VariantStateBase<T...> {
+ private:
+ using Base = VariantStateBase<T...>;
+
+ protected:
+ using Base::Base;
+
+ VariantStateBaseDestructorNontrivial() = default;
+ VariantStateBaseDestructorNontrivial(VariantStateBaseDestructorNontrivial&&) =
+ default;
+ VariantStateBaseDestructorNontrivial(
+ const VariantStateBaseDestructorNontrivial&) = default;
+ VariantStateBaseDestructorNontrivial& operator=(
+ VariantStateBaseDestructorNontrivial&&) = default;
+ VariantStateBaseDestructorNontrivial& operator=(
+ const VariantStateBaseDestructorNontrivial&) = default;
+
+ struct Destroyer {
+ template <std::size_t I>
+ void operator()(SizeT<I> i) const {
+ using Alternative =
+ typename absl::variant_alternative<I, variant<T...>>::type;
+ variant_internal::AccessUnion(self->state_, i).~Alternative();
+ }
+
+ void operator()(SizeT<absl::variant_npos> /*i*/) const {
+ // This space intentionally left blank
+ }
+
+ VariantStateBaseDestructorNontrivial* self;
+ };
+
+ void destroy() {
+ variant_internal::visit_indices<sizeof...(T)>(Destroyer{this}, index_);
+ }
+
+ ~VariantStateBaseDestructorNontrivial() { destroy(); }
+
+ protected:
+ using Base::index_;
+ using Base::state_;
+};
+
+template <class... T>
+class VariantMoveBaseNontrivial : protected VariantStateBaseDestructor<T...> {
+ private:
+ using Base = VariantStateBaseDestructor<T...>;
+
+ protected:
+ using Base::Base;
+
+ struct Construct {
+ template <std::size_t I>
+ void operator()(SizeT<I> i) const {
+ using Alternative =
+ typename absl::variant_alternative<I, variant<T...>>::type;
+ ::new (static_cast<void*>(&self->state_)) Alternative(
+ variant_internal::AccessUnion(absl::move(other->state_), i));
+ }
+
+ void operator()(SizeT<absl::variant_npos> /*i*/) const {}
+
+ VariantMoveBaseNontrivial* self;
+ VariantMoveBaseNontrivial* other;
+ };
+
+ VariantMoveBaseNontrivial() = default;
+ VariantMoveBaseNontrivial(VariantMoveBaseNontrivial&& other) noexcept(
+ absl::conjunction<std::is_nothrow_move_constructible<T>...>::value)
+ : Base(NoopConstructorTag()) {
+ variant_internal::visit_indices<sizeof...(T)>(Construct{this, &other},
+ other.index_);
+ index_ = other.index_;
+ }
+
+ VariantMoveBaseNontrivial(VariantMoveBaseNontrivial const&) = default;
+
+ VariantMoveBaseNontrivial& operator=(VariantMoveBaseNontrivial&&) = default;
+ VariantMoveBaseNontrivial& operator=(VariantMoveBaseNontrivial const&) =
+ default;
+
+ protected:
+ using Base::index_;
+ using Base::state_;
+};
+
+template <class... T>
+class VariantCopyBaseNontrivial : protected VariantMoveBase<T...> {
+ private:
+ using Base = VariantMoveBase<T...>;
+
+ protected:
+ using Base::Base;
+
+ VariantCopyBaseNontrivial() = default;
+ VariantCopyBaseNontrivial(VariantCopyBaseNontrivial&&) = default;
+
+ struct Construct {
+ template <std::size_t I>
+ void operator()(SizeT<I> i) const {
+ using Alternative =
+ typename absl::variant_alternative<I, variant<T...>>::type;
+ ::new (static_cast<void*>(&self->state_))
+ Alternative(variant_internal::AccessUnion(other->state_, i));
+ }
+
+ void operator()(SizeT<absl::variant_npos> /*i*/) const {}
+
+ VariantCopyBaseNontrivial* self;
+ const VariantCopyBaseNontrivial* other;
+ };
+
+ VariantCopyBaseNontrivial(VariantCopyBaseNontrivial const& other)
+ : Base(NoopConstructorTag()) {
+ variant_internal::visit_indices<sizeof...(T)>(Construct{this, &other},
+ other.index_);
+ index_ = other.index_;
+ }
+
+ VariantCopyBaseNontrivial& operator=(VariantCopyBaseNontrivial&&) = default;
+ VariantCopyBaseNontrivial& operator=(VariantCopyBaseNontrivial const&) =
+ default;
+
+ protected:
+ using Base::index_;
+ using Base::state_;
+};
+
+template <class... T>
+class VariantMoveAssignBaseNontrivial : protected VariantCopyBase<T...> {
+ friend struct VariantCoreAccess;
+
+ private:
+ using Base = VariantCopyBase<T...>;
+
+ protected:
+ using Base::Base;
+
+ VariantMoveAssignBaseNontrivial() = default;
+ VariantMoveAssignBaseNontrivial(VariantMoveAssignBaseNontrivial&&) = default;
+ VariantMoveAssignBaseNontrivial(const VariantMoveAssignBaseNontrivial&) =
+ default;
+ VariantMoveAssignBaseNontrivial& operator=(
+ VariantMoveAssignBaseNontrivial const&) = default;
+
+ VariantMoveAssignBaseNontrivial&
+ operator=(VariantMoveAssignBaseNontrivial&& other) noexcept(
+ absl::conjunction<std::is_nothrow_move_constructible<T>...,
+ std::is_nothrow_move_assignable<T>...>::value) {
+ variant_internal::visit_indices<sizeof...(T)>(
+ VariantCoreAccess::MakeMoveAssignVisitor(this, &other), other.index_);
+ return *this;
+ }
+
+ protected:
+ using Base::index_;
+ using Base::state_;
+};
+
+template <class... T>
+class VariantCopyAssignBaseNontrivial : protected VariantMoveAssignBase<T...> {
+ friend struct VariantCoreAccess;
+
+ private:
+ using Base = VariantMoveAssignBase<T...>;
+
+ protected:
+ using Base::Base;
+
+ VariantCopyAssignBaseNontrivial() = default;
+ VariantCopyAssignBaseNontrivial(VariantCopyAssignBaseNontrivial&&) = default;
+ VariantCopyAssignBaseNontrivial(const VariantCopyAssignBaseNontrivial&) =
+ default;
+ VariantCopyAssignBaseNontrivial& operator=(
+ VariantCopyAssignBaseNontrivial&&) = default;
+
+ VariantCopyAssignBaseNontrivial& operator=(
+ const VariantCopyAssignBaseNontrivial& other) {
+ variant_internal::visit_indices<sizeof...(T)>(
+ VariantCoreAccess::MakeCopyAssignVisitor(this, other), other.index_);
+ return *this;
+ }
+
+ protected:
+ using Base::index_;
+ using Base::state_;
+};
+
+////////////////////////////////////////
+// Visitors for Comparison Operations //
+////////////////////////////////////////
+
+template <class... Types>
+struct EqualsOp {
+ const variant<Types...>* v;
+ const variant<Types...>* w;
+
+ constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+ return true;
+ }
+
+ template <std::size_t I>
+ constexpr bool operator()(SizeT<I> /*v_i*/) const {
+ return VariantCoreAccess::Access<I>(*v) == VariantCoreAccess::Access<I>(*w);
+ }
+};
+
+template <class... Types>
+struct NotEqualsOp {
+ const variant<Types...>* v;
+ const variant<Types...>* w;
+
+ constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+ return false;
+ }
+
+ template <std::size_t I>
+ constexpr bool operator()(SizeT<I> /*v_i*/) const {
+ return VariantCoreAccess::Access<I>(*v) != VariantCoreAccess::Access<I>(*w);
+ }
+};
+
+template <class... Types>
+struct LessThanOp {
+ const variant<Types...>* v;
+ const variant<Types...>* w;
+
+ constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+ return false;
+ }
+
+ template <std::size_t I>
+ constexpr bool operator()(SizeT<I> /*v_i*/) const {
+ return VariantCoreAccess::Access<I>(*v) < VariantCoreAccess::Access<I>(*w);
+ }
+};
+
+template <class... Types>
+struct GreaterThanOp {
+ const variant<Types...>* v;
+ const variant<Types...>* w;
+
+ constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+ return false;
+ }
+
+ template <std::size_t I>
+ constexpr bool operator()(SizeT<I> /*v_i*/) const {
+ return VariantCoreAccess::Access<I>(*v) > VariantCoreAccess::Access<I>(*w);
+ }
+};
+
+template <class... Types>
+struct LessThanOrEqualsOp {
+ const variant<Types...>* v;
+ const variant<Types...>* w;
+
+ constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+ return true;
+ }
+
+ template <std::size_t I>
+ constexpr bool operator()(SizeT<I> /*v_i*/) const {
+ return VariantCoreAccess::Access<I>(*v) <= VariantCoreAccess::Access<I>(*w);
+ }
+};
+
+template <class... Types>
+struct GreaterThanOrEqualsOp {
+ const variant<Types...>* v;
+ const variant<Types...>* w;
+
+ constexpr bool operator()(SizeT<absl::variant_npos> /*v_i*/) const {
+ return true;
+ }
+
+ template <std::size_t I>
+ constexpr bool operator()(SizeT<I> /*v_i*/) const {
+ return VariantCoreAccess::Access<I>(*v) >= VariantCoreAccess::Access<I>(*w);
+ }
+};
+
+// Precondition: v.index() == w.index();
+template <class... Types>
+struct SwapSameIndex {
+ variant<Types...>* v;
+ variant<Types...>* w;
+ template <std::size_t I>
+ void operator()(SizeT<I>) const {
+ using std::swap;
+ swap(VariantCoreAccess::Access<I>(*v), VariantCoreAccess::Access<I>(*w));
+ }
+
+ void operator()(SizeT<variant_npos>) const {}
+};
+
+// TODO(calabrese) do this from a different namespace for proper adl usage
+template <class... Types>
+struct Swap {
+ variant<Types...>* v;
+ variant<Types...>* w;
+
+ void generic_swap() const {
+ variant<Types...> tmp(std::move(*w));
+ VariantCoreAccess::Destroy(*w);
+ VariantCoreAccess::InitFrom(*w, std::move(*v));
+ VariantCoreAccess::Destroy(*v);
+ VariantCoreAccess::InitFrom(*v, std::move(tmp));
+ }
+
+ void operator()(SizeT<absl::variant_npos> /*w_i*/) const {
+ if (!v->valueless_by_exception()) {
+ generic_swap();
+ }
+ }
+
+ template <std::size_t Wi>
+ void operator()(SizeT<Wi> /*w_i*/) {
+ if (v->index() == Wi) {
+ visit_indices<sizeof...(Types)>(SwapSameIndex<Types...>{v, w}, Wi);
+ } else {
+ generic_swap();
+ }
+ }
+};
+
+template <typename Variant, typename = void, typename... Ts>
+struct VariantHashBase {
+ VariantHashBase() = delete;
+ VariantHashBase(const VariantHashBase&) = delete;
+ VariantHashBase(VariantHashBase&&) = delete;
+ VariantHashBase& operator=(const VariantHashBase&) = delete;
+ VariantHashBase& operator=(VariantHashBase&&) = delete;
+};
+
+struct VariantHashVisitor {
+ template <typename T>
+ size_t operator()(const T& t) {
+ return std::hash<T>{}(t);
+ }
+};
+
+template <typename Variant, typename... Ts>
+struct VariantHashBase<Variant,
+ absl::enable_if_t<absl::conjunction<
+ type_traits_internal::IsHashEnabled<Ts>...>::value>,
+ Ts...> {
+ using argument_type = Variant;
+ using result_type = size_t;
+ size_t operator()(const Variant& var) const {
+ if (var.valueless_by_exception()) {
+ return 239799884;
+ }
+ size_t result =
+ variant_internal::visit_indices<variant_size<Variant>::value>(
+ PerformVisitation<VariantHashVisitor, const Variant&>{
+ std::forward_as_tuple(var), VariantHashVisitor{}},
+ var.index());
+ // Combine the index and the hash result in order to distinguish
+ // std::variant<int, int> holding the same value as different alternative.
+ return result ^ var.index();
+ }
+};
+
+} // namespace variant_internal
+} // namespace absl
+
+#endif // ABSL_TYPES_variant_internal_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional.cc
new file mode 100644
index 0000000..ef27290
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional.cc
@@ -0,0 +1,24 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/types/optional.h"
+
+#ifndef ABSL_HAVE_STD_OPTIONAL
+namespace absl {
+
+nullopt_t::init_t nullopt_t::init;
+extern const nullopt_t nullopt{nullopt_t::init};
+
+} // namespace absl
+#endif // ABSL_HAVE_STD_OPTIONAL
[44/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_wait.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_wait.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_wait.h
new file mode 100644
index 0000000..5f65821
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_wait.h
@@ -0,0 +1,91 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
+#define ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
+
+// Operations to make atomic transitions on a word, and to allow
+// waiting for those transitions to become possible.
+
+#include <stdint.h>
+#include <atomic>
+
+#include "absl/base/internal/scheduling_mode.h"
+
+namespace absl {
+namespace base_internal {
+
+// SpinLockWait() waits until it can perform one of several transitions from
+// "from" to "to". It returns when it performs a transition where done==true.
+struct SpinLockWaitTransition {
+ uint32_t from;
+ uint32_t to;
+ bool done;
+};
+
+// Wait until *w can transition from trans[i].from to trans[i].to for some i
+// satisfying 0<=i<n && trans[i].done, atomically make the transition,
+// then return the old value of *w. Make any other atomic transitions
+// where !trans[i].done, but continue waiting.
+uint32_t SpinLockWait(std::atomic<uint32_t> *w, int n,
+ const SpinLockWaitTransition trans[],
+ SchedulingMode scheduling_mode);
+
+// If possible, wake some thread that has called SpinLockDelay(w, ...). If
+// "all" is true, wake all such threads. This call is a hint, and on some
+// systems it may be a no-op; threads calling SpinLockDelay() will always wake
+// eventually even if SpinLockWake() is never called.
+void SpinLockWake(std::atomic<uint32_t> *w, bool all);
+
+// Wait for an appropriate spin delay on iteration "loop" of a
+// spin loop on location *w, whose previously observed value was "value".
+// SpinLockDelay() may do nothing, may yield the CPU, may sleep a clock tick,
+// or may wait for a delay that can be truncated by a call to SpinLockWake(w).
+// In all cases, it must return in bounded time even if SpinLockWake() is not
+// called.
+void SpinLockDelay(std::atomic<uint32_t> *w, uint32_t value, int loop,
+ base_internal::SchedulingMode scheduling_mode);
+
+// Helper used by AbslInternalSpinLockDelay.
+// Returns a suggested delay in nanoseconds for iteration number "loop".
+int SpinLockSuggestedDelayNS(int loop);
+
+} // namespace base_internal
+} // namespace absl
+
+// In some build configurations we pass --detect-odr-violations to the
+// gold linker. This causes it to flag weak symbol overrides as ODR
+// violations. Because ODR only applies to C++ and not C,
+// --detect-odr-violations ignores symbols not mangled with C++ names.
+// By changing our extension points to be extern "C", we dodge this
+// check.
+extern "C" {
+void AbslInternalSpinLockWake(std::atomic<uint32_t> *w, bool all);
+void AbslInternalSpinLockDelay(
+ std::atomic<uint32_t> *w, uint32_t value, int loop,
+ absl::base_internal::SchedulingMode scheduling_mode);
+}
+
+inline void absl::base_internal::SpinLockWake(std::atomic<uint32_t> *w,
+ bool all) {
+ AbslInternalSpinLockWake(w, all);
+}
+
+inline void absl::base_internal::SpinLockDelay(
+ std::atomic<uint32_t> *w, uint32_t value, int loop,
+ base_internal::SchedulingMode scheduling_mode) {
+ AbslInternalSpinLockDelay(w, value, loop, scheduling_mode);
+}
+
+#endif // ABSL_BASE_INTERNAL_SPINLOCK_WAIT_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_win32.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_win32.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_win32.inc
new file mode 100644
index 0000000..32c8fc0
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_win32.inc
@@ -0,0 +1,37 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is a Win32-specific part of spinlock_wait.cc
+
+#include <windows.h>
+#include <atomic>
+#include "absl/base/internal/scheduling_mode.h"
+
+extern "C" {
+
+void AbslInternalSpinLockDelay(std::atomic<uint32_t>* /* lock_word */,
+ uint32_t /* value */, int loop,
+ absl::base_internal::SchedulingMode /* mode */) {
+ if (loop == 0) {
+ } else if (loop == 1) {
+ Sleep(0);
+ } else {
+ Sleep(absl::base_internal::SpinLockSuggestedDelayNS(loop) / 1000000);
+ }
+}
+
+void AbslInternalSpinLockWake(std::atomic<uint32_t>* /* lock_word */,
+ bool /* all */) {}
+
+} // extern "C"
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo.cc
new file mode 100644
index 0000000..db41bac
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo.cc
@@ -0,0 +1,404 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/sysinfo.h"
+
+#include "absl/base/attributes.h"
+
+#ifdef _WIN32
+#include <shlwapi.h>
+#include <windows.h>
+#else
+#include <fcntl.h>
+#include <pthread.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+#ifdef __linux__
+#include <sys/syscall.h>
+#endif
+
+#if defined(__APPLE__) || defined(__FreeBSD__)
+#include <sys/sysctl.h>
+#endif
+
+#if defined(__myriad2__)
+#include <rtems.h>
+#endif
+
+#include <string.h>
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <ctime>
+#include <limits>
+#include <thread> // NOLINT(build/c++11)
+#include <utility>
+#include <vector>
+
+#include "absl/base/call_once.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/spinlock.h"
+#include "absl/base/internal/unscaledcycleclock.h"
+
+namespace absl {
+namespace base_internal {
+
+static once_flag init_system_info_once;
+static int num_cpus = 0;
+static double nominal_cpu_frequency = 1.0; // 0.0 might be dangerous.
+
+static int GetNumCPUs() {
+#if defined(__myriad2__)
+ return 1;
+#else
+ // Other possibilities:
+ // - Read /sys/devices/system/cpu/online and use cpumask_parse()
+ // - sysconf(_SC_NPROCESSORS_ONLN)
+ return std::thread::hardware_concurrency();
+#endif
+}
+
+#if defined(_WIN32)
+
+static double GetNominalCPUFrequency() {
+ DWORD data;
+ DWORD data_size = sizeof(data);
+ #pragma comment(lib, "shlwapi.lib") // For SHGetValue().
+ if (SUCCEEDED(
+ SHGetValueA(HKEY_LOCAL_MACHINE,
+ "HARDWARE\\DESCRIPTION\\System\\CentralProcessor\\0",
+ "~MHz", nullptr, &data, &data_size))) {
+ return data * 1e6; // Value is MHz.
+ }
+ return 1.0;
+}
+
+#elif defined(CTL_HW) && defined(HW_CPU_FREQ)
+
+static double GetNominalCPUFrequency() {
+ unsigned freq;
+ size_t size = sizeof(freq);
+ int mib[2] = {CTL_HW, HW_CPU_FREQ};
+ if (sysctl(mib, 2, &freq, &size, nullptr, 0) == 0) {
+ return static_cast<double>(freq);
+ }
+ return 1.0;
+}
+
+#else
+
+// Helper function for reading a long from a file. Returns true if successful
+// and the memory location pointed to by value is set to the value read.
+static bool ReadLongFromFile(const char *file, long *value) {
+ bool ret = false;
+ int fd = open(file, O_RDONLY);
+ if (fd != -1) {
+ char line[1024];
+ char *err;
+ memset(line, '\0', sizeof(line));
+ int len = read(fd, line, sizeof(line) - 1);
+ if (len <= 0) {
+ ret = false;
+ } else {
+ const long temp_value = strtol(line, &err, 10);
+ if (line[0] != '\0' && (*err == '\n' || *err == '\0')) {
+ *value = temp_value;
+ ret = true;
+ }
+ }
+ close(fd);
+ }
+ return ret;
+}
+
+#if defined(ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY)
+
+// Reads a monotonic time source and returns a value in
+// nanoseconds. The returned value uses an arbitrary epoch, not the
+// Unix epoch.
+static int64_t ReadMonotonicClockNanos() {
+ struct timespec t;
+#ifdef CLOCK_MONOTONIC_RAW
+ int rc = clock_gettime(CLOCK_MONOTONIC_RAW, &t);
+#else
+ int rc = clock_gettime(CLOCK_MONOTONIC, &t);
+#endif
+ if (rc != 0) {
+ perror("clock_gettime() failed");
+ abort();
+ }
+ return int64_t{t.tv_sec} * 1000000000 + t.tv_nsec;
+}
+
+class UnscaledCycleClockWrapperForInitializeFrequency {
+ public:
+ static int64_t Now() { return base_internal::UnscaledCycleClock::Now(); }
+};
+
+struct TimeTscPair {
+ int64_t time; // From ReadMonotonicClockNanos().
+ int64_t tsc; // From UnscaledCycleClock::Now().
+};
+
+// Returns a pair of values (monotonic kernel time, TSC ticks) that
+// approximately correspond to each other. This is accomplished by
+// doing several reads and picking the reading with the lowest
+// latency. This approach is used to minimize the probability that
+// our thread was preempted between clock reads.
+static TimeTscPair GetTimeTscPair() {
+ int64_t best_latency = std::numeric_limits<int64_t>::max();
+ TimeTscPair best;
+ for (int i = 0; i < 10; ++i) {
+ int64_t t0 = ReadMonotonicClockNanos();
+ int64_t tsc = UnscaledCycleClockWrapperForInitializeFrequency::Now();
+ int64_t t1 = ReadMonotonicClockNanos();
+ int64_t latency = t1 - t0;
+ if (latency < best_latency) {
+ best_latency = latency;
+ best.time = t0;
+ best.tsc = tsc;
+ }
+ }
+ return best;
+}
+
+// Measures and returns the TSC frequency by taking a pair of
+// measurements approximately `sleep_nanoseconds` apart.
+static double MeasureTscFrequencyWithSleep(int sleep_nanoseconds) {
+ auto t0 = GetTimeTscPair();
+ struct timespec ts;
+ ts.tv_sec = 0;
+ ts.tv_nsec = sleep_nanoseconds;
+ while (nanosleep(&ts, &ts) != 0 && errno == EINTR) {}
+ auto t1 = GetTimeTscPair();
+ double elapsed_ticks = t1.tsc - t0.tsc;
+ double elapsed_time = (t1.time - t0.time) * 1e-9;
+ return elapsed_ticks / elapsed_time;
+}
+
+// Measures and returns the TSC frequency by calling
+// MeasureTscFrequencyWithSleep(), doubling the sleep interval until the
+// frequency measurement stabilizes.
+static double MeasureTscFrequency() {
+ double last_measurement = -1.0;
+ int sleep_nanoseconds = 1000000; // 1 millisecond.
+ for (int i = 0; i < 8; ++i) {
+ double measurement = MeasureTscFrequencyWithSleep(sleep_nanoseconds);
+ if (measurement * 0.99 < last_measurement &&
+ last_measurement < measurement * 1.01) {
+ // Use the current measurement if it is within 1% of the
+ // previous measurement.
+ return measurement;
+ }
+ last_measurement = measurement;
+ sleep_nanoseconds *= 2;
+ }
+ return last_measurement;
+}
+
+#endif // ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
+
+static double GetNominalCPUFrequency() {
+ long freq = 0;
+
+ // Google's production kernel has a patch to export the TSC
+ // frequency through sysfs. If the kernel is exporting the TSC
+ // frequency use that. There are issues where cpuinfo_max_freq
+ // cannot be relied on because the BIOS may be exporting an invalid
+ // p-state (on x86) or p-states may be used to put the processor in
+ // a new mode (turbo mode). Essentially, those frequencies cannot
+ // always be relied upon. The same reasons apply to /proc/cpuinfo as
+ // well.
+ if (ReadLongFromFile("/sys/devices/system/cpu/cpu0/tsc_freq_khz", &freq)) {
+ return freq * 1e3; // Value is kHz.
+ }
+
+#if defined(ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY)
+ // On these platforms, the TSC frequency is the nominal CPU
+ // frequency. But without having the kernel export it directly
+ // though /sys/devices/system/cpu/cpu0/tsc_freq_khz, there is no
+ // other way to reliably get the TSC frequency, so we have to
+ // measure it ourselves. Some CPUs abuse cpuinfo_max_freq by
+ // exporting "fake" frequencies for implementing new features. For
+ // example, Intel's turbo mode is enabled by exposing a p-state
+ // value with a higher frequency than that of the real TSC
+ // rate. Because of this, we prefer to measure the TSC rate
+ // ourselves on i386 and x86-64.
+ return MeasureTscFrequency();
+#else
+
+ // If CPU scaling is in effect, we want to use the *maximum*
+ // frequency, not whatever CPU speed some random processor happens
+ // to be using now.
+ if (ReadLongFromFile("/sys/devices/system/cpu/cpu0/cpufreq/cpuinfo_max_freq",
+ &freq)) {
+ return freq * 1e3; // Value is kHz.
+ }
+
+ return 1.0;
+#endif // !ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
+}
+
+#endif
+
+// InitializeSystemInfo() may be called before main() and before
+// malloc is properly initialized, therefore this must not allocate
+// memory.
+static void InitializeSystemInfo() {
+ num_cpus = GetNumCPUs();
+ nominal_cpu_frequency = GetNominalCPUFrequency();
+}
+
+int NumCPUs() {
+ base_internal::LowLevelCallOnce(&init_system_info_once, InitializeSystemInfo);
+ return num_cpus;
+}
+
+double NominalCPUFrequency() {
+ base_internal::LowLevelCallOnce(&init_system_info_once, InitializeSystemInfo);
+ return nominal_cpu_frequency;
+}
+
+#if defined(_WIN32)
+
+pid_t GetTID() {
+ return GetCurrentThreadId();
+}
+
+#elif defined(__linux__)
+
+#ifndef SYS_gettid
+#define SYS_gettid __NR_gettid
+#endif
+
+pid_t GetTID() {
+ return syscall(SYS_gettid);
+}
+
+#elif defined(__akaros__)
+
+pid_t GetTID() {
+ // Akaros has a concept of "vcore context", which is the state the program
+ // is forced into when we need to make a user-level scheduling decision, or
+ // run a signal handler. This is analogous to the interrupt context that a
+ // CPU might enter if it encounters some kind of exception.
+ //
+ // There is no current thread context in vcore context, but we need to give
+ // a reasonable answer if asked for a thread ID (e.g., in a signal handler).
+ // Thread 0 always exists, so if we are in vcore context, we return that.
+ //
+ // Otherwise, we know (since we are using pthreads) that the uthread struct
+ // current_uthread is pointing to is the first element of a
+ // struct pthread_tcb, so we extract and return the thread ID from that.
+ //
+ // TODO(dcross): Akaros anticipates moving the thread ID to the uthread
+ // structure at some point. We should modify this code to remove the cast
+ // when that happens.
+ if (in_vcore_context())
+ return 0;
+ return reinterpret_cast<struct pthread_tcb *>(current_uthread)->id;
+}
+
+#elif defined(__myriad2__)
+
+pid_t GetTID() {
+ uint32_t tid;
+ rtems_task_ident(RTEMS_SELF, 0, &tid);
+ return tid;
+}
+
+#else
+
+// Fallback implementation of GetTID using pthread_getspecific.
+static once_flag tid_once;
+static pthread_key_t tid_key;
+static absl::base_internal::SpinLock tid_lock(
+ absl::base_internal::kLinkerInitialized);
+
+// We set a bit per thread in this array to indicate that an ID is in
+// use. ID 0 is unused because it is the default value returned by
+// pthread_getspecific().
+static std::vector<uint32_t>* tid_array GUARDED_BY(tid_lock) = nullptr;
+static constexpr int kBitsPerWord = 32; // tid_array is uint32_t.
+
+// Returns the TID to tid_array.
+static void FreeTID(void *v) {
+ intptr_t tid = reinterpret_cast<intptr_t>(v);
+ int word = tid / kBitsPerWord;
+ uint32_t mask = ~(1u << (tid % kBitsPerWord));
+ absl::base_internal::SpinLockHolder lock(&tid_lock);
+ assert(0 <= word && static_cast<size_t>(word) < tid_array->size());
+ (*tid_array)[word] &= mask;
+}
+
+static void InitGetTID() {
+ if (pthread_key_create(&tid_key, FreeTID) != 0) {
+ // The logging system calls GetTID() so it can't be used here.
+ perror("pthread_key_create failed");
+ abort();
+ }
+
+ // Initialize tid_array.
+ absl::base_internal::SpinLockHolder lock(&tid_lock);
+ tid_array = new std::vector<uint32_t>(1);
+ (*tid_array)[0] = 1; // ID 0 is never-allocated.
+}
+
+// Return a per-thread small integer ID from pthread's thread-specific data.
+pid_t GetTID() {
+ absl::call_once(tid_once, InitGetTID);
+
+ intptr_t tid = reinterpret_cast<intptr_t>(pthread_getspecific(tid_key));
+ if (tid != 0) {
+ return tid;
+ }
+
+ int bit; // tid_array[word] = 1u << bit;
+ size_t word;
+ {
+ // Search for the first unused ID.
+ absl::base_internal::SpinLockHolder lock(&tid_lock);
+ // First search for a word in the array that is not all ones.
+ word = 0;
+ while (word < tid_array->size() && ~(*tid_array)[word] == 0) {
+ ++word;
+ }
+ if (word == tid_array->size()) {
+ tid_array->push_back(0); // No space left, add kBitsPerWord more IDs.
+ }
+ // Search for a zero bit in the word.
+ bit = 0;
+ while (bit < kBitsPerWord && (((*tid_array)[word] >> bit) & 1) != 0) {
+ ++bit;
+ }
+ tid = (word * kBitsPerWord) + bit;
+ (*tid_array)[word] |= 1u << bit; // Mark the TID as allocated.
+ }
+
+ if (pthread_setspecific(tid_key, reinterpret_cast<void *>(tid)) != 0) {
+ perror("pthread_setspecific failed");
+ abort();
+ }
+
+ return static_cast<pid_t>(tid);
+}
+
+#endif
+
+} // namespace base_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo.h
new file mode 100644
index 0000000..5bd1c50
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo.h
@@ -0,0 +1,63 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file includes routines to find out characteristics
+// of the machine a program is running on. It is undoubtedly
+// system-dependent.
+
+// Functions listed here that accept a pid_t as an argument act on the
+// current process if the pid_t argument is 0
+// All functions here are thread-hostile due to file caching unless
+// commented otherwise.
+
+#ifndef ABSL_BASE_INTERNAL_SYSINFO_H_
+#define ABSL_BASE_INTERNAL_SYSINFO_H_
+
+#ifndef _WIN32
+#include <sys/types.h>
+#else
+#include <intsafe.h>
+#endif
+
+#include "absl/base/port.h"
+
+namespace absl {
+namespace base_internal {
+
+// Nominal core processor cycles per second of each processor. This is _not_
+// necessarily the frequency of the CycleClock counter (see cycleclock.h)
+// Thread-safe.
+double NominalCPUFrequency();
+
+// Number of logical processors (hyperthreads) in system. Thread-safe.
+int NumCPUs();
+
+// Return the thread id of the current thread, as told by the system.
+// No two currently-live threads implemented by the OS shall have the same ID.
+// Thread ids of exited threads may be reused. Multiple user-level threads
+// may have the same thread ID if multiplexed on the same OS thread.
+//
+// On Linux, you may send a signal to the resulting ID with kill(). However,
+// it is recommended for portability that you use pthread_kill() instead.
+#ifdef _WIN32
+// On Windows, process id and thread id are of the same type according to
+// the return types of GetProcessId() and GetThreadId() are both DWORD.
+using pid_t = DWORD;
+#endif
+pid_t GetTID();
+
+} // namespace base_internal
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_SYSINFO_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo_test.cc
new file mode 100644
index 0000000..e0d9aab
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/sysinfo_test.cc
@@ -0,0 +1,98 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/sysinfo.h"
+
+#ifndef _WIN32
+#include <sys/types.h>
+#include <unistd.h>
+#endif
+
+#include <thread> // NOLINT(build/c++11)
+#include <unordered_set>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/synchronization/barrier.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+namespace base_internal {
+namespace {
+
+TEST(SysinfoTest, NumCPUs) {
+ EXPECT_NE(NumCPUs(), 0)
+ << "NumCPUs() should not have the default value of 0";
+}
+
+TEST(SysinfoTest, NominalCPUFrequency) {
+#if !(defined(__aarch64__) && defined(__linux__))
+ EXPECT_GE(NominalCPUFrequency(), 1000.0)
+ << "NominalCPUFrequency() did not return a reasonable value";
+#else
+ // TODO(absl-team): Aarch64 cannot read the CPU frequency from sysfs, so we
+ // get back 1.0. Fix once the value is available.
+ EXPECT_EQ(NominalCPUFrequency(), 1.0)
+ << "CPU frequency detection was fixed! Please update unittest.";
+#endif
+}
+
+TEST(SysinfoTest, GetTID) {
+ EXPECT_EQ(GetTID(), GetTID()); // Basic compile and equality test.
+#ifdef __native_client__
+ // Native Client has a race condition bug that leads to memory
+ // exaustion when repeatedly creating and joining threads.
+ // https://bugs.chromium.org/p/nativeclient/issues/detail?id=1027
+ return;
+#endif
+ // Test that TIDs are unique to each thread.
+ // Uses a few loops to exercise implementations that reallocate IDs.
+ for (int i = 0; i < 32; ++i) {
+ constexpr int kNumThreads = 64;
+ Barrier all_threads_done(kNumThreads);
+ std::vector<std::thread> threads;
+
+ Mutex mutex;
+ std::unordered_set<pid_t> tids;
+
+ for (int j = 0; j < kNumThreads; ++j) {
+ threads.push_back(std::thread([&]() {
+ pid_t id = GetTID();
+ {
+ MutexLock lock(&mutex);
+ ASSERT_TRUE(tids.find(id) == tids.end());
+ tids.insert(id);
+ }
+ // We can't simply join the threads here. The threads need to
+ // be alive otherwise the TID might have been reallocated to
+ // another live thread.
+ all_threads_done.Block();
+ }));
+ }
+ for (auto& thread : threads) {
+ thread.join();
+ }
+ }
+}
+
+#ifdef __linux__
+TEST(SysinfoTest, LinuxGetTID) {
+ // On Linux, for the main thread, GetTID()==getpid() is guaranteed by the API.
+ EXPECT_EQ(GetTID(), getpid());
+}
+#endif
+
+} // namespace
+} // namespace base_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity.cc
new file mode 100644
index 0000000..678e856
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity.cc
@@ -0,0 +1,123 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/thread_identity.h"
+
+#ifndef _WIN32
+#include <pthread.h>
+#include <signal.h>
+#endif
+
+#include <atomic>
+#include <cassert>
+#include <memory>
+
+#include "absl/base/call_once.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/spinlock.h"
+
+namespace absl {
+namespace base_internal {
+
+#if ABSL_THREAD_IDENTITY_MODE != ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+namespace {
+// Used to co-ordinate one-time creation of our pthread_key
+absl::once_flag init_thread_identity_key_once;
+pthread_key_t thread_identity_pthread_key;
+std::atomic<bool> pthread_key_initialized(false);
+
+void AllocateThreadIdentityKey(ThreadIdentityReclaimerFunction reclaimer) {
+ pthread_key_create(&thread_identity_pthread_key, reclaimer);
+ pthread_key_initialized.store(true, std::memory_order_release);
+}
+} // namespace
+#endif
+
+#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
+ ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+// The actual TLS storage for a thread's currently associated ThreadIdentity.
+// This is referenced by inline accessors in the header.
+// "protected" visibility ensures that if multiple instances of Abseil code
+// exist within a process (via dlopen() or similar), references to
+// thread_identity_ptr from each instance of the code will refer to
+// *different* instances of this ptr.
+#ifdef __GNUC__
+__attribute__((visibility("protected")))
+#endif // __GNUC__
+ ABSL_PER_THREAD_TLS_KEYWORD ThreadIdentity* thread_identity_ptr;
+#endif // TLS or CPP11
+
+void SetCurrentThreadIdentity(
+ ThreadIdentity* identity, ThreadIdentityReclaimerFunction reclaimer) {
+ assert(CurrentThreadIdentityIfPresent() == nullptr);
+ // Associate our destructor.
+ // NOTE: This call to pthread_setspecific is currently the only immovable
+ // barrier to CurrentThreadIdentity() always being async signal safe.
+#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+ // NOTE: Not async-safe. But can be open-coded.
+ absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey,
+ reclaimer);
+ // We must mask signals around the call to setspecific as with current glibc,
+ // a concurrent getspecific (needed for GetCurrentThreadIdentityIfPresent())
+ // may zero our value.
+ //
+ // While not officially async-signal safe, getspecific within a signal handler
+ // is otherwise OK.
+ sigset_t all_signals;
+ sigset_t curr_signals;
+ sigfillset(&all_signals);
+ pthread_sigmask(SIG_SETMASK, &all_signals, &curr_signals);
+ pthread_setspecific(thread_identity_pthread_key,
+ reinterpret_cast<void*>(identity));
+ pthread_sigmask(SIG_SETMASK, &curr_signals, nullptr);
+#elif ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS
+ // NOTE: Not async-safe. But can be open-coded.
+ absl::call_once(init_thread_identity_key_once, AllocateThreadIdentityKey,
+ reclaimer);
+ pthread_setspecific(thread_identity_pthread_key,
+ reinterpret_cast<void*>(identity));
+ thread_identity_ptr = identity;
+#elif ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+ thread_local std::unique_ptr<ThreadIdentity, ThreadIdentityReclaimerFunction>
+ holder(identity, reclaimer);
+ thread_identity_ptr = identity;
+#else
+#error Unimplemented ABSL_THREAD_IDENTITY_MODE
+#endif
+}
+
+void ClearCurrentThreadIdentity() {
+#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
+ ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+ thread_identity_ptr = nullptr;
+#elif ABSL_THREAD_IDENTITY_MODE == \
+ ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+ // pthread_setspecific expected to clear value on destruction
+ assert(CurrentThreadIdentityIfPresent() == nullptr);
+#endif
+}
+
+#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+ThreadIdentity* CurrentThreadIdentityIfPresent() {
+ bool initialized = pthread_key_initialized.load(std::memory_order_acquire);
+ if (!initialized) {
+ return nullptr;
+ }
+ return reinterpret_cast<ThreadIdentity*>(
+ pthread_getspecific(thread_identity_pthread_key));
+}
+#endif
+
+} // namespace base_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity.h
new file mode 100644
index 0000000..a51722f
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity.h
@@ -0,0 +1,240 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Each active thread has an ThreadIdentity that may represent the thread in
+// various level interfaces. ThreadIdentity objects are never deallocated.
+// When a thread terminates, its ThreadIdentity object may be reused for a
+// thread created later.
+
+#ifndef ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
+#define ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
+
+#ifndef _WIN32
+#include <pthread.h>
+// Defines __GOOGLE_GRTE_VERSION__ (via glibc-specific features.h) when
+// supported.
+#include <unistd.h>
+#endif
+
+#include <atomic>
+#include <cstdint>
+
+#include "absl/base/internal/per_thread_tls.h"
+
+namespace absl {
+
+struct SynchLocksHeld;
+struct SynchWaitParams;
+
+namespace base_internal {
+
+class SpinLock;
+struct ThreadIdentity;
+
+// Used by the implementation of base::Mutex and base::CondVar.
+struct PerThreadSynch {
+ // The internal representation of base::Mutex and base::CondVar rely
+ // on the alignment of PerThreadSynch. Both store the address of the
+ // PerThreadSynch in the high-order bits of their internal state,
+ // which means the low kLowZeroBits of the address of PerThreadSynch
+ // must be zero.
+ static constexpr int kLowZeroBits = 8;
+ static constexpr int kAlignment = 1 << kLowZeroBits;
+
+ // Returns the associated ThreadIdentity.
+ // This can be implemented as a cast because we guarantee
+ // PerThreadSynch is the first element of ThreadIdentity.
+ ThreadIdentity* thread_identity() {
+ return reinterpret_cast<ThreadIdentity*>(this);
+ }
+
+ PerThreadSynch *next; // Circular waiter queue; initialized to 0.
+ PerThreadSynch *skip; // If non-zero, all entries in Mutex queue
+ // up to and including "skip" have same
+ // condition as this, and will be woken later
+ bool may_skip; // if false while on mutex queue, a mutex unlocker
+ // is using this PerThreadSynch as a terminator. Its
+ // skip field must not be filled in because the loop
+ // might then skip over the terminator.
+
+ // The wait parameters of the current wait. waitp is null if the
+ // thread is not waiting. Transitions from null to non-null must
+ // occur before the enqueue commit point (state = kQueued in
+ // Enqueue() and CondVarEnqueue()). Transitions from non-null to
+ // null must occur after the wait is finished (state = kAvailable in
+ // Mutex::Block() and CondVar::WaitCommon()). This field may be
+ // changed only by the thread that describes this PerThreadSynch. A
+ // special case is Fer(), which calls Enqueue() on another thread,
+ // but with an identical SynchWaitParams pointer, thus leaving the
+ // pointer unchanged.
+ SynchWaitParams *waitp;
+
+ bool suppress_fatal_errors; // If true, try to proceed even in the face of
+ // broken invariants. This is used within fatal
+ // signal handlers to improve the chances of
+ // debug logging information being output
+ // successfully.
+
+ intptr_t readers; // Number of readers in mutex.
+ int priority; // Priority of thread (updated every so often).
+
+ // When priority will next be read (cycles).
+ int64_t next_priority_read_cycles;
+
+ // State values:
+ // kAvailable: This PerThreadSynch is available.
+ // kQueued: This PerThreadSynch is unavailable, it's currently queued on a
+ // Mutex or CondVar waistlist.
+ //
+ // Transitions from kQueued to kAvailable require a release
+ // barrier. This is needed as a waiter may use "state" to
+ // independently observe that it's no longer queued.
+ //
+ // Transitions from kAvailable to kQueued require no barrier, they
+ // are externally ordered by the Mutex.
+ enum State {
+ kAvailable,
+ kQueued
+ };
+ std::atomic<State> state;
+
+ bool maybe_unlocking; // Valid at head of Mutex waiter queue;
+ // true if UnlockSlow could be searching
+ // for a waiter to wake. Used for an optimization
+ // in Enqueue(). true is always a valid value.
+ // Can be reset to false when the unlocker or any
+ // writer releases the lock, or a reader fully releases
+ // the lock. It may not be set to false by a reader
+ // that decrements the count to non-zero.
+ // protected by mutex spinlock
+
+ bool wake; // This thread is to be woken from a Mutex.
+
+ // If "x" is on a waiter list for a mutex, "x->cond_waiter" is true iff the
+ // waiter is waiting on the mutex as part of a CV Wait or Mutex Await.
+ //
+ // The value of "x->cond_waiter" is meaningless if "x" is not on a
+ // Mutex waiter list.
+ bool cond_waiter;
+
+ // Locks held; used during deadlock detection.
+ // Allocated in Synch_GetAllLocks() and freed in ReclaimThreadIdentity().
+ SynchLocksHeld *all_locks;
+};
+
+struct ThreadIdentity {
+ // Must be the first member. The Mutex implementation requires that
+ // the PerThreadSynch object associated with each thread is
+ // PerThreadSynch::kAlignment aligned. We provide this alignment on
+ // ThreadIdentity itself.
+ PerThreadSynch per_thread_synch;
+
+ // Private: Reserved for absl::synchronization_internal::Waiter.
+ struct WaiterState {
+ char data[128];
+ } waiter_state;
+
+ // Used by PerThreadSem::{Get,Set}ThreadBlockedCounter().
+ std::atomic<int>* blocked_count_ptr;
+
+ // The following variables are mostly read/written just by the
+ // thread itself. The only exception is that these are read by
+ // a ticker thread as a hint.
+ std::atomic<int> ticker; // Tick counter, incremented once per second.
+ std::atomic<int> wait_start; // Ticker value when thread started waiting.
+ std::atomic<bool> is_idle; // Has thread become idle yet?
+
+ ThreadIdentity* next;
+};
+
+// Returns the ThreadIdentity object representing the calling thread; guaranteed
+// to be unique for its lifetime. The returned object will remain valid for the
+// program's lifetime; although it may be re-assigned to a subsequent thread.
+// If one does not exist, return nullptr instead.
+//
+// Does not malloc(*), and is async-signal safe.
+// [*] Technically pthread_setspecific() does malloc on first use; however this
+// is handled internally within tcmalloc's initialization already.
+//
+// New ThreadIdentity objects can be constructed and associated with a thread
+// by calling GetOrCreateCurrentThreadIdentity() in per-thread-sem.h.
+ThreadIdentity* CurrentThreadIdentityIfPresent();
+
+using ThreadIdentityReclaimerFunction = void (*)(void*);
+
+// Sets the current thread identity to the given value. 'reclaimer' is a
+// pointer to the global function for cleaning up instances on thread
+// destruction.
+void SetCurrentThreadIdentity(ThreadIdentity* identity,
+ ThreadIdentityReclaimerFunction reclaimer);
+
+// Removes the currently associated ThreadIdentity from the running thread.
+// This must be called from inside the ThreadIdentityReclaimerFunction, and only
+// from that function.
+void ClearCurrentThreadIdentity();
+
+// May be chosen at compile time via: -DABSL_FORCE_THREAD_IDENTITY_MODE=<mode
+// index>
+#ifdef ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#error ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC cannot be direcly set
+#else
+#define ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC 0
+#endif
+
+#ifdef ABSL_THREAD_IDENTITY_MODE_USE_TLS
+#error ABSL_THREAD_IDENTITY_MODE_USE_TLS cannot be direcly set
+#else
+#define ABSL_THREAD_IDENTITY_MODE_USE_TLS 1
+#endif
+
+#ifdef ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#error ABSL_THREAD_IDENTITY_MODE_USE_CPP11 cannot be direcly set
+#else
+#define ABSL_THREAD_IDENTITY_MODE_USE_CPP11 2
+#endif
+
+#ifdef ABSL_THREAD_IDENTITY_MODE
+#error ABSL_THREAD_IDENTITY_MODE cannot be direcly set
+#elif defined(ABSL_FORCE_THREAD_IDENTITY_MODE)
+#define ABSL_THREAD_IDENTITY_MODE ABSL_FORCE_THREAD_IDENTITY_MODE
+#elif defined(_WIN32)
+#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+#elif ABSL_PER_THREAD_TLS && defined(__GOOGLE_GRTE_VERSION__) && \
+ (__GOOGLE_GRTE_VERSION__ >= 20140228L)
+// Support for async-safe TLS was specifically added in GRTEv4. It's not
+// present in the upstream eglibc.
+// Note: Current default for production systems.
+#define ABSL_THREAD_IDENTITY_MODE ABSL_THREAD_IDENTITY_MODE_USE_TLS
+#else
+#define ABSL_THREAD_IDENTITY_MODE \
+ ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#endif
+
+#if ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_TLS || \
+ ABSL_THREAD_IDENTITY_MODE == ABSL_THREAD_IDENTITY_MODE_USE_CPP11
+
+extern ABSL_PER_THREAD_TLS_KEYWORD ThreadIdentity* thread_identity_ptr;
+
+inline ThreadIdentity* CurrentThreadIdentityIfPresent() {
+ return thread_identity_ptr;
+}
+
+#elif ABSL_THREAD_IDENTITY_MODE != \
+ ABSL_THREAD_IDENTITY_MODE_USE_POSIX_SETSPECIFIC
+#error Unknown ABSL_THREAD_IDENTITY_MODE
+#endif
+
+} // namespace base_internal
+} // namespace absl
+#endif // ABSL_BASE_INTERNAL_THREAD_IDENTITY_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity_test.cc
new file mode 100644
index 0000000..ecb8af6
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/thread_identity_test.cc
@@ -0,0 +1,126 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/thread_identity.h"
+
+#include <thread> // NOLINT(build/c++11)
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/attributes.h"
+#include "absl/base/internal/spinlock.h"
+#include "absl/base/macros.h"
+#include "absl/synchronization/internal/per_thread_sem.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+namespace base_internal {
+namespace {
+
+// protects num_identities_reused
+static absl::base_internal::SpinLock map_lock(
+ absl::base_internal::kLinkerInitialized);
+static int num_identities_reused;
+
+static const void* const kCheckNoIdentity = reinterpret_cast<void*>(1);
+
+static void TestThreadIdentityCurrent(const void* assert_no_identity) {
+ ThreadIdentity* identity;
+
+ // We have to test this conditionally, because if the test framework relies
+ // on Abseil, then some previous action may have already allocated an
+ // identity.
+ if (assert_no_identity == kCheckNoIdentity) {
+ identity = CurrentThreadIdentityIfPresent();
+ EXPECT_TRUE(identity == nullptr);
+ }
+
+ identity = synchronization_internal::GetOrCreateCurrentThreadIdentity();
+ EXPECT_TRUE(identity != nullptr);
+ ThreadIdentity* identity_no_init;
+ identity_no_init = CurrentThreadIdentityIfPresent();
+ EXPECT_TRUE(identity == identity_no_init);
+
+ // Check that per_thread_synch is correctly aligned.
+ EXPECT_EQ(0, reinterpret_cast<intptr_t>(&identity->per_thread_synch) %
+ PerThreadSynch::kAlignment);
+ EXPECT_EQ(identity, identity->per_thread_synch.thread_identity());
+
+ absl::base_internal::SpinLockHolder l(&map_lock);
+ num_identities_reused++;
+}
+
+TEST(ThreadIdentityTest, BasicIdentityWorks) {
+ // This tests for the main() thread.
+ TestThreadIdentityCurrent(nullptr);
+}
+
+TEST(ThreadIdentityTest, BasicIdentityWorksThreaded) {
+ // Now try the same basic test with multiple threads being created and
+ // destroyed. This makes sure that:
+ // - New threads are created without a ThreadIdentity.
+ // - We re-allocate ThreadIdentity objects from the free-list.
+ // - If a thread implementation chooses to recycle threads, that
+ // correct re-initialization occurs.
+ static const int kNumLoops = 3;
+ static const int kNumThreads = 400;
+ for (int iter = 0; iter < kNumLoops; iter++) {
+ std::vector<std::thread> threads;
+ for (int i = 0; i < kNumThreads; ++i) {
+ threads.push_back(
+ std::thread(TestThreadIdentityCurrent, kCheckNoIdentity));
+ }
+ for (auto& thread : threads) {
+ thread.join();
+ }
+ }
+
+ // We should have recycled ThreadIdentity objects above; while (external)
+ // library threads allocating their own identities may preclude some
+ // reuse, we should have sufficient repetitions to exclude this.
+ EXPECT_LT(kNumThreads, num_identities_reused);
+}
+
+TEST(ThreadIdentityTest, ReusedThreadIdentityMutexTest) {
+ // This test repeatly creates and joins a series of threads, each of
+ // which acquires and releases shared Mutex locks. This verifies
+ // Mutex operations work correctly under a reused
+ // ThreadIdentity. Note that the most likely failure mode of this
+ // test is a crash or deadlock.
+ static const int kNumLoops = 10;
+ static const int kNumThreads = 12;
+ static const int kNumMutexes = 3;
+ static const int kNumLockLoops = 5;
+
+ Mutex mutexes[kNumMutexes];
+ for (int iter = 0; iter < kNumLoops; ++iter) {
+ std::vector<std::thread> threads;
+ for (int thread = 0; thread < kNumThreads; ++thread) {
+ threads.push_back(std::thread([&]() {
+ for (int l = 0; l < kNumLockLoops; ++l) {
+ for (int m = 0; m < kNumMutexes; ++m) {
+ MutexLock lock(&mutexes[m]);
+ }
+ }
+ }));
+ }
+ for (auto& thread : threads) {
+ thread.join();
+ }
+ }
+}
+
+} // namespace
+} // namespace base_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/throw_delegate.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/throw_delegate.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/throw_delegate.cc
new file mode 100644
index 0000000..46dc573
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/throw_delegate.cc
@@ -0,0 +1,106 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/throw_delegate.h"
+
+#include <cstdlib>
+#include <functional>
+#include <new>
+#include <stdexcept>
+#include "absl/base/config.h"
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+namespace base_internal {
+
+namespace {
+template <typename T>
+[[noreturn]] void Throw(const T& error) {
+#ifdef ABSL_HAVE_EXCEPTIONS
+ throw error;
+#else
+ ABSL_RAW_LOG(ERROR, "%s", error.what());
+ abort();
+#endif
+}
+} // namespace
+
+void ThrowStdLogicError(const std::string& what_arg) {
+ Throw(std::logic_error(what_arg));
+}
+void ThrowStdLogicError(const char* what_arg) {
+ Throw(std::logic_error(what_arg));
+}
+void ThrowStdInvalidArgument(const std::string& what_arg) {
+ Throw(std::invalid_argument(what_arg));
+}
+void ThrowStdInvalidArgument(const char* what_arg) {
+ Throw(std::invalid_argument(what_arg));
+}
+
+void ThrowStdDomainError(const std::string& what_arg) {
+ Throw(std::domain_error(what_arg));
+}
+void ThrowStdDomainError(const char* what_arg) {
+ Throw(std::domain_error(what_arg));
+}
+
+void ThrowStdLengthError(const std::string& what_arg) {
+ Throw(std::length_error(what_arg));
+}
+void ThrowStdLengthError(const char* what_arg) {
+ Throw(std::length_error(what_arg));
+}
+
+void ThrowStdOutOfRange(const std::string& what_arg) {
+ Throw(std::out_of_range(what_arg));
+}
+void ThrowStdOutOfRange(const char* what_arg) {
+ Throw(std::out_of_range(what_arg));
+}
+
+void ThrowStdRuntimeError(const std::string& what_arg) {
+ Throw(std::runtime_error(what_arg));
+}
+void ThrowStdRuntimeError(const char* what_arg) {
+ Throw(std::runtime_error(what_arg));
+}
+
+void ThrowStdRangeError(const std::string& what_arg) {
+ Throw(std::range_error(what_arg));
+}
+void ThrowStdRangeError(const char* what_arg) {
+ Throw(std::range_error(what_arg));
+}
+
+void ThrowStdOverflowError(const std::string& what_arg) {
+ Throw(std::overflow_error(what_arg));
+}
+void ThrowStdOverflowError(const char* what_arg) {
+ Throw(std::overflow_error(what_arg));
+}
+
+void ThrowStdUnderflowError(const std::string& what_arg) {
+ Throw(std::underflow_error(what_arg));
+}
+void ThrowStdUnderflowError(const char* what_arg) {
+ Throw(std::underflow_error(what_arg));
+}
+
+void ThrowStdBadFunctionCall() { Throw(std::bad_function_call()); }
+
+void ThrowStdBadAlloc() { Throw(std::bad_alloc()); }
+
+} // namespace base_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/throw_delegate.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/throw_delegate.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/throw_delegate.h
new file mode 100644
index 0000000..70e2d77
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/throw_delegate.h
@@ -0,0 +1,71 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
+#define ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
+
+#include <string>
+
+namespace absl {
+namespace base_internal {
+
+// Helper functions that allow throwing exceptions consistently from anywhere.
+// The main use case is for header-based libraries (eg templates), as they will
+// be built by many different targets with their own compiler options.
+// In particular, this will allow a safe way to throw exceptions even if the
+// caller is compiled with -fno-exceptions. This is intended for implementing
+// things like map<>::at(), which the standard documents as throwing an
+// exception on error.
+//
+// Using other techniques like #if tricks could lead to ODR violations.
+//
+// You shouldn't use it unless you're writing code that you know will be built
+// both with and without exceptions and you need to conform to an interface
+// that uses exceptions.
+
+[[noreturn]] void ThrowStdLogicError(const std::string& what_arg);
+[[noreturn]] void ThrowStdLogicError(const char* what_arg);
+[[noreturn]] void ThrowStdInvalidArgument(const std::string& what_arg);
+[[noreturn]] void ThrowStdInvalidArgument(const char* what_arg);
+[[noreturn]] void ThrowStdDomainError(const std::string& what_arg);
+[[noreturn]] void ThrowStdDomainError(const char* what_arg);
+[[noreturn]] void ThrowStdLengthError(const std::string& what_arg);
+[[noreturn]] void ThrowStdLengthError(const char* what_arg);
+[[noreturn]] void ThrowStdOutOfRange(const std::string& what_arg);
+[[noreturn]] void ThrowStdOutOfRange(const char* what_arg);
+[[noreturn]] void ThrowStdRuntimeError(const std::string& what_arg);
+[[noreturn]] void ThrowStdRuntimeError(const char* what_arg);
+[[noreturn]] void ThrowStdRangeError(const std::string& what_arg);
+[[noreturn]] void ThrowStdRangeError(const char* what_arg);
+[[noreturn]] void ThrowStdOverflowError(const std::string& what_arg);
+[[noreturn]] void ThrowStdOverflowError(const char* what_arg);
+[[noreturn]] void ThrowStdUnderflowError(const std::string& what_arg);
+[[noreturn]] void ThrowStdUnderflowError(const char* what_arg);
+
+[[noreturn]] void ThrowStdBadFunctionCall();
+[[noreturn]] void ThrowStdBadAlloc();
+
+// ThrowStdBadArrayNewLength() cannot be consistently supported because
+// std::bad_array_new_length is missing in libstdc++ until 4.9.0.
+// https://gcc.gnu.org/onlinedocs/gcc-4.8.3/libstdc++/api/a01379_source.html
+// https://gcc.gnu.org/onlinedocs/gcc-4.9.0/libstdc++/api/a01327_source.html
+// libcxx (as of 3.2) and msvc (as of 2015) both have it.
+// [[noreturn]] void ThrowStdBadArrayNewLength();
+
+} // namespace base_internal
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_THROW_DELEGATE_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/tsan_mutex_interface.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/tsan_mutex_interface.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/tsan_mutex_interface.h
new file mode 100644
index 0000000..6bb4fae
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/tsan_mutex_interface.h
@@ -0,0 +1,66 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is intended solely for spinlock.h.
+// It provides ThreadSanitizer annotations for custom mutexes.
+// See <sanitizer/tsan_interface.h> for meaning of these annotations.
+
+#ifndef ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
+#define ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
+
+// ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+// Macro intended only for internal use.
+//
+// Checks whether LLVM Thread Sanitizer interfaces are available.
+// First made available in LLVM 5.0 (Sep 2017).
+#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+#error "ABSL_INTERNAL_HAVE_TSAN_INTERFACE cannot be directly set."
+#endif
+
+#if defined(THREAD_SANITIZER) && defined(__has_include)
+#if __has_include(<sanitizer/tsan_interface.h>)
+#define ABSL_INTERNAL_HAVE_TSAN_INTERFACE 1
+#endif
+#endif
+
+#ifdef ABSL_INTERNAL_HAVE_TSAN_INTERFACE
+#include <sanitizer/tsan_interface.h>
+
+#define ABSL_TSAN_MUTEX_CREATE __tsan_mutex_create
+#define ABSL_TSAN_MUTEX_DESTROY __tsan_mutex_destroy
+#define ABSL_TSAN_MUTEX_PRE_LOCK __tsan_mutex_pre_lock
+#define ABSL_TSAN_MUTEX_POST_LOCK __tsan_mutex_post_lock
+#define ABSL_TSAN_MUTEX_PRE_UNLOCK __tsan_mutex_pre_unlock
+#define ABSL_TSAN_MUTEX_POST_UNLOCK __tsan_mutex_post_unlock
+#define ABSL_TSAN_MUTEX_PRE_SIGNAL __tsan_mutex_pre_signal
+#define ABSL_TSAN_MUTEX_POST_SIGNAL __tsan_mutex_post_signal
+#define ABSL_TSAN_MUTEX_PRE_DIVERT __tsan_mutex_pre_divert
+#define ABSL_TSAN_MUTEX_POST_DIVERT __tsan_mutex_post_divert
+
+#else
+
+#define ABSL_TSAN_MUTEX_CREATE(...)
+#define ABSL_TSAN_MUTEX_DESTROY(...)
+#define ABSL_TSAN_MUTEX_PRE_LOCK(...)
+#define ABSL_TSAN_MUTEX_POST_LOCK(...)
+#define ABSL_TSAN_MUTEX_PRE_UNLOCK(...)
+#define ABSL_TSAN_MUTEX_POST_UNLOCK(...)
+#define ABSL_TSAN_MUTEX_PRE_SIGNAL(...)
+#define ABSL_TSAN_MUTEX_POST_SIGNAL(...)
+#define ABSL_TSAN_MUTEX_PRE_DIVERT(...)
+#define ABSL_TSAN_MUTEX_POST_DIVERT(...)
+
+#endif
+
+#endif // ABSL_BASE_INTERNAL_TSAN_MUTEX_INTERFACE_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unaligned_access.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unaligned_access.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unaligned_access.h
new file mode 100644
index 0000000..c572436
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unaligned_access.h
@@ -0,0 +1,256 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
+#define ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
+
+#include <string.h>
+#include <cstdint>
+
+#include "absl/base/attributes.h"
+
+// unaligned APIs
+
+// Portable handling of unaligned loads, stores, and copies.
+// On some platforms, like ARM, the copy functions can be more efficient
+// then a load and a store.
+//
+// It is possible to implement all of these these using constant-length memcpy
+// calls, which is portable and will usually be inlined into simple loads and
+// stores if the architecture supports it. However, such inlining usually
+// happens in a pass that's quite late in compilation, which means the resulting
+// loads and stores cannot participate in many other optimizations, leading to
+// overall worse code.
+
+// The unaligned API is C++ only. The declarations use C++ features
+// (namespaces, inline) which are absent or incompatible in C.
+#if defined(__cplusplus)
+
+#if defined(ADDRESS_SANITIZER) || defined(THREAD_SANITIZER) ||\
+ defined(MEMORY_SANITIZER)
+// Consider we have an unaligned load/store of 4 bytes from address 0x...05.
+// AddressSanitizer will treat it as a 3-byte access to the range 05:07 and
+// will miss a bug if 08 is the first unaddressable byte.
+// ThreadSanitizer will also treat this as a 3-byte access to 05:07 and will
+// miss a race between this access and some other accesses to 08.
+// MemorySanitizer will correctly propagate the shadow on unaligned stores
+// and correctly report bugs on unaligned loads, but it may not properly
+// update and report the origin of the uninitialized memory.
+// For all three tools, replacing an unaligned access with a tool-specific
+// callback solves the problem.
+
+// Make sure uint16_t/uint32_t/uint64_t are defined.
+#include <stdint.h>
+
+extern "C" {
+uint16_t __sanitizer_unaligned_load16(const void *p);
+uint32_t __sanitizer_unaligned_load32(const void *p);
+uint64_t __sanitizer_unaligned_load64(const void *p);
+void __sanitizer_unaligned_store16(void *p, uint16_t v);
+void __sanitizer_unaligned_store32(void *p, uint32_t v);
+void __sanitizer_unaligned_store64(void *p, uint64_t v);
+} // extern "C"
+
+namespace absl {
+
+inline uint16_t UnalignedLoad16(const void *p) {
+ return __sanitizer_unaligned_load16(p);
+}
+
+inline uint32_t UnalignedLoad32(const void *p) {
+ return __sanitizer_unaligned_load32(p);
+}
+
+inline uint64_t UnalignedLoad64(const void *p) {
+ return __sanitizer_unaligned_load64(p);
+}
+
+inline void UnalignedStore16(void *p, uint16_t v) {
+ __sanitizer_unaligned_store16(p, v);
+}
+
+inline void UnalignedStore32(void *p, uint32_t v) {
+ __sanitizer_unaligned_store32(p, v);
+}
+
+inline void UnalignedStore64(void *p, uint64_t v) {
+ __sanitizer_unaligned_store64(p, v);
+}
+
+} // namespace absl
+
+#define ABSL_INTERNAL_UNALIGNED_LOAD16(_p) (absl::UnalignedLoad16(_p))
+#define ABSL_INTERNAL_UNALIGNED_LOAD32(_p) (absl::UnalignedLoad32(_p))
+#define ABSL_INTERNAL_UNALIGNED_LOAD64(_p) (absl::UnalignedLoad64(_p))
+
+#define ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val) \
+ (absl::UnalignedStore16(_p, _val))
+#define ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val) \
+ (absl::UnalignedStore32(_p, _val))
+#define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \
+ (absl::UnalignedStore64(_p, _val))
+
+#elif defined(__x86_64__) || defined(_M_X64) || defined(__i386) || \
+ defined(_M_IX86) || defined(__ppc__) || defined(__PPC__) || \
+ defined(__ppc64__) || defined(__PPC64__)
+
+// x86 and x86-64 can perform unaligned loads/stores directly;
+// modern PowerPC hardware can also do unaligned integer loads and stores;
+// but note: the FPU still sends unaligned loads and stores to a trap handler!
+
+#define ABSL_INTERNAL_UNALIGNED_LOAD16(_p) \
+ (*reinterpret_cast<const uint16_t *>(_p))
+#define ABSL_INTERNAL_UNALIGNED_LOAD32(_p) \
+ (*reinterpret_cast<const uint32_t *>(_p))
+#define ABSL_INTERNAL_UNALIGNED_LOAD64(_p) \
+ (*reinterpret_cast<const uint64_t *>(_p))
+
+#define ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val) \
+ (*reinterpret_cast<uint16_t *>(_p) = (_val))
+#define ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val) \
+ (*reinterpret_cast<uint32_t *>(_p) = (_val))
+#define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \
+ (*reinterpret_cast<uint64_t *>(_p) = (_val))
+
+#elif defined(__arm__) && \
+ !defined(__ARM_ARCH_5__) && \
+ !defined(__ARM_ARCH_5T__) && \
+ !defined(__ARM_ARCH_5TE__) && \
+ !defined(__ARM_ARCH_5TEJ__) && \
+ !defined(__ARM_ARCH_6__) && \
+ !defined(__ARM_ARCH_6J__) && \
+ !defined(__ARM_ARCH_6K__) && \
+ !defined(__ARM_ARCH_6Z__) && \
+ !defined(__ARM_ARCH_6ZK__) && \
+ !defined(__ARM_ARCH_6T2__)
+
+
+// ARMv7 and newer support native unaligned accesses, but only of 16-bit
+// and 32-bit values (not 64-bit); older versions either raise a fatal signal,
+// do an unaligned read and rotate the words around a bit, or do the reads very
+// slowly (trip through kernel mode). There's no simple #define that says just
+// "ARMv7 or higher", so we have to filter away all ARMv5 and ARMv6
+// sub-architectures. Newer gcc (>= 4.6) set an __ARM_FEATURE_ALIGNED #define,
+// so in time, maybe we can move on to that.
+//
+// This is a mess, but there's not much we can do about it.
+//
+// To further complicate matters, only LDR instructions (single reads) are
+// allowed to be unaligned, not LDRD (two reads) or LDM (many reads). Unless we
+// explicitly tell the compiler that these accesses can be unaligned, it can and
+// will combine accesses. On armcc, the way to signal this is done by accessing
+// through the type (uint32_t __packed *), but GCC has no such attribute
+// (it ignores __attribute__((packed)) on individual variables). However,
+// we can tell it that a _struct_ is unaligned, which has the same effect,
+// so we do that.
+
+namespace absl {
+namespace internal {
+
+struct Unaligned16Struct {
+ uint16_t value;
+ uint8_t dummy; // To make the size non-power-of-two.
+} ABSL_ATTRIBUTE_PACKED;
+
+struct Unaligned32Struct {
+ uint32_t value;
+ uint8_t dummy; // To make the size non-power-of-two.
+} ABSL_ATTRIBUTE_PACKED;
+
+} // namespace internal
+} // namespace absl
+
+#define ABSL_INTERNAL_UNALIGNED_LOAD16(_p) \
+ ((reinterpret_cast<const ::absl::internal::Unaligned16Struct *>(_p))->value)
+#define ABSL_INTERNAL_UNALIGNED_LOAD32(_p) \
+ ((reinterpret_cast<const ::absl::internal::Unaligned32Struct *>(_p))->value)
+
+#define ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val) \
+ ((reinterpret_cast< ::absl::internal::Unaligned16Struct *>(_p))->value = \
+ (_val))
+#define ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val) \
+ ((reinterpret_cast< ::absl::internal::Unaligned32Struct *>(_p))->value = \
+ (_val))
+
+namespace absl {
+
+inline uint64_t UnalignedLoad64(const void *p) {
+ uint64_t t;
+ memcpy(&t, p, sizeof t);
+ return t;
+}
+
+inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); }
+
+} // namespace absl
+
+#define ABSL_INTERNAL_UNALIGNED_LOAD64(_p) (absl::UnalignedLoad64(_p))
+#define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \
+ (absl::UnalignedStore64(_p, _val))
+
+#else
+
+// ABSL_INTERNAL_NEED_ALIGNED_LOADS is defined when the underlying platform
+// doesn't support unaligned access.
+#define ABSL_INTERNAL_NEED_ALIGNED_LOADS
+
+// These functions are provided for architectures that don't support
+// unaligned loads and stores.
+
+namespace absl {
+
+inline uint16_t UnalignedLoad16(const void *p) {
+ uint16_t t;
+ memcpy(&t, p, sizeof t);
+ return t;
+}
+
+inline uint32_t UnalignedLoad32(const void *p) {
+ uint32_t t;
+ memcpy(&t, p, sizeof t);
+ return t;
+}
+
+inline uint64_t UnalignedLoad64(const void *p) {
+ uint64_t t;
+ memcpy(&t, p, sizeof t);
+ return t;
+}
+
+inline void UnalignedStore16(void *p, uint16_t v) { memcpy(p, &v, sizeof v); }
+
+inline void UnalignedStore32(void *p, uint32_t v) { memcpy(p, &v, sizeof v); }
+
+inline void UnalignedStore64(void *p, uint64_t v) { memcpy(p, &v, sizeof v); }
+
+} // namespace absl
+
+#define ABSL_INTERNAL_UNALIGNED_LOAD16(_p) (absl::UnalignedLoad16(_p))
+#define ABSL_INTERNAL_UNALIGNED_LOAD32(_p) (absl::UnalignedLoad32(_p))
+#define ABSL_INTERNAL_UNALIGNED_LOAD64(_p) (absl::UnalignedLoad64(_p))
+
+#define ABSL_INTERNAL_UNALIGNED_STORE16(_p, _val) \
+ (absl::UnalignedStore16(_p, _val))
+#define ABSL_INTERNAL_UNALIGNED_STORE32(_p, _val) \
+ (absl::UnalignedStore32(_p, _val))
+#define ABSL_INTERNAL_UNALIGNED_STORE64(_p, _val) \
+ (absl::UnalignedStore64(_p, _val))
+
+#endif
+
+#endif // defined(__cplusplus), end of unaligned API
+
+#endif // ABSL_BASE_INTERNAL_UNALIGNED_ACCESS_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unscaledcycleclock.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unscaledcycleclock.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unscaledcycleclock.cc
new file mode 100644
index 0000000..a12d68b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unscaledcycleclock.cc
@@ -0,0 +1,101 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/unscaledcycleclock.h"
+
+#if ABSL_USE_UNSCALED_CYCLECLOCK
+
+#if defined(_WIN32)
+#include <intrin.h>
+#endif
+
+#if defined(__powerpc__) || defined(__ppc__)
+#include <sys/platform/ppc.h>
+#endif
+
+#include "absl/base/internal/sysinfo.h"
+
+namespace absl {
+namespace base_internal {
+
+#if defined(__i386__)
+
+int64_t UnscaledCycleClock::Now() {
+ int64_t ret;
+ __asm__ volatile("rdtsc" : "=A"(ret));
+ return ret;
+}
+
+double UnscaledCycleClock::Frequency() {
+ return base_internal::NominalCPUFrequency();
+}
+
+#elif defined(__x86_64__)
+
+int64_t UnscaledCycleClock::Now() {
+ uint64_t low, high;
+ __asm__ volatile("rdtsc" : "=a"(low), "=d"(high));
+ return (high << 32) | low;
+}
+
+double UnscaledCycleClock::Frequency() {
+ return base_internal::NominalCPUFrequency();
+}
+
+#elif defined(__powerpc__) || defined(__ppc__)
+
+int64_t UnscaledCycleClock::Now() {
+ return __ppc_get_timebase();
+}
+
+double UnscaledCycleClock::Frequency() {
+ return __ppc_get_timebase_freq();
+}
+
+#elif defined(__aarch64__)
+
+// System timer of ARMv8 runs at a different frequency than the CPU's.
+// The frequency is fixed, typically in the range 1-50MHz. It can be
+// read at CNTFRQ special register. We assume the OS has set up
+// the virtual timer properly.
+int64_t UnscaledCycleClock::Now() {
+ int64_t virtual_timer_value;
+ asm volatile("mrs %0, cntvct_el0" : "=r"(virtual_timer_value));
+ return virtual_timer_value;
+}
+
+double UnscaledCycleClock::Frequency() {
+ uint64_t aarch64_timer_frequency;
+ asm volatile("mrs %0, cntfrq_el0" : "=r"(aarch64_timer_frequency));
+ return aarch64_timer_frequency;
+}
+
+#elif defined(_M_IX86) || defined(_M_X64)
+
+#pragma intrinsic(__rdtsc)
+
+int64_t UnscaledCycleClock::Now() {
+ return __rdtsc();
+}
+
+double UnscaledCycleClock::Frequency() {
+ return base_internal::NominalCPUFrequency();
+}
+
+#endif
+
+} // namespace base_internal
+} // namespace absl
+
+#endif // ABSL_USE_UNSCALED_CYCLECLOCK
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unscaledcycleclock.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unscaledcycleclock.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unscaledcycleclock.h
new file mode 100644
index 0000000..049f1ca
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/unscaledcycleclock.h
@@ -0,0 +1,119 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// UnscaledCycleClock
+// An UnscaledCycleClock yields the value and frequency of a cycle counter
+// that increments at a rate that is approximately constant.
+// This class is for internal / whitelisted use only, you should consider
+// using CycleClock instead.
+//
+// Notes:
+// The cycle counter frequency is not necessarily the core clock frequency.
+// That is, CycleCounter cycles are not necessarily "CPU cycles".
+//
+// An arbitrary offset may have been added to the counter at power on.
+//
+// On some platforms, the rate and offset of the counter may differ
+// slightly when read from different CPUs of a multiprocessor. Usually,
+// we try to ensure that the operating system adjusts values periodically
+// so that values agree approximately. If you need stronger guarantees,
+// consider using alternate interfaces.
+//
+// The CPU is not required to maintain the ordering of a cycle counter read
+// with respect to surrounding instructions.
+
+#ifndef ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
+#define ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
+
+#include <cstdint>
+
+#if defined(__APPLE__)
+#include <TargetConditionals.h>
+#endif
+
+#include "absl/base/port.h"
+
+// The following platforms have an implementation of a hardware counter.
+#if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__) || \
+ defined(__powerpc__) || defined(__ppc__) || \
+ defined(_M_IX86) || defined(_M_X64)
+#define ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION 1
+#else
+#define ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION 0
+#endif
+
+// The following platforms often disable access to the hardware
+// counter (through a sandbox) even if the underlying hardware has a
+// usable counter. The CycleTimer interface also requires a *scaled*
+// CycleClock that runs at atleast 1 MHz. We've found some Android
+// ARM64 devices where this is not the case, so we disable it by
+// default on Android ARM64.
+#if defined(__native_client__) || TARGET_OS_IPHONE || \
+ (defined(__ANDROID__) && defined(__aarch64__))
+#define ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT 0
+#else
+#define ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT 1
+#endif
+
+// UnscaledCycleClock is an optional internal feature.
+// Use "#if ABSL_USE_UNSCALED_CYCLECLOCK" to test for its presence.
+// Can be overridden at compile-time via -DABSL_USE_UNSCALED_CYCLECLOCK=0|1
+#if !defined(ABSL_USE_UNSCALED_CYCLECLOCK)
+#define ABSL_USE_UNSCALED_CYCLECLOCK \
+ (ABSL_HAVE_UNSCALED_CYCLECLOCK_IMPLEMENTATION && \
+ ABSL_USE_UNSCALED_CYCLECLOCK_DEFAULT)
+#endif
+
+#if ABSL_USE_UNSCALED_CYCLECLOCK
+
+// This macro can be used to test if UnscaledCycleClock::Frequency()
+// is NominalCPUFrequency() on a particular platform.
+#if (defined(__i386__) || defined(__x86_64__) || \
+ defined(_M_IX86) || defined(_M_X64))
+#define ABSL_INTERNAL_UNSCALED_CYCLECLOCK_FREQUENCY_IS_CPU_FREQUENCY
+#endif
+namespace absl {
+namespace time_internal {
+class UnscaledCycleClockWrapperForGetCurrentTime;
+} // namespace time_internal
+
+namespace base_internal {
+class CycleClock;
+class UnscaledCycleClockWrapperForInitializeFrequency;
+
+class UnscaledCycleClock {
+ private:
+ UnscaledCycleClock() = delete;
+
+ // Return the value of a cycle counter that counts at a rate that is
+ // approximately constant.
+ static int64_t Now();
+
+ // Return the how much UnscaledCycleClock::Now() increases per second.
+ // This is not necessarily the core CPU clock frequency.
+ // It may be the nominal value report by the kernel, rather than a measured
+ // value.
+ static double Frequency();
+
+ // Whitelisted friends.
+ friend class base_internal::CycleClock;
+ friend class time_internal::UnscaledCycleClockWrapperForGetCurrentTime;
+ friend class base_internal::UnscaledCycleClockWrapperForInitializeFrequency;
+};
+
+} // namespace base_internal
+} // namespace absl
+#endif // ABSL_USE_UNSCALED_CYCLECLOCK
+
+#endif // ABSL_BASE_INTERNAL_UNSCALEDCYCLECLOCK_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/invoke_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/invoke_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/invoke_test.cc
new file mode 100644
index 0000000..466bf11
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/invoke_test.cc
@@ -0,0 +1,200 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/invoke.h"
+
+#include <functional>
+#include <memory>
+#include <string>
+#include <utility>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/memory/memory.h"
+#include "absl/strings/str_cat.h"
+
+namespace absl {
+namespace base_internal {
+namespace {
+
+int Function(int a, int b) { return a - b; }
+
+int Sink(std::unique_ptr<int> p) {
+ return *p;
+}
+
+std::unique_ptr<int> Factory(int n) {
+ return make_unique<int>(n);
+}
+
+void NoOp() {}
+
+struct ConstFunctor {
+ int operator()(int a, int b) const { return a - b; }
+};
+
+struct MutableFunctor {
+ int operator()(int a, int b) { return a - b; }
+};
+
+struct EphemeralFunctor {
+ int operator()(int a, int b) && { return a - b; }
+};
+
+struct OverloadedFunctor {
+ template <typename... Args>
+ std::string operator()(const Args&... args) & {
+ return StrCat("&", args...);
+ }
+ template <typename... Args>
+ std::string operator()(const Args&... args) const& {
+ return StrCat("const&", args...);
+ }
+ template <typename... Args>
+ std::string operator()(const Args&... args) && {
+ return StrCat("&&", args...);
+ }
+};
+
+struct Class {
+ int Method(int a, int b) { return a - b; }
+ int ConstMethod(int a, int b) const { return a - b; }
+
+ int member;
+};
+
+struct FlipFlop {
+ int ConstMethod() const { return member; }
+ FlipFlop operator*() const { return {-member}; }
+
+ int member;
+};
+
+// CallMaybeWithArg(f) resolves either to Invoke(f) or Invoke(f, 42), depending
+// on which one is valid.
+template <typename F>
+decltype(Invoke(std::declval<const F&>())) CallMaybeWithArg(const F& f) {
+ return Invoke(f);
+}
+
+template <typename F>
+decltype(Invoke(std::declval<const F&>(), 42)) CallMaybeWithArg(const F& f) {
+ return Invoke(f, 42);
+}
+
+TEST(InvokeTest, Function) {
+ EXPECT_EQ(1, Invoke(Function, 3, 2));
+ EXPECT_EQ(1, Invoke(&Function, 3, 2));
+}
+
+TEST(InvokeTest, NonCopyableArgument) {
+ EXPECT_EQ(42, Invoke(Sink, make_unique<int>(42)));
+}
+
+TEST(InvokeTest, NonCopyableResult) {
+ EXPECT_THAT(Invoke(Factory, 42), ::testing::Pointee(42));
+}
+
+TEST(InvokeTest, VoidResult) {
+ Invoke(NoOp);
+}
+
+TEST(InvokeTest, ConstFunctor) {
+ EXPECT_EQ(1, Invoke(ConstFunctor(), 3, 2));
+}
+
+TEST(InvokeTest, MutableFunctor) {
+ MutableFunctor f;
+ EXPECT_EQ(1, Invoke(f, 3, 2));
+ EXPECT_EQ(1, Invoke(MutableFunctor(), 3, 2));
+}
+
+TEST(InvokeTest, EphemeralFunctor) {
+ EphemeralFunctor f;
+ EXPECT_EQ(1, Invoke(std::move(f), 3, 2));
+ EXPECT_EQ(1, Invoke(EphemeralFunctor(), 3, 2));
+}
+
+TEST(InvokeTest, OverloadedFunctor) {
+ OverloadedFunctor f;
+ const OverloadedFunctor& cf = f;
+
+ EXPECT_EQ("&", Invoke(f));
+ EXPECT_EQ("& 42", Invoke(f, " 42"));
+
+ EXPECT_EQ("const&", Invoke(cf));
+ EXPECT_EQ("const& 42", Invoke(cf, " 42"));
+
+ EXPECT_EQ("&&", Invoke(std::move(f)));
+ EXPECT_EQ("&& 42", Invoke(std::move(f), " 42"));
+}
+
+TEST(InvokeTest, ReferenceWrapper) {
+ ConstFunctor cf;
+ MutableFunctor mf;
+ EXPECT_EQ(1, Invoke(std::cref(cf), 3, 2));
+ EXPECT_EQ(1, Invoke(std::ref(cf), 3, 2));
+ EXPECT_EQ(1, Invoke(std::ref(mf), 3, 2));
+}
+
+TEST(InvokeTest, MemberFunction) {
+ std::unique_ptr<Class> p(new Class);
+ std::unique_ptr<const Class> cp(new Class);
+ EXPECT_EQ(1, Invoke(&Class::Method, p, 3, 2));
+ EXPECT_EQ(1, Invoke(&Class::Method, p.get(), 3, 2));
+
+ EXPECT_EQ(1, Invoke(&Class::ConstMethod, p, 3, 2));
+ EXPECT_EQ(1, Invoke(&Class::ConstMethod, p.get(), 3, 2));
+ EXPECT_EQ(1, Invoke(&Class::ConstMethod, *p, 3, 2));
+
+ EXPECT_EQ(1, Invoke(&Class::ConstMethod, cp, 3, 2));
+ EXPECT_EQ(1, Invoke(&Class::ConstMethod, cp.get(), 3, 2));
+ EXPECT_EQ(1, Invoke(&Class::ConstMethod, *cp, 3, 2));
+
+ EXPECT_EQ(1, Invoke(&Class::Method, make_unique<Class>(), 3, 2));
+ EXPECT_EQ(1, Invoke(&Class::ConstMethod, make_unique<Class>(), 3, 2));
+ EXPECT_EQ(1, Invoke(&Class::ConstMethod, make_unique<const Class>(), 3, 2));
+}
+
+TEST(InvokeTest, DataMember) {
+ std::unique_ptr<Class> p(new Class{42});
+ std::unique_ptr<const Class> cp(new Class{42});
+ EXPECT_EQ(42, Invoke(&Class::member, p));
+ EXPECT_EQ(42, Invoke(&Class::member, *p));
+ EXPECT_EQ(42, Invoke(&Class::member, p.get()));
+
+ Invoke(&Class::member, p) = 42;
+ Invoke(&Class::member, p.get()) = 42;
+
+ EXPECT_EQ(42, Invoke(&Class::member, cp));
+ EXPECT_EQ(42, Invoke(&Class::member, *cp));
+ EXPECT_EQ(42, Invoke(&Class::member, cp.get()));
+}
+
+TEST(InvokeTest, FlipFlop) {
+ FlipFlop obj = {42};
+ // This call could resolve to (obj.*&FlipFlop::ConstMethod)() or
+ // ((*obj).*&FlipFlop::ConstMethod)(). We verify that it's the former.
+ EXPECT_EQ(42, Invoke(&FlipFlop::ConstMethod, obj));
+ EXPECT_EQ(42, Invoke(&FlipFlop::member, obj));
+}
+
+TEST(InvokeTest, SfinaeFriendly) {
+ CallMaybeWithArg(NoOp);
+ EXPECT_THAT(CallMaybeWithArg(Factory), ::testing::Pointee(42));
+}
+
+} // namespace
+} // namespace base_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/log_severity.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/log_severity.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/log_severity.h
new file mode 100644
index 0000000..e2931c3
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/log_severity.h
@@ -0,0 +1,67 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_BASE_INTERNAL_LOG_SEVERITY_H_
+#define ABSL_BASE_INTERNAL_LOG_SEVERITY_H_
+
+#include <array>
+
+#include "absl/base/attributes.h"
+
+namespace absl {
+
+// Four severity levels are defined. Logging APIs should terminate the program
+// when a message is logged at severity `kFatal`; the other levels have no
+// special semantics.
+enum class LogSeverity : int {
+ kInfo = 0,
+ kWarning = 1,
+ kError = 2,
+ kFatal = 3,
+};
+
+// Returns an iterable of all standard `absl::LogSeverity` values, ordered from
+// least to most severe.
+constexpr std::array<absl::LogSeverity, 4> LogSeverities() {
+ return {{absl::LogSeverity::kInfo, absl::LogSeverity::kWarning,
+ absl::LogSeverity::kError, absl::LogSeverity::kFatal}};
+}
+
+// Returns the all-caps std::string representation (e.g. "INFO") of the specified
+// severity level if it is one of the normal levels and "UNKNOWN" otherwise.
+constexpr const char* LogSeverityName(absl::LogSeverity s) {
+ return s == absl::LogSeverity::kInfo
+ ? "INFO"
+ : s == absl::LogSeverity::kWarning
+ ? "WARNING"
+ : s == absl::LogSeverity::kError
+ ? "ERROR"
+ : s == absl::LogSeverity::kFatal ? "FATAL" : "UNKNOWN";
+}
+
+// Values less than `kInfo` normalize to `kInfo`; values greater than `kFatal`
+// normalize to `kError` (**NOT** `kFatal`).
+constexpr absl::LogSeverity NormalizeLogSeverity(absl::LogSeverity s) {
+ return s < absl::LogSeverity::kInfo
+ ? absl::LogSeverity::kInfo
+ : s > absl::LogSeverity::kFatal ? absl::LogSeverity::kError : s;
+}
+constexpr absl::LogSeverity NormalizeLogSeverity(int s) {
+ return NormalizeLogSeverity(static_cast<absl::LogSeverity>(s));
+}
+
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_LOG_SEVERITY_H_
[62/62] [abbrv] marmotta git commit: Merge branch 'master' into
develop
Posted by ja...@apache.org.
Merge branch 'master' into develop
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/4ab4f15c
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/4ab4f15c
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/4ab4f15c
Branch: refs/heads/develop
Commit: 4ab4f15ce9ad7bcc4d744804408ca6188b1a73b0
Parents: d7e8770 28c9b8b
Author: Jakob Frank <ja...@apache.org>
Authored: Mon Jun 18 20:32:38 2018 +0200
Committer: Jakob Frank <ja...@apache.org>
Committed: Mon Jun 18 20:32:38 2018 +0200
----------------------------------------------------------------------
----------------------------------------------------------------------
[02/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/variant_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/variant_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/types/variant_test.cc
new file mode 100644
index 0000000..262bd94
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/variant_test.cc
@@ -0,0 +1,2612 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Unit tests for the variant template. The 'is' and 'IsEmpty' methods
+// of variant are not explicitly tested because they are used repeatedly
+// in building other tests. All other public variant methods should have
+// explicit tests.
+
+#include "absl/types/variant.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <initializer_list>
+#include <memory>
+#include <ostream>
+#include <queue>
+#include <type_traits>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/config.h"
+#include "absl/base/port.h"
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+
+#define ABSL_VARIANT_TEST_EXPECT_FAIL(expr, exception_t, text) \
+ EXPECT_THROW(expr, exception_t)
+
+#else
+
+#define ABSL_VARIANT_TEST_EXPECT_FAIL(expr, exception_t, text) \
+ EXPECT_DEATH(expr, text)
+
+#endif // ABSL_HAVE_EXCEPTIONS
+
+#define ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(...) \
+ ABSL_VARIANT_TEST_EXPECT_FAIL((__VA_ARGS__), absl::bad_variant_access, \
+ "Bad variant access")
+
+struct Hashable {};
+
+namespace std {
+template <>
+struct hash<Hashable> {
+ size_t operator()(const Hashable&);
+};
+} // namespace std
+
+struct NonHashable {};
+
+namespace absl {
+namespace {
+
+using ::testing::DoubleEq;
+using ::testing::Pointee;
+using ::testing::VariantWith;
+
+struct MoveCanThrow {
+ MoveCanThrow() : v(0) {}
+ MoveCanThrow(int v) : v(v) {} // NOLINT(runtime/explicit)
+ MoveCanThrow(const MoveCanThrow& other) : v(other.v) {}
+ MoveCanThrow& operator=(const MoveCanThrow& /*other*/) { return *this; }
+ int v;
+};
+
+bool operator==(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v == rhs.v; }
+bool operator!=(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v != rhs.v; }
+bool operator<(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v < rhs.v; }
+bool operator<=(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v <= rhs.v; }
+bool operator>=(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v >= rhs.v; }
+bool operator>(MoveCanThrow lhs, MoveCanThrow rhs) { return lhs.v > rhs.v; }
+
+// This helper class allows us to determine if it was swapped with std::swap()
+// or with its friend swap() function.
+struct SpecialSwap {
+ explicit SpecialSwap(int i) : i(i) {}
+ friend void swap(SpecialSwap& a, SpecialSwap& b) {
+ a.special_swap = b.special_swap = true;
+ std::swap(a.i, b.i);
+ }
+ bool operator==(SpecialSwap other) const { return i == other.i; }
+ int i;
+ bool special_swap = false;
+};
+
+struct MoveOnlyWithListConstructor {
+ MoveOnlyWithListConstructor() = default;
+ explicit MoveOnlyWithListConstructor(std::initializer_list<int> /*ilist*/,
+ int value)
+ : value(value) {}
+ MoveOnlyWithListConstructor(MoveOnlyWithListConstructor&&) = default;
+ MoveOnlyWithListConstructor& operator=(MoveOnlyWithListConstructor&&) =
+ default;
+
+ int value = 0;
+};
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+
+struct ConversionException {};
+
+template <class T>
+struct ExceptionOnConversion {
+ operator T() const { // NOLINT(runtime/explicit)
+ throw ConversionException();
+ }
+};
+
+// Forces a variant into the valueless by exception state.
+template <class H, class... T>
+void ToValuelessByException(absl::variant<H, T...>& v) { // NOLINT
+ try {
+ v.template emplace<0>(ExceptionOnConversion<H>());
+ } catch (ConversionException& /*e*/) {
+ // This space intentionally left blank.
+ }
+}
+
+#endif // ABSL_HAVE_EXCEPTIONS
+
+// An indexed sequence of distinct structures holding a single
+// value of type T
+template<typename T, size_t N>
+struct ValueHolder {
+ explicit ValueHolder(const T& x) : value(x) {}
+ typedef T value_type;
+ value_type value;
+ static const size_t kIndex = N;
+};
+template<typename T, size_t N>
+const size_t ValueHolder<T, N>::kIndex;
+
+// The following three functions make ValueHolder compatible with
+// EXPECT_EQ and EXPECT_NE
+template<typename T, size_t N>
+inline bool operator==(const ValueHolder<T, N>& left,
+ const ValueHolder<T, N>& right) {
+ return left.value == right.value;
+}
+
+template<typename T, size_t N>
+inline bool operator!=(const ValueHolder<T, N>& left,
+ const ValueHolder<T, N>& right) {
+ return left.value != right.value;
+}
+
+template<typename T, size_t N>
+inline std::ostream& operator<<(
+ std::ostream& stream, const ValueHolder<T, N>& object) {
+ return stream << object.value;
+}
+
+// Makes a variant holding twelve uniquely typed T wrappers.
+template<typename T>
+struct VariantFactory {
+ typedef variant<ValueHolder<T, 1>, ValueHolder<T, 2>, ValueHolder<T, 3>,
+ ValueHolder<T, 4>>
+ Type;
+};
+
+// A typelist in 1:1 with VariantFactory, to use type driven unit tests.
+typedef ::testing::Types<ValueHolder<size_t, 1>, ValueHolder<size_t, 2>,
+ ValueHolder<size_t, 3>,
+ ValueHolder<size_t, 4>> VariantTypes;
+
+// Increments the provided counter pointer in the destructor
+struct IncrementInDtor {
+ explicit IncrementInDtor(int* counter) : counter(counter) {}
+ ~IncrementInDtor() { *counter += 1; }
+ int* counter;
+};
+
+struct IncrementInDtorCopyCanThrow {
+ explicit IncrementInDtorCopyCanThrow(int* counter) : counter(counter) {}
+ IncrementInDtorCopyCanThrow(IncrementInDtorCopyCanThrow&& other) noexcept =
+ default;
+ IncrementInDtorCopyCanThrow(const IncrementInDtorCopyCanThrow& other)
+ : counter(other.counter) {}
+ IncrementInDtorCopyCanThrow& operator=(
+ IncrementInDtorCopyCanThrow&&) noexcept = default;
+ IncrementInDtorCopyCanThrow& operator=(
+ IncrementInDtorCopyCanThrow const& other) {
+ counter = other.counter;
+ return *this;
+ }
+ ~IncrementInDtorCopyCanThrow() { *counter += 1; }
+ int* counter;
+};
+
+// This is defined so operator== for ValueHolder<IncrementInDtor> will
+// return true if two IncrementInDtor objects increment the same
+// counter
+inline bool operator==(const IncrementInDtor& left,
+ const IncrementInDtor& right) {
+ return left.counter == right.counter;
+}
+
+// This is defined so EXPECT_EQ can work with IncrementInDtor
+inline std::ostream& operator<<(
+ std::ostream& stream, const IncrementInDtor& object) {
+ return stream << object.counter;
+}
+
+// A class that can be copied, but not assigned.
+class CopyNoAssign {
+ public:
+ explicit CopyNoAssign(int value) : foo(value) {}
+ CopyNoAssign(const CopyNoAssign& other) : foo(other.foo) {}
+ int foo;
+ private:
+ const CopyNoAssign& operator=(const CopyNoAssign&);
+};
+
+// A class that can neither be copied nor assigned. We provide
+// overloads for the constructor with up to four parameters so we can
+// test the overloads of variant::emplace.
+class NonCopyable {
+ public:
+ NonCopyable()
+ : value(0) {}
+ explicit NonCopyable(int value1)
+ : value(value1) {}
+
+ NonCopyable(int value1, int value2)
+ : value(value1 + value2) {}
+
+ NonCopyable(int value1, int value2, int value3)
+ : value(value1 + value2 + value3) {}
+
+ NonCopyable(int value1, int value2, int value3, int value4)
+ : value(value1 + value2 + value3 + value4) {}
+ NonCopyable(const NonCopyable&) = delete;
+ NonCopyable& operator=(const NonCopyable&) = delete;
+ int value;
+};
+
+// A typed test and typed test case over the VariantTypes typelist,
+// from which we derive a number of tests that will execute for one of
+// each type.
+template <typename T>
+class VariantTypesTest : public ::testing::Test {};
+TYPED_TEST_CASE(VariantTypesTest, VariantTypes);
+
+////////////////////
+// [variant.ctor] //
+////////////////////
+
+struct NonNoexceptDefaultConstructible {
+ NonNoexceptDefaultConstructible() {}
+ int value = 5;
+};
+
+struct NonDefaultConstructible {
+ NonDefaultConstructible() = delete;
+};
+
+TEST(VariantTest, TestDefaultConstructor) {
+ {
+ using X = variant<int>;
+ constexpr variant<int> x{};
+ ASSERT_FALSE(x.valueless_by_exception());
+ ASSERT_EQ(0, x.index());
+ EXPECT_EQ(0, absl::get<0>(x));
+ EXPECT_TRUE(std::is_nothrow_default_constructible<X>::value);
+ }
+
+ {
+ using X = variant<NonNoexceptDefaultConstructible>;
+ X x{};
+ ASSERT_FALSE(x.valueless_by_exception());
+ ASSERT_EQ(0, x.index());
+ EXPECT_EQ(5, absl::get<0>(x).value);
+ EXPECT_FALSE(std::is_nothrow_default_constructible<X>::value);
+ }
+
+ {
+ using X = variant<int, NonNoexceptDefaultConstructible>;
+ X x{};
+ ASSERT_FALSE(x.valueless_by_exception());
+ ASSERT_EQ(0, x.index());
+ EXPECT_EQ(0, absl::get<0>(x));
+ EXPECT_TRUE(std::is_nothrow_default_constructible<X>::value);
+ }
+
+ {
+ using X = variant<NonNoexceptDefaultConstructible, int>;
+ X x{};
+ ASSERT_FALSE(x.valueless_by_exception());
+ ASSERT_EQ(0, x.index());
+ EXPECT_EQ(5, absl::get<0>(x).value);
+ EXPECT_FALSE(std::is_nothrow_default_constructible<X>::value);
+ }
+ EXPECT_FALSE(
+ std::is_default_constructible<variant<NonDefaultConstructible>>::value);
+ EXPECT_FALSE((std::is_default_constructible<
+ variant<NonDefaultConstructible, int>>::value));
+ EXPECT_TRUE((std::is_default_constructible<
+ variant<int, NonDefaultConstructible>>::value));
+}
+
+// Test that for each slot, copy constructing a variant with that type
+// produces a sensible object that correctly reports its type, and
+// that copies the provided value.
+TYPED_TEST(VariantTypesTest, TestCopyCtor) {
+ typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;
+ using value_type1 = absl::variant_alternative_t<0, Variant>;
+ using value_type2 = absl::variant_alternative_t<1, Variant>;
+ using value_type3 = absl::variant_alternative_t<2, Variant>;
+ using value_type4 = absl::variant_alternative_t<3, Variant>;
+ const TypeParam value(TypeParam::kIndex);
+ Variant original(value);
+ Variant copied(original);
+ EXPECT_TRUE(absl::holds_alternative<value_type1>(copied) ||
+ TypeParam::kIndex != 1);
+ EXPECT_TRUE(absl::holds_alternative<value_type2>(copied) ||
+ TypeParam::kIndex != 2);
+ EXPECT_TRUE(absl::holds_alternative<value_type3>(copied) ||
+ TypeParam::kIndex != 3);
+ EXPECT_TRUE(absl::holds_alternative<value_type4>(copied) ||
+ TypeParam::kIndex != 4);
+ EXPECT_TRUE((absl::get_if<value_type1>(&original) ==
+ absl::get_if<value_type1>(&copied)) ||
+ TypeParam::kIndex == 1);
+ EXPECT_TRUE((absl::get_if<value_type2>(&original) ==
+ absl::get_if<value_type2>(&copied)) ||
+ TypeParam::kIndex == 2);
+ EXPECT_TRUE((absl::get_if<value_type3>(&original) ==
+ absl::get_if<value_type3>(&copied)) ||
+ TypeParam::kIndex == 3);
+ EXPECT_TRUE((absl::get_if<value_type4>(&original) ==
+ absl::get_if<value_type4>(&copied)) ||
+ TypeParam::kIndex == 4);
+ EXPECT_TRUE((absl::get_if<value_type1>(&original) ==
+ absl::get_if<value_type1>(&copied)) ||
+ TypeParam::kIndex == 1);
+ EXPECT_TRUE((absl::get_if<value_type2>(&original) ==
+ absl::get_if<value_type2>(&copied)) ||
+ TypeParam::kIndex == 2);
+ EXPECT_TRUE((absl::get_if<value_type3>(&original) ==
+ absl::get_if<value_type3>(&copied)) ||
+ TypeParam::kIndex == 3);
+ EXPECT_TRUE((absl::get_if<value_type4>(&original) ==
+ absl::get_if<value_type4>(&copied)) ||
+ TypeParam::kIndex == 4);
+ const TypeParam* ovalptr = absl::get_if<TypeParam>(&original);
+ const TypeParam* cvalptr = absl::get_if<TypeParam>(&copied);
+ ASSERT_TRUE(ovalptr != nullptr);
+ ASSERT_TRUE(cvalptr != nullptr);
+ EXPECT_EQ(*ovalptr, *cvalptr);
+ TypeParam* mutable_ovalptr = absl::get_if<TypeParam>(&original);
+ TypeParam* mutable_cvalptr = absl::get_if<TypeParam>(&copied);
+ ASSERT_TRUE(mutable_ovalptr != nullptr);
+ ASSERT_TRUE(mutable_cvalptr != nullptr);
+ EXPECT_EQ(*mutable_ovalptr, *mutable_cvalptr);
+}
+
+template <class>
+struct MoveOnly {
+ MoveOnly() = default;
+ explicit MoveOnly(int value) : value(value) {}
+ MoveOnly(MoveOnly&&) = default;
+ MoveOnly& operator=(MoveOnly&&) = default;
+ int value = 5;
+};
+
+TEST(VariantTest, TestMoveConstruct) {
+ using V = variant<MoveOnly<class A>, MoveOnly<class B>, MoveOnly<class C>>;
+
+ V v(in_place_index_t<1>{}, 10);
+ V v2 = absl::move(v);
+ EXPECT_EQ(10, absl::get<1>(v2).value);
+}
+
+// Used internally to emulate missing triviality traits for tests.
+template <class T>
+union SingleUnion {
+ T member;
+};
+
+// NOTE: These don't work with types that can't be union members.
+// They are just for testing.
+template <class T>
+struct is_trivially_move_constructible
+ : std::is_move_constructible<SingleUnion<T>>::type {};
+
+template <class T>
+struct is_trivially_move_assignable
+ : std::is_move_assignable<SingleUnion<T>>::type {};
+
+TEST(VariantTest, NothrowMoveConstructible) {
+ // Verify that variant is nothrow move constructible iff its template
+ // arguments are.
+ using U = std::unique_ptr<int>;
+ struct E {
+ E(E&&) {}
+ };
+ static_assert(std::is_nothrow_move_constructible<variant<U>>::value, "");
+ static_assert(std::is_nothrow_move_constructible<variant<U, int>>::value, "");
+ static_assert(!std::is_nothrow_move_constructible<variant<U, E>>::value, "");
+}
+
+// Test that for each slot, constructing a variant with that type
+// produces a sensible object that correctly reports its type, and
+// that copies the provided value.
+TYPED_TEST(VariantTypesTest, TestValueCtor) {
+ typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;
+ using value_type1 = absl::variant_alternative_t<0, Variant>;
+ using value_type2 = absl::variant_alternative_t<1, Variant>;
+ using value_type3 = absl::variant_alternative_t<2, Variant>;
+ using value_type4 = absl::variant_alternative_t<3, Variant>;
+ const TypeParam value(TypeParam::kIndex);
+ Variant v(value);
+ EXPECT_TRUE(absl::holds_alternative<value_type1>(v) ||
+ TypeParam::kIndex != 1);
+ EXPECT_TRUE(absl::holds_alternative<value_type2>(v) ||
+ TypeParam::kIndex != 2);
+ EXPECT_TRUE(absl::holds_alternative<value_type3>(v) ||
+ TypeParam::kIndex != 3);
+ EXPECT_TRUE(absl::holds_alternative<value_type4>(v) ||
+ TypeParam::kIndex != 4);
+ EXPECT_TRUE(nullptr != absl::get_if<value_type1>(&v) ||
+ TypeParam::kIndex != 1);
+ EXPECT_TRUE(nullptr != absl::get_if<value_type2>(&v) ||
+ TypeParam::kIndex != 2);
+ EXPECT_TRUE(nullptr != absl::get_if<value_type3>(&v) ||
+ TypeParam::kIndex != 3);
+ EXPECT_TRUE(nullptr != absl::get_if<value_type4>(&v) ||
+ TypeParam::kIndex != 4);
+ EXPECT_TRUE(nullptr != absl::get_if<value_type1>(&v) ||
+ TypeParam::kIndex != 1);
+ EXPECT_TRUE(nullptr != absl::get_if<value_type2>(&v) ||
+ TypeParam::kIndex != 2);
+ EXPECT_TRUE(nullptr != absl::get_if<value_type3>(&v) ||
+ TypeParam::kIndex != 3);
+ EXPECT_TRUE(nullptr != absl::get_if<value_type4>(&v) ||
+ TypeParam::kIndex != 4);
+ const TypeParam* valptr = absl::get_if<TypeParam>(&v);
+ ASSERT_TRUE(nullptr != valptr);
+ EXPECT_EQ(value.value, valptr->value);
+ const TypeParam* mutable_valptr = absl::get_if<TypeParam>(&v);
+ ASSERT_TRUE(nullptr != mutable_valptr);
+ EXPECT_EQ(value.value, mutable_valptr->value);
+}
+
+TEST(VariantTest, InPlaceType) {
+ using Var = variant<int, std::string, NonCopyable, std::vector<int>>;
+
+ Var v1(in_place_type_t<int>(), 7);
+ ASSERT_TRUE(absl::holds_alternative<int>(v1));
+ EXPECT_EQ(7, absl::get<int>(v1));
+
+ Var v2(in_place_type_t<std::string>(), "ABC");
+ ASSERT_TRUE(absl::holds_alternative<std::string>(v2));
+ EXPECT_EQ("ABC", absl::get<std::string>(v2));
+
+ Var v3(in_place_type_t<std::string>(), "ABC", 2);
+ ASSERT_TRUE(absl::holds_alternative<std::string>(v3));
+ EXPECT_EQ("AB", absl::get<std::string>(v3));
+
+ Var v4(in_place_type_t<NonCopyable>{});
+ ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v4));
+
+ Var v5(in_place_type_t<std::vector<int>>(), {1, 2, 3});
+ ASSERT_TRUE(absl::holds_alternative<std::vector<int>>(v5));
+ EXPECT_THAT(absl::get<std::vector<int>>(v5), ::testing::ElementsAre(1, 2, 3));
+}
+
+TEST(VariantTest, InPlaceTypeInitializerList) {
+ using Var = variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;
+
+ Var v1(in_place_type_t<MoveOnlyWithListConstructor>(), {1, 2, 3, 4, 5}, 6);
+ ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));
+ EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);
+}
+
+TEST(VariantTest, InPlaceIndex) {
+ using Var = variant<int, std::string, NonCopyable, std::vector<int>>;
+
+ Var v1(in_place_index_t<0>(), 7);
+ ASSERT_TRUE(absl::holds_alternative<int>(v1));
+ EXPECT_EQ(7, absl::get<int>(v1));
+
+ Var v2(in_place_index_t<1>(), "ABC");
+ ASSERT_TRUE(absl::holds_alternative<std::string>(v2));
+ EXPECT_EQ("ABC", absl::get<std::string>(v2));
+
+ Var v3(in_place_index_t<1>(), "ABC", 2);
+ ASSERT_TRUE(absl::holds_alternative<std::string>(v3));
+ EXPECT_EQ("AB", absl::get<std::string>(v3));
+
+ Var v4(in_place_index_t<2>{});
+ EXPECT_TRUE(absl::holds_alternative<NonCopyable>(v4));
+
+ // Verify that a variant with only non-copyables can still be constructed.
+ EXPECT_TRUE(absl::holds_alternative<NonCopyable>(
+ variant<NonCopyable>(in_place_index_t<0>{})));
+
+ Var v5(in_place_index_t<3>(), {1, 2, 3});
+ ASSERT_TRUE(absl::holds_alternative<std::vector<int>>(v5));
+ EXPECT_THAT(absl::get<std::vector<int>>(v5), ::testing::ElementsAre(1, 2, 3));
+}
+
+TEST(VariantTest, InPlaceIndexInitializerList) {
+ using Var = variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;
+
+ Var v1(in_place_index_t<3>(), {1, 2, 3, 4, 5}, 6);
+ ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));
+ EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);
+}
+
+////////////////////
+// [variant.dtor] //
+////////////////////
+
+// Make sure that the destructor destroys the contained value
+TEST(VariantTest, TestDtor) {
+ typedef VariantFactory<IncrementInDtor>::Type Variant;
+ using value_type1 = absl::variant_alternative_t<0, Variant>;
+ using value_type2 = absl::variant_alternative_t<1, Variant>;
+ using value_type3 = absl::variant_alternative_t<2, Variant>;
+ using value_type4 = absl::variant_alternative_t<3, Variant>;
+ int counter = 0;
+ IncrementInDtor counter_adjuster(&counter);
+ EXPECT_EQ(0, counter);
+
+ value_type1 value1(counter_adjuster);
+ { Variant object(value1); }
+ EXPECT_EQ(1, counter);
+
+ value_type2 value2(counter_adjuster);
+ { Variant object(value2); }
+ EXPECT_EQ(2, counter);
+
+ value_type3 value3(counter_adjuster);
+ { Variant object(value3); }
+ EXPECT_EQ(3, counter);
+
+ value_type4 value4(counter_adjuster);
+ { Variant object(value4); }
+ EXPECT_EQ(4, counter);
+}
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+
+// Test destruction when in the valueless_by_exception state.
+TEST(VariantTest, TestDtorValuelessByException) {
+ int counter = 0;
+ IncrementInDtor counter_adjuster(&counter);
+
+ {
+ using Variant = VariantFactory<IncrementInDtor>::Type;
+
+ Variant v(in_place_index_t<0>(), counter_adjuster);
+ EXPECT_EQ(0, counter);
+
+ ToValuelessByException(v);
+ ASSERT_TRUE(v.valueless_by_exception());
+ EXPECT_EQ(1, counter);
+ }
+ EXPECT_EQ(1, counter);
+}
+
+#endif // ABSL_HAVE_EXCEPTIONS
+
+//////////////////////
+// [variant.assign] //
+//////////////////////
+
+// Test that self-assignment doesn't destroy the current value
+TEST(VariantTest, TestSelfAssignment) {
+ typedef VariantFactory<IncrementInDtor>::Type Variant;
+ int counter = 0;
+ IncrementInDtor counter_adjuster(&counter);
+ absl::variant_alternative_t<0, Variant> value(counter_adjuster);
+ Variant object(value);
+ object.operator=(object);
+ EXPECT_EQ(0, counter);
+
+ // A std::string long enough that it's likely to defeat any inline representation
+ // optimization.
+ const std::string long_str(128, 'a');
+
+ std::string foo = long_str;
+ foo = *&foo;
+ EXPECT_EQ(long_str, foo);
+
+ variant<int, std::string> so = long_str;
+ ASSERT_EQ(1, so.index());
+ EXPECT_EQ(long_str, absl::get<1>(so));
+ so = *&so;
+
+ ASSERT_EQ(1, so.index());
+ EXPECT_EQ(long_str, absl::get<1>(so));
+}
+
+// Test that assigning a variant<..., T, ...> to a variant<..., T, ...> produces
+// a variant<..., T, ...> with the correct value.
+TYPED_TEST(VariantTypesTest, TestAssignmentCopiesValueSameTypes) {
+ typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;
+ const TypeParam value(TypeParam::kIndex);
+ const Variant source(value);
+ Variant target(TypeParam(value.value + 1));
+ ASSERT_TRUE(absl::holds_alternative<TypeParam>(source));
+ ASSERT_TRUE(absl::holds_alternative<TypeParam>(target));
+ ASSERT_NE(absl::get<TypeParam>(source), absl::get<TypeParam>(target));
+ target = source;
+ ASSERT_TRUE(absl::holds_alternative<TypeParam>(source));
+ ASSERT_TRUE(absl::holds_alternative<TypeParam>(target));
+ EXPECT_EQ(absl::get<TypeParam>(source), absl::get<TypeParam>(target));
+}
+
+// Test that assisnging a variant<..., T, ...> to a variant<1, ...>
+// produces a variant<..., T, ...> with the correct value.
+TYPED_TEST(VariantTypesTest, TestAssignmentCopiesValuesVaryingSourceType) {
+ typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;
+ using value_type1 = absl::variant_alternative_t<0, Variant>;
+ const TypeParam value(TypeParam::kIndex);
+ const Variant source(value);
+ ASSERT_TRUE(absl::holds_alternative<TypeParam>(source));
+ Variant target(value_type1(1));
+ ASSERT_TRUE(absl::holds_alternative<value_type1>(target));
+ target = source;
+ EXPECT_TRUE(absl::holds_alternative<TypeParam>(source));
+ EXPECT_TRUE(absl::holds_alternative<TypeParam>(target));
+ EXPECT_EQ(absl::get<TypeParam>(source), absl::get<TypeParam>(target));
+}
+
+// Test that assigning a variant<1, ...> to a variant<..., T, ...>
+// produces a variant<1, ...> with the correct value.
+TYPED_TEST(VariantTypesTest, TestAssignmentCopiesValuesVaryingTargetType) {
+ typedef typename VariantFactory<typename TypeParam::value_type>::Type Variant;
+ using value_type1 = absl::variant_alternative_t<0, Variant>;
+ const Variant source(value_type1(1));
+ ASSERT_TRUE(absl::holds_alternative<value_type1>(source));
+ const TypeParam value(TypeParam::kIndex);
+ Variant target(value);
+ ASSERT_TRUE(absl::holds_alternative<TypeParam>(target));
+ target = source;
+ EXPECT_TRUE(absl::holds_alternative<value_type1>(target));
+ EXPECT_TRUE(absl::holds_alternative<value_type1>(source));
+ EXPECT_EQ(absl::get<value_type1>(source), absl::get<value_type1>(target));
+}
+
+// Test that operator=<T> works, that assigning a new value destroys
+// the old and that assigning the new value again does not redestroy
+// the old
+TEST(VariantTest, TestAssign) {
+ typedef VariantFactory<IncrementInDtor>::Type Variant;
+ using value_type1 = absl::variant_alternative_t<0, Variant>;
+ using value_type2 = absl::variant_alternative_t<1, Variant>;
+ using value_type3 = absl::variant_alternative_t<2, Variant>;
+ using value_type4 = absl::variant_alternative_t<3, Variant>;
+
+ const int kSize = 4;
+ int counter[kSize];
+ std::unique_ptr<IncrementInDtor> counter_adjustor[kSize];
+ for (int i = 0; i != kSize; i++) {
+ counter[i] = 0;
+ counter_adjustor[i] = absl::make_unique<IncrementInDtor>(&counter[i]);
+ }
+
+ value_type1 v1(*counter_adjustor[0]);
+ value_type2 v2(*counter_adjustor[1]);
+ value_type3 v3(*counter_adjustor[2]);
+ value_type4 v4(*counter_adjustor[3]);
+
+ // Test that reassignment causes destruction of old value
+ {
+ Variant object(v1);
+ object = v2;
+ object = v3;
+ object = v4;
+ object = v1;
+ }
+
+ EXPECT_EQ(2, counter[0]);
+ EXPECT_EQ(1, counter[1]);
+ EXPECT_EQ(1, counter[2]);
+ EXPECT_EQ(1, counter[3]);
+
+ std::fill(std::begin(counter), std::end(counter), 0);
+
+ // Test that self-assignment does not cause destruction of old value
+ {
+ Variant object(v1);
+ object.operator=(object);
+ EXPECT_EQ(0, counter[0]);
+ }
+ {
+ Variant object(v2);
+ object.operator=(object);
+ EXPECT_EQ(0, counter[1]);
+ }
+ {
+ Variant object(v3);
+ object.operator=(object);
+ EXPECT_EQ(0, counter[2]);
+ }
+ {
+ Variant object(v4);
+ object.operator=(object);
+ EXPECT_EQ(0, counter[3]);
+ }
+
+ EXPECT_EQ(1, counter[0]);
+ EXPECT_EQ(1, counter[1]);
+ EXPECT_EQ(1, counter[2]);
+ EXPECT_EQ(1, counter[3]);
+}
+
+// This tests that we perform a backup if the copy-assign can throw but the move
+// cannot throw.
+TEST(VariantTest, TestBackupAssign) {
+ typedef VariantFactory<IncrementInDtorCopyCanThrow>::Type Variant;
+ using value_type1 = absl::variant_alternative_t<0, Variant>;
+ using value_type2 = absl::variant_alternative_t<1, Variant>;
+ using value_type3 = absl::variant_alternative_t<2, Variant>;
+ using value_type4 = absl::variant_alternative_t<3, Variant>;
+
+ const int kSize = 4;
+ int counter[kSize];
+ std::unique_ptr<IncrementInDtorCopyCanThrow> counter_adjustor[kSize];
+ for (int i = 0; i != kSize; i++) {
+ counter[i] = 0;
+ counter_adjustor[i].reset(new IncrementInDtorCopyCanThrow(&counter[i]));
+ }
+
+ value_type1 v1(*counter_adjustor[0]);
+ value_type2 v2(*counter_adjustor[1]);
+ value_type3 v3(*counter_adjustor[2]);
+ value_type4 v4(*counter_adjustor[3]);
+
+ // Test that reassignment causes destruction of old value
+ {
+ Variant object(v1);
+ object = v2;
+ object = v3;
+ object = v4;
+ object = v1;
+ }
+
+ // libstdc++ doesn't pass this test
+#if !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))
+ EXPECT_EQ(3, counter[0]);
+ EXPECT_EQ(2, counter[1]);
+ EXPECT_EQ(2, counter[2]);
+ EXPECT_EQ(2, counter[3]);
+#endif
+
+ std::fill(std::begin(counter), std::end(counter), 0);
+
+ // Test that self-assignment does not cause destruction of old value
+ {
+ Variant object(v1);
+ object.operator=(object);
+ EXPECT_EQ(0, counter[0]);
+ }
+ {
+ Variant object(v2);
+ object.operator=(object);
+ EXPECT_EQ(0, counter[1]);
+ }
+ {
+ Variant object(v3);
+ object.operator=(object);
+ EXPECT_EQ(0, counter[2]);
+ }
+ {
+ Variant object(v4);
+ object.operator=(object);
+ EXPECT_EQ(0, counter[3]);
+ }
+
+ EXPECT_EQ(1, counter[0]);
+ EXPECT_EQ(1, counter[1]);
+ EXPECT_EQ(1, counter[2]);
+ EXPECT_EQ(1, counter[3]);
+}
+
+///////////////////
+// [variant.mod] //
+///////////////////
+
+TEST(VariantTest, TestEmplaceBasic) {
+ using Variant = variant<int, char>;
+
+ Variant v(absl::in_place_index_t<0>{}, 0);
+
+ {
+ char& emplace_result = v.emplace<char>();
+ ASSERT_TRUE(absl::holds_alternative<char>(v));
+ EXPECT_EQ(absl::get<char>(v), 0);
+ EXPECT_EQ(&emplace_result, &absl::get<char>(v));
+ }
+
+ // Make sure that another emplace does zero-initialization
+ absl::get<char>(v) = 'a';
+ v.emplace<char>('b');
+ ASSERT_TRUE(absl::holds_alternative<char>(v));
+ EXPECT_EQ(absl::get<char>(v), 'b');
+
+ {
+ int& emplace_result = v.emplace<int>();
+ EXPECT_TRUE(absl::holds_alternative<int>(v));
+ EXPECT_EQ(absl::get<int>(v), 0);
+ EXPECT_EQ(&emplace_result, &absl::get<int>(v));
+ }
+}
+
+TEST(VariantTest, TestEmplaceInitializerList) {
+ using Var = variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;
+
+ Var v1(absl::in_place_index_t<0>{}, 555);
+ MoveOnlyWithListConstructor& emplace_result =
+ v1.emplace<MoveOnlyWithListConstructor>({1, 2, 3, 4, 5}, 6);
+ ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));
+ EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);
+ EXPECT_EQ(&emplace_result, &absl::get<MoveOnlyWithListConstructor>(v1));
+}
+
+TEST(VariantTest, TestEmplaceIndex) {
+ using Variant = variant<int, char>;
+
+ Variant v(absl::in_place_index_t<0>{}, 555);
+
+ {
+ char& emplace_result = v.emplace<1>();
+ ASSERT_TRUE(absl::holds_alternative<char>(v));
+ EXPECT_EQ(absl::get<char>(v), 0);
+ EXPECT_EQ(&emplace_result, &absl::get<char>(v));
+ }
+
+ // Make sure that another emplace does zero-initialization
+ absl::get<char>(v) = 'a';
+ v.emplace<1>('b');
+ ASSERT_TRUE(absl::holds_alternative<char>(v));
+ EXPECT_EQ(absl::get<char>(v), 'b');
+
+ {
+ int& emplace_result = v.emplace<0>();
+ EXPECT_TRUE(absl::holds_alternative<int>(v));
+ EXPECT_EQ(absl::get<int>(v), 0);
+ EXPECT_EQ(&emplace_result, &absl::get<int>(v));
+ }
+}
+
+TEST(VariantTest, TestEmplaceIndexInitializerList) {
+ using Var = variant<int, std::string, NonCopyable, MoveOnlyWithListConstructor>;
+
+ Var v1(absl::in_place_index_t<0>{}, 555);
+ MoveOnlyWithListConstructor& emplace_result =
+ v1.emplace<3>({1, 2, 3, 4, 5}, 6);
+ ASSERT_TRUE(absl::holds_alternative<MoveOnlyWithListConstructor>(v1));
+ EXPECT_EQ(6, absl::get<MoveOnlyWithListConstructor>(v1).value);
+ EXPECT_EQ(&emplace_result, &absl::get<MoveOnlyWithListConstructor>(v1));
+}
+
+//////////////////////
+// [variant.status] //
+//////////////////////
+
+TEST(VariantTest, Index) {
+ using Var = variant<int, std::string, double>;
+
+ Var v = 1;
+ EXPECT_EQ(0, v.index());
+ v = "str";
+ EXPECT_EQ(1, v.index());
+ v = 0.;
+ EXPECT_EQ(2, v.index());
+
+ Var v2 = v;
+ EXPECT_EQ(2, v2.index());
+ v2.emplace<int>(3);
+ EXPECT_EQ(0, v2.index());
+}
+
+TEST(VariantTest, NotValuelessByException) {
+ using Var = variant<int, std::string, double>;
+
+ Var v = 1;
+ EXPECT_FALSE(v.valueless_by_exception());
+ v = "str";
+ EXPECT_FALSE(v.valueless_by_exception());
+ v = 0.;
+ EXPECT_FALSE(v.valueless_by_exception());
+
+ Var v2 = v;
+ EXPECT_FALSE(v.valueless_by_exception());
+ v2.emplace<int>(3);
+ EXPECT_FALSE(v.valueless_by_exception());
+}
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+
+TEST(VariantTest, IndexValuelessByException) {
+ using Var = variant<MoveCanThrow, std::string, double>;
+
+ Var v(absl::in_place_index_t<0>{});
+ EXPECT_EQ(0, v.index());
+ ToValuelessByException(v);
+ EXPECT_EQ(absl::variant_npos, v.index());
+ v = "str";
+ EXPECT_EQ(1, v.index());
+}
+
+TEST(VariantTest, ValuelessByException) {
+ using Var = variant<MoveCanThrow, std::string, double>;
+
+ Var v(absl::in_place_index_t<0>{});
+ EXPECT_FALSE(v.valueless_by_exception());
+ ToValuelessByException(v);
+ EXPECT_TRUE(v.valueless_by_exception());
+ v = "str";
+ EXPECT_FALSE(v.valueless_by_exception());
+}
+
+#endif // ABSL_HAVE_EXCEPTIONS
+
+////////////////////
+// [variant.swap] //
+////////////////////
+
+TEST(VariantTest, MemberSwap) {
+ SpecialSwap v1(3);
+ SpecialSwap v2(7);
+
+ variant<SpecialSwap> a = v1, b = v2;
+
+ EXPECT_THAT(a, VariantWith<SpecialSwap>(v1));
+ EXPECT_THAT(b, VariantWith<SpecialSwap>(v2));
+
+ a.swap(b);
+ EXPECT_THAT(a, VariantWith<SpecialSwap>(v2));
+ EXPECT_THAT(b, VariantWith<SpecialSwap>(v1));
+ EXPECT_TRUE(absl::get<SpecialSwap>(a).special_swap);
+
+ using V = variant<MoveCanThrow, std::string, int>;
+ int i = 33;
+ std::string s = "abc";
+ V valueless(in_place_index_t<0>{});
+ ToValuelessByException(valueless);
+ {
+ // lhs and rhs holds different alternative
+ V lhs(i), rhs(s);
+ lhs.swap(rhs);
+ EXPECT_THAT(lhs, VariantWith<std::string>(s));
+ EXPECT_THAT(rhs, VariantWith<int>(i));
+ }
+ {
+ // lhs is valueless
+ V lhs(valueless), rhs(i);
+ lhs.swap(rhs);
+ EXPECT_THAT(lhs, VariantWith<int>(i));
+ EXPECT_TRUE(rhs.valueless_by_exception());
+ }
+ {
+ // rhs is valueless
+ V lhs(s), rhs(valueless);
+ lhs.swap(rhs);
+ EXPECT_THAT(rhs, VariantWith<std::string>(s));
+ EXPECT_TRUE(lhs.valueless_by_exception());
+ }
+ {
+ // both are valueless
+ V lhs(valueless), rhs(valueless);
+ lhs.swap(rhs);
+ EXPECT_TRUE(lhs.valueless_by_exception());
+ EXPECT_TRUE(rhs.valueless_by_exception());
+ }
+}
+
+//////////////////////
+// [variant.helper] //
+//////////////////////
+
+TEST(VariantTest, VariantSize) {
+ {
+ using Size1Variant = absl::variant<int>;
+ EXPECT_EQ(1, absl::variant_size<Size1Variant>::value);
+ EXPECT_EQ(1, absl::variant_size<const Size1Variant>::value);
+ EXPECT_EQ(1, absl::variant_size<volatile Size1Variant>::value);
+ EXPECT_EQ(1, absl::variant_size<const volatile Size1Variant>::value);
+ }
+
+ {
+ using Size3Variant = absl::variant<int, float, int>;
+ EXPECT_EQ(3, absl::variant_size<Size3Variant>::value);
+ EXPECT_EQ(3, absl::variant_size<const Size3Variant>::value);
+ EXPECT_EQ(3, absl::variant_size<volatile Size3Variant>::value);
+ EXPECT_EQ(3, absl::variant_size<const volatile Size3Variant>::value);
+ }
+}
+
+TEST(VariantTest, VariantAlternative) {
+ {
+ using V = absl::variant<float, int, const char*>;
+ EXPECT_TRUE(
+ (std::is_same<float, absl::variant_alternative_t<0, V>>::value));
+ EXPECT_TRUE((std::is_same<const float,
+ absl::variant_alternative_t<0, const V>>::value));
+ EXPECT_TRUE(
+ (std::is_same<volatile float,
+ absl::variant_alternative_t<0, volatile V>>::value));
+ EXPECT_TRUE((
+ std::is_same<const volatile float,
+ absl::variant_alternative_t<0, const volatile V>>::value));
+
+ EXPECT_TRUE((std::is_same<int, absl::variant_alternative_t<1, V>>::value));
+ EXPECT_TRUE((std::is_same<const int,
+ absl::variant_alternative_t<1, const V>>::value));
+ EXPECT_TRUE(
+ (std::is_same<volatile int,
+ absl::variant_alternative_t<1, volatile V>>::value));
+ EXPECT_TRUE((
+ std::is_same<const volatile int,
+ absl::variant_alternative_t<1, const volatile V>>::value));
+
+ EXPECT_TRUE(
+ (std::is_same<const char*, absl::variant_alternative_t<2, V>>::value));
+ EXPECT_TRUE((std::is_same<const char* const,
+ absl::variant_alternative_t<2, const V>>::value));
+ EXPECT_TRUE(
+ (std::is_same<const char* volatile,
+ absl::variant_alternative_t<2, volatile V>>::value));
+ EXPECT_TRUE((
+ std::is_same<const char* const volatile,
+ absl::variant_alternative_t<2, const volatile V>>::value));
+ }
+
+ {
+ using V = absl::variant<float, volatile int, const char*>;
+ EXPECT_TRUE(
+ (std::is_same<float, absl::variant_alternative_t<0, V>>::value));
+ EXPECT_TRUE((std::is_same<const float,
+ absl::variant_alternative_t<0, const V>>::value));
+ EXPECT_TRUE(
+ (std::is_same<volatile float,
+ absl::variant_alternative_t<0, volatile V>>::value));
+ EXPECT_TRUE((
+ std::is_same<const volatile float,
+ absl::variant_alternative_t<0, const volatile V>>::value));
+
+ EXPECT_TRUE(
+ (std::is_same<volatile int, absl::variant_alternative_t<1, V>>::value));
+ EXPECT_TRUE((std::is_same<const volatile int,
+ absl::variant_alternative_t<1, const V>>::value));
+ EXPECT_TRUE(
+ (std::is_same<volatile int,
+ absl::variant_alternative_t<1, volatile V>>::value));
+ EXPECT_TRUE((
+ std::is_same<const volatile int,
+ absl::variant_alternative_t<1, const volatile V>>::value));
+
+ EXPECT_TRUE(
+ (std::is_same<const char*, absl::variant_alternative_t<2, V>>::value));
+ EXPECT_TRUE((std::is_same<const char* const,
+ absl::variant_alternative_t<2, const V>>::value));
+ EXPECT_TRUE(
+ (std::is_same<const char* volatile,
+ absl::variant_alternative_t<2, volatile V>>::value));
+ EXPECT_TRUE((
+ std::is_same<const char* const volatile,
+ absl::variant_alternative_t<2, const volatile V>>::value));
+ }
+}
+
+///////////////////
+// [variant.get] //
+///////////////////
+
+TEST(VariantTest, HoldsAlternative) {
+ using Var = variant<int, std::string, double>;
+
+ Var v = 1;
+ EXPECT_TRUE(absl::holds_alternative<int>(v));
+ EXPECT_FALSE(absl::holds_alternative<std::string>(v));
+ EXPECT_FALSE(absl::holds_alternative<double>(v));
+ v = "str";
+ EXPECT_FALSE(absl::holds_alternative<int>(v));
+ EXPECT_TRUE(absl::holds_alternative<std::string>(v));
+ EXPECT_FALSE(absl::holds_alternative<double>(v));
+ v = 0.;
+ EXPECT_FALSE(absl::holds_alternative<int>(v));
+ EXPECT_FALSE(absl::holds_alternative<std::string>(v));
+ EXPECT_TRUE(absl::holds_alternative<double>(v));
+
+ Var v2 = v;
+ EXPECT_FALSE(absl::holds_alternative<int>(v2));
+ EXPECT_FALSE(absl::holds_alternative<std::string>(v2));
+ EXPECT_TRUE(absl::holds_alternative<double>(v2));
+ v2.emplace<int>(3);
+ EXPECT_TRUE(absl::holds_alternative<int>(v2));
+ EXPECT_FALSE(absl::holds_alternative<std::string>(v2));
+ EXPECT_FALSE(absl::holds_alternative<double>(v2));
+}
+
+TEST(VariantTest, GetIndex) {
+ using Var = variant<int, std::string, double, int>;
+
+ {
+ Var v(absl::in_place_index_t<0>{}, 0);
+
+ using LValueGetType = decltype(absl::get<0>(v));
+ using RValueGetType = decltype(absl::get<0>(absl::move(v)));
+
+ EXPECT_TRUE((std::is_same<LValueGetType, int&>::value));
+ EXPECT_TRUE((std::is_same<RValueGetType, int&&>::value));
+ EXPECT_EQ(absl::get<0>(v), 0);
+ EXPECT_EQ(absl::get<0>(absl::move(v)), 0);
+
+ const Var& const_v = v;
+ using ConstLValueGetType = decltype(absl::get<0>(const_v));
+ using ConstRValueGetType = decltype(absl::get<0>(absl::move(const_v)));
+ EXPECT_TRUE((std::is_same<ConstLValueGetType, const int&>::value));
+ EXPECT_TRUE((std::is_same<ConstRValueGetType, const int&&>::value));
+ EXPECT_EQ(absl::get<0>(const_v), 0);
+ EXPECT_EQ(absl::get<0>(absl::move(const_v)), 0);
+ }
+
+ {
+ Var v = std::string("Hello");
+
+ using LValueGetType = decltype(absl::get<1>(v));
+ using RValueGetType = decltype(absl::get<1>(absl::move(v)));
+
+ EXPECT_TRUE((std::is_same<LValueGetType, std::string&>::value));
+ EXPECT_TRUE((std::is_same<RValueGetType, std::string&&>::value));
+ EXPECT_EQ(absl::get<1>(v), "Hello");
+ EXPECT_EQ(absl::get<1>(absl::move(v)), "Hello");
+
+ const Var& const_v = v;
+ using ConstLValueGetType = decltype(absl::get<1>(const_v));
+ using ConstRValueGetType = decltype(absl::get<1>(absl::move(const_v)));
+ EXPECT_TRUE((std::is_same<ConstLValueGetType, const std::string&>::value));
+ EXPECT_TRUE((std::is_same<ConstRValueGetType, const std::string&&>::value));
+ EXPECT_EQ(absl::get<1>(const_v), "Hello");
+ EXPECT_EQ(absl::get<1>(absl::move(const_v)), "Hello");
+ }
+
+ {
+ Var v = 2.0;
+
+ using LValueGetType = decltype(absl::get<2>(v));
+ using RValueGetType = decltype(absl::get<2>(absl::move(v)));
+
+ EXPECT_TRUE((std::is_same<LValueGetType, double&>::value));
+ EXPECT_TRUE((std::is_same<RValueGetType, double&&>::value));
+ EXPECT_EQ(absl::get<2>(v), 2.);
+ EXPECT_EQ(absl::get<2>(absl::move(v)), 2.);
+
+ const Var& const_v = v;
+ using ConstLValueGetType = decltype(absl::get<2>(const_v));
+ using ConstRValueGetType = decltype(absl::get<2>(absl::move(const_v)));
+ EXPECT_TRUE((std::is_same<ConstLValueGetType, const double&>::value));
+ EXPECT_TRUE((std::is_same<ConstRValueGetType, const double&&>::value));
+ EXPECT_EQ(absl::get<2>(const_v), 2.);
+ EXPECT_EQ(absl::get<2>(absl::move(const_v)), 2.);
+ }
+
+ {
+ Var v(absl::in_place_index_t<0>{}, 0);
+ v.emplace<3>(1);
+
+ using LValueGetType = decltype(absl::get<3>(v));
+ using RValueGetType = decltype(absl::get<3>(absl::move(v)));
+
+ EXPECT_TRUE((std::is_same<LValueGetType, int&>::value));
+ EXPECT_TRUE((std::is_same<RValueGetType, int&&>::value));
+ EXPECT_EQ(absl::get<3>(v), 1);
+ EXPECT_EQ(absl::get<3>(absl::move(v)), 1);
+
+ const Var& const_v = v;
+ using ConstLValueGetType = decltype(absl::get<3>(const_v));
+ using ConstRValueGetType = decltype(absl::get<3>(absl::move(const_v)));
+ EXPECT_TRUE((std::is_same<ConstLValueGetType, const int&>::value));
+ EXPECT_TRUE((std::is_same<ConstRValueGetType, const int&&>::value));
+ EXPECT_EQ(absl::get<3>(const_v), 1);
+ EXPECT_EQ(absl::get<3>(absl::move(const_v)), 1); // NOLINT
+ }
+}
+
+TEST(VariantTest, BadGetIndex) {
+ using Var = variant<int, std::string, double>;
+
+ {
+ Var v = 1;
+
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<1>(v));
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<1>(std::move(v)));
+
+ const Var& const_v = v;
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<1>(const_v));
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
+ absl::get<1>(std::move(const_v))); // NOLINT
+ }
+
+ {
+ Var v = std::string("Hello");
+
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<0>(v));
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<0>(std::move(v)));
+
+ const Var& const_v = v;
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<0>(const_v));
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
+ absl::get<0>(std::move(const_v))); // NOLINT
+ }
+}
+
+TEST(VariantTest, GetType) {
+ using Var = variant<int, std::string, double>;
+
+ {
+ Var v = 1;
+
+ using LValueGetType = decltype(absl::get<int>(v));
+ using RValueGetType = decltype(absl::get<int>(absl::move(v)));
+
+ EXPECT_TRUE((std::is_same<LValueGetType, int&>::value));
+ EXPECT_TRUE((std::is_same<RValueGetType, int&&>::value));
+ EXPECT_EQ(absl::get<int>(v), 1);
+ EXPECT_EQ(absl::get<int>(absl::move(v)), 1);
+
+ const Var& const_v = v;
+ using ConstLValueGetType = decltype(absl::get<int>(const_v));
+ using ConstRValueGetType = decltype(absl::get<int>(absl::move(const_v)));
+ EXPECT_TRUE((std::is_same<ConstLValueGetType, const int&>::value));
+ EXPECT_TRUE((std::is_same<ConstRValueGetType, const int&&>::value));
+ EXPECT_EQ(absl::get<int>(const_v), 1);
+ EXPECT_EQ(absl::get<int>(absl::move(const_v)), 1);
+ }
+
+ {
+ Var v = std::string("Hello");
+
+ using LValueGetType = decltype(absl::get<1>(v));
+ using RValueGetType = decltype(absl::get<1>(absl::move(v)));
+
+ EXPECT_TRUE((std::is_same<LValueGetType, std::string&>::value));
+ EXPECT_TRUE((std::is_same<RValueGetType, std::string&&>::value));
+ EXPECT_EQ(absl::get<std::string>(v), "Hello");
+ EXPECT_EQ(absl::get<std::string>(absl::move(v)), "Hello");
+
+ const Var& const_v = v;
+ using ConstLValueGetType = decltype(absl::get<1>(const_v));
+ using ConstRValueGetType = decltype(absl::get<1>(absl::move(const_v)));
+ EXPECT_TRUE((std::is_same<ConstLValueGetType, const std::string&>::value));
+ EXPECT_TRUE((std::is_same<ConstRValueGetType, const std::string&&>::value));
+ EXPECT_EQ(absl::get<std::string>(const_v), "Hello");
+ EXPECT_EQ(absl::get<std::string>(absl::move(const_v)), "Hello");
+ }
+
+ {
+ Var v = 2.0;
+
+ using LValueGetType = decltype(absl::get<2>(v));
+ using RValueGetType = decltype(absl::get<2>(absl::move(v)));
+
+ EXPECT_TRUE((std::is_same<LValueGetType, double&>::value));
+ EXPECT_TRUE((std::is_same<RValueGetType, double&&>::value));
+ EXPECT_EQ(absl::get<double>(v), 2.);
+ EXPECT_EQ(absl::get<double>(absl::move(v)), 2.);
+
+ const Var& const_v = v;
+ using ConstLValueGetType = decltype(absl::get<2>(const_v));
+ using ConstRValueGetType = decltype(absl::get<2>(absl::move(const_v)));
+ EXPECT_TRUE((std::is_same<ConstLValueGetType, const double&>::value));
+ EXPECT_TRUE((std::is_same<ConstRValueGetType, const double&&>::value));
+ EXPECT_EQ(absl::get<double>(const_v), 2.);
+ EXPECT_EQ(absl::get<double>(absl::move(const_v)), 2.);
+ }
+}
+
+TEST(VariantTest, BadGetType) {
+ using Var = variant<int, std::string, double>;
+
+ {
+ Var v = 1;
+
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<std::string>(v));
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
+ absl::get<std::string>(std::move(v)));
+
+ const Var& const_v = v;
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<std::string>(const_v));
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
+ absl::get<std::string>(std::move(const_v))); // NOLINT
+ }
+
+ {
+ Var v = std::string("Hello");
+
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<int>(v));
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<int>(std::move(v)));
+
+ const Var& const_v = v;
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(absl::get<int>(const_v));
+ ABSL_VARIANT_TEST_EXPECT_BAD_VARIANT_ACCESS(
+ absl::get<int>(std::move(const_v))); // NOLINT
+ }
+}
+
+TEST(VariantTest, GetIfIndex) {
+ using Var = variant<int, std::string, double, int>;
+
+ {
+ Var v(absl::in_place_index_t<0>{}, 0);
+ EXPECT_TRUE(noexcept(absl::get_if<0>(&v)));
+
+ {
+ auto* elem = absl::get_if<0>(&v);
+ EXPECT_TRUE((std::is_same<decltype(elem), int*>::value));
+ ASSERT_NE(elem, nullptr);
+ EXPECT_EQ(*elem, 0);
+ {
+ auto* bad_elem = absl::get_if<1>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), std::string*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<2>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), double*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<3>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ }
+
+ const Var& const_v = v;
+ EXPECT_TRUE(noexcept(absl::get_if<0>(&const_v)));
+
+ {
+ auto* elem = absl::get_if<0>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(elem), const int*>::value));
+ ASSERT_NE(elem, nullptr);
+ EXPECT_EQ(*elem, 0);
+ {
+ auto* bad_elem = absl::get_if<1>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const std::string*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<2>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const double*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<3>(&const_v);
+ EXPECT_EQ(bad_elem, nullptr);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
+ }
+ }
+ }
+
+ {
+ Var v = std::string("Hello");
+ EXPECT_TRUE(noexcept(absl::get_if<1>(&v)));
+
+ {
+ auto* elem = absl::get_if<1>(&v);
+ EXPECT_TRUE((std::is_same<decltype(elem), std::string*>::value));
+ ASSERT_NE(elem, nullptr);
+ EXPECT_EQ(*elem, "Hello");
+ {
+ auto* bad_elem = absl::get_if<0>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<2>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), double*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<3>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ }
+
+ const Var& const_v = v;
+ EXPECT_TRUE(noexcept(absl::get_if<1>(&const_v)));
+
+ {
+ auto* elem = absl::get_if<1>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(elem), const std::string*>::value));
+ ASSERT_NE(elem, nullptr);
+ EXPECT_EQ(*elem, "Hello");
+ {
+ auto* bad_elem = absl::get_if<0>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<2>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const double*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<3>(&const_v);
+ EXPECT_EQ(bad_elem, nullptr);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
+ }
+ }
+ }
+
+ {
+ Var v = 2.0;
+ EXPECT_TRUE(noexcept(absl::get_if<2>(&v)));
+
+ {
+ auto* elem = absl::get_if<2>(&v);
+ EXPECT_TRUE((std::is_same<decltype(elem), double*>::value));
+ ASSERT_NE(elem, nullptr);
+ EXPECT_EQ(*elem, 2.0);
+ {
+ auto* bad_elem = absl::get_if<0>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<1>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), std::string*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<3>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ }
+
+ const Var& const_v = v;
+ EXPECT_TRUE(noexcept(absl::get_if<2>(&const_v)));
+
+ {
+ auto* elem = absl::get_if<2>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(elem), const double*>::value));
+ ASSERT_NE(elem, nullptr);
+ EXPECT_EQ(*elem, 2.0);
+ {
+ auto* bad_elem = absl::get_if<0>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<1>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const std::string*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<3>(&const_v);
+ EXPECT_EQ(bad_elem, nullptr);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
+ }
+ }
+ }
+
+ {
+ Var v(absl::in_place_index_t<0>{}, 0);
+ v.emplace<3>(1);
+ EXPECT_TRUE(noexcept(absl::get_if<3>(&v)));
+
+ {
+ auto* elem = absl::get_if<3>(&v);
+ EXPECT_TRUE((std::is_same<decltype(elem), int*>::value));
+ ASSERT_NE(elem, nullptr);
+ EXPECT_EQ(*elem, 1);
+ {
+ auto* bad_elem = absl::get_if<0>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), int*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<1>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), std::string*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<2>(&v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), double*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ }
+
+ const Var& const_v = v;
+ EXPECT_TRUE(noexcept(absl::get_if<3>(&const_v)));
+
+ {
+ auto* elem = absl::get_if<3>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(elem), const int*>::value));
+ ASSERT_NE(elem, nullptr);
+ EXPECT_EQ(*elem, 1);
+ {
+ auto* bad_elem = absl::get_if<0>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const int*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<1>(&const_v);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const std::string*>::value));
+ EXPECT_EQ(bad_elem, nullptr);
+ }
+ {
+ auto* bad_elem = absl::get_if<2>(&const_v);
+ EXPECT_EQ(bad_elem, nullptr);
+ EXPECT_TRUE((std::is_same<decltype(bad_elem), const double*>::value));
+ }
+ }
+ }
+}
+
+//////////////////////
+// [variant.relops] //
+//////////////////////
+
+TEST(VariantTest, OperatorEquals) {
+ variant<int, std::string> a(1), b(1);
+ EXPECT_TRUE(a == b);
+ EXPECT_TRUE(b == a);
+ EXPECT_FALSE(a != b);
+ EXPECT_FALSE(b != a);
+
+ b = "str";
+ EXPECT_FALSE(a == b);
+ EXPECT_FALSE(b == a);
+ EXPECT_TRUE(a != b);
+ EXPECT_TRUE(b != a);
+
+ b = 0;
+ EXPECT_FALSE(a == b);
+ EXPECT_FALSE(b == a);
+ EXPECT_TRUE(a != b);
+ EXPECT_TRUE(b != a);
+
+ a = b = "foo";
+ EXPECT_TRUE(a == b);
+ EXPECT_TRUE(b == a);
+ EXPECT_FALSE(a != b);
+ EXPECT_FALSE(b != a);
+
+ a = "bar";
+ EXPECT_FALSE(a == b);
+ EXPECT_FALSE(b == a);
+ EXPECT_TRUE(a != b);
+ EXPECT_TRUE(b != a);
+}
+
+TEST(VariantTest, OperatorRelational) {
+ variant<int, std::string> a(1), b(1);
+ EXPECT_FALSE(a < b);
+ EXPECT_FALSE(b < a);
+ EXPECT_FALSE(a > b);
+ EXPECT_FALSE(b > a);
+ EXPECT_TRUE(a <= b);
+ EXPECT_TRUE(b <= a);
+ EXPECT_TRUE(a >= b);
+ EXPECT_TRUE(b >= a);
+
+ b = "str";
+ EXPECT_TRUE(a < b);
+ EXPECT_FALSE(b < a);
+ EXPECT_FALSE(a > b);
+ EXPECT_TRUE(b > a);
+ EXPECT_TRUE(a <= b);
+ EXPECT_FALSE(b <= a);
+ EXPECT_FALSE(a >= b);
+ EXPECT_TRUE(b >= a);
+
+ b = 0;
+ EXPECT_FALSE(a < b);
+ EXPECT_TRUE(b < a);
+ EXPECT_TRUE(a > b);
+ EXPECT_FALSE(b > a);
+ EXPECT_FALSE(a <= b);
+ EXPECT_TRUE(b <= a);
+ EXPECT_TRUE(a >= b);
+ EXPECT_FALSE(b >= a);
+
+ a = b = "foo";
+ EXPECT_FALSE(a < b);
+ EXPECT_FALSE(b < a);
+ EXPECT_FALSE(a > b);
+ EXPECT_FALSE(b > a);
+ EXPECT_TRUE(a <= b);
+ EXPECT_TRUE(b <= a);
+ EXPECT_TRUE(a >= b);
+ EXPECT_TRUE(b >= a);
+
+ a = "bar";
+ EXPECT_TRUE(a < b);
+ EXPECT_FALSE(b < a);
+ EXPECT_FALSE(a > b);
+ EXPECT_TRUE(b > a);
+ EXPECT_TRUE(a <= b);
+ EXPECT_FALSE(b <= a);
+ EXPECT_FALSE(a >= b);
+ EXPECT_TRUE(b >= a);
+}
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+
+TEST(VariantTest, ValuelessOperatorEquals) {
+ variant<MoveCanThrow, std::string> int_v(1), string_v("Hello"),
+ valueless(absl::in_place_index_t<0>{}),
+ other_valueless(absl::in_place_index_t<0>{});
+ ToValuelessByException(valueless);
+ ToValuelessByException(other_valueless);
+
+ EXPECT_TRUE(valueless == other_valueless);
+ EXPECT_TRUE(other_valueless == valueless);
+ EXPECT_FALSE(valueless == int_v);
+ EXPECT_FALSE(valueless == string_v);
+ EXPECT_FALSE(int_v == valueless);
+ EXPECT_FALSE(string_v == valueless);
+
+ EXPECT_FALSE(valueless != other_valueless);
+ EXPECT_FALSE(other_valueless != valueless);
+ EXPECT_TRUE(valueless != int_v);
+ EXPECT_TRUE(valueless != string_v);
+ EXPECT_TRUE(int_v != valueless);
+ EXPECT_TRUE(string_v != valueless);
+}
+
+TEST(VariantTest, ValuelessOperatorRelational) {
+ variant<MoveCanThrow, std::string> int_v(1), string_v("Hello"),
+ valueless(absl::in_place_index_t<0>{}),
+ other_valueless(absl::in_place_index_t<0>{});
+ ToValuelessByException(valueless);
+ ToValuelessByException(other_valueless);
+
+ EXPECT_FALSE(valueless < other_valueless);
+ EXPECT_FALSE(other_valueless < valueless);
+ EXPECT_TRUE(valueless < int_v);
+ EXPECT_TRUE(valueless < string_v);
+ EXPECT_FALSE(int_v < valueless);
+ EXPECT_FALSE(string_v < valueless);
+
+ EXPECT_TRUE(valueless <= other_valueless);
+ EXPECT_TRUE(other_valueless <= valueless);
+ EXPECT_TRUE(valueless <= int_v);
+ EXPECT_TRUE(valueless <= string_v);
+ EXPECT_FALSE(int_v <= valueless);
+ EXPECT_FALSE(string_v <= valueless);
+
+ EXPECT_TRUE(valueless >= other_valueless);
+ EXPECT_TRUE(other_valueless >= valueless);
+ EXPECT_FALSE(valueless >= int_v);
+ EXPECT_FALSE(valueless >= string_v);
+ EXPECT_TRUE(int_v >= valueless);
+ EXPECT_TRUE(string_v >= valueless);
+
+ EXPECT_FALSE(valueless > other_valueless);
+ EXPECT_FALSE(other_valueless > valueless);
+ EXPECT_FALSE(valueless > int_v);
+ EXPECT_FALSE(valueless > string_v);
+ EXPECT_TRUE(int_v > valueless);
+ EXPECT_TRUE(string_v > valueless);
+}
+
+#endif
+
+/////////////////////
+// [variant.visit] //
+/////////////////////
+
+template <typename T>
+struct ConvertTo {
+ template <typename U>
+ T operator()(const U& u) const {
+ return u;
+ }
+};
+
+TEST(VariantTest, VisitSimple) {
+ variant<std::string, const char*> v = "A";
+
+ std::string str = absl::visit(ConvertTo<std::string>{}, v);
+ EXPECT_EQ("A", str);
+
+ v = std::string("B");
+
+ absl::string_view piece = absl::visit(ConvertTo<absl::string_view>{}, v);
+ EXPECT_EQ("B", piece);
+
+ struct StrLen {
+ int operator()(const std::string& s) const { return s.size(); }
+ int operator()(const char* s) const { return strlen(s); }
+ };
+
+ v = "SomeStr";
+ EXPECT_EQ(7, absl::visit(StrLen{}, v));
+ v = std::string("VeryLargeThisTime");
+ EXPECT_EQ(17, absl::visit(StrLen{}, v));
+}
+
+TEST(VariantTest, VisitRValue) {
+ variant<std::string> v = std::string("X");
+ struct Visitor {
+ bool operator()(const std::string&) const { return false; }
+ bool operator()(std::string&&) const { return true; } // NOLINT
+
+ int operator()(const std::string&, const std::string&) const { return 0; }
+ int operator()(const std::string&, std::string&&) const { return 1; } // NOLINT
+ int operator()(std::string&&, const std::string&) const { return 2; } // NOLINT
+ int operator()(std::string&&, std::string&&) const { return 3; } // NOLINT
+ };
+ EXPECT_FALSE(absl::visit(Visitor{}, v));
+ EXPECT_TRUE(absl::visit(Visitor{}, absl::move(v)));
+
+ // Also test the variadic overload.
+ EXPECT_EQ(0, absl::visit(Visitor{}, v, v));
+ EXPECT_EQ(1, absl::visit(Visitor{}, v, absl::move(v)));
+ EXPECT_EQ(2, absl::visit(Visitor{}, absl::move(v), v));
+ EXPECT_EQ(3, absl::visit(Visitor{}, absl::move(v), absl::move(v)));
+}
+
+TEST(VariantTest, VisitRValueVisitor) {
+ variant<std::string> v = std::string("X");
+ struct Visitor {
+ bool operator()(const std::string&) const& { return false; }
+ bool operator()(const std::string&) && { return true; }
+ };
+ Visitor visitor;
+ EXPECT_FALSE(absl::visit(visitor, v));
+ EXPECT_TRUE(absl::visit(Visitor{}, v));
+}
+
+TEST(VariantTest, VisitResultTypeDifferent) {
+ variant<std::string> v = std::string("X");
+ struct LValue_LValue {};
+ struct RValue_LValue {};
+ struct LValue_RValue {};
+ struct RValue_RValue {};
+ struct Visitor {
+ LValue_LValue operator()(const std::string&) const& { return {}; }
+ RValue_LValue operator()(std::string&&) const& { return {}; } // NOLINT
+ LValue_RValue operator()(const std::string&) && { return {}; }
+ RValue_RValue operator()(std::string&&) && { return {}; } // NOLINT
+ } visitor;
+
+ EXPECT_TRUE(
+ (std::is_same<LValue_LValue, decltype(absl::visit(visitor, v))>::value));
+ EXPECT_TRUE(
+ (std::is_same<RValue_LValue,
+ decltype(absl::visit(visitor, absl::move(v)))>::value));
+ EXPECT_TRUE((
+ std::is_same<LValue_RValue, decltype(absl::visit(Visitor{}, v))>::value));
+ EXPECT_TRUE(
+ (std::is_same<RValue_RValue,
+ decltype(absl::visit(Visitor{}, absl::move(v)))>::value));
+}
+
+TEST(VariantTest, VisitVariadic) {
+ using A = variant<int, std::string>;
+ using B = variant<std::unique_ptr<int>, absl::string_view>;
+
+ struct Visitor {
+ std::pair<int, int> operator()(int a, std::unique_ptr<int> b) const {
+ return {a, *b};
+ }
+ std::pair<int, int> operator()(absl::string_view a,
+ std::unique_ptr<int> b) const {
+ return {static_cast<int>(a.size()), static_cast<int>(*b)};
+ }
+ std::pair<int, int> operator()(int a, absl::string_view b) const {
+ return {a, static_cast<int>(b.size())};
+ }
+ std::pair<int, int> operator()(absl::string_view a,
+ absl::string_view b) const {
+ return {static_cast<int>(a.size()), static_cast<int>(b.size())};
+ }
+ };
+
+ EXPECT_THAT(absl::visit(Visitor(), A(1), B(std::unique_ptr<int>(new int(7)))),
+ ::testing::Pair(1, 7));
+ EXPECT_THAT(absl::visit(Visitor(), A(1), B(absl::string_view("ABC"))),
+ ::testing::Pair(1, 3));
+ EXPECT_THAT(absl::visit(Visitor(), A(std::string("BBBBB")),
+ B(std::unique_ptr<int>(new int(7)))),
+ ::testing::Pair(5, 7));
+ EXPECT_THAT(
+ absl::visit(Visitor(), A(std::string("BBBBB")), B(absl::string_view("ABC"))),
+ ::testing::Pair(5, 3));
+}
+
+TEST(VariantTest, VisitNoArgs) {
+ EXPECT_EQ(5, absl::visit([] { return 5; }));
+}
+
+struct ConstFunctor {
+ int operator()(int a, int b) const { return a - b; }
+};
+
+struct MutableFunctor {
+ int operator()(int a, int b) { return a - b; }
+};
+
+struct Class {
+ int Method(int a, int b) { return a - b; }
+ int ConstMethod(int a, int b) const { return a - b; }
+
+ int member;
+};
+
+TEST(VariantTest, VisitReferenceWrapper) {
+ ConstFunctor cf;
+ MutableFunctor mf;
+ absl::variant<int> three = 3;
+ absl::variant<int> two = 2;
+
+ EXPECT_EQ(1, absl::visit(std::cref(cf), three, two));
+ EXPECT_EQ(1, absl::visit(std::ref(cf), three, two));
+ EXPECT_EQ(1, absl::visit(std::ref(mf), three, two));
+}
+
+// libstdc++ std::variant doesn't support the INVOKE semantics.
+#if !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))
+TEST(VariantTest, VisitMemberFunction) {
+ absl::variant<std::unique_ptr<Class>> p(absl::make_unique<Class>());
+ absl::variant<std::unique_ptr<const Class>> cp(
+ absl::make_unique<const Class>());
+ absl::variant<int> three = 3;
+ absl::variant<int> two = 2;
+
+ EXPECT_EQ(1, absl::visit(&Class::Method, p, three, two));
+ EXPECT_EQ(1, absl::visit(&Class::ConstMethod, p, three, two));
+ EXPECT_EQ(1, absl::visit(&Class::ConstMethod, cp, three, two));
+}
+
+TEST(VariantTest, VisitDataMember) {
+ absl::variant<std::unique_ptr<Class>> p(absl::make_unique<Class>(Class{42}));
+ absl::variant<std::unique_ptr<const Class>> cp(
+ absl::make_unique<const Class>(Class{42}));
+ EXPECT_EQ(42, absl::visit(&Class::member, p));
+
+ absl::visit(&Class::member, p) = 5;
+ EXPECT_EQ(5, absl::visit(&Class::member, p));
+
+ EXPECT_EQ(42, absl::visit(&Class::member, cp));
+}
+#endif // !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))
+
+/////////////////////////
+// [variant.monostate] //
+/////////////////////////
+
+TEST(VariantTest, MonostateBasic) {
+ absl::monostate mono;
+ (void)mono;
+
+ // TODO(mattcalabrese) Expose move triviality metafunctions in absl.
+ EXPECT_TRUE(absl::is_trivially_default_constructible<absl::monostate>::value);
+ EXPECT_TRUE(is_trivially_move_constructible<absl::monostate>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<absl::monostate>::value);
+ EXPECT_TRUE(is_trivially_move_assignable<absl::monostate>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<absl::monostate>::value);
+ EXPECT_TRUE(absl::is_trivially_destructible<absl::monostate>::value);
+}
+
+TEST(VariantTest, VariantMonostateDefaultConstruction) {
+ absl::variant<absl::monostate, NonDefaultConstructible> var;
+ EXPECT_EQ(var.index(), 0);
+}
+
+////////////////////////////////
+// [variant.monostate.relops] //
+////////////////////////////////
+
+TEST(VariantTest, MonostateComparisons) {
+ absl::monostate lhs, rhs;
+
+ EXPECT_EQ(lhs, lhs);
+ EXPECT_EQ(lhs, rhs);
+
+ EXPECT_FALSE(lhs != lhs);
+ EXPECT_FALSE(lhs != rhs);
+ EXPECT_FALSE(lhs < lhs);
+ EXPECT_FALSE(lhs < rhs);
+ EXPECT_FALSE(lhs > lhs);
+ EXPECT_FALSE(lhs > rhs);
+
+ EXPECT_LE(lhs, lhs);
+ EXPECT_LE(lhs, rhs);
+ EXPECT_GE(lhs, lhs);
+ EXPECT_GE(lhs, rhs);
+
+ EXPECT_TRUE(noexcept(std::declval<absl::monostate>() ==
+ std::declval<absl::monostate>()));
+ EXPECT_TRUE(noexcept(std::declval<absl::monostate>() !=
+ std::declval<absl::monostate>()));
+ EXPECT_TRUE(noexcept(std::declval<absl::monostate>() <
+ std::declval<absl::monostate>()));
+ EXPECT_TRUE(noexcept(std::declval<absl::monostate>() >
+ std::declval<absl::monostate>()));
+ EXPECT_TRUE(noexcept(std::declval<absl::monostate>() <=
+ std::declval<absl::monostate>()));
+ EXPECT_TRUE(noexcept(std::declval<absl::monostate>() >=
+ std::declval<absl::monostate>()));
+}
+
+///////////////////////
+// [variant.specalg] //
+///////////////////////
+
+TEST(VariantTest, NonmemberSwap) {
+ using std::swap;
+
+ SpecialSwap v1(3);
+ SpecialSwap v2(7);
+
+ variant<SpecialSwap> a = v1, b = v2;
+
+ EXPECT_THAT(a, VariantWith<SpecialSwap>(v1));
+ EXPECT_THAT(b, VariantWith<SpecialSwap>(v2));
+
+ std::swap(a, b);
+ EXPECT_THAT(a, VariantWith<SpecialSwap>(v2));
+ EXPECT_THAT(b, VariantWith<SpecialSwap>(v1));
+#ifndef ABSL_HAVE_STD_VARIANT
+ EXPECT_FALSE(absl::get<SpecialSwap>(a).special_swap);
+#endif
+
+ swap(a, b);
+ EXPECT_THAT(a, VariantWith<SpecialSwap>(v1));
+ EXPECT_THAT(b, VariantWith<SpecialSwap>(v2));
+ EXPECT_TRUE(absl::get<SpecialSwap>(b).special_swap);
+}
+
+//////////////////////////
+// [variant.bad.access] //
+//////////////////////////
+
+TEST(VariantTest, BadAccess) {
+ EXPECT_TRUE(noexcept(absl::bad_variant_access()));
+ absl::bad_variant_access exception_obj;
+ std::exception* base = &exception_obj;
+ (void)base;
+}
+
+////////////////////
+// [variant.hash] //
+////////////////////
+
+TEST(VariantTest, MonostateHash) {
+ absl::monostate mono, other_mono;
+ std::hash<absl::monostate> const hasher{};
+ static_assert(std::is_same<decltype(hasher(mono)), std::size_t>::value, "");
+ EXPECT_EQ(hasher(mono), hasher(other_mono));
+}
+
+TEST(VariantTest, Hash) {
+ static_assert(type_traits_internal::IsHashEnabled<variant<int>>::value, "");
+ static_assert(type_traits_internal::IsHashEnabled<variant<Hashable>>::value,
+ "");
+ static_assert(
+ type_traits_internal::IsHashEnabled<variant<int, Hashable>>::value, "");
+
+#if defined(_MSC_VER) || \
+ (defined(_LIBCPP_VERSION) && _LIBCPP_VERSION < 4000 && \
+ _LIBCPP_STD_VER > 11) || \
+ defined(__APPLE__)
+ // For MSVC and libc++ (< 4.0 and c++14), std::hash primary template has a
+ // static_assert to catch any user-defined type T that doesn't provide a hash
+ // specialization. So instantiating std::hash<variant<T>> will result
+ // in a hard error which is not SFINAE friendly.
+#define ABSL_STD_HASH_NOT_SFINAE_FRIENDLY 1
+#endif
+
+#ifndef ABSL_STD_HASH_NOT_SFINAE_FRIENDLY
+ static_assert(
+ !type_traits_internal::IsHashEnabled<variant<NonHashable>>::value, "");
+ static_assert(!type_traits_internal::IsHashEnabled<
+ variant<Hashable, NonHashable>>::value,
+ "");
+#endif
+
+// MSVC std::hash<std::variant> does not use the index, thus produce the same
+// result on the same value as different alternative.
+#if !(defined(_MSC_VER) && defined(ABSL_HAVE_STD_VARIANT))
+ {
+ // same value as different alternative
+ variant<int, int> v0(in_place_index_t<0>{}, 42);
+ variant<int, int> v1(in_place_index_t<1>{}, 42);
+ std::hash<variant<int, int>> hash;
+ EXPECT_NE(hash(v0), hash(v1));
+ }
+#endif // !(defined(_MSC_VER) && defined(ABSL_HAVE_STD_VARIANT))
+
+ {
+ std::hash<variant<int>> hash;
+ std::set<size_t> hashcodes;
+ for (int i = 0; i < 100; ++i) {
+ hashcodes.insert(hash(i));
+ }
+ EXPECT_GT(hashcodes.size(), 90);
+
+ // test const-qualified
+ static_assert(
+ type_traits_internal::IsHashEnabled<variant<const int>>::value, "");
+ static_assert(
+ type_traits_internal::IsHashEnabled<variant<const Hashable>>::value,
+ "");
+ std::hash<absl::variant<const int>> c_hash;
+ for (int i = 0; i < 100; ++i) {
+ EXPECT_EQ(hash(i), c_hash(i));
+ }
+ }
+}
+
+////////////////////////////////////////
+// Miscellaneous and deprecated tests //
+////////////////////////////////////////
+
+// Test that a set requiring a basic type conversion works correctly.
+TEST(VariantTest, TestConvertingSet) {
+ typedef variant<double> Variant;
+ Variant v(1.0);
+ const int two = 2;
+ v = two;
+ EXPECT_TRUE(absl::holds_alternative<double>(v));
+ ASSERT_TRUE(nullptr != absl::get_if<double>(&v));
+ EXPECT_DOUBLE_EQ(2, absl::get<double>(v));
+}
+
+// Test that a vector of variants behaves reasonably.
+TEST(VariantTest, Container) {
+ typedef variant<int, float> Variant;
+
+ // Creation of vector should work
+ std::vector<Variant> vec;
+ vec.push_back(Variant(10));
+ vec.push_back(Variant(20.0f));
+
+ // Vector resizing should work if we supply a value for new slots
+ vec.resize(10, Variant(0));
+}
+
+// Test that a variant with a non-copyable type can be constructed and
+// manipulated to some degree.
+TEST(VariantTest, TestVariantWithNonCopyableType) {
+ typedef variant<int, NonCopyable> Variant;
+ const int kValue = 1;
+ Variant v(kValue);
+ ASSERT_TRUE(absl::holds_alternative<int>(v));
+ EXPECT_EQ(kValue, absl::get<int>(v));
+}
+
+// Test that a variant with a non-copyable type can be transformed to
+// the non-copyable type with a call to `emplace` for different numbers
+// of arguments. We do not need to test this for each of T1 ... T8
+// because `emplace` does not overload on T1 ... to T8, so if this
+// works for any one of T1 ... T8, then it works for all of them. We
+// do need to test that it works with varying numbers of parameters
+// though.
+TEST(VariantTest, TestEmplace) {
+ typedef variant<int, NonCopyable> Variant;
+ const int kValue = 1;
+ Variant v(kValue);
+ ASSERT_TRUE(absl::holds_alternative<int>(v));
+ EXPECT_EQ(kValue, absl::get<int>(v));
+
+ // emplace with zero arguments, then back to 'int'
+ v.emplace<NonCopyable>();
+ ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
+ EXPECT_EQ(0, absl::get<NonCopyable>(v).value);
+ v = kValue;
+ ASSERT_TRUE(absl::holds_alternative<int>(v));
+
+ // emplace with one argument:
+ v.emplace<NonCopyable>(1);
+ ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
+ EXPECT_EQ(1, absl::get<NonCopyable>(v).value);
+ v = kValue;
+ ASSERT_TRUE(absl::holds_alternative<int>(v));
+
+ // emplace with two arguments:
+ v.emplace<NonCopyable>(1, 2);
+ ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
+ EXPECT_EQ(3, absl::get<NonCopyable>(v).value);
+ v = kValue;
+ ASSERT_TRUE(absl::holds_alternative<int>(v));
+
+ // emplace with three arguments
+ v.emplace<NonCopyable>(1, 2, 3);
+ ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
+ EXPECT_EQ(6, absl::get<NonCopyable>(v).value);
+ v = kValue;
+ ASSERT_TRUE(absl::holds_alternative<int>(v));
+
+ // emplace with four arguments
+ v.emplace<NonCopyable>(1, 2, 3, 4);
+ ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
+ EXPECT_EQ(10, absl::get<NonCopyable>(v).value);
+ v = kValue;
+ ASSERT_TRUE(absl::holds_alternative<int>(v));
+}
+
+TEST(VariantTest, TestEmplaceDestroysCurrentValue) {
+ typedef variant<int, IncrementInDtor, NonCopyable> Variant;
+ int counter = 0;
+ Variant v(0);
+ ASSERT_TRUE(absl::holds_alternative<int>(v));
+ v.emplace<IncrementInDtor>(&counter);
+ ASSERT_TRUE(absl::holds_alternative<IncrementInDtor>(v));
+ ASSERT_EQ(0, counter);
+ v.emplace<NonCopyable>();
+ ASSERT_TRUE(absl::holds_alternative<NonCopyable>(v));
+ EXPECT_EQ(1, counter);
+}
+
+TEST(VariantTest, TestMoveSemantics) {
+ typedef variant<std::unique_ptr<int>, std::unique_ptr<std::string>> Variant;
+
+ // Construct a variant by moving from an element value.
+ Variant v(absl::WrapUnique(new int(10)));
+ EXPECT_TRUE(absl::holds_alternative<std::unique_ptr<int>>(v));
+
+ // Construct a variant by moving from another variant.
+ Variant v2(absl::move(v));
+ ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<int>>(v2));
+ ASSERT_NE(nullptr, absl::get<std::unique_ptr<int>>(v2));
+ EXPECT_EQ(10, *absl::get<std::unique_ptr<int>>(v2));
+
+ // Moving from a variant object leaves it holding moved-from value of the
+ // same element type.
+ EXPECT_TRUE(absl::holds_alternative<std::unique_ptr<int>>(v));
+ ASSERT_NE(nullptr, absl::get_if<std::unique_ptr<int>>(&v));
+ EXPECT_EQ(nullptr, absl::get<std::unique_ptr<int>>(v));
+
+ // Assign a variant from an element value by move.
+ v = absl::make_unique<std::string>("foo");
+ ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<std::string>>(v));
+ EXPECT_EQ("foo", *absl::get<std::unique_ptr<std::string>>(v));
+
+ // Move-assign a variant.
+ v2 = absl::move(v);
+ ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<std::string>>(v2));
+ EXPECT_EQ("foo", *absl::get<std::unique_ptr<std::string>>(v2));
+ EXPECT_TRUE(absl::holds_alternative<std::unique_ptr<std::string>>(v));
+}
+
+variant<int, std::string> PassThrough(const variant<int, std::string>& arg) {
+ return arg;
+}
+
+TEST(VariantTest, TestImplicitConversion) {
+ EXPECT_TRUE(absl::holds_alternative<int>(PassThrough(0)));
+
+ // We still need the explicit cast for std::string, because C++ won't apply
+ // two user-defined implicit conversions in a row.
+ EXPECT_TRUE(absl::holds_alternative<std::string>(PassThrough(std::string("foo"))));
+}
+
+struct Convertible2;
+struct Convertible1 {
+ Convertible1() {}
+ Convertible1(const Convertible1&) {}
+ Convertible1& operator=(const Convertible1&) { return *this; }
+
+ // implicit conversion from Convertible2
+ Convertible1(const Convertible2&) {} // NOLINT(runtime/explicit)
+};
+
+struct Convertible2 {
+ Convertible2() {}
+ Convertible2(const Convertible2&) {}
+ Convertible2& operator=(const Convertible2&) { return *this; }
+
+ // implicit conversion from Convertible1
+ Convertible2(const Convertible1&) {} // NOLINT(runtime/explicit)
+};
+
+TEST(VariantTest, TestRvalueConversion) {
+ variant<double, std::string> var(
+ ConvertVariantTo<variant<double, std::string>>(variant<std::string, int>(0)));
+ ASSERT_TRUE(absl::holds_alternative<double>(var));
+ EXPECT_EQ(0.0, absl::get<double>(var));
+
+ var = ConvertVariantTo<variant<double, std::string>>(
+ variant<const char*, float>("foo"));
+ ASSERT_TRUE(absl::holds_alternative<std::string>(var));
+ EXPECT_EQ("foo", absl::get<std::string>(var));
+
+ variant<double> singleton(
+ ConvertVariantTo<variant<double>>(variant<int, float>(42)));
+ ASSERT_TRUE(absl::holds_alternative<double>(singleton));
+ EXPECT_EQ(42.0, absl::get<double>(singleton));
+
+ singleton = ConvertVariantTo<variant<double>>(variant<int, float>(3.14f));
+ ASSERT_TRUE(absl::holds_alternative<double>(singleton));
+ EXPECT_FLOAT_EQ(3.14f, static_cast<float>(absl::get<double>(singleton)));
+
+ singleton = ConvertVariantTo<variant<double>>(variant<int>(0));
+ ASSERT_TRUE(absl::holds_alternative<double>(singleton));
+ EXPECT_EQ(0.0, absl::get<double>(singleton));
+
+ variant<int32_t, uint32_t> variant2(
+ ConvertVariantTo<variant<int32_t, uint32_t>>(variant<int32_t>(42)));
+ ASSERT_TRUE(absl::holds_alternative<int32_t>(variant2));
+ EXPECT_EQ(42, absl::get<int32_t>(variant2));
+
+ variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(variant<uint32_t>(42));
+ ASSERT_TRUE(absl::holds_alternative<uint32_t>(variant2));
+ EXPECT_EQ(42, absl::get<uint32_t>(variant2));
+
+ variant<Convertible1, Convertible2> variant3(
+ ConvertVariantTo<variant<Convertible1, Convertible2>>(
+ (variant<Convertible2, Convertible1>(Convertible1()))));
+ ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));
+
+ variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(
+ variant<Convertible2, Convertible1>(Convertible2()));
+ ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));
+}
+
+TEST(VariantTest, TestLvalueConversion) {
+ variant<std::string, int> source1 = 0;
+ variant<double, std::string> destination(
+ ConvertVariantTo<variant<double, std::string>>(source1));
+ ASSERT_TRUE(absl::holds_alternative<double>(destination));
+ EXPECT_EQ(0.0, absl::get<double>(destination));
+
+ variant<const char*, float> source2 = "foo";
+ destination = ConvertVariantTo<variant<double, std::string>>(source2);
+ ASSERT_TRUE(absl::holds_alternative<std::string>(destination));
+ EXPECT_EQ("foo", absl::get<std::string>(destination));
+
+ variant<int, float> source3(42);
+ variant<double> singleton(ConvertVariantTo<variant<double>>(source3));
+ ASSERT_TRUE(absl::holds_alternative<double>(singleton));
+ EXPECT_EQ(42.0, absl::get<double>(singleton));
+
+ source3 = 3.14f;
+ singleton = ConvertVariantTo<variant<double>>(source3);
+ ASSERT_TRUE(absl::holds_alternative<double>(singleton));
+ EXPECT_FLOAT_EQ(3.14f, static_cast<float>(absl::get<double>(singleton)));
+
+ variant<int> source4(0);
+ singleton = ConvertVariantTo<variant<double>>(source4);
+ ASSERT_TRUE(absl::holds_alternative<double>(singleton));
+ EXPECT_EQ(0.0, absl::get<double>(singleton));
+
+ variant<int32_t> source5(42);
+ variant<int32_t, uint32_t> variant2(
+ ConvertVariantTo<variant<int32_t, uint32_t>>(source5));
+ ASSERT_TRUE(absl::holds_alternative<int32_t>(variant2));
+ EXPECT_EQ(42, absl::get<int32_t>(variant2));
+
+ variant<uint32_t> source6(42);
+ variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(source6);
+ ASSERT_TRUE(absl::holds_alternative<uint32_t>(variant2));
+ EXPECT_EQ(42, absl::get<uint32_t>(variant2));
+
+ variant<Convertible2, Convertible1> source7((Convertible1()));
+ variant<Convertible1, Convertible2> variant3(
+ ConvertVariantTo<variant<Convertible1, Convertible2>>(source7));
+ ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));
+
+ source7 = Convertible2();
+ variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(source7);
+ ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));
+}
+
+TEST(VariantTest, TestMoveConversion) {
+ using Variant =
+ variant<std::unique_ptr<const int>, std::unique_ptr<const std::string>>;
+ using OtherVariant = variant<std::unique_ptr<int>, std::unique_ptr<std::string>>;
+
+ Variant var(
+ ConvertVariantTo<Variant>(OtherVariant{absl::make_unique<int>(0)}));
+ ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<const int>>(var));
+ ASSERT_NE(absl::get<std::unique_ptr<const int>>(var), nullptr);
+ EXPECT_EQ(0, *absl::get<std::unique_ptr<const int>>(var));
+
+ var =
+ ConvertVariantTo<Variant>(OtherVariant(absl::make_unique<std::string>("foo")));
+ ASSERT_TRUE(absl::holds_alternative<std::unique_ptr<const std::string>>(var));
+ EXPECT_EQ("foo", *absl::get<std::unique_ptr<const std::string>>(var));
+}
+
+TEST(VariantTest, DoesNotMoveFromLvalues) {
+ // We use shared_ptr here because it's both copyable and movable, and
+ // a moved-from shared_ptr is guaranteed to be null, so we can detect
+ // whether moving or copying has occurred.
+ using Variant =
+ variant<std::shared_ptr<const int>, std::shared_ptr<const std::string>>;
+ using OtherVariant = variant<std::shared_ptr<int>, std::shared_ptr<std::string>>;
+
+ Variant v1(std::make_shared<const int>(0));
+
+ // Test copy constructor
+ Variant v2(v1);
+ EXPECT_EQ(absl::get<std::shared_ptr<const int>>(v1),
+ absl::get<std::shared_ptr<const int>>(v2));
+
+ // Test copy-assignment operator
+ v1 = std::make_shared<const std::string>("foo");
+ v2 = v1;
+ EXPECT_EQ(absl::get<std::shared_ptr<const std::string>>(v1),
+ absl::get<std::shared_ptr<const std::string>>(v2));
+
+ // Test converting copy constructor
+ OtherVariant other(std::make_shared<int>(0));
+ Variant v3(ConvertVariantTo<Variant>(other));
+ EXPECT_EQ(absl::get<std::shared_ptr<int>>(other),
+ absl::get<std::shared_ptr<const int>>(v3));
+
+ other = std::make_shared<std::string>("foo");
+ v3 = ConvertVariantTo<Variant>(other);
+ EXPECT_EQ(absl::get<std::shared_ptr<std::string>>(other),
+ absl::get<std::shared_ptr<const std::string>>(v3));
+}
+
+TEST(VariantTest, TestRvalueConversionViaConvertVariantTo) {
+ variant<double, std::string> var(
+ ConvertVariantTo<variant<double, std::string>>(variant<std::string, int>(3)));
+ EXPECT_THAT(absl::get_if<double>(&var), Pointee(3.0));
+
+ var = ConvertVariantTo<variant<double, std::string>>(
+ variant<const char*, float>("foo"));
+ EXPECT_THAT(absl::get_if<std::string>(&var), Pointee(std::string("foo")));
+
+ variant<double> singleton(
+ ConvertVariantTo<variant<double>>(variant<int, float>(42)));
+ EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(42.0));
+
+ singleton = ConvertVariantTo<variant<double>>(variant<int, float>(3.14f));
+ EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(DoubleEq(3.14f)));
+
+ singleton = ConvertVariantTo<variant<double>>(variant<int>(3));
+ EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(3.0));
+
+ variant<int32_t, uint32_t> variant2(
+ ConvertVariantTo<variant<int32_t, uint32_t>>(variant<int32_t>(42)));
+ EXPECT_THAT(absl::get_if<int32_t>(&variant2), Pointee(42));
+
+ variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(variant<uint32_t>(42));
+ EXPECT_THAT(absl::get_if<uint32_t>(&variant2), Pointee(42));
+
+ variant<Convertible1, Convertible2> variant3(
+ ConvertVariantTo<variant<Convertible1, Convertible2>>(
+ (variant<Convertible2, Convertible1>(Convertible1()))));
+ ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));
+
+ variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(
+ variant<Convertible2, Convertible1>(Convertible2()));
+ ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));
+}
+
+TEST(VariantTest, TestLvalueConversionViaConvertVariantTo) {
+ variant<std::string, int> source1 = 3;
+ variant<double, std::string> destination(
+ ConvertVariantTo<variant<double, std::string>>(source1));
+ EXPECT_THAT(absl::get_if<double>(&destination), Pointee(3.0));
+
+ variant<const char*, float> source2 = "foo";
+ destination = ConvertVariantTo<variant<double, std::string>>(source2);
+ EXPECT_THAT(absl::get_if<std::string>(&destination), Pointee(std::string("foo")));
+
+ variant<int, float> source3(42);
+ variant<double> singleton(ConvertVariantTo<variant<double>>(source3));
+ EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(42.0));
+
+ source3 = 3.14f;
+ singleton = ConvertVariantTo<variant<double>>(source3);
+ EXPECT_FLOAT_EQ(3.14f, static_cast<float>(absl::get<double>(singleton)));
+ EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(DoubleEq(3.14f)));
+
+ variant<int> source4(3);
+ singleton = ConvertVariantTo<variant<double>>(source4);
+ EXPECT_THAT(absl::get_if<double>(&singleton), Pointee(3.0));
+
+ variant<int32_t> source5(42);
+ variant<int32_t, uint32_t> variant2(
+ ConvertVariantTo<variant<int32_t, uint32_t>>(source5));
+ EXPECT_THAT(absl::get_if<int32_t>(&variant2), Pointee(42));
+
+ variant<uint32_t> source6(42);
+ variant2 = ConvertVariantTo<variant<int32_t, uint32_t>>(source6);
+ EXPECT_THAT(absl::get_if<uint32_t>(&variant2), Pointee(42));
+
+ variant<Convertible2, Convertible1> source7((Convertible1()));
+ variant<Convertible1, Convertible2> variant3(
+ ConvertVariantTo<variant<Convertible1, Convertible2>>(source7));
+ ASSERT_TRUE(absl::holds_alternative<Convertible1>(variant3));
+
+ source7 = Convertible2();
+ variant3 = ConvertVariantTo<variant<Convertible1, Convertible2>>(source7);
+ ASSERT_TRUE(absl::holds_alternative<Convertible2>(variant3));
+}
+
+TEST(VariantTest, TestMoveConversionViaConvertVariantTo) {
+ using Variant =
+ variant<std::unique_ptr<const int>, std::unique_ptr<const std::string>>;
+ using OtherVariant = variant<std::unique_ptr<int>, std::unique_ptr<std::string>>;
+
+ Variant var(
+ ConvertVariantTo<Variant>(OtherVariant{absl::make_unique<int>(3)}));
+ EXPECT_THAT(absl::get_if<std::unique_ptr<const int>>(&var),
+ Pointee(Pointee(3)));
+
+ var =
+ ConvertVariantTo<Variant>(OtherVariant(absl::make_unique<std::string>("foo")));
+ EXPECT_THAT(absl::get_if<std::unique_ptr<const std::string>>(&var),
+ Pointee(Pointee(std::string("foo"))));
+}
+
+// If all alternatives are trivially copy/move constructible, variant should
+// also be trivially copy/move constructible. This is not required by the
+// standard and we know that libstdc++ variant doesn't have this feature.
+// For more details see the paper:
+// http://open-std.org/JTC1/SC22/WG21/docs/papers/2017/p0602r0.html
+#if !(defined(ABSL_HAVE_STD_VARIANT) && defined(__GLIBCXX__))
+#define ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY 1
+#endif
+
+TEST(VariantTest, TestCopyAndMoveTypeTraits) {
+ EXPECT_TRUE(std::is_copy_constructible<variant<std::string>>::value);
+ EXPECT_TRUE(std::is_copy_assignable<variant<std::string>>::value);
+ EXPECT_TRUE(std::is_move_constructible<variant<std::string>>::value);
+ EXPECT_TRUE(std::is_move_assignable<variant<std::string>>::value);
+ EXPECT_TRUE(std::is_move_constructible<variant<std::unique_ptr<int>>>::value);
+ EXPECT_TRUE(std::is_move_assignable<variant<std::unique_ptr<int>>>::value);
+ EXPECT_FALSE(
+ std::is_copy_constructible<variant<std::unique_ptr<int>>>::value);
+ EXPECT_FALSE(std::is_copy_assignable<variant<std::unique_ptr<int>>>::value);
+
+ EXPECT_FALSE(
+ absl::is_trivially_copy_constructible<variant<std::string>>::value);
+ EXPECT_FALSE(absl::is_trivially_copy_assignable<variant<std::string>>::value);
+#if ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY
+ EXPECT_TRUE(absl::is_trivially_copy_constructible<variant<int>>::value);
+ EXPECT_TRUE(absl::is_trivially_copy_assignable<variant<int>>::value);
+ EXPECT_TRUE(is_trivially_move_constructible<variant<int>>::value);
+ EXPECT_TRUE(is_trivially_move_assignable<variant<int>>::value);
+#endif // ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY
+}
+
+TEST(VariantTest, TestVectorOfMoveonlyVariant) {
+ // Verify that variant<MoveonlyType> works correctly as a std::vector element.
+ std::vector<variant<std::unique_ptr<int>, std::string>> vec;
+ vec.push_back(absl::make_unique<int>(42));
+ vec.emplace_back("Hello");
+ vec.reserve(3);
+ auto another_vec = absl::move(vec);
+ // As a sanity check, verify vector contents.
+ ASSERT_EQ(2, another_vec.size());
+ EXPECT_EQ(42, *absl::get<std::unique_ptr<int>>(another_vec[0]));
+ EXPECT_EQ("Hello", absl::get<std::string>(another_vec[1]));
+}
+
+TEST(VariantTest, NestedVariant) {
+#if ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY
+ static_assert(absl::is_trivially_copy_constructible<variant<int>>(), "");
+ static_assert(absl::is_trivially_copy_assignable<variant<int>>(), "");
+ static_assert(is_trivially_move_constructible<variant<int>>(), "");
+ static_assert(is_trivially_move_assignable<variant<int>>(), "");
+
+ static_assert(absl::is_trivially_copy_constructible<variant<variant<int>>>(),
+ "");
+ static_assert(absl::is_trivially_copy_assignable<variant<variant<int>>>(),
+ "");
+ static_assert(is_trivially_move_constructible<variant<variant<int>>>(), "");
+ static_assert(is_trivially_move_assignable<variant<variant<int>>>(), "");
+#endif // ABSL_VARIANT_PROPAGATE_COPY_MOVE_TRIVIALITY
+
+ variant<int> x(42);
+ variant<variant<int>> y(x);
+ variant<variant<int>> z(y);
+ EXPECT_TRUE(absl::holds_alternative<variant<int>>(z));
+ EXPECT_EQ(x, absl::get<variant<int>>(z));
+}
+
+struct TriviallyDestructible {
+ TriviallyDestructible(TriviallyDestructible&&) {}
+ TriviallyDestructible(const TriviallyDestructible&) {}
+ TriviallyDestructible& operator=(TriviallyDestructible&&) { return *this; }
+ TriviallyDestructible& operator=(const TriviallyDestructible&) {
+ return *this;
+ }
+};
+
+struct TriviallyMovable {
+ TriviallyMovable(TriviallyMovable&&) = default;
+ TriviallyMovable(TriviallyMovable const&) {}
+ TriviallyMovable& operator=(const TriviallyMovable&) { return *this; }
+};
+
+struct TriviallyCopyable {
+ TriviallyCopyable(const TriviallyCopyable&) = default;
+ TriviallyCopyable& operator=(const TriviallyCopyable&) { return *this; }
+};
+
+struct TriviallyMoveAssignable {
+ TriviallyMoveAssignable(TriviallyMoveAssignable&&) = default;
+ TriviallyMoveAssignable(const TriviallyMoveAssignable&) {}
+ TriviallyMoveAssignable& operator=(TriviallyMoveAssignable&&) = default;
+ TriviallyMoveAssignable& operator=(const TriviallyMoveAssignable&) {
+ return *this;
+ }
+};
+
+struct TriviallyCopyAssignable {};
+
+#if ABSL_V
<TRUNCATED>
[37/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/symbolize.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/symbolize.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/symbolize.h
new file mode 100644
index 0000000..7ae1383
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/symbolize.h
@@ -0,0 +1,122 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains internal parts of the Abseil symbolizer.
+// Do not depend on the anything in this file, it may change at anytime.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
+#define ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
+
+#include <cstddef>
+#include <cstdint>
+
+#ifdef ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
+#error ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE cannot be directly set
+#elif defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) && \
+ !defined(__asmjs__) && !defined(__wasm__)
+#define ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE 1
+
+#include <elf.h>
+#include <link.h> // For ElfW() macro.
+#include <functional>
+#include <string>
+
+namespace absl {
+namespace debugging_internal {
+
+// Iterates over all sections, invoking callback on each with the section name
+// and the section header.
+//
+// Returns true on success; otherwise returns false in case of errors.
+//
+// This is not async-signal-safe.
+bool ForEachSection(
+ int fd, const std::function<bool(const std::string& name, const ElfW(Shdr) &)>&
+ callback);
+
+// Gets the section header for the given name, if it exists. Returns true on
+// success. Otherwise, returns false.
+bool GetSectionHeaderByName(int fd, const char *name, size_t name_len,
+ ElfW(Shdr) *out);
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE
+
+namespace absl {
+namespace debugging_internal {
+
+struct SymbolDecoratorArgs {
+ // The program counter we are getting symbolic name for.
+ const void *pc;
+ // 0 for main executable, load address for shared libraries.
+ ptrdiff_t relocation;
+ // Read-only file descriptor for ELF image covering "pc",
+ // or -1 if no such ELF image exists in /proc/self/maps.
+ int fd;
+ // Output buffer, size.
+ // Note: the buffer may not be empty -- default symbolizer may have already
+ // produced some output, and earlier decorators may have adorned it in
+ // some way. You are free to replace or augment the contents (within the
+ // symbol_buf_size limit).
+ char *const symbol_buf;
+ size_t symbol_buf_size;
+ // Temporary scratch space, size.
+ // Use that space in preference to allocating your own stack buffer to
+ // conserve stack.
+ char *const tmp_buf;
+ size_t tmp_buf_size;
+ // User-provided argument
+ void* arg;
+};
+using SymbolDecorator = void (*)(const SymbolDecoratorArgs *);
+
+// Installs a function-pointer as a decorator. Returns a value less than zero
+// if the system cannot install the decorator. Otherwise, returns a unique
+// identifier corresponding to the decorator. This identifier can be used to
+// uninstall the decorator - See RemoveSymbolDecorator() below.
+int InstallSymbolDecorator(SymbolDecorator decorator, void* arg);
+
+// Removes a previously installed function-pointer decorator. Parameter "ticket"
+// is the return-value from calling InstallSymbolDecorator().
+bool RemoveSymbolDecorator(int ticket);
+
+// Remove all installed decorators. Returns true if successful, false if
+// symbolization is currently in progress.
+bool RemoveAllSymbolDecorators(void);
+
+// Registers an address range to a file mapping.
+//
+// Preconditions:
+// start <= end
+// filename != nullptr
+//
+// Returns true if the file was successfully registered.
+bool RegisterFileMappingHint(
+ const void* start, const void* end, uint64_t offset, const char* filename);
+
+// Looks up the file mapping registered by RegisterFileMappingHint for an
+// address range. If there is one, the file name is stored in *filename and
+// *start and *end are modified to reflect the registered mapping. Returns
+// whether any hint was found.
+bool GetFileMappingHint(const void** start,
+ const void** end,
+ uint64_t * offset,
+ const char** filename);
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_SYMBOLIZE_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/vdso_support.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/vdso_support.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/vdso_support.cc
new file mode 100644
index 0000000..44ec7c0
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/vdso_support.cc
@@ -0,0 +1,192 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Allow dynamic symbol lookup in the kernel VDSO page.
+//
+// VDSOSupport -- a class representing kernel VDSO (if present).
+
+#include "absl/debugging/internal/vdso_support.h"
+
+#ifdef ABSL_HAVE_VDSO_SUPPORT // defined in vdso_support.h
+
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+
+#if __GLIBC_PREREQ(2, 16) // GLIBC-2.16 implements getauxval.
+#include <sys/auxv.h>
+#endif
+
+#include "absl/base/dynamic_annotations.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/port.h"
+
+#ifndef AT_SYSINFO_EHDR
+#define AT_SYSINFO_EHDR 33 // for crosstoolv10
+#endif
+
+namespace absl {
+namespace debugging_internal {
+
+ABSL_CONST_INIT
+std::atomic<const void *> VDSOSupport::vdso_base_(
+ debugging_internal::ElfMemImage::kInvalidBase);
+
+std::atomic<VDSOSupport::GetCpuFn> VDSOSupport::getcpu_fn_(&InitAndGetCPU);
+VDSOSupport::VDSOSupport()
+ // If vdso_base_ is still set to kInvalidBase, we got here
+ // before VDSOSupport::Init has been called. Call it now.
+ : image_(vdso_base_.load(std::memory_order_relaxed) ==
+ debugging_internal::ElfMemImage::kInvalidBase
+ ? Init()
+ : vdso_base_.load(std::memory_order_relaxed)) {}
+
+// NOTE: we can't use GoogleOnceInit() below, because we can be
+// called by tcmalloc, and none of the *once* stuff may be functional yet.
+//
+// In addition, we hope that the VDSOSupportHelper constructor
+// causes this code to run before there are any threads, and before
+// InitGoogle() has executed any chroot or setuid calls.
+//
+// Finally, even if there is a race here, it is harmless, because
+// the operation should be idempotent.
+const void *VDSOSupport::Init() {
+ const auto kInvalidBase = debugging_internal::ElfMemImage::kInvalidBase;
+#if __GLIBC_PREREQ(2, 16)
+ if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
+ errno = 0;
+ const void *const sysinfo_ehdr =
+ reinterpret_cast<const void *>(getauxval(AT_SYSINFO_EHDR));
+ if (errno == 0) {
+ vdso_base_.store(sysinfo_ehdr, std::memory_order_relaxed);
+ }
+ }
+#endif // __GLIBC_PREREQ(2, 16)
+ if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
+ // Valgrind zaps AT_SYSINFO_EHDR and friends from the auxv[]
+ // on stack, and so glibc works as if VDSO was not present.
+ // But going directly to kernel via /proc/self/auxv below bypasses
+ // Valgrind zapping. So we check for Valgrind separately.
+ if (RunningOnValgrind()) {
+ vdso_base_.store(nullptr, std::memory_order_relaxed);
+ getcpu_fn_.store(&GetCPUViaSyscall, std::memory_order_relaxed);
+ return nullptr;
+ }
+ int fd = open("/proc/self/auxv", O_RDONLY);
+ if (fd == -1) {
+ // Kernel too old to have a VDSO.
+ vdso_base_.store(nullptr, std::memory_order_relaxed);
+ getcpu_fn_.store(&GetCPUViaSyscall, std::memory_order_relaxed);
+ return nullptr;
+ }
+ ElfW(auxv_t) aux;
+ while (read(fd, &aux, sizeof(aux)) == sizeof(aux)) {
+ if (aux.a_type == AT_SYSINFO_EHDR) {
+ vdso_base_.store(reinterpret_cast<void *>(aux.a_un.a_val),
+ std::memory_order_relaxed);
+ break;
+ }
+ }
+ close(fd);
+ if (vdso_base_.load(std::memory_order_relaxed) == kInvalidBase) {
+ // Didn't find AT_SYSINFO_EHDR in auxv[].
+ vdso_base_.store(nullptr, std::memory_order_relaxed);
+ }
+ }
+ GetCpuFn fn = &GetCPUViaSyscall; // default if VDSO not present.
+ if (vdso_base_.load(std::memory_order_relaxed)) {
+ VDSOSupport vdso;
+ SymbolInfo info;
+ if (vdso.LookupSymbol("__vdso_getcpu", "LINUX_2.6", STT_FUNC, &info)) {
+ fn = reinterpret_cast<GetCpuFn>(const_cast<void *>(info.address));
+ }
+ }
+ // Subtle: this code runs outside of any locks; prevent compiler
+ // from assigning to getcpu_fn_ more than once.
+ getcpu_fn_.store(fn, std::memory_order_relaxed);
+ return vdso_base_.load(std::memory_order_relaxed);
+}
+
+const void *VDSOSupport::SetBase(const void *base) {
+ ABSL_RAW_CHECK(base != debugging_internal::ElfMemImage::kInvalidBase,
+ "internal error");
+ const void *old_base = vdso_base_.load(std::memory_order_relaxed);
+ vdso_base_.store(base, std::memory_order_relaxed);
+ image_.Init(base);
+ // Also reset getcpu_fn_, so GetCPU could be tested with simulated VDSO.
+ getcpu_fn_.store(&InitAndGetCPU, std::memory_order_relaxed);
+ return old_base;
+}
+
+bool VDSOSupport::LookupSymbol(const char *name,
+ const char *version,
+ int type,
+ SymbolInfo *info) const {
+ return image_.LookupSymbol(name, version, type, info);
+}
+
+bool VDSOSupport::LookupSymbolByAddress(const void *address,
+ SymbolInfo *info_out) const {
+ return image_.LookupSymbolByAddress(address, info_out);
+}
+
+// NOLINT on 'long' because this routine mimics kernel api.
+long VDSOSupport::GetCPUViaSyscall(unsigned *cpu, // NOLINT(runtime/int)
+ void *, void *) {
+#ifdef SYS_getcpu
+ return syscall(SYS_getcpu, cpu, nullptr, nullptr);
+#else
+ // x86_64 never implemented sys_getcpu(), except as a VDSO call.
+ static_cast<void>(cpu); // Avoid an unused argument compiler warning.
+ errno = ENOSYS;
+ return -1;
+#endif
+}
+
+// Use fast __vdso_getcpu if available.
+long VDSOSupport::InitAndGetCPU(unsigned *cpu, // NOLINT(runtime/int)
+ void *x, void *y) {
+ Init();
+ GetCpuFn fn = getcpu_fn_.load(std::memory_order_relaxed);
+ ABSL_RAW_CHECK(fn != &InitAndGetCPU, "Init() did not set getcpu_fn_");
+ return (*fn)(cpu, x, y);
+}
+
+// This function must be very fast, and may be called from very
+// low level (e.g. tcmalloc). Hence I avoid things like
+// GoogleOnceInit() and ::operator new.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
+int GetCPU() {
+ unsigned cpu;
+ int ret_code = (*VDSOSupport::getcpu_fn_)(&cpu, nullptr, nullptr);
+ return ret_code == 0 ? cpu : ret_code;
+}
+
+// We need to make sure VDSOSupport::Init() is called before
+// InitGoogle() does any setuid or chroot calls. If VDSOSupport
+// is used in any global constructor, this will happen, since
+// VDSOSupport's constructor calls Init. But if not, we need to
+// ensure it here, with a global constructor of our own. This
+// is an allowed exception to the normal rule against non-trivial
+// global constructors.
+static class VDSOInitHelper {
+ public:
+ VDSOInitHelper() { VDSOSupport::Init(); }
+} vdso_init_helper;
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_HAVE_VDSO_SUPPORT
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/vdso_support.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/vdso_support.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/vdso_support.h
new file mode 100644
index 0000000..870a60a
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/vdso_support.h
@@ -0,0 +1,155 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Allow dynamic symbol lookup in the kernel VDSO page.
+//
+// VDSO stands for "Virtual Dynamic Shared Object" -- a page of
+// executable code, which looks like a shared library, but doesn't
+// necessarily exist anywhere on disk, and which gets mmap()ed into
+// every process by kernels which support VDSO, such as 2.6.x for 32-bit
+// executables, and 2.6.24 and above for 64-bit executables.
+//
+// More details could be found here:
+// http://www.trilithium.com/johan/2005/08/linux-gate/
+//
+// VDSOSupport -- a class representing kernel VDSO (if present).
+//
+// Example usage:
+// VDSOSupport vdso;
+// VDSOSupport::SymbolInfo info;
+// typedef (*FN)(unsigned *, void *, void *);
+// FN fn = nullptr;
+// if (vdso.LookupSymbol("__vdso_getcpu", "LINUX_2.6", STT_FUNC, &info)) {
+// fn = reinterpret_cast<FN>(info.address);
+// }
+
+#ifndef ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
+#define ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
+
+#include <atomic>
+
+#include "absl/debugging/internal/elf_mem_image.h"
+
+#ifdef ABSL_HAVE_ELF_MEM_IMAGE
+
+#ifdef ABSL_HAVE_VDSO_SUPPORT
+#error ABSL_HAVE_VDSO_SUPPORT cannot be directly set
+#else
+#define ABSL_HAVE_VDSO_SUPPORT 1
+#endif
+
+namespace absl {
+namespace debugging_internal {
+
+// NOTE: this class may be used from within tcmalloc, and can not
+// use any memory allocation routines.
+class VDSOSupport {
+ public:
+ VDSOSupport();
+
+ typedef ElfMemImage::SymbolInfo SymbolInfo;
+ typedef ElfMemImage::SymbolIterator SymbolIterator;
+
+ // On PowerPC64 VDSO symbols can either be of type STT_FUNC or STT_NOTYPE
+ // depending on how the kernel is built. The kernel is normally built with
+ // STT_NOTYPE type VDSO symbols. Let's make things simpler first by using a
+ // compile-time constant.
+#ifdef __powerpc64__
+ enum { kVDSOSymbolType = STT_NOTYPE };
+#else
+ enum { kVDSOSymbolType = STT_FUNC };
+#endif
+
+ // Answers whether we have a vdso at all.
+ bool IsPresent() const { return image_.IsPresent(); }
+
+ // Allow to iterate over all VDSO symbols.
+ SymbolIterator begin() const { return image_.begin(); }
+ SymbolIterator end() const { return image_.end(); }
+
+ // Look up versioned dynamic symbol in the kernel VDSO.
+ // Returns false if VDSO is not present, or doesn't contain given
+ // symbol/version/type combination.
+ // If info_out != nullptr, additional details are filled in.
+ bool LookupSymbol(const char *name, const char *version,
+ int symbol_type, SymbolInfo *info_out) const;
+
+ // Find info about symbol (if any) which overlaps given address.
+ // Returns true if symbol was found; false if VDSO isn't present
+ // or doesn't have a symbol overlapping given address.
+ // If info_out != nullptr, additional details are filled in.
+ bool LookupSymbolByAddress(const void *address, SymbolInfo *info_out) const;
+
+ // Used only for testing. Replace real VDSO base with a mock.
+ // Returns previous value of vdso_base_. After you are done testing,
+ // you are expected to call SetBase() with previous value, in order to
+ // reset state to the way it was.
+ const void *SetBase(const void *s);
+
+ // Computes vdso_base_ and returns it. Should be called as early as
+ // possible; before any thread creation, chroot or setuid.
+ static const void *Init();
+
+ private:
+ // image_ represents VDSO ELF image in memory.
+ // image_.ehdr_ == nullptr implies there is no VDSO.
+ ElfMemImage image_;
+
+ // Cached value of auxv AT_SYSINFO_EHDR, computed once.
+ // This is a tri-state:
+ // kInvalidBase => value hasn't been determined yet.
+ // 0 => there is no VDSO.
+ // else => vma of VDSO Elf{32,64}_Ehdr.
+ //
+ // When testing with mock VDSO, low bit is set.
+ // The low bit is always available because vdso_base_ is
+ // page-aligned.
+ static std::atomic<const void *> vdso_base_;
+
+ // NOLINT on 'long' because these routines mimic kernel api.
+ // The 'cache' parameter may be used by some versions of the kernel,
+ // and should be nullptr or point to a static buffer containing at
+ // least two 'long's.
+ static long InitAndGetCPU(unsigned *cpu, void *cache, // NOLINT 'long'.
+ void *unused);
+ static long GetCPUViaSyscall(unsigned *cpu, void *cache, // NOLINT 'long'.
+ void *unused);
+ typedef long (*GetCpuFn)(unsigned *cpu, void *cache, // NOLINT 'long'.
+ void *unused);
+
+ // This function pointer may point to InitAndGetCPU,
+ // GetCPUViaSyscall, or __vdso_getcpu at different stages of initialization.
+ static std::atomic<GetCpuFn> getcpu_fn_;
+
+ friend int GetCPU(void); // Needs access to getcpu_fn_.
+
+ VDSOSupport(const VDSOSupport&) = delete;
+ VDSOSupport& operator=(const VDSOSupport&) = delete;
+};
+
+// Same as sched_getcpu() on later glibc versions.
+// Return current CPU, using (fast) __vdso_getcpu@LINUX_2.6 if present,
+// otherwise use syscall(SYS_getcpu,...).
+// May return -1 with errno == ENOSYS if the kernel doesn't
+// support SYS_getcpu.
+int GetCPU();
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_HAVE_ELF_MEM_IMAGE
+
+#endif // ABSL_DEBUGGING_INTERNAL_VDSO_SUPPORT_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check.cc
new file mode 100644
index 0000000..e01e5f8
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check.cc
@@ -0,0 +1,48 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+// Wrappers around lsan_interface functions.
+// When lsan is not linked in, these functions are not available,
+// therefore Abseil code which depends on these functions is conditioned on the
+// definition of LEAK_SANITIZER.
+#include "absl/debugging/leak_check.h"
+
+#ifndef LEAK_SANITIZER
+
+namespace absl {
+bool HaveLeakSanitizer() { return false; }
+void DoIgnoreLeak(const void*) { }
+void RegisterLivePointers(const void*, size_t) { }
+void UnRegisterLivePointers(const void*, size_t) { }
+LeakCheckDisabler::LeakCheckDisabler() { }
+LeakCheckDisabler::~LeakCheckDisabler() { }
+} // namespace absl
+
+#else
+
+#include <sanitizer/lsan_interface.h>
+
+namespace absl {
+bool HaveLeakSanitizer() { return true; }
+void DoIgnoreLeak(const void* ptr) { __lsan_ignore_object(ptr); }
+void RegisterLivePointers(const void* ptr, size_t size) {
+ __lsan_register_root_region(ptr, size);
+}
+void UnRegisterLivePointers(const void* ptr, size_t size) {
+ __lsan_unregister_root_region(ptr, size);
+}
+LeakCheckDisabler::LeakCheckDisabler() { __lsan_disable(); }
+LeakCheckDisabler::~LeakCheckDisabler() { __lsan_enable(); }
+} // namespace absl
+
+#endif // LEAK_SANITIZER
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check.h
new file mode 100644
index 0000000..f67fe88
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check.h
@@ -0,0 +1,111 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// -----------------------------------------------------------------------------
+// File: leak_check.h
+// -----------------------------------------------------------------------------
+//
+// This package contains functions that affect leak checking behavior within
+// targets built with the LeakSanitizer (LSan), a memory leak detector that is
+// integrated within the AddressSanitizer (ASan) as an additional component, or
+// which can be used standalone. LSan and ASan are included or can be provided
+// as additional components for most compilers such as Clang, gcc and MSVC.
+// Note: this leak checking API is not yet supported in MSVC.
+// Leak checking is enabled by default in all ASan builds.
+//
+// See https://github.com/google/sanitizers/wiki/AddressSanitizerLeakSanitizer
+//
+// -----------------------------------------------------------------------------
+#ifndef ABSL_DEBUGGING_LEAK_CHECK_H_
+#define ABSL_DEBUGGING_LEAK_CHECK_H_
+
+#include <cstddef>
+
+namespace absl {
+
+// HaveLeakSanitizer()
+//
+// Returns true if a leak-checking sanitizer (either ASan or standalone LSan) is
+// currently built into this target.
+bool HaveLeakSanitizer();
+
+// DoIgnoreLeak()
+//
+// Implements `IgnoreLeak()` below. This function should usually
+// not be called directly; calling `IgnoreLeak()` is preferred.
+void DoIgnoreLeak(const void* ptr);
+
+// IgnoreLeak()
+//
+// Instruct the leak sanitizer to ignore leak warnings on the object referenced
+// by the passed pointer, as well as all heap objects transitively referenced
+// by it. The passed object pointer can point to either the beginning of the
+// object or anywhere within it.
+//
+// Example:
+//
+// static T* obj = IgnoreLeak(new T(...));
+//
+// If the passed `ptr` does not point to an actively allocated object at the
+// time `IgnoreLeak()` is called, the call is a no-op; if it is actively
+// allocated, the object must not get deallocated later.
+//
+template <typename T>
+T* IgnoreLeak(T* ptr) {
+ DoIgnoreLeak(ptr);
+ return ptr;
+}
+
+// LeakCheckDisabler
+//
+// This helper class indicates that any heap allocations done in the code block
+// covered by the scoped object, which should be allocated on the stack, will
+// not be reported as leaks. Leak check disabling will occur within the code
+// block and any nested function calls within the code block.
+//
+// Example:
+//
+// void Foo() {
+// LeakCheckDisabler disabler;
+// ... code that allocates objects whose leaks should be ignored ...
+// }
+//
+// REQUIRES: Destructor runs in same thread as constructor
+class LeakCheckDisabler {
+ public:
+ LeakCheckDisabler();
+ LeakCheckDisabler(const LeakCheckDisabler&) = delete;
+ LeakCheckDisabler& operator=(const LeakCheckDisabler&) = delete;
+ ~LeakCheckDisabler();
+};
+
+// RegisterLivePointers()
+//
+// Registers `ptr[0,size-1]` as pointers to memory that is still actively being
+// referenced and for which leak checking should be ignored. This function is
+// useful if you store pointers in mapped memory, for memory ranges that we know
+// are correct but for which normal analysis would flag as leaked code.
+void RegisterLivePointers(const void* ptr, size_t size);
+
+// UnRegisterLivePointers()
+//
+// Deregisters the pointers previously marked as active in
+// `RegisterLivePointers()`, enabling leak checking of those pointers.
+void UnRegisterLivePointers(const void* ptr, size_t size);
+
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_LEAK_CHECK_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_disable.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_disable.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_disable.cc
new file mode 100644
index 0000000..df22c1c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_disable.cc
@@ -0,0 +1,20 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Disable LeakSanitizer when this file is linked in.
+// This function overrides __lsan_is_turned_off from sanitizer/lsan_interface.h
+extern "C" int __lsan_is_turned_off();
+extern "C" int __lsan_is_turned_off() {
+ return 1;
+}
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_fail_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_fail_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_fail_test.cc
new file mode 100644
index 0000000..bf541fe
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_fail_test.cc
@@ -0,0 +1,41 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <memory>
+#include "gtest/gtest.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/debugging/leak_check.h"
+
+namespace {
+
+TEST(LeakCheckTest, LeakMemory) {
+ // This test is expected to cause lsan failures on program exit. Therefore the
+ // test will be run only by leak_check_test.sh, which will verify a
+ // failed exit code.
+
+ char* foo = strdup("lsan should complain about this leaked string");
+ ABSL_RAW_LOG(INFO, "Should detect leaked std::string %s", foo);
+}
+
+TEST(LeakCheckTest, LeakMemoryAfterDisablerScope) {
+ // This test is expected to cause lsan failures on program exit. Therefore the
+ // test will be run only by external_leak_check_test.sh, which will verify a
+ // failed exit code.
+ { absl::LeakCheckDisabler disabler; }
+ char* foo = strdup("lsan should also complain about this leaked string");
+ ABSL_RAW_LOG(INFO, "Re-enabled leak detection.Should detect leaked std::string %s",
+ foo);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_test.cc
new file mode 100644
index 0000000..febd1ee
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/leak_check_test.cc
@@ -0,0 +1,42 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string>
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/debugging/leak_check.h"
+
+namespace {
+
+TEST(LeakCheckTest, DetectLeakSanitizer) {
+#ifdef ABSL_EXPECT_LEAK_SANITIZER
+ EXPECT_TRUE(absl::HaveLeakSanitizer());
+#else
+ EXPECT_FALSE(absl::HaveLeakSanitizer());
+#endif
+}
+
+TEST(LeakCheckTest, IgnoreLeakSuppressesLeakedMemoryErrors) {
+ auto foo = absl::IgnoreLeak(new std::string("some ignored leaked string"));
+ ABSL_RAW_LOG(INFO, "Ignoring leaked std::string %s", foo->c_str());
+}
+
+TEST(LeakCheckTest, LeakCheckDisablerIgnoresLeak) {
+ absl::LeakCheckDisabler disabler;
+ auto foo = new std::string("some std::string leaked while checks are disabled");
+ ABSL_RAW_LOG(INFO, "Ignoring leaked std::string %s", foo->c_str());
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/stacktrace.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/stacktrace.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/stacktrace.cc
new file mode 100644
index 0000000..61fee61
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/stacktrace.cc
@@ -0,0 +1,133 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Produce stack trace.
+//
+// There are three different ways we can try to get the stack trace:
+//
+// 1) Our hand-coded stack-unwinder. This depends on a certain stack
+// layout, which is used by gcc (and those systems using a
+// gcc-compatible ABI) on x86 systems, at least since gcc 2.95.
+// It uses the frame pointer to do its work.
+//
+// 2) The libunwind library. This is still in development, and as a
+// separate library adds a new dependency, but doesn't need a frame
+// pointer. It also doesn't call malloc.
+//
+// 3) The gdb unwinder -- also the one used by the c++ exception code.
+// It's obviously well-tested, but has a fatal flaw: it can call
+// malloc() from the unwinder. This is a problem because we're
+// trying to use the unwinder to instrument malloc().
+//
+// Note: if you add a new implementation here, make sure it works
+// correctly when absl::GetStackTrace() is called with max_depth == 0.
+// Some code may do that.
+
+#include "absl/debugging/stacktrace.h"
+
+#include <atomic>
+
+#include "absl/base/attributes.h"
+#include "absl/base/port.h"
+#include "absl/debugging/internal/stacktrace_config.h"
+
+#if defined(ABSL_STACKTRACE_INL_HEADER)
+#include ABSL_STACKTRACE_INL_HEADER
+#else
+# error Cannot calculate stack trace: will need to write for your environment
+# include "absl/debugging/internal/stacktrace_aarch64-inl.inc"
+# include "absl/debugging/internal/stacktrace_arm-inl.inc"
+# include "absl/debugging/internal/stacktrace_generic-inl.inc"
+# include "absl/debugging/internal/stacktrace_powerpc-inl.inc"
+# include "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
+# include "absl/debugging/internal/stacktrace_win32-inl.inc"
+# include "absl/debugging/internal/stacktrace_x86-inl.inc"
+#endif
+
+namespace absl {
+namespace {
+
+typedef int (*Unwinder)(void**, int*, int, int, const void*, int*);
+std::atomic<Unwinder> custom;
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+ABSL_ATTRIBUTE_ALWAYS_INLINE inline int Unwind(void** result, int* sizes,
+ int max_depth, int skip_count,
+ const void* uc,
+ int* min_dropped_frames) {
+ Unwinder f = &UnwindImpl<IS_STACK_FRAMES, IS_WITH_CONTEXT>;
+ Unwinder g = custom.load(std::memory_order_acquire);
+ if (g != nullptr) f = g;
+
+ // Add 1 to skip count for the unwinder function itself
+ int size = (*f)(result, sizes, max_depth, skip_count + 1, uc,
+ min_dropped_frames);
+ // To disable tail call to (*f)(...)
+ ABSL_BLOCK_TAIL_CALL_OPTIMIZATION();
+ return size;
+}
+
+} // anonymous namespace
+
+int GetStackFrames(void** result, int* sizes, int max_depth, int skip_count) {
+ return Unwind<true, false>(result, sizes, max_depth, skip_count, nullptr,
+ nullptr);
+}
+
+int GetStackFramesWithContext(void** result, int* sizes, int max_depth,
+ int skip_count, const void* uc,
+ int* min_dropped_frames) {
+ return Unwind<true, true>(result, sizes, max_depth, skip_count, uc,
+ min_dropped_frames);
+}
+
+int GetStackTrace(void** result, int max_depth, int skip_count) {
+ return Unwind<false, false>(result, nullptr, max_depth, skip_count, nullptr,
+ nullptr);
+}
+
+int GetStackTraceWithContext(void** result, int max_depth, int skip_count,
+ const void* uc, int* min_dropped_frames) {
+ return Unwind<false, true>(result, nullptr, max_depth, skip_count, uc,
+ min_dropped_frames);
+}
+
+void SetStackUnwinder(Unwinder w) {
+ custom.store(w, std::memory_order_release);
+}
+
+int DefaultStackUnwinder(void** pcs, int* sizes, int depth, int skip,
+ const void* uc, int* min_dropped_frames) {
+ skip++; // For this function
+ Unwinder f = nullptr;
+ if (sizes == nullptr) {
+ if (uc == nullptr) {
+ f = &UnwindImpl<false, false>;
+ } else {
+ f = &UnwindImpl<false, true>;
+ }
+ } else {
+ if (uc == nullptr) {
+ f = &UnwindImpl<true, false>;
+ } else {
+ f = &UnwindImpl<true, true>;
+ }
+ }
+ volatile int x = 0;
+ int n = (*f)(pcs, sizes, depth, skip, uc, min_dropped_frames);
+ x = 1; (void) x; // To disable tail call to (*f)(...)
+ return n;
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/stacktrace.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/stacktrace.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/stacktrace.h
new file mode 100644
index 0000000..82da3f1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/stacktrace.h
@@ -0,0 +1,167 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Routines to extract the current stack trace. These functions are
+// thread-safe and async-signal-safe.
+// Note that stack trace functionality is platform dependent and requires
+// additional support from the compiler/build system in many cases. (That is,
+// this generally only works on platforms/builds that have been specifically
+// configured to support it.)
+
+#ifndef ABSL_DEBUGGING_STACKTRACE_H_
+#define ABSL_DEBUGGING_STACKTRACE_H_
+
+namespace absl {
+
+// Skips the most recent "skip_count" stack frames (also skips the
+// frame generated for the "absl::GetStackFrames" routine itself), and then
+// records the pc values for up to the next "max_depth" frames in
+// "result", and the corresponding stack frame sizes in "sizes".
+// Returns the number of values recorded in "result"/"sizes".
+//
+// Example:
+// main() { foo(); }
+// foo() { bar(); }
+// bar() {
+// void* result[10];
+// int sizes[10];
+// int depth = absl::GetStackFrames(result, sizes, 10, 1);
+// }
+//
+// The absl::GetStackFrames call will skip the frame for "bar". It will
+// return 2 and will produce pc values that map to the following
+// procedures:
+// result[0] foo
+// result[1] main
+// (Actually, there may be a few more entries after "main" to account for
+// startup procedures.)
+// And corresponding stack frame sizes will also be recorded:
+// sizes[0] 16
+// sizes[1] 16
+// (Stack frame sizes of 16 above are just for illustration purposes.)
+// Stack frame sizes of 0 or less indicate that those frame sizes couldn't
+// be identified.
+//
+// This routine may return fewer stack frame entries than are
+// available. Also note that "result" and "sizes" must both be non-null.
+extern int GetStackFrames(void** result, int* sizes, int max_depth,
+ int skip_count);
+
+// Same as above, but to be used from a signal handler. The "uc" parameter
+// should be the pointer to ucontext_t which was passed as the 3rd parameter
+// to sa_sigaction signal handler. It may help the unwinder to get a
+// better stack trace under certain conditions. The "uc" may safely be null.
+//
+// If min_dropped_frames is not null, stores in *min_dropped_frames a
+// lower bound on the number of dropped stack frames. The stored value is
+// guaranteed to be >= 0. The number of real stack frames is guaranteed to
+// be >= skip_count + max_depth + *min_dropped_frames.
+extern int GetStackFramesWithContext(void** result, int* sizes, int max_depth,
+ int skip_count, const void* uc,
+ int* min_dropped_frames);
+
+// This is similar to the absl::GetStackFrames routine, except that it returns
+// the stack trace only, and not the stack frame sizes as well.
+// Example:
+// main() { foo(); }
+// foo() { bar(); }
+// bar() {
+// void* result[10];
+// int depth = absl::GetStackTrace(result, 10, 1);
+// }
+//
+// This produces:
+// result[0] foo
+// result[1] main
+// .... ...
+//
+// "result" must not be null.
+extern int GetStackTrace(void** result, int max_depth, int skip_count);
+
+// Same as above, but to be used from a signal handler. The "uc" parameter
+// should be the pointer to ucontext_t which was passed as the 3rd parameter
+// to sa_sigaction signal handler. It may help the unwinder to get a
+// better stack trace under certain conditions. The "uc" may safely be null.
+//
+// If min_dropped_frames is not null, stores in *min_dropped_frames a
+// lower bound on the number of dropped stack frames. The stored value is
+// guaranteed to be >= 0. The number of real stack frames is guaranteed to
+// be >= skip_count + max_depth + *min_dropped_frames.
+extern int GetStackTraceWithContext(void** result, int max_depth,
+ int skip_count, const void* uc,
+ int* min_dropped_frames);
+
+// Call this to provide a custom function for unwinding stack frames
+// that will be used every time someone invokes one of the static
+// GetStack{Frames,Trace}{,WithContext}() functions above.
+//
+// The arguments passed to the unwinder function will match the
+// arguments passed to absl::GetStackFramesWithContext() except that sizes
+// will be non-null iff the caller is interested in frame sizes.
+//
+// If unwinder is null, we revert to the default stack-tracing behavior.
+//
+// ****************************************************************
+// WARNINGS
+//
+// absl::SetStackUnwinder is not suitable for general purpose use. It is
+// provided for custom runtimes.
+// Some things to watch out for when calling absl::SetStackUnwinder:
+//
+// (a) The unwinder may be called from within signal handlers and
+// therefore must be async-signal-safe.
+//
+// (b) Even after a custom stack unwinder has been unregistered, other
+// threads may still be in the process of using that unwinder.
+// Therefore do not clean up any state that may be needed by an old
+// unwinder.
+// ****************************************************************
+extern void SetStackUnwinder(int (*unwinder)(void** pcs, int* sizes,
+ int max_depth, int skip_count,
+ const void* uc,
+ int* min_dropped_frames));
+
+// Function that exposes built-in stack-unwinding behavior, ignoring
+// any calls to absl::SetStackUnwinder().
+//
+// pcs must NOT be null.
+//
+// sizes may be null.
+// uc may be null.
+// min_dropped_frames may be null.
+//
+// The semantics are the same as the corresponding GetStack*() function in the
+// case where absl::SetStackUnwinder() was never called. Equivalents are:
+//
+// null sizes | non-nullptr sizes
+// |==========================================================|
+// null uc | GetStackTrace() | GetStackFrames() |
+// non-null uc | GetStackTraceWithContext() | GetStackFramesWithContext() |
+// |==========================================================|
+extern int DefaultStackUnwinder(void** pcs, int* sizes, int max_depth,
+ int skip_count, const void* uc,
+ int* min_dropped_frames);
+
+namespace debugging_internal {
+// Returns true for platforms which are expected to have functioning stack trace
+// implementations. Intended to be used for tests which want to exclude
+// verification of logic known to be broken because stack traces are not
+// working.
+extern bool StackTraceWorksForTest();
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_STACKTRACE_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize.cc
new file mode 100644
index 0000000..a35e24c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize.cc
@@ -0,0 +1,28 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/debugging/symbolize.h"
+
+#if defined(ABSL_INTERNAL_HAVE_ELF_SYMBOLIZE)
+#include "absl/debugging/symbolize_elf.inc"
+#elif defined(_WIN32) && defined(_DEBUG)
+// The Windows Symbolizer only works in debug mode. Note that _DEBUG
+// is the macro that defines whether or not MS C-Runtime debug info is
+// available. Note that the PDB files containing the debug info must
+// also be available to the program at runtime for the symbolizer to
+// work.
+#include "absl/debugging/symbolize_win32.inc"
+#else
+#include "absl/debugging/symbolize_unimplemented.inc"
+#endif
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize.h
new file mode 100644
index 0000000..073a447
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/symbolize.h
@@ -0,0 +1,35 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_DEBUGGING_SYMBOLIZE_H_
+#define ABSL_DEBUGGING_SYMBOLIZE_H_
+
+#include "absl/debugging/internal/symbolize.h"
+
+namespace absl {
+
+// Initializes this module. Symbolize() may fail prior calling this function.
+// `argv0` is the path to this program, which is usually obtained in main()
+// though argv[0].
+void InitializeSymbolizer(const char* argv0);
+
+// Symbolizes a program counter. On success, returns true and write the
+// symbol name to "out". The symbol name is demangled if possible
+// (supports symbols generated by GCC 3.x or newer), may be truncated, and
+// will be '\0' terminated. Otherwise, returns false.
+bool Symbolize(const void *pc, char *out, int out_size);
+
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_SYMBOLIZE_H_
[22/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex.h b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex.h
new file mode 100644
index 0000000..c4e026f
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex.h
@@ -0,0 +1,1022 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// mutex.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a `Mutex` -- a mutually exclusive lock -- and the
+// most common type of synchronization primitive for facilitating locks on
+// shared resources. A mutex is used to prevent multiple threads from accessing
+// and/or writing to a shared resource concurrently.
+//
+// Unlike a `std::mutex`, the Abseil `Mutex` provides the following additional
+// features:
+// * Conditional predicates intrinsic to the `Mutex` object
+// * Reader/writer locks, in addition to standard exclusive/writer locks
+// * Deadlock detection and debug support.
+//
+// The following helper classes are also defined within this file:
+//
+// MutexLock - An RAII wrapper to acquire and release a `Mutex` for exclusive/
+// write access within the current scope.
+// ReaderMutexLock
+// - An RAII wrapper to acquire and release a `Mutex` for shared/read
+// access within the current scope.
+//
+// WriterMutexLock
+// - Alias for `MutexLock` above, designed for use in distinguishing
+// reader and writer locks within code.
+//
+// In addition to simple mutex locks, this file also defines ways to perform
+// locking under certain conditions.
+//
+// Condition - (Preferred) Used to wait for a particular predicate that
+// depends on state protected by the `Mutex` to become true.
+// CondVar - A lower-level variant of `Condition` that relies on
+// application code to explicitly signal the `CondVar` when
+// a condition has been met.
+//
+// See below for more information on using `Condition` or `CondVar`.
+//
+// Mutexes and mutex behavior can be quite complicated. The information within
+// this header file is limited, as a result. Please consult the Mutex guide for
+// more complete information and examples.
+
+#ifndef ABSL_SYNCHRONIZATION_MUTEX_H_
+#define ABSL_SYNCHRONIZATION_MUTEX_H_
+
+#include <atomic>
+#include <cstdint>
+#include <string>
+
+#include "absl/base/internal/identity.h"
+#include "absl/base/internal/low_level_alloc.h"
+#include "absl/base/internal/thread_identity.h"
+#include "absl/base/internal/tsan_mutex_interface.h"
+#include "absl/base/port.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/internal/kernel_timeout.h"
+#include "absl/synchronization/internal/per_thread_sem.h"
+#include "absl/time/time.h"
+
+// Decide if we should use the non-production implementation because
+// the production implementation hasn't been fully ported yet.
+#ifdef ABSL_INTERNAL_USE_NONPROD_MUTEX
+#error ABSL_INTERNAL_USE_NONPROD_MUTEX cannot be directly set
+#elif defined(ABSL_LOW_LEVEL_ALLOC_MISSING)
+#define ABSL_INTERNAL_USE_NONPROD_MUTEX 1
+#include "absl/synchronization/internal/mutex_nonprod.inc"
+#endif
+
+namespace absl {
+
+class Condition;
+struct SynchWaitParams;
+
+// -----------------------------------------------------------------------------
+// Mutex
+// -----------------------------------------------------------------------------
+//
+// A `Mutex` is a non-reentrant (aka non-recursive) Mutually Exclusive lock
+// on some resource, typically a variable or data structure with associated
+// invariants. Proper usage of mutexes prevents concurrent access by different
+// threads to the same resource.
+//
+// A `Mutex` has two basic operations: `Mutex::Lock()` and `Mutex::Unlock()`.
+// The `Lock()` operation *acquires* a `Mutex` (in a state known as an
+// *exclusive* -- or write -- lock), while the `Unlock()` operation *releases* a
+// Mutex. During the span of time between the Lock() and Unlock() operations,
+// a mutex is said to be *held*. By design all mutexes support exclusive/write
+// locks, as this is the most common way to use a mutex.
+//
+// The `Mutex` state machine for basic lock/unlock operations is quite simple:
+//
+// | | Lock() | Unlock() |
+// |----------------+------------+----------|
+// | Free | Exclusive | invalid |
+// | Exclusive | blocks | Free |
+//
+// Attempts to `Unlock()` must originate from the thread that performed the
+// corresponding `Lock()` operation.
+//
+// An "invalid" operation is disallowed by the API. The `Mutex` implementation
+// is allowed to do anything on an invalid call, including but not limited to
+// crashing with a useful error message, silently succeeding, or corrupting
+// data structures. In debug mode, the implementation attempts to crash with a
+// useful error message.
+//
+// `Mutex` is not guaranteed to be "fair" in prioritizing waiting threads; it
+// is, however, approximately fair over long periods, and starvation-free for
+// threads at the same priority.
+//
+// The lock/unlock primitives are now annotated with lock annotations
+// defined in (base/thread_annotations.h). When writing multi-threaded code,
+// you should use lock annotations whenever possible to document your lock
+// synchronization policy. Besides acting as documentation, these annotations
+// also help compilers or static analysis tools to identify and warn about
+// issues that could potentially result in race conditions and deadlocks.
+//
+// For more information about the lock annotations, please see
+// [Thread Safety Analysis](http://clang.llvm.org/docs/ThreadSafetyAnalysis.html)
+// in the Clang documentation.
+//
+// See also `MutexLock`, below, for scoped `Mutex` acquisition.
+
+class LOCKABLE Mutex {
+ public:
+ Mutex();
+ ~Mutex();
+
+ // Mutex::Lock()
+ //
+ // Blocks the calling thread, if necessary, until this `Mutex` is free, and
+ // then acquires it exclusively. (This lock is also known as a "write lock.")
+ void Lock() EXCLUSIVE_LOCK_FUNCTION();
+
+ // Mutex::Unlock()
+ //
+ // Releases this `Mutex` and returns it from the exclusive/write state to the
+ // free state. Caller must hold the `Mutex` exclusively.
+ void Unlock() UNLOCK_FUNCTION();
+
+ // Mutex::TryLock()
+ //
+ // If the mutex can be acquired without blocking, does so exclusively and
+ // returns `true`. Otherwise, returns `false`. Returns `true` with high
+ // probability if the `Mutex` was free.
+ bool TryLock() EXCLUSIVE_TRYLOCK_FUNCTION(true);
+
+ // Mutex::AssertHeld()
+ //
+ // Return immediately if this thread holds the `Mutex` exclusively (in write
+ // mode). Otherwise, may report an error (typically by crashing with a
+ // diagnostic), or may return immediately.
+ void AssertHeld() const ASSERT_EXCLUSIVE_LOCK();
+
+ // ---------------------------------------------------------------------------
+ // Reader-Writer Locking
+ // ---------------------------------------------------------------------------
+
+ // A Mutex can also be used as a starvation-free reader-writer lock.
+ // Neither read-locks nor write-locks are reentrant/recursive to avoid
+ // potential client programming errors.
+ //
+ // The Mutex API provides `Writer*()` aliases for the existing `Lock()`,
+ // `Unlock()` and `TryLock()` methods for use within applications mixing
+ // reader/writer locks. Using `Reader*()` and `Writer*()` operations in this
+ // manner can make locking behavior clearer when mixing read and write modes.
+ //
+ // Introducing reader locks necessarily complicates the `Mutex` state
+ // machine somewhat. The table below illustrates the allowed state transitions
+ // of a mutex in such cases. Note that ReaderLock() may block even if the lock
+ // is held in shared mode; this occurs when another thread is blocked on a
+ // call to WriterLock().
+ //
+ // ---------------------------------------------------------------------------
+ // Operation: WriterLock() Unlock() ReaderLock() ReaderUnlock()
+ // ---------------------------------------------------------------------------
+ // State
+ // ---------------------------------------------------------------------------
+ // Free Exclusive invalid Shared(1) invalid
+ // Shared(1) blocks invalid Shared(2) or blocks Free
+ // Shared(n) n>1 blocks invalid Shared(n+1) or blocks Shared(n-1)
+ // Exclusive blocks Free blocks invalid
+ // ---------------------------------------------------------------------------
+ //
+ // In comments below, "shared" refers to a state of Shared(n) for any n > 0.
+
+ // Mutex::ReaderLock()
+ //
+ // Blocks the calling thread, if necessary, until this `Mutex` is either free,
+ // or in shared mode, and then acquires a share of it. Note that
+ // `ReaderLock()` will block if some other thread has an exclusive/writer lock
+ // on the mutex.
+
+ void ReaderLock() SHARED_LOCK_FUNCTION();
+
+ // Mutex::ReaderUnlock()
+ //
+ // Releases a read share of this `Mutex`. `ReaderUnlock` may return a mutex to
+ // the free state if this thread holds the last reader lock on the mutex. Note
+ // that you cannot call `ReaderUnlock()` on a mutex held in write mode.
+ void ReaderUnlock() UNLOCK_FUNCTION();
+
+ // Mutex::ReaderTryLock()
+ //
+ // If the mutex can be acquired without blocking, acquires this mutex for
+ // shared access and returns `true`. Otherwise, returns `false`. Returns
+ // `true` with high probability if the `Mutex` was free or shared.
+ bool ReaderTryLock() SHARED_TRYLOCK_FUNCTION(true);
+
+ // Mutex::AssertReaderHeld()
+ //
+ // Returns immediately if this thread holds the `Mutex` in at least shared
+ // mode (read mode). Otherwise, may report an error (typically by
+ // crashing with a diagnostic), or may return immediately.
+ void AssertReaderHeld() const ASSERT_SHARED_LOCK();
+
+ // Mutex::WriterLock()
+ // Mutex::WriterUnlock()
+ // Mutex::WriterTryLock()
+ //
+ // Aliases for `Mutex::Lock()`, `Mutex::Unlock()`, and `Mutex::TryLock()`.
+ //
+ // These methods may be used (along with the complementary `Reader*()`
+ // methods) to distingish simple exclusive `Mutex` usage (`Lock()`,
+ // etc.) from reader/writer lock usage.
+ void WriterLock() EXCLUSIVE_LOCK_FUNCTION() { this->Lock(); }
+
+ void WriterUnlock() UNLOCK_FUNCTION() { this->Unlock(); }
+
+ bool WriterTryLock() EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+ return this->TryLock();
+ }
+
+ // ---------------------------------------------------------------------------
+ // Conditional Critical Regions
+ // ---------------------------------------------------------------------------
+
+ // Conditional usage of a `Mutex` can occur using two distinct paradigms:
+ //
+ // * Use of `Mutex` member functions with `Condition` objects.
+ // * Use of the separate `CondVar` abstraction.
+ //
+ // In general, prefer use of `Condition` and the `Mutex` member functions
+ // listed below over `CondVar`. When there are multiple threads waiting on
+ // distinctly different conditions, however, a battery of `CondVar`s may be
+ // more efficient. This section discusses use of `Condition` objects.
+ //
+ // `Mutex` contains member functions for performing lock operations only under
+ // certain conditions, of class `Condition`. For correctness, the `Condition`
+ // must return a boolean that is a pure function, only of state protected by
+ // the `Mutex`. The condition must be invariant w.r.t. environmental state
+ // such as thread, cpu id, or time, and must be `noexcept`. The condition will
+ // always be invoked with the mutex held in at least read mode, so you should
+ // not block it for long periods or sleep it on a timer.
+ //
+ // Since a condition must not depend directly on the current time, use
+ // `*WithTimeout()` member function variants to make your condition
+ // effectively true after a given duration, or `*WithDeadline()` variants to
+ // make your condition effectively true after a given time.
+ //
+ // The condition function should have no side-effects aside from debug
+ // logging; as a special exception, the function may acquire other mutexes
+ // provided it releases all those that it acquires. (This exception was
+ // required to allow logging.)
+
+ // Mutex::Await()
+ //
+ // Unlocks this `Mutex` and blocks until simultaneously both `cond` is `true`
+ // and this `Mutex` can be reacquired, then reacquires this `Mutex` in the
+ // same mode in which it was previously held. If the condition is initially
+ // `true`, `Await()` *may* skip the release/re-acquire step.
+ //
+ // `Await()` requires that this thread holds this `Mutex` in some mode.
+ void Await(const Condition &cond);
+
+ // Mutex::LockWhen()
+ // Mutex::ReaderLockWhen()
+ // Mutex::WriterLockWhen()
+ //
+ // Blocks until simultaneously both `cond` is `true` and this` Mutex` can
+ // be acquired, then atomically acquires this `Mutex`. `LockWhen()` is
+ // logically equivalent to `*Lock(); Await();` though they may have different
+ // performance characteristics.
+ void LockWhen(const Condition &cond) EXCLUSIVE_LOCK_FUNCTION();
+
+ void ReaderLockWhen(const Condition &cond) SHARED_LOCK_FUNCTION();
+
+ void WriterLockWhen(const Condition &cond) EXCLUSIVE_LOCK_FUNCTION() {
+ this->LockWhen(cond);
+ }
+
+ // ---------------------------------------------------------------------------
+ // Mutex Variants with Timeouts/Deadlines
+ // ---------------------------------------------------------------------------
+
+ // Mutex::AwaitWithTimeout()
+ // Mutex::AwaitWithDeadline()
+ //
+ // If `cond` is initially true, do nothing, or act as though `cond` is
+ // initially false.
+ //
+ // If `cond` is initially false, unlock this `Mutex` and block until
+ // simultaneously:
+ // - either `cond` is true or the {timeout has expired, deadline has passed}
+ // and
+ // - this `Mutex` can be reacquired,
+ // then reacquire this `Mutex` in the same mode in which it was previously
+ // held, returning `true` iff `cond` is `true` on return.
+ //
+ // Deadlines in the past are equivalent to an immediate deadline.
+ // Negative timeouts are equivalent to a zero timeout.
+ //
+ // This method requires that this thread holds this `Mutex` in some mode.
+ bool AwaitWithTimeout(const Condition &cond, absl::Duration timeout);
+
+ bool AwaitWithDeadline(const Condition &cond, absl::Time deadline);
+
+ // Mutex::LockWhenWithTimeout()
+ // Mutex::ReaderLockWhenWithTimeout()
+ // Mutex::WriterLockWhenWithTimeout()
+ //
+ // Blocks until simultaneously both:
+ // - either `cond` is `true` or the timeout has expired, and
+ // - this `Mutex` can be acquired,
+ // then atomically acquires this `Mutex`, returning `true` iff `cond` is
+ // `true` on return.
+ //
+ // Negative timeouts are equivalent to a zero timeout.
+ bool LockWhenWithTimeout(const Condition &cond, absl::Duration timeout)
+ EXCLUSIVE_LOCK_FUNCTION();
+ bool ReaderLockWhenWithTimeout(const Condition &cond, absl::Duration timeout)
+ SHARED_LOCK_FUNCTION();
+ bool WriterLockWhenWithTimeout(const Condition &cond, absl::Duration timeout)
+ EXCLUSIVE_LOCK_FUNCTION() {
+ return this->LockWhenWithTimeout(cond, timeout);
+ }
+
+ // Mutex::LockWhenWithDeadline()
+ // Mutex::ReaderLockWhenWithDeadline()
+ // Mutex::WriterLockWhenWithDeadline()
+ //
+ // Blocks until simultaneously both:
+ // - either `cond` is `true` or the deadline has been passed, and
+ // - this `Mutex` can be acquired,
+ // then atomically acquires this Mutex, returning `true` iff `cond` is `true`
+ // on return.
+ //
+ // Deadlines in the past are equivalent to an immediate deadline.
+ bool LockWhenWithDeadline(const Condition &cond, absl::Time deadline)
+ EXCLUSIVE_LOCK_FUNCTION();
+ bool ReaderLockWhenWithDeadline(const Condition &cond, absl::Time deadline)
+ SHARED_LOCK_FUNCTION();
+ bool WriterLockWhenWithDeadline(const Condition &cond, absl::Time deadline)
+ EXCLUSIVE_LOCK_FUNCTION() {
+ return this->LockWhenWithDeadline(cond, deadline);
+ }
+
+ // ---------------------------------------------------------------------------
+ // Debug Support: Invariant Checking, Deadlock Detection, Logging.
+ // ---------------------------------------------------------------------------
+
+ // Mutex::EnableInvariantDebugging()
+ //
+ // If `invariant`!=null and if invariant debugging has been enabled globally,
+ // cause `(*invariant)(arg)` to be called at moments when the invariant for
+ // this `Mutex` should hold (for example: just after acquire, just before
+ // release).
+ //
+ // The routine `invariant` should have no side-effects since it is not
+ // guaranteed how many times it will be called; it should check the invariant
+ // and crash if it does not hold. Enabling global invariant debugging may
+ // substantially reduce `Mutex` performance; it should be set only for
+ // non-production runs. Optimization options may also disable invariant
+ // checks.
+ void EnableInvariantDebugging(void (*invariant)(void *), void *arg);
+
+ // Mutex::EnableDebugLog()
+ //
+ // Cause all subsequent uses of this `Mutex` to be logged via
+ // `ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if no previous
+ // call to `EnableInvariantDebugging()` or `EnableDebugLog()` has been made.
+ //
+ // Note: This method substantially reduces `Mutex` performance.
+ void EnableDebugLog(const char *name);
+
+ // Deadlock detection
+
+ // Mutex::ForgetDeadlockInfo()
+ //
+ // Forget any deadlock-detection information previously gathered
+ // about this `Mutex`. Call this method in debug mode when the lock ordering
+ // of a `Mutex` changes.
+ void ForgetDeadlockInfo();
+
+ // Mutex::AssertNotHeld()
+ //
+ // Return immediately if this thread does not hold this `Mutex` in any
+ // mode; otherwise, may report an error (typically by crashing with a
+ // diagnostic), or may return immediately.
+ //
+ // Currently this check is performed only if all of:
+ // - in debug mode
+ // - SetMutexDeadlockDetectionMode() has been set to kReport or kAbort
+ // - number of locks concurrently held by this thread is not large.
+ // are true.
+ void AssertNotHeld() const;
+
+ // Special cases.
+
+ // A `MuHow` is a constant that indicates how a lock should be acquired.
+ // Internal implementation detail. Clients should ignore.
+ typedef const struct MuHowS *MuHow;
+
+ // Mutex::InternalAttemptToUseMutexInFatalSignalHandler()
+ //
+ // Causes the `Mutex` implementation to prepare itself for re-entry caused by
+ // future use of `Mutex` within a fatal signal handler. This method is
+ // intended for use only for last-ditch attempts to log crash information.
+ // It does not guarantee that attempts to use Mutexes within the handler will
+ // not deadlock; it merely makes other faults less likely.
+ //
+ // WARNING: This routine must be invoked from a signal handler, and the
+ // signal handler must either loop forever or terminate the process.
+ // Attempts to return from (or `longjmp` out of) the signal handler once this
+ // call has been made may cause arbitrary program behaviour including
+ // crashes and deadlocks.
+ static void InternalAttemptToUseMutexInFatalSignalHandler();
+
+ private:
+#ifdef ABSL_INTERNAL_USE_NONPROD_MUTEX
+ friend class CondVar;
+
+ synchronization_internal::MutexImpl *impl() { return impl_.get(); }
+
+ synchronization_internal::SynchronizationStorage<
+ synchronization_internal::MutexImpl>
+ impl_;
+#else
+ std::atomic<intptr_t> mu_; // The Mutex state.
+
+ // Post()/Wait() versus associated PerThreadSem; in class for required
+ // friendship with PerThreadSem.
+ static inline void IncrementSynchSem(Mutex *mu,
+ base_internal::PerThreadSynch *w);
+ static inline bool DecrementSynchSem(
+ Mutex *mu, base_internal::PerThreadSynch *w,
+ synchronization_internal::KernelTimeout t);
+
+ // slow path acquire
+ void LockSlowLoop(SynchWaitParams *waitp, int flags);
+ // wrappers around LockSlowLoop()
+ bool LockSlowWithDeadline(MuHow how, const Condition *cond,
+ synchronization_internal::KernelTimeout t,
+ int flags);
+ void LockSlow(MuHow how, const Condition *cond,
+ int flags) ABSL_ATTRIBUTE_COLD;
+ // slow path release
+ void UnlockSlow(SynchWaitParams *waitp) ABSL_ATTRIBUTE_COLD;
+ // Common code between Await() and AwaitWithTimeout/Deadline()
+ bool AwaitCommon(const Condition &cond,
+ synchronization_internal::KernelTimeout t);
+ // Attempt to remove thread s from queue.
+ void TryRemove(base_internal::PerThreadSynch *s);
+ // Block a thread on mutex.
+ void Block(base_internal::PerThreadSynch *s);
+ // Wake a thread; return successor.
+ base_internal::PerThreadSynch *Wakeup(base_internal::PerThreadSynch *w);
+
+ friend class CondVar; // for access to Trans()/Fer().
+ void Trans(MuHow how); // used for CondVar->Mutex transfer
+ void Fer(
+ base_internal::PerThreadSynch *w); // used for CondVar->Mutex transfer
+#endif
+
+ // Catch the error of writing Mutex when intending MutexLock.
+ Mutex(const volatile Mutex * /*ignored*/) {} // NOLINT(runtime/explicit)
+
+ Mutex(const Mutex&) = delete;
+ Mutex& operator=(const Mutex&) = delete;
+};
+
+// -----------------------------------------------------------------------------
+// Mutex RAII Wrappers
+// -----------------------------------------------------------------------------
+
+// MutexLock
+//
+// `MutexLock` is a helper class, which acquires and releases a `Mutex` via
+// RAII.
+//
+// Example:
+//
+// Class Foo {
+//
+// Foo::Bar* Baz() {
+// MutexLock l(&lock_);
+// ...
+// return bar;
+// }
+//
+// private:
+// Mutex lock_;
+// };
+class SCOPED_LOCKABLE MutexLock {
+ public:
+ explicit MutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu) : mu_(mu) {
+ this->mu_->Lock();
+ }
+
+ MutexLock(const MutexLock &) = delete; // NOLINT(runtime/mutex)
+ MutexLock(MutexLock&&) = delete; // NOLINT(runtime/mutex)
+ MutexLock& operator=(const MutexLock&) = delete;
+ MutexLock& operator=(MutexLock&&) = delete;
+
+ ~MutexLock() UNLOCK_FUNCTION() { this->mu_->Unlock(); }
+
+ private:
+ Mutex *const mu_;
+};
+
+// ReaderMutexLock
+//
+// The `ReaderMutexLock` is a helper class, like `MutexLock`, which acquires and
+// releases a shared lock on a `Mutex` via RAII.
+class SCOPED_LOCKABLE ReaderMutexLock {
+ public:
+ explicit ReaderMutexLock(Mutex *mu) SHARED_LOCK_FUNCTION(mu)
+ : mu_(mu) {
+ mu->ReaderLock();
+ }
+
+ ReaderMutexLock(const ReaderMutexLock&) = delete;
+ ReaderMutexLock(ReaderMutexLock&&) = delete;
+ ReaderMutexLock& operator=(const ReaderMutexLock&) = delete;
+ ReaderMutexLock& operator=(ReaderMutexLock&&) = delete;
+
+ ~ReaderMutexLock() UNLOCK_FUNCTION() {
+ this->mu_->ReaderUnlock();
+ }
+
+ private:
+ Mutex *const mu_;
+};
+
+// WriterMutexLock
+//
+// The `WriterMutexLock` is a helper class, like `MutexLock`, which acquires and
+// releases a write (exclusive) lock on a `Mutex` va RAII.
+class SCOPED_LOCKABLE WriterMutexLock {
+ public:
+ explicit WriterMutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu)
+ : mu_(mu) {
+ mu->WriterLock();
+ }
+
+ WriterMutexLock(const WriterMutexLock&) = delete;
+ WriterMutexLock(WriterMutexLock&&) = delete;
+ WriterMutexLock& operator=(const WriterMutexLock&) = delete;
+ WriterMutexLock& operator=(WriterMutexLock&&) = delete;
+
+ ~WriterMutexLock() UNLOCK_FUNCTION() {
+ this->mu_->WriterUnlock();
+ }
+
+ private:
+ Mutex *const mu_;
+};
+
+// -----------------------------------------------------------------------------
+// Condition
+// -----------------------------------------------------------------------------
+//
+// As noted above, `Mutex` contains a number of member functions which take a
+// `Condition` as a argument; clients can wait for conditions to become `true`
+// before attempting to acquire the mutex. These sections are known as
+// "condition critical" sections. To use a `Condition`, you simply need to
+// construct it, and use within an appropriate `Mutex` member function;
+// everything else in the `Condition` class is an implementation detail.
+//
+// A `Condition` is specified as a function pointer which returns a boolean.
+// `Condition` functions should be pure functions -- their results should depend
+// only on passed arguments, should not consult any external state (such as
+// clocks), and should have no side-effects, aside from debug logging. Any
+// objects that the function may access should be limited to those which are
+// constant while the mutex is blocked on the condition (e.g. a stack variable),
+// or objects of state protected explicitly by the mutex.
+//
+// No matter which construction is used for `Condition`, the underlying
+// function pointer / functor / callable must not throw any
+// exceptions. Correctness of `Mutex` / `Condition` is not guaranteed in
+// the face of a throwing `Condition`. (When Abseil is allowed to depend
+// on C++17, these function pointers will be explicitly marked
+// `noexcept`; until then this requirement cannot be enforced in the
+// type system.)
+//
+// Note: to use a `Condition`, you need only construct it and pass it within the
+// appropriate `Mutex' member function, such as `Mutex::Await()`.
+//
+// Example:
+//
+// // assume count_ is not internal reference count
+// int count_ GUARDED_BY(mu_);
+//
+// mu_.LockWhen(Condition(+[](int* count) { return *count == 0; },
+// &count_));
+//
+// When multiple threads are waiting on exactly the same condition, make sure
+// that they are constructed with the same parameters (same pointer to function
+// + arg, or same pointer to object + method), so that the mutex implementation
+// can avoid redundantly evaluating the same condition for each thread.
+class Condition {
+ public:
+ // A Condition that returns the result of "(*func)(arg)"
+ Condition(bool (*func)(void *), void *arg);
+
+ // Templated version for people who are averse to casts.
+ //
+ // To use a lambda, prepend it with unary plus, which converts the lambda
+ // into a function pointer:
+ // Condition(+[](T* t) { return ...; }, arg).
+ //
+ // Note: lambdas in this case must contain no bound variables.
+ //
+ // See class comment for performance advice.
+ template<typename T>
+ Condition(bool (*func)(T *), T *arg);
+
+ // Templated version for invoking a method that returns a `bool`.
+ //
+ // `Condition(object, &Class::Method)` constructs a `Condition` that evaluates
+ // `object->Method()`.
+ //
+ // Implementation Note: `absl::internal::identity` is used to allow methods to
+ // come from base classes. A simpler signature like
+ // `Condition(T*, bool (T::*)())` does not suffice.
+ template<typename T>
+ Condition(T *object, bool (absl::internal::identity<T>::type::* method)());
+
+ // Same as above, for const members
+ template<typename T>
+ Condition(const T *object,
+ bool (absl::internal::identity<T>::type::* method)() const);
+
+ // A Condition that returns the value of `*cond`
+ explicit Condition(const bool *cond);
+
+ // Templated version for invoking a functor that returns a `bool`.
+ // This approach accepts pointers to non-mutable lambdas, `std::function`,
+ // the result of` std::bind` and user-defined functors that define
+ // `bool F::operator()() const`.
+ //
+ // Example:
+ //
+ // auto reached = [this, current]() {
+ // mu_.AssertReaderHeld(); // For annotalysis.
+ // return processed_ >= current;
+ // };
+ // mu_.Await(Condition(&reached));
+
+ // See class comment for performance advice. In particular, if there
+ // might be more than one waiter for the same condition, make sure
+ // that all waiters construct the condition with the same pointers.
+
+ // Implementation note: The second template parameter ensures that this
+ // constructor doesn't participate in overload resolution if T doesn't have
+ // `bool operator() const`.
+ template <typename T, typename E = decltype(
+ static_cast<bool (T::*)() const>(&T::operator()))>
+ explicit Condition(const T *obj)
+ : Condition(obj, static_cast<bool (T::*)() const>(&T::operator())) {}
+
+ // A Condition that always returns `true`.
+ static const Condition kTrue;
+
+ // Evaluates the condition.
+ bool Eval() const;
+
+ // Returns `true` if the two conditions are guaranteed to return the same
+ // value if evaluated at the same time, `false` if the evaluation *may* return
+ // different results.
+ //
+ // Two `Condition` values are guaranteed equal if both their `func` and `arg`
+ // components are the same. A null pointer is equivalent to a `true`
+ // condition.
+ static bool GuaranteedEqual(const Condition *a, const Condition *b);
+
+ private:
+ typedef bool (*InternalFunctionType)(void * arg);
+ typedef bool (Condition::*InternalMethodType)();
+ typedef bool (*InternalMethodCallerType)(void * arg,
+ InternalMethodType internal_method);
+
+ bool (*eval_)(const Condition*); // Actual evaluator
+ InternalFunctionType function_; // function taking pointer returning bool
+ InternalMethodType method_; // method returning bool
+ void *arg_; // arg of function_ or object of method_
+
+ Condition(); // null constructor used only to create kTrue
+
+ // Various functions eval_ can point to:
+ static bool CallVoidPtrFunction(const Condition*);
+ template <typename T> static bool CastAndCallFunction(const Condition* c);
+ template <typename T> static bool CastAndCallMethod(const Condition* c);
+};
+
+// -----------------------------------------------------------------------------
+// CondVar
+// -----------------------------------------------------------------------------
+//
+// A condition variable, reflecting state evaluated separately outside of the
+// `Mutex` object, which can be signaled to wake callers.
+// This class is not normally needed; use `Mutex` member functions such as
+// `Mutex::Await()` and intrinsic `Condition` abstractions. In rare cases
+// with many threads and many conditions, `CondVar` may be faster.
+//
+// The implementation may deliver signals to any condition variable at
+// any time, even when no call to `Signal()` or `SignalAll()` is made; as a
+// result, upon being awoken, you must check the logical condition you have
+// been waiting upon.
+//
+// Examples:
+//
+// Usage for a thread waiting for some condition C protected by mutex mu:
+// mu.Lock();
+// while (!C) { cv->Wait(&mu); } // releases and reacquires mu
+// // C holds; process data
+// mu.Unlock();
+//
+// Usage to wake T is:
+// mu.Lock();
+// // process data, possibly establishing C
+// if (C) { cv->Signal(); }
+// mu.Unlock();
+//
+// If C may be useful to more than one waiter, use `SignalAll()` instead of
+// `Signal()`.
+//
+// With this implementation it is efficient to use `Signal()/SignalAll()` inside
+// the locked region; this usage can make reasoning about your program easier.
+//
+class CondVar {
+ public:
+ CondVar();
+ ~CondVar();
+
+ // CondVar::Wait()
+ //
+ // Atomically releases a `Mutex` and blocks on this condition variable.
+ // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
+ // spurious wakeup), then reacquires the `Mutex` and returns.
+ //
+ // Requires and ensures that the current thread holds the `Mutex`.
+ void Wait(Mutex *mu);
+
+ // CondVar::WaitWithTimeout()
+ //
+ // Atomically releases a `Mutex` and blocks on this condition variable.
+ // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
+ // spurious wakeup), or until the timeout has expired, then reacquires
+ // the `Mutex` and returns.
+ //
+ // Returns true if the timeout has expired without this `CondVar`
+ // being signalled in any manner. If both the timeout has expired
+ // and this `CondVar` has been signalled, the implementation is free
+ // to return `true` or `false`.
+ //
+ // Requires and ensures that the current thread holds the `Mutex`.
+ bool WaitWithTimeout(Mutex *mu, absl::Duration timeout);
+
+ // CondVar::WaitWithDeadline()
+ //
+ // Atomically releases a `Mutex` and blocks on this condition variable.
+ // Waits until awakened by a call to `Signal()` or `SignalAll()` (or a
+ // spurious wakeup), or until the deadline has passed, then reacquires
+ // the `Mutex` and returns.
+ //
+ // Deadlines in the past are equivalent to an immediate deadline.
+ //
+ // Returns true if the deadline has passed without this `CondVar`
+ // being signalled in any manner. If both the deadline has passed
+ // and this `CondVar` has been signalled, the implementation is free
+ // to return `true` or `false`.
+ //
+ // Requires and ensures that the current thread holds the `Mutex`.
+ bool WaitWithDeadline(Mutex *mu, absl::Time deadline);
+
+ // CondVar::Signal()
+ //
+ // Signal this `CondVar`; wake at least one waiter if one exists.
+ void Signal();
+
+ // CondVar::SignalAll()
+ //
+ // Signal this `CondVar`; wake all waiters.
+ void SignalAll();
+
+ // CondVar::EnableDebugLog()
+ //
+ // Causes all subsequent uses of this `CondVar` to be logged via
+ // `ABSL_RAW_LOG(INFO)`. Log entries are tagged with `name` if `name != 0`.
+ // Note: this method substantially reduces `CondVar` performance.
+ void EnableDebugLog(const char *name);
+
+ private:
+#ifdef ABSL_INTERNAL_USE_NONPROD_MUTEX
+ synchronization_internal::CondVarImpl *impl() { return impl_.get(); }
+ synchronization_internal::SynchronizationStorage<
+ synchronization_internal::CondVarImpl>
+ impl_;
+#else
+ bool WaitCommon(Mutex *mutex, synchronization_internal::KernelTimeout t);
+ void Remove(base_internal::PerThreadSynch *s);
+ void Wakeup(base_internal::PerThreadSynch *w);
+ std::atomic<intptr_t> cv_; // Condition variable state.
+#endif
+ CondVar(const CondVar&) = delete;
+ CondVar& operator=(const CondVar&) = delete;
+};
+
+
+// Variants of MutexLock.
+//
+// If you find yourself using one of these, consider instead using
+// Mutex::Unlock() and/or if-statements for clarity.
+
+// MutexLockMaybe
+//
+// MutexLockMaybe is like MutexLock, but is a no-op when mu is null.
+class SCOPED_LOCKABLE MutexLockMaybe {
+ public:
+ explicit MutexLockMaybe(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu)
+ : mu_(mu) { if (this->mu_ != nullptr) { this->mu_->Lock(); } }
+ ~MutexLockMaybe() UNLOCK_FUNCTION() {
+ if (this->mu_ != nullptr) { this->mu_->Unlock(); }
+ }
+ private:
+ Mutex *const mu_;
+ MutexLockMaybe(const MutexLockMaybe&) = delete;
+ MutexLockMaybe(MutexLockMaybe&&) = delete;
+ MutexLockMaybe& operator=(const MutexLockMaybe&) = delete;
+ MutexLockMaybe& operator=(MutexLockMaybe&&) = delete;
+};
+
+// ReleaseableMutexLock
+//
+// ReleasableMutexLock is like MutexLock, but permits `Release()` of its
+// mutex before destruction. `Release()` may be called at most once.
+class SCOPED_LOCKABLE ReleasableMutexLock {
+ public:
+ explicit ReleasableMutexLock(Mutex *mu) EXCLUSIVE_LOCK_FUNCTION(mu)
+ : mu_(mu) {
+ this->mu_->Lock();
+ }
+ ~ReleasableMutexLock() UNLOCK_FUNCTION() {
+ if (this->mu_ != nullptr) { this->mu_->Unlock(); }
+ }
+
+ void Release() UNLOCK_FUNCTION();
+
+ private:
+ Mutex *mu_;
+ ReleasableMutexLock(const ReleasableMutexLock&) = delete;
+ ReleasableMutexLock(ReleasableMutexLock&&) = delete;
+ ReleasableMutexLock& operator=(const ReleasableMutexLock&) = delete;
+ ReleasableMutexLock& operator=(ReleasableMutexLock&&) = delete;
+};
+
+#ifdef ABSL_INTERNAL_USE_NONPROD_MUTEX
+#else
+inline Mutex::Mutex() : mu_(0) {
+ ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
+}
+
+inline CondVar::CondVar() : cv_(0) {}
+#endif
+
+// static
+template <typename T>
+bool Condition::CastAndCallMethod(const Condition *c) {
+ typedef bool (T::*MemberType)();
+ MemberType rm = reinterpret_cast<MemberType>(c->method_);
+ T *x = static_cast<T *>(c->arg_);
+ return (x->*rm)();
+}
+
+// static
+template <typename T>
+bool Condition::CastAndCallFunction(const Condition *c) {
+ typedef bool (*FuncType)(T *);
+ FuncType fn = reinterpret_cast<FuncType>(c->function_);
+ T *x = static_cast<T *>(c->arg_);
+ return (*fn)(x);
+}
+
+template <typename T>
+inline Condition::Condition(bool (*func)(T *), T *arg)
+ : eval_(&CastAndCallFunction<T>),
+ function_(reinterpret_cast<InternalFunctionType>(func)),
+ method_(nullptr),
+ arg_(const_cast<void *>(static_cast<const void *>(arg))) {}
+
+template <typename T>
+inline Condition::Condition(T *object,
+ bool (absl::internal::identity<T>::type::*method)())
+ : eval_(&CastAndCallMethod<T>),
+ function_(nullptr),
+ method_(reinterpret_cast<InternalMethodType>(method)),
+ arg_(object) {}
+
+template <typename T>
+inline Condition::Condition(const T *object,
+ bool (absl::internal::identity<T>::type::*method)()
+ const)
+ : eval_(&CastAndCallMethod<T>),
+ function_(nullptr),
+ method_(reinterpret_cast<InternalMethodType>(method)),
+ arg_(reinterpret_cast<void *>(const_cast<T *>(object))) {}
+
+// Register a hook for profiling support.
+//
+// The function pointer registered here will be called whenever a mutex is
+// contended. The callback is given the absl/base/cycleclock.h timestamp when
+// waiting began.
+//
+// Calls to this function do not race or block, but there is no ordering
+// guaranteed between calls to this function and call to the provided hook.
+// In particular, the previously registered hook may still be called for some
+// time after this function returns.
+void RegisterMutexProfiler(void (*fn)(int64_t wait_timestamp));
+
+// Register a hook for Mutex tracing.
+//
+// The function pointer registered here will be called whenever a mutex is
+// contended. The callback is given an opaque handle to the contended mutex,
+// an event name, and the number of wait cycles (as measured by
+// //absl/base/internal/cycleclock.h, and which may not be real
+// "cycle" counts.)
+//
+// The only event name currently sent is "slow release".
+//
+// This has the same memory ordering concerns as RegisterMutexProfiler() above.
+void RegisterMutexTracer(void (*fn)(const char *msg, const void *obj,
+ int64_t wait_cycles));
+
+// TODO(gfalcon): Combine RegisterMutexProfiler() and RegisterMutexTracer()
+// into a single interface, since they are only ever called in pairs.
+
+// Register a hook for CondVar tracing.
+//
+// The function pointer registered here will be called here on various CondVar
+// events. The callback is given an opaque handle to the CondVar object and
+// a std::string identifying the event. This is thread-safe, but only a single
+// tracer can be registered.
+//
+// Events that can be sent are "Wait", "Unwait", "Signal wakeup", and
+// "SignalAll wakeup".
+//
+// This has the same memory ordering concerns as RegisterMutexProfiler() above.
+void RegisterCondVarTracer(void (*fn)(const char *msg, const void *cv));
+
+// Register a hook for symbolizing stack traces in deadlock detector reports.
+//
+// 'pc' is the program counter being symbolized, 'out' is the buffer to write
+// into, and 'out_size' is the size of the buffer. This function can return
+// false if symbolizing failed, or true if a null-terminated symbol was written
+// to 'out.'
+//
+// This has the same memory ordering concerns as RegisterMutexProfiler() above.
+void RegisterSymbolizer(bool (*fn)(const void *pc, char *out, int out_size));
+
+// EnableMutexInvariantDebugging()
+//
+// Enable or disable global support for Mutex invariant debugging. If enabled,
+// then invariant predicates can be registered per-Mutex for debug checking.
+// See Mutex::EnableInvariantDebugging().
+void EnableMutexInvariantDebugging(bool enabled);
+
+// When in debug mode, and when the feature has been enabled globally, the
+// implementation will keep track of lock ordering and complain (or optionally
+// crash) if a cycle is detected in the acquired-before graph.
+
+// Possible modes of operation for the deadlock detector in debug mode.
+enum class OnDeadlockCycle {
+ kIgnore, // Neither report on nor attempt to track cycles in lock ordering
+ kReport, // Report lock cycles to stderr when detected
+ kAbort, // Report lock cycles to stderr when detected, then abort
+};
+
+// SetMutexDeadlockDetectionMode()
+//
+// Enable or disable global support for detection of potential deadlocks
+// due to Mutex lock ordering inversions. When set to 'kIgnore', tracking of
+// lock ordering is disabled. Otherwise, in debug builds, a lock ordering graph
+// will be maintained internally, and detected cycles will be reported in
+// the manner chosen here.
+void SetMutexDeadlockDetectionMode(OnDeadlockCycle mode);
+
+} // namespace absl
+
+// In some build configurations we pass --detect-odr-violations to the
+// gold linker. This causes it to flag weak symbol overrides as ODR
+// violations. Because ODR only applies to C++ and not C,
+// --detect-odr-violations ignores symbols not mangled with C++ names.
+// By changing our extension points to be extern "C", we dodge this
+// check.
+extern "C" {
+void AbslInternalMutexYield();
+} // extern "C"
+#endif // ABSL_SYNCHRONIZATION_MUTEX_H_
[30/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/str_split_internal.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/str_split_internal.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/str_split_internal.h
new file mode 100644
index 0000000..a1b10f3
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/str_split_internal.h
@@ -0,0 +1,435 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// This file declares INTERNAL parts of the Split API that are inline/templated
+// or otherwise need to be available at compile time. The main abstractions
+// defined in here are
+//
+// - ConvertibleToStringView
+// - SplitIterator<>
+// - Splitter<>
+//
+// DO NOT INCLUDE THIS FILE DIRECTLY. Use this file by including
+// absl/strings/str_split.h.
+//
+// IWYU pragma: private, include "absl/strings/str_split.h"
+
+#ifndef ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
+#define ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
+
+#include <array>
+#include <initializer_list>
+#include <iterator>
+#include <map>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/meta/type_traits.h"
+#include "absl/strings/string_view.h"
+
+#ifdef _GLIBCXX_DEBUG
+#include "absl/strings/internal/stl_type_traits.h"
+#endif // _GLIBCXX_DEBUG
+
+namespace absl {
+namespace strings_internal {
+
+// This class is implicitly constructible from everything that absl::string_view
+// is implicitly constructible from. If it's constructed from a temporary
+// std::string, the data is moved into a data member so its lifetime matches that of
+// the ConvertibleToStringView instance.
+class ConvertibleToStringView {
+ public:
+ ConvertibleToStringView(const char* s) // NOLINT(runtime/explicit)
+ : value_(s) {}
+ ConvertibleToStringView(char* s) : value_(s) {} // NOLINT(runtime/explicit)
+ ConvertibleToStringView(absl::string_view s) // NOLINT(runtime/explicit)
+ : value_(s) {}
+ ConvertibleToStringView(const std::string& s) // NOLINT(runtime/explicit)
+ : value_(s) {}
+
+ // Matches rvalue strings and moves their data to a member.
+ConvertibleToStringView(std::string&& s) // NOLINT(runtime/explicit)
+ : copy_(std::move(s)), value_(copy_) {}
+
+ ConvertibleToStringView(const ConvertibleToStringView& other)
+ : copy_(other.copy_),
+ value_(other.IsSelfReferential() ? copy_ : other.value_) {}
+
+ ConvertibleToStringView(ConvertibleToStringView&& other) {
+ StealMembers(std::move(other));
+ }
+
+ ConvertibleToStringView& operator=(ConvertibleToStringView other) {
+ StealMembers(std::move(other));
+ return *this;
+ }
+
+ absl::string_view value() const { return value_; }
+
+ private:
+ // Returns true if ctsp's value refers to its internal copy_ member.
+ bool IsSelfReferential() const { return value_.data() == copy_.data(); }
+
+ void StealMembers(ConvertibleToStringView&& other) {
+ if (other.IsSelfReferential()) {
+ copy_ = std::move(other.copy_);
+ value_ = copy_;
+ other.value_ = other.copy_;
+ } else {
+ value_ = other.value_;
+ }
+ }
+
+ // Holds the data moved from temporary std::string arguments. Declared first so
+ // that 'value' can refer to 'copy_'.
+ std::string copy_;
+ absl::string_view value_;
+};
+
+// An iterator that enumerates the parts of a std::string from a Splitter. The text
+// to be split, the Delimiter, and the Predicate are all taken from the given
+// Splitter object. Iterators may only be compared if they refer to the same
+// Splitter instance.
+//
+// This class is NOT part of the public splitting API.
+template <typename Splitter>
+class SplitIterator {
+ public:
+ using iterator_category = std::input_iterator_tag;
+ using value_type = absl::string_view;
+ using difference_type = ptrdiff_t;
+ using pointer = const value_type*;
+ using reference = const value_type&;
+
+ enum State { kInitState, kLastState, kEndState };
+ SplitIterator(State state, const Splitter* splitter)
+ : pos_(0),
+ state_(state),
+ splitter_(splitter),
+ delimiter_(splitter->delimiter()),
+ predicate_(splitter->predicate()) {
+ // Hack to maintain backward compatibility. This one block makes it so an
+ // empty absl::string_view whose .data() happens to be nullptr behaves
+ // *differently* from an otherwise empty absl::string_view whose .data() is
+ // not nullptr. This is an undesirable difference in general, but this
+ // behavior is maintained to avoid breaking existing code that happens to
+ // depend on this old behavior/bug. Perhaps it will be fixed one day. The
+ // difference in behavior is as follows:
+ // Split(absl::string_view(""), '-'); // {""}
+ // Split(absl::string_view(), '-'); // {}
+ if (splitter_->text().data() == nullptr) {
+ state_ = kEndState;
+ pos_ = splitter_->text().size();
+ return;
+ }
+
+ if (state_ == kEndState) {
+ pos_ = splitter_->text().size();
+ } else {
+ ++(*this);
+ }
+ }
+
+ bool at_end() const { return state_ == kEndState; }
+
+ reference operator*() const { return curr_; }
+ pointer operator->() const { return &curr_; }
+
+ SplitIterator& operator++() {
+ do {
+ if (state_ == kLastState) {
+ state_ = kEndState;
+ return *this;
+ }
+ const absl::string_view text = splitter_->text();
+ const absl::string_view d = delimiter_.Find(text, pos_);
+ if (d.data() == text.end()) state_ = kLastState;
+ curr_ = text.substr(pos_, d.data() - (text.data() + pos_));
+ pos_ += curr_.size() + d.size();
+ } while (!predicate_(curr_));
+ return *this;
+ }
+
+ SplitIterator operator++(int) {
+ SplitIterator old(*this);
+ ++(*this);
+ return old;
+ }
+
+ friend bool operator==(const SplitIterator& a, const SplitIterator& b) {
+ return a.state_ == b.state_ && a.pos_ == b.pos_;
+ }
+
+ friend bool operator!=(const SplitIterator& a, const SplitIterator& b) {
+ return !(a == b);
+ }
+
+ private:
+ size_t pos_;
+ State state_;
+ absl::string_view curr_;
+ const Splitter* splitter_;
+ typename Splitter::DelimiterType delimiter_;
+ typename Splitter::PredicateType predicate_;
+};
+
+// HasMappedType<T>::value is true iff there exists a type T::mapped_type.
+template <typename T, typename = void>
+struct HasMappedType : std::false_type {};
+template <typename T>
+struct HasMappedType<T, absl::void_t<typename T::mapped_type>>
+ : std::true_type {};
+
+// HasValueType<T>::value is true iff there exists a type T::value_type.
+template <typename T, typename = void>
+struct HasValueType : std::false_type {};
+template <typename T>
+struct HasValueType<T, absl::void_t<typename T::value_type>> : std::true_type {
+};
+
+// HasConstIterator<T>::value is true iff there exists a type T::const_iterator.
+template <typename T, typename = void>
+struct HasConstIterator : std::false_type {};
+template <typename T>
+struct HasConstIterator<T, absl::void_t<typename T::const_iterator>>
+ : std::true_type {};
+
+// IsInitializerList<T>::value is true iff T is an std::initializer_list. More
+// details below in Splitter<> where this is used.
+std::false_type IsInitializerListDispatch(...); // default: No
+template <typename T>
+std::true_type IsInitializerListDispatch(std::initializer_list<T>*);
+template <typename T>
+struct IsInitializerList
+ : decltype(IsInitializerListDispatch(static_cast<T*>(nullptr))) {};
+
+// A SplitterIsConvertibleTo<C>::type alias exists iff the specified condition
+// is true for type 'C'.
+//
+// Restricts conversion to container-like types (by testing for the presence of
+// a const_iterator member type) and also to disable conversion to an
+// std::initializer_list (which also has a const_iterator). Otherwise, code
+// compiled in C++11 will get an error due to ambiguous conversion paths (in
+// C++11 std::vector<T>::operator= is overloaded to take either a std::vector<T>
+// or an std::initializer_list<T>).
+template <typename C>
+struct SplitterIsConvertibleTo
+ : std::enable_if<
+#ifdef _GLIBCXX_DEBUG
+ !IsStrictlyBaseOfAndConvertibleToSTLContainer<C>::value &&
+#endif // _GLIBCXX_DEBUG
+ !IsInitializerList<C>::value && HasValueType<C>::value &&
+ HasConstIterator<C>::value> {
+};
+
+// This class implements the range that is returned by absl::StrSplit(). This
+// class has templated conversion operators that allow it to be implicitly
+// converted to a variety of types that the caller may have specified on the
+// left-hand side of an assignment.
+//
+// The main interface for interacting with this class is through its implicit
+// conversion operators. However, this class may also be used like a container
+// in that it has .begin() and .end() member functions. It may also be used
+// within a range-for loop.
+//
+// Output containers can be collections of any type that is constructible from
+// an absl::string_view.
+//
+// An Predicate functor may be supplied. This predicate will be used to filter
+// the split strings: only strings for which the predicate returns true will be
+// kept. A Predicate object is any unary functor that takes an absl::string_view
+// and returns bool.
+template <typename Delimiter, typename Predicate>
+class Splitter {
+ public:
+ using DelimiterType = Delimiter;
+ using PredicateType = Predicate;
+ using const_iterator = strings_internal::SplitIterator<Splitter>;
+ using value_type = typename std::iterator_traits<const_iterator>::value_type;
+
+ Splitter(ConvertibleToStringView input_text, Delimiter d, Predicate p)
+ : text_(std::move(input_text)),
+ delimiter_(std::move(d)),
+ predicate_(std::move(p)) {}
+
+ absl::string_view text() const { return text_.value(); }
+ const Delimiter& delimiter() const { return delimiter_; }
+ const Predicate& predicate() const { return predicate_; }
+
+ // Range functions that iterate the split substrings as absl::string_view
+ // objects. These methods enable a Splitter to be used in a range-based for
+ // loop.
+ const_iterator begin() const { return {const_iterator::kInitState, this}; }
+ const_iterator end() const { return {const_iterator::kEndState, this}; }
+
+ // An implicit conversion operator that is restricted to only those containers
+ // that the splitter is convertible to.
+ template <typename Container,
+ typename OnlyIf = typename SplitterIsConvertibleTo<Container>::type>
+ operator Container() const { // NOLINT(runtime/explicit)
+ return ConvertToContainer<Container, typename Container::value_type,
+ HasMappedType<Container>::value>()(*this);
+ }
+
+ // Returns a pair with its .first and .second members set to the first two
+ // strings returned by the begin() iterator. Either/both of .first and .second
+ // will be constructed with empty strings if the iterator doesn't have a
+ // corresponding value.
+ template <typename First, typename Second>
+ operator std::pair<First, Second>() const { // NOLINT(runtime/explicit)
+ absl::string_view first, second;
+ auto it = begin();
+ if (it != end()) {
+ first = *it;
+ if (++it != end()) {
+ second = *it;
+ }
+ }
+ return {First(first), Second(second)};
+ }
+
+ private:
+ // ConvertToContainer is a functor converting a Splitter to the requested
+ // Container of ValueType. It is specialized below to optimize splitting to
+ // certain combinations of Container and ValueType.
+ //
+ // This base template handles the generic case of storing the split results in
+ // the requested non-map-like container and converting the split substrings to
+ // the requested type.
+ template <typename Container, typename ValueType, bool is_map = false>
+ struct ConvertToContainer {
+ Container operator()(const Splitter& splitter) const {
+ Container c;
+ auto it = std::inserter(c, c.end());
+ for (const auto sp : splitter) {
+ *it++ = ValueType(sp);
+ }
+ return c;
+ }
+ };
+
+ // Partial specialization for a std::vector<absl::string_view>.
+ //
+ // Optimized for the common case of splitting to a
+ // std::vector<absl::string_view>. In this case we first split the results to
+ // a small array of absl::string_view on the stack, to reduce reallocations.
+ template <typename A>
+ struct ConvertToContainer<std::vector<absl::string_view, A>,
+ absl::string_view, false> {
+ std::vector<absl::string_view, A> operator()(
+ const Splitter& splitter) const {
+ struct raw_view {
+ const char* data;
+ size_t size;
+ operator absl::string_view() const { // NOLINT(runtime/explicit)
+ return {data, size};
+ }
+ };
+ std::vector<absl::string_view, A> v;
+ std::array<raw_view, 16> ar;
+ for (auto it = splitter.begin(); !it.at_end();) {
+ size_t index = 0;
+ do {
+ ar[index].data = it->data();
+ ar[index].size = it->size();
+ ++it;
+ } while (++index != ar.size() && !it.at_end());
+ v.insert(v.end(), ar.begin(), ar.begin() + index);
+ }
+ return v;
+ }
+ };
+
+ // Partial specialization for a std::vector<std::string>.
+ //
+ // Optimized for the common case of splitting to a std::vector<std::string>. In
+ // this case we first split the results to a std::vector<absl::string_view> so
+ // the returned std::vector<std::string> can have space reserved to avoid std::string
+ // moves.
+ template <typename A>
+ struct ConvertToContainer<std::vector<std::string, A>, std::string, false> {
+ std::vector<std::string, A> operator()(const Splitter& splitter) const {
+ const std::vector<absl::string_view> v = splitter;
+ return std::vector<std::string, A>(v.begin(), v.end());
+ }
+ };
+
+ // Partial specialization for containers of pairs (e.g., maps).
+ //
+ // The algorithm is to insert a new pair into the map for each even-numbered
+ // item, with the even-numbered item as the key with a default-constructed
+ // value. Each odd-numbered item will then be assigned to the last pair's
+ // value.
+ template <typename Container, typename First, typename Second>
+ struct ConvertToContainer<Container, std::pair<const First, Second>, true> {
+ Container operator()(const Splitter& splitter) const {
+ Container m;
+ typename Container::iterator it;
+ bool insert = true;
+ for (const auto sp : splitter) {
+ if (insert) {
+ it = Inserter<Container>::Insert(&m, First(sp), Second());
+ } else {
+ it->second = Second(sp);
+ }
+ insert = !insert;
+ }
+ return m;
+ }
+
+ // Inserts the key and value into the given map, returning an iterator to
+ // the inserted item. Specialized for std::map and std::multimap to use
+ // emplace() and adapt emplace()'s return value.
+ template <typename Map>
+ struct Inserter {
+ using M = Map;
+ template <typename... Args>
+ static typename M::iterator Insert(M* m, Args&&... args) {
+ return m->insert(std::make_pair(std::forward<Args>(args)...)).first;
+ }
+ };
+
+ template <typename... Ts>
+ struct Inserter<std::map<Ts...>> {
+ using M = std::map<Ts...>;
+ template <typename... Args>
+ static typename M::iterator Insert(M* m, Args&&... args) {
+ return m->emplace(std::make_pair(std::forward<Args>(args)...)).first;
+ }
+ };
+
+ template <typename... Ts>
+ struct Inserter<std::multimap<Ts...>> {
+ using M = std::multimap<Ts...>;
+ template <typename... Args>
+ static typename M::iterator Insert(M* m, Args&&... args) {
+ return m->emplace(std::make_pair(std::forward<Args>(args)...));
+ }
+ };
+ };
+
+ ConvertibleToStringView text_;
+ Delimiter delimiter_;
+ Predicate predicate_;
+};
+
+} // namespace strings_internal
+} // namespace absl
+
+#endif // ABSL_STRINGS_INTERNAL_STR_SPLIT_INTERNAL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8.cc
new file mode 100644
index 0000000..2415c2c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8.cc
@@ -0,0 +1,51 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// UTF8 utilities, implemented to reduce dependencies.
+
+#include "absl/strings/internal/utf8.h"
+
+namespace absl {
+namespace strings_internal {
+
+size_t EncodeUTF8Char(char *buffer, char32_t utf8_char) {
+ if (utf8_char <= 0x7F) {
+ *buffer = static_cast<char>(utf8_char);
+ return 1;
+ } else if (utf8_char <= 0x7FF) {
+ buffer[1] = 0x80 | (utf8_char & 0x3F);
+ utf8_char >>= 6;
+ buffer[0] = 0xC0 | utf8_char;
+ return 2;
+ } else if (utf8_char <= 0xFFFF) {
+ buffer[2] = 0x80 | (utf8_char & 0x3F);
+ utf8_char >>= 6;
+ buffer[1] = 0x80 | (utf8_char & 0x3F);
+ utf8_char >>= 6;
+ buffer[0] = 0xE0 | utf8_char;
+ return 3;
+ } else {
+ buffer[3] = 0x80 | (utf8_char & 0x3F);
+ utf8_char >>= 6;
+ buffer[2] = 0x80 | (utf8_char & 0x3F);
+ utf8_char >>= 6;
+ buffer[1] = 0x80 | (utf8_char & 0x3F);
+ utf8_char >>= 6;
+ buffer[0] = 0xF0 | utf8_char;
+ return 4;
+ }
+}
+
+} // namespace strings_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8.h
new file mode 100644
index 0000000..d2c3c0b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8.h
@@ -0,0 +1,47 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// UTF8 utilities, implemented to reduce dependencies.
+//
+
+#ifndef ABSL_STRINGS_INTERNAL_UTF8_H_
+#define ABSL_STRINGS_INTERNAL_UTF8_H_
+
+#include <cstddef>
+#include <cstdint>
+
+namespace absl {
+namespace strings_internal {
+
+// For Unicode code points 0 through 0x10FFFF, EncodeUTF8Char writes
+// out the UTF-8 encoding into buffer, and returns the number of chars
+// it wrote.
+//
+// As described in https://tools.ietf.org/html/rfc3629#section-3 , the encodings
+// are:
+// 00 - 7F : 0xxxxxxx
+// 80 - 7FF : 110xxxxx 10xxxxxx
+// 800 - FFFF : 1110xxxx 10xxxxxx 10xxxxxx
+// 10000 - 10FFFF : 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
+//
+// Values greater than 0x10FFFF are not supported and may or may not write
+// characters into buffer, however never will more than kMaxEncodedUTF8Size
+// bytes be written, regardless of the value of utf8_char.
+enum { kMaxEncodedUTF8Size = 4 };
+size_t EncodeUTF8Char(char *buffer, char32_t utf8_char);
+
+} // namespace strings_internal
+} // namespace absl
+
+#endif // ABSL_STRINGS_INTERNAL_UTF8_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8_test.cc
new file mode 100644
index 0000000..64cec70
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/internal/utf8_test.cc
@@ -0,0 +1,57 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/internal/utf8.h"
+
+#include <cstdint>
+#include <utility>
+
+#include "gtest/gtest.h"
+#include "absl/base/port.h"
+
+namespace {
+
+TEST(EncodeUTF8Char, BasicFunction) {
+ std::pair<char32_t, std::string> tests[] = {{0x0030, u8"\u0030"},
+ {0x00A3, u8"\u00A3"},
+ {0x00010000, u8"\U00010000"},
+ {0x0000FFFF, u8"\U0000FFFF"},
+ {0x0010FFFD, u8"\U0010FFFD"}};
+ for (auto &test : tests) {
+ char buf0[7] = {'\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x00'};
+ char buf1[7] = {'\xFF', '\xFF', '\xFF', '\xFF', '\xFF', '\xFF', '\xFF'};
+ char *buf0_written =
+ &buf0[absl::strings_internal::EncodeUTF8Char(buf0, test.first)];
+ char *buf1_written =
+ &buf1[absl::strings_internal::EncodeUTF8Char(buf1, test.first)];
+ int apparent_length = 7;
+ while (buf0[apparent_length - 1] == '\x00' &&
+ buf1[apparent_length - 1] == '\xFF') {
+ if (--apparent_length == 0) break;
+ }
+ EXPECT_EQ(apparent_length, buf0_written - buf0);
+ EXPECT_EQ(apparent_length, buf1_written - buf1);
+ EXPECT_EQ(apparent_length, test.second.length());
+ EXPECT_EQ(std::string(buf0, apparent_length), test.second);
+ EXPECT_EQ(std::string(buf1, apparent_length), test.second);
+ }
+ char buf[32] = "Don't Tread On Me";
+ EXPECT_LE(absl::strings_internal::EncodeUTF8Char(buf, 0x00110000),
+ absl::strings_internal::kMaxEncodedUTF8Size);
+ char buf2[32] = "Negative is invalid but sane";
+ EXPECT_LE(absl::strings_internal::EncodeUTF8Char(buf2, -1),
+ absl::strings_internal::kMaxEncodedUTF8Size);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match.cc
new file mode 100644
index 0000000..25bd7f0
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match.cc
@@ -0,0 +1,40 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/match.h"
+
+#include "absl/strings/internal/memutil.h"
+
+namespace absl {
+
+namespace {
+bool CaseEqual(absl::string_view piece1, absl::string_view piece2) {
+ return (piece1.size() == piece2.size() &&
+ 0 == strings_internal::memcasecmp(piece1.data(), piece2.data(),
+ piece1.size()));
+ // memcasecmp uses ascii_tolower().
+}
+} // namespace
+
+bool StartsWithIgnoreCase(absl::string_view text, absl::string_view prefix) {
+ return (text.size() >= prefix.size()) &&
+ CaseEqual(text.substr(0, prefix.size()), prefix);
+}
+
+bool EndsWithIgnoreCase(absl::string_view text, absl::string_view suffix) {
+ return (text.size() >= suffix.size()) &&
+ CaseEqual(text.substr(text.size() - suffix.size()), suffix);
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match.h
new file mode 100644
index 0000000..6005533
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match.h
@@ -0,0 +1,84 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: match.h
+// -----------------------------------------------------------------------------
+//
+// This file contains simple utilities for performing std::string matching checks.
+// All of these function parameters are specified as `absl::string_view`,
+// meaning that these functions can accept `std::string`, `absl::string_view` or
+// nul-terminated C-style strings.
+//
+// Examples:
+// std::string s = "foo";
+// absl::string_view sv = "f";
+// assert(absl::StrContains(s, sv));
+//
+// Note: The order of parameters in these functions is designed to mimic the
+// order an equivalent member function would exhibit;
+// e.g. `s.Contains(x)` ==> `absl::StrContains(s, x).
+#ifndef ABSL_STRINGS_MATCH_H_
+#define ABSL_STRINGS_MATCH_H_
+
+#include <cstring>
+
+#include "absl/strings/string_view.h"
+
+namespace absl {
+
+// StrContains()
+//
+// Returns whether a given std::string `haystack` contains the substring `needle`.
+inline bool StrContains(absl::string_view haystack, absl::string_view needle) {
+ return static_cast<absl::string_view::size_type>(haystack.find(needle, 0)) !=
+ haystack.npos;
+}
+
+// StartsWith()
+//
+// Returns whether a given std::string `text` begins with `prefix`.
+inline bool StartsWith(absl::string_view text, absl::string_view prefix) {
+ return prefix.empty() ||
+ (text.size() >= prefix.size() &&
+ memcmp(text.data(), prefix.data(), prefix.size()) == 0);
+}
+
+// EndsWith()
+//
+// Returns whether a given std::string `text` ends with `suffix`.
+inline bool EndsWith(absl::string_view text, absl::string_view suffix) {
+ return suffix.empty() ||
+ (text.size() >= suffix.size() &&
+ memcmp(text.data() + (text.size() - suffix.size()), suffix.data(),
+ suffix.size()) == 0
+ );
+}
+
+// StartsWithIgnoreCase()
+//
+// Returns whether a given std::string `text` starts with `starts_with`, ignoring
+// case in the comparison.
+bool StartsWithIgnoreCase(absl::string_view text, absl::string_view prefix);
+
+// EndsWithIgnoreCase()
+//
+// Returns whether a given std::string `text` ends with `ends_with`, ignoring case
+// in the comparison.
+bool EndsWithIgnoreCase(absl::string_view text, absl::string_view suffix);
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_MATCH_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match_test.cc
new file mode 100644
index 0000000..d194f0e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/match_test.cc
@@ -0,0 +1,99 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/match.h"
+
+#include "gtest/gtest.h"
+
+namespace {
+
+TEST(MatchTest, StartsWith) {
+ const std::string s1("123" "\0" "456", 7);
+ const absl::string_view a("foobar");
+ const absl::string_view b(s1);
+ const absl::string_view e;
+ EXPECT_TRUE(absl::StartsWith(a, a));
+ EXPECT_TRUE(absl::StartsWith(a, "foo"));
+ EXPECT_TRUE(absl::StartsWith(a, e));
+ EXPECT_TRUE(absl::StartsWith(b, s1));
+ EXPECT_TRUE(absl::StartsWith(b, b));
+ EXPECT_TRUE(absl::StartsWith(b, e));
+ EXPECT_TRUE(absl::StartsWith(e, ""));
+ EXPECT_FALSE(absl::StartsWith(a, b));
+ EXPECT_FALSE(absl::StartsWith(b, a));
+ EXPECT_FALSE(absl::StartsWith(e, a));
+}
+
+TEST(MatchTest, EndsWith) {
+ const std::string s1("123" "\0" "456", 7);
+ const absl::string_view a("foobar");
+ const absl::string_view b(s1);
+ const absl::string_view e;
+ EXPECT_TRUE(absl::EndsWith(a, a));
+ EXPECT_TRUE(absl::EndsWith(a, "bar"));
+ EXPECT_TRUE(absl::EndsWith(a, e));
+ EXPECT_TRUE(absl::EndsWith(b, s1));
+ EXPECT_TRUE(absl::EndsWith(b, b));
+ EXPECT_TRUE(absl::EndsWith(b, e));
+ EXPECT_TRUE(absl::EndsWith(e, ""));
+ EXPECT_FALSE(absl::EndsWith(a, b));
+ EXPECT_FALSE(absl::EndsWith(b, a));
+ EXPECT_FALSE(absl::EndsWith(e, a));
+}
+
+TEST(MatchTest, Contains) {
+ absl::string_view a("abcdefg");
+ absl::string_view b("abcd");
+ absl::string_view c("efg");
+ absl::string_view d("gh");
+ EXPECT_TRUE(absl::StrContains(a, a));
+ EXPECT_TRUE(absl::StrContains(a, b));
+ EXPECT_TRUE(absl::StrContains(a, c));
+ EXPECT_FALSE(absl::StrContains(a, d));
+ EXPECT_TRUE(absl::StrContains("", ""));
+ EXPECT_TRUE(absl::StrContains("abc", ""));
+ EXPECT_FALSE(absl::StrContains("", "a"));
+}
+
+TEST(MatchTest, ContainsNull) {
+ const std::string s = "foo";
+ const char* cs = "foo";
+ const absl::string_view sv("foo");
+ const absl::string_view sv2("foo\0bar", 4);
+ EXPECT_EQ(s, "foo");
+ EXPECT_EQ(sv, "foo");
+ EXPECT_NE(sv2, "foo");
+ EXPECT_TRUE(absl::EndsWith(s, sv));
+ EXPECT_TRUE(absl::StartsWith(cs, sv));
+ EXPECT_TRUE(absl::StrContains(cs, sv));
+ EXPECT_FALSE(absl::StrContains(cs, sv2));
+}
+
+TEST(MatchTest, StartsWithIgnoreCase) {
+ EXPECT_TRUE(absl::StartsWithIgnoreCase("foo", "foo"));
+ EXPECT_TRUE(absl::StartsWithIgnoreCase("foo", "Fo"));
+ EXPECT_TRUE(absl::StartsWithIgnoreCase("foo", ""));
+ EXPECT_FALSE(absl::StartsWithIgnoreCase("foo", "fooo"));
+ EXPECT_FALSE(absl::StartsWithIgnoreCase("", "fo"));
+}
+
+TEST(MatchTest, EndsWithIgnoreCase) {
+ EXPECT_TRUE(absl::EndsWithIgnoreCase("foo", "foo"));
+ EXPECT_TRUE(absl::EndsWithIgnoreCase("foo", "Oo"));
+ EXPECT_TRUE(absl::EndsWithIgnoreCase("foo", ""));
+ EXPECT_FALSE(absl::EndsWithIgnoreCase("foo", "fooo"));
+ EXPECT_FALSE(absl::EndsWithIgnoreCase("", "fo"));
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers.cc
new file mode 100644
index 0000000..b4140b3
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers.cc
@@ -0,0 +1,919 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains std::string processing functions related to
+// numeric values.
+
+#include "absl/strings/numbers.h"
+
+#include <algorithm>
+#include <cassert>
+#include <cfloat> // for DBL_DIG and FLT_DIG
+#include <cmath> // for HUGE_VAL
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <iterator>
+#include <limits>
+#include <memory>
+#include <utility>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/strings/ascii.h"
+#include "absl/strings/internal/memutil.h"
+#include "absl/strings/str_cat.h"
+
+namespace absl {
+
+bool SimpleAtof(absl::string_view str, float* value) {
+ *value = 0.0;
+ if (str.empty()) return false;
+ char buf[32];
+ std::unique_ptr<char[]> bigbuf;
+ char* ptr = buf;
+ if (str.size() > sizeof(buf) - 1) {
+ bigbuf.reset(new char[str.size() + 1]);
+ ptr = bigbuf.get();
+ }
+ memcpy(ptr, str.data(), str.size());
+ ptr[str.size()] = '\0';
+
+ char* endptr;
+ *value = strtof(ptr, &endptr);
+ if (endptr != ptr) {
+ while (absl::ascii_isspace(*endptr)) ++endptr;
+ }
+ // Ignore range errors from strtod/strtof.
+ // The values it returns on underflow and
+ // overflow are the right fallback in a
+ // robust setting.
+ return *ptr != '\0' && *endptr == '\0';
+}
+
+bool SimpleAtod(absl::string_view str, double* value) {
+ *value = 0.0;
+ if (str.empty()) return false;
+ char buf[32];
+ std::unique_ptr<char[]> bigbuf;
+ char* ptr = buf;
+ if (str.size() > sizeof(buf) - 1) {
+ bigbuf.reset(new char[str.size() + 1]);
+ ptr = bigbuf.get();
+ }
+ memcpy(ptr, str.data(), str.size());
+ ptr[str.size()] = '\0';
+
+ char* endptr;
+ *value = strtod(ptr, &endptr);
+ if (endptr != ptr) {
+ while (absl::ascii_isspace(*endptr)) ++endptr;
+ }
+ // Ignore range errors from strtod. The values it
+ // returns on underflow and overflow are the right
+ // fallback in a robust setting.
+ return *ptr != '\0' && *endptr == '\0';
+}
+
+namespace {
+
+// TODO(rogeeff): replace with the real released thing once we figure out what
+// it is.
+inline bool CaseEqual(absl::string_view piece1, absl::string_view piece2) {
+ return (piece1.size() == piece2.size() &&
+ 0 == strings_internal::memcasecmp(piece1.data(), piece2.data(),
+ piece1.size()));
+}
+
+// Writes a two-character representation of 'i' to 'buf'. 'i' must be in the
+// range 0 <= i < 100, and buf must have space for two characters. Example:
+// char buf[2];
+// PutTwoDigits(42, buf);
+// // buf[0] == '4'
+// // buf[1] == '2'
+inline void PutTwoDigits(size_t i, char* buf) {
+ static const char two_ASCII_digits[100][2] = {
+ {'0', '0'}, {'0', '1'}, {'0', '2'}, {'0', '3'}, {'0', '4'},
+ {'0', '5'}, {'0', '6'}, {'0', '7'}, {'0', '8'}, {'0', '9'},
+ {'1', '0'}, {'1', '1'}, {'1', '2'}, {'1', '3'}, {'1', '4'},
+ {'1', '5'}, {'1', '6'}, {'1', '7'}, {'1', '8'}, {'1', '9'},
+ {'2', '0'}, {'2', '1'}, {'2', '2'}, {'2', '3'}, {'2', '4'},
+ {'2', '5'}, {'2', '6'}, {'2', '7'}, {'2', '8'}, {'2', '9'},
+ {'3', '0'}, {'3', '1'}, {'3', '2'}, {'3', '3'}, {'3', '4'},
+ {'3', '5'}, {'3', '6'}, {'3', '7'}, {'3', '8'}, {'3', '9'},
+ {'4', '0'}, {'4', '1'}, {'4', '2'}, {'4', '3'}, {'4', '4'},
+ {'4', '5'}, {'4', '6'}, {'4', '7'}, {'4', '8'}, {'4', '9'},
+ {'5', '0'}, {'5', '1'}, {'5', '2'}, {'5', '3'}, {'5', '4'},
+ {'5', '5'}, {'5', '6'}, {'5', '7'}, {'5', '8'}, {'5', '9'},
+ {'6', '0'}, {'6', '1'}, {'6', '2'}, {'6', '3'}, {'6', '4'},
+ {'6', '5'}, {'6', '6'}, {'6', '7'}, {'6', '8'}, {'6', '9'},
+ {'7', '0'}, {'7', '1'}, {'7', '2'}, {'7', '3'}, {'7', '4'},
+ {'7', '5'}, {'7', '6'}, {'7', '7'}, {'7', '8'}, {'7', '9'},
+ {'8', '0'}, {'8', '1'}, {'8', '2'}, {'8', '3'}, {'8', '4'},
+ {'8', '5'}, {'8', '6'}, {'8', '7'}, {'8', '8'}, {'8', '9'},
+ {'9', '0'}, {'9', '1'}, {'9', '2'}, {'9', '3'}, {'9', '4'},
+ {'9', '5'}, {'9', '6'}, {'9', '7'}, {'9', '8'}, {'9', '9'}
+ };
+ assert(i < 100);
+ memcpy(buf, two_ASCII_digits[i], 2);
+}
+
+} // namespace
+
+bool SimpleAtob(absl::string_view str, bool* value) {
+ ABSL_RAW_CHECK(value != nullptr, "Output pointer must not be nullptr.");
+ if (CaseEqual(str, "true") || CaseEqual(str, "t") ||
+ CaseEqual(str, "yes") || CaseEqual(str, "y") ||
+ CaseEqual(str, "1")) {
+ *value = true;
+ return true;
+ }
+ if (CaseEqual(str, "false") || CaseEqual(str, "f") ||
+ CaseEqual(str, "no") || CaseEqual(str, "n") ||
+ CaseEqual(str, "0")) {
+ *value = false;
+ return true;
+ }
+ return false;
+}
+
+// ----------------------------------------------------------------------
+// FastIntToBuffer() overloads
+//
+// Like the Fast*ToBuffer() functions above, these are intended for speed.
+// Unlike the Fast*ToBuffer() functions, however, these functions write
+// their output to the beginning of the buffer. The caller is responsible
+// for ensuring that the buffer has enough space to hold the output.
+//
+// Returns a pointer to the end of the std::string (i.e. the null character
+// terminating the std::string).
+// ----------------------------------------------------------------------
+
+namespace {
+
+// Used to optimize printing a decimal number's final digit.
+const char one_ASCII_final_digits[10][2] {
+ {'0', 0}, {'1', 0}, {'2', 0}, {'3', 0}, {'4', 0},
+ {'5', 0}, {'6', 0}, {'7', 0}, {'8', 0}, {'9', 0},
+};
+
+} // namespace
+
+char* numbers_internal::FastIntToBuffer(uint32_t i, char* buffer) {
+ uint32_t digits;
+ // The idea of this implementation is to trim the number of divides to as few
+ // as possible, and also reducing memory stores and branches, by going in
+ // steps of two digits at a time rather than one whenever possible.
+ // The huge-number case is first, in the hopes that the compiler will output
+ // that case in one branch-free block of code, and only output conditional
+ // branches into it from below.
+ if (i >= 1000000000) { // >= 1,000,000,000
+ digits = i / 100000000; // 100,000,000
+ i -= digits * 100000000;
+ PutTwoDigits(digits, buffer);
+ buffer += 2;
+ lt100_000_000:
+ digits = i / 1000000; // 1,000,000
+ i -= digits * 1000000;
+ PutTwoDigits(digits, buffer);
+ buffer += 2;
+ lt1_000_000:
+ digits = i / 10000; // 10,000
+ i -= digits * 10000;
+ PutTwoDigits(digits, buffer);
+ buffer += 2;
+ lt10_000:
+ digits = i / 100;
+ i -= digits * 100;
+ PutTwoDigits(digits, buffer);
+ buffer += 2;
+ lt100:
+ digits = i;
+ PutTwoDigits(digits, buffer);
+ buffer += 2;
+ *buffer = 0;
+ return buffer;
+ }
+
+ if (i < 100) {
+ digits = i;
+ if (i >= 10) goto lt100;
+ memcpy(buffer, one_ASCII_final_digits[i], 2);
+ return buffer + 1;
+ }
+ if (i < 10000) { // 10,000
+ if (i >= 1000) goto lt10_000;
+ digits = i / 100;
+ i -= digits * 100;
+ *buffer++ = '0' + digits;
+ goto lt100;
+ }
+ if (i < 1000000) { // 1,000,000
+ if (i >= 100000) goto lt1_000_000;
+ digits = i / 10000; // 10,000
+ i -= digits * 10000;
+ *buffer++ = '0' + digits;
+ goto lt10_000;
+ }
+ if (i < 100000000) { // 100,000,000
+ if (i >= 10000000) goto lt100_000_000;
+ digits = i / 1000000; // 1,000,000
+ i -= digits * 1000000;
+ *buffer++ = '0' + digits;
+ goto lt1_000_000;
+ }
+ // we already know that i < 1,000,000,000
+ digits = i / 100000000; // 100,000,000
+ i -= digits * 100000000;
+ *buffer++ = '0' + digits;
+ goto lt100_000_000;
+}
+
+char* numbers_internal::FastIntToBuffer(int32_t i, char* buffer) {
+ uint32_t u = i;
+ if (i < 0) {
+ *buffer++ = '-';
+ // We need to do the negation in modular (i.e., "unsigned")
+ // arithmetic; MSVC++ apprently warns for plain "-u", so
+ // we write the equivalent expression "0 - u" instead.
+ u = 0 - u;
+ }
+ return numbers_internal::FastIntToBuffer(u, buffer);
+}
+
+char* numbers_internal::FastIntToBuffer(uint64_t i, char* buffer) {
+ uint32_t u32 = static_cast<uint32_t>(i);
+ if (u32 == i) return numbers_internal::FastIntToBuffer(u32, buffer);
+
+ // Here we know i has at least 10 decimal digits.
+ uint64_t top_1to11 = i / 1000000000;
+ u32 = static_cast<uint32_t>(i - top_1to11 * 1000000000);
+ uint32_t top_1to11_32 = static_cast<uint32_t>(top_1to11);
+
+ if (top_1to11_32 == top_1to11) {
+ buffer = numbers_internal::FastIntToBuffer(top_1to11_32, buffer);
+ } else {
+ // top_1to11 has more than 32 bits too; print it in two steps.
+ uint32_t top_8to9 = static_cast<uint32_t>(top_1to11 / 100);
+ uint32_t mid_2 = static_cast<uint32_t>(top_1to11 - top_8to9 * 100);
+ buffer = numbers_internal::FastIntToBuffer(top_8to9, buffer);
+ PutTwoDigits(mid_2, buffer);
+ buffer += 2;
+ }
+
+ // We have only 9 digits now, again the maximum uint32_t can handle fully.
+ uint32_t digits = u32 / 10000000; // 10,000,000
+ u32 -= digits * 10000000;
+ PutTwoDigits(digits, buffer);
+ buffer += 2;
+ digits = u32 / 100000; // 100,000
+ u32 -= digits * 100000;
+ PutTwoDigits(digits, buffer);
+ buffer += 2;
+ digits = u32 / 1000; // 1,000
+ u32 -= digits * 1000;
+ PutTwoDigits(digits, buffer);
+ buffer += 2;
+ digits = u32 / 10;
+ u32 -= digits * 10;
+ PutTwoDigits(digits, buffer);
+ buffer += 2;
+ memcpy(buffer, one_ASCII_final_digits[u32], 2);
+ return buffer + 1;
+}
+
+char* numbers_internal::FastIntToBuffer(int64_t i, char* buffer) {
+ uint64_t u = i;
+ if (i < 0) {
+ *buffer++ = '-';
+ u = 0 - u;
+ }
+ return numbers_internal::FastIntToBuffer(u, buffer);
+}
+
+// Returns the number of leading 0 bits in a 64-bit value.
+// TODO(jorg): Replace with builtin_clzll if available.
+// Are we shipping util/bits in absl?
+static inline int CountLeadingZeros64(uint64_t n) {
+ int zeroes = 60;
+ if (n >> 32) zeroes -= 32, n >>= 32;
+ if (n >> 16) zeroes -= 16, n >>= 16;
+ if (n >> 8) zeroes -= 8, n >>= 8;
+ if (n >> 4) zeroes -= 4, n >>= 4;
+ return "\4\3\2\2\1\1\1\1\0\0\0\0\0\0\0\0"[n] + zeroes;
+}
+
+// Given a 128-bit number expressed as a pair of uint64_t, high half first,
+// return that number multiplied by the given 32-bit value. If the result is
+// too large to fit in a 128-bit number, divide it by 2 until it fits.
+static std::pair<uint64_t, uint64_t> Mul32(std::pair<uint64_t, uint64_t> num,
+ uint32_t mul) {
+ uint64_t bits0_31 = num.second & 0xFFFFFFFF;
+ uint64_t bits32_63 = num.second >> 32;
+ uint64_t bits64_95 = num.first & 0xFFFFFFFF;
+ uint64_t bits96_127 = num.first >> 32;
+
+ // The picture so far: each of these 64-bit values has only the lower 32 bits
+ // filled in.
+ // bits96_127: [ 00000000 xxxxxxxx ]
+ // bits64_95: [ 00000000 xxxxxxxx ]
+ // bits32_63: [ 00000000 xxxxxxxx ]
+ // bits0_31: [ 00000000 xxxxxxxx ]
+
+ bits0_31 *= mul;
+ bits32_63 *= mul;
+ bits64_95 *= mul;
+ bits96_127 *= mul;
+
+ // Now the top halves may also have value, though all 64 of their bits will
+ // never be set at the same time, since they are a result of a 32x32 bit
+ // multiply. This makes the carry calculation slightly easier.
+ // bits96_127: [ mmmmmmmm | mmmmmmmm ]
+ // bits64_95: [ | mmmmmmmm mmmmmmmm | ]
+ // bits32_63: | [ mmmmmmmm | mmmmmmmm ]
+ // bits0_31: | [ | mmmmmmmm mmmmmmmm ]
+ // eventually: [ bits128_up | ...bits64_127.... | ..bits0_63... ]
+
+ uint64_t bits0_63 = bits0_31 + (bits32_63 << 32);
+ uint64_t bits64_127 = bits64_95 + (bits96_127 << 32) + (bits32_63 >> 32) +
+ (bits0_63 < bits0_31);
+ uint64_t bits128_up = (bits96_127 >> 32) + (bits64_127 < bits64_95);
+ if (bits128_up == 0) return {bits64_127, bits0_63};
+
+ int shift = 64 - CountLeadingZeros64(bits128_up);
+ uint64_t lo = (bits0_63 >> shift) + (bits64_127 << (64 - shift));
+ uint64_t hi = (bits64_127 >> shift) + (bits128_up << (64 - shift));
+ return {hi, lo};
+}
+
+// Compute num * 5 ^ expfive, and return the first 128 bits of the result,
+// where the first bit is always a one. So PowFive(1, 0) starts 0b100000,
+// PowFive(1, 1) starts 0b101000, PowFive(1, 2) starts 0b110010, etc.
+static std::pair<uint64_t, uint64_t> PowFive(uint64_t num, int expfive) {
+ std::pair<uint64_t, uint64_t> result = {num, 0};
+ while (expfive >= 13) {
+ // 5^13 is the highest power of five that will fit in a 32-bit integer.
+ result = Mul32(result, 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5);
+ expfive -= 13;
+ }
+ constexpr int powers_of_five[13] = {
+ 1,
+ 5,
+ 5 * 5,
+ 5 * 5 * 5,
+ 5 * 5 * 5 * 5,
+ 5 * 5 * 5 * 5 * 5,
+ 5 * 5 * 5 * 5 * 5 * 5,
+ 5 * 5 * 5 * 5 * 5 * 5 * 5,
+ 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+ 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+ 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+ 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+ 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5 * 5};
+ result = Mul32(result, powers_of_five[expfive & 15]);
+ int shift = CountLeadingZeros64(result.first);
+ if (shift != 0) {
+ result.first = (result.first << shift) + (result.second >> (64 - shift));
+ result.second = (result.second << shift);
+ }
+ return result;
+}
+
+struct ExpDigits {
+ int32_t exponent;
+ char digits[6];
+};
+
+// SplitToSix converts value, a positive double-precision floating-point number,
+// into a base-10 exponent and 6 ASCII digits, where the first digit is never
+// zero. For example, SplitToSix(1) returns an exponent of zero and a digits
+// array of {'1', '0', '0', '0', '0', '0'}. If value is exactly halfway between
+// two possible representations, e.g. value = 100000.5, then "round to even" is
+// performed.
+static ExpDigits SplitToSix(const double value) {
+ ExpDigits exp_dig;
+ int exp = 5;
+ double d = value;
+ // First step: calculate a close approximation of the output, where the
+ // value d will be between 100,000 and 999,999, representing the digits
+ // in the output ASCII array, and exp is the base-10 exponent. It would be
+ // faster to use a table here, and to look up the base-2 exponent of value,
+ // however value is an IEEE-754 64-bit number, so the table would have 2,000
+ // entries, which is not cache-friendly.
+ if (d >= 999999.5) {
+ if (d >= 1e+261) exp += 256, d *= 1e-256;
+ if (d >= 1e+133) exp += 128, d *= 1e-128;
+ if (d >= 1e+69) exp += 64, d *= 1e-64;
+ if (d >= 1e+37) exp += 32, d *= 1e-32;
+ if (d >= 1e+21) exp += 16, d *= 1e-16;
+ if (d >= 1e+13) exp += 8, d *= 1e-8;
+ if (d >= 1e+9) exp += 4, d *= 1e-4;
+ if (d >= 1e+7) exp += 2, d *= 1e-2;
+ if (d >= 1e+6) exp += 1, d *= 1e-1;
+ } else {
+ if (d < 1e-250) exp -= 256, d *= 1e256;
+ if (d < 1e-122) exp -= 128, d *= 1e128;
+ if (d < 1e-58) exp -= 64, d *= 1e64;
+ if (d < 1e-26) exp -= 32, d *= 1e32;
+ if (d < 1e-10) exp -= 16, d *= 1e16;
+ if (d < 1e-2) exp -= 8, d *= 1e8;
+ if (d < 1e+2) exp -= 4, d *= 1e4;
+ if (d < 1e+4) exp -= 2, d *= 1e2;
+ if (d < 1e+5) exp -= 1, d *= 1e1;
+ }
+ // At this point, d is in the range [99999.5..999999.5) and exp is in the
+ // range [-324..308]. Since we need to round d up, we want to add a half
+ // and truncate.
+ // However, the technique above may have lost some precision, due to its
+ // repeated multiplication by constants that each may be off by half a bit
+ // of precision. This only matters if we're close to the edge though.
+ // Since we'd like to know if the fractional part of d is close to a half,
+ // we multiply it by 65536 and see if the fractional part is close to 32768.
+ // (The number doesn't have to be a power of two,but powers of two are faster)
+ uint64_t d64k = d * 65536;
+ int dddddd; // A 6-digit decimal integer.
+ if ((d64k % 65536) == 32767 || (d64k % 65536) == 32768) {
+ // OK, it's fairly likely that precision was lost above, which is
+ // not a surprise given only 52 mantissa bits are available. Therefore
+ // redo the calculation using 128-bit numbers. (64 bits are not enough).
+
+ // Start out with digits rounded down; maybe add one below.
+ dddddd = static_cast<int>(d64k / 65536);
+
+ // mantissa is a 64-bit integer representing M.mmm... * 2^63. The actual
+ // value we're representing, of course, is M.mmm... * 2^exp2.
+ int exp2;
+ double m = std::frexp(value, &exp2);
+ uint64_t mantissa = m * (32768.0 * 65536.0 * 65536.0 * 65536.0);
+ // std::frexp returns an m value in the range [0.5, 1.0), however we
+ // can't multiply it by 2^64 and convert to an integer because some FPUs
+ // throw an exception when converting an number higher than 2^63 into an
+ // integer - even an unsigned 64-bit integer! Fortunately it doesn't matter
+ // since m only has 52 significant bits anyway.
+ mantissa <<= 1;
+ exp2 -= 64; // not needed, but nice for debugging
+
+ // OK, we are here to compare:
+ // (dddddd + 0.5) * 10^(exp-5) vs. mantissa * 2^exp2
+ // so we can round up dddddd if appropriate. Those values span the full
+ // range of 600 orders of magnitude of IEE 64-bit floating-point.
+ // Fortunately, we already know they are very close, so we don't need to
+ // track the base-2 exponent of both sides. This greatly simplifies the
+ // the math since the 2^exp2 calculation is unnecessary and the power-of-10
+ // calculation can become a power-of-5 instead.
+
+ std::pair<uint64_t, uint64_t> edge, val;
+ if (exp >= 6) {
+ // Compare (dddddd + 0.5) * 5 ^ (exp - 5) to mantissa
+ // Since we're tossing powers of two, 2 * dddddd + 1 is the
+ // same as dddddd + 0.5
+ edge = PowFive(2 * dddddd + 1, exp - 5);
+
+ val.first = mantissa;
+ val.second = 0;
+ } else {
+ // We can't compare (dddddd + 0.5) * 5 ^ (exp - 5) to mantissa as we did
+ // above because (exp - 5) is negative. So we compare (dddddd + 0.5) to
+ // mantissa * 5 ^ (5 - exp)
+ edge = PowFive(2 * dddddd + 1, 0);
+
+ val = PowFive(mantissa, 5 - exp);
+ }
+ // printf("exp=%d %016lx %016lx vs %016lx %016lx\n", exp, val.first,
+ // val.second, edge.first, edge.second);
+ if (val > edge) {
+ dddddd++;
+ } else if (val == edge) {
+ dddddd += (dddddd & 1);
+ }
+ } else {
+ // Here, we are not close to the edge.
+ dddddd = static_cast<int>((d64k + 32768) / 65536);
+ }
+ if (dddddd == 1000000) {
+ dddddd = 100000;
+ exp += 1;
+ }
+ exp_dig.exponent = exp;
+
+ int two_digits = dddddd / 10000;
+ dddddd -= two_digits * 10000;
+ PutTwoDigits(two_digits, &exp_dig.digits[0]);
+
+ two_digits = dddddd / 100;
+ dddddd -= two_digits * 100;
+ PutTwoDigits(two_digits, &exp_dig.digits[2]);
+
+ PutTwoDigits(dddddd, &exp_dig.digits[4]);
+ return exp_dig;
+}
+
+// Helper function for fast formatting of floating-point.
+// The result is the same as "%g", a.k.a. "%.6g".
+size_t numbers_internal::SixDigitsToBuffer(double d, char* const buffer) {
+ static_assert(std::numeric_limits<float>::is_iec559,
+ "IEEE-754/IEC-559 support only");
+
+ char* out = buffer; // we write data to out, incrementing as we go, but
+ // FloatToBuffer always returns the address of the buffer
+ // passed in.
+
+ if (std::isnan(d)) {
+ strcpy(out, "nan"); // NOLINT(runtime/printf)
+ return 3;
+ }
+ if (d == 0) { // +0 and -0 are handled here
+ if (std::signbit(d)) *out++ = '-';
+ *out++ = '0';
+ *out = 0;
+ return out - buffer;
+ }
+ if (d < 0) {
+ *out++ = '-';
+ d = -d;
+ }
+ if (std::isinf(d)) {
+ strcpy(out, "inf"); // NOLINT(runtime/printf)
+ return out + 3 - buffer;
+ }
+
+ auto exp_dig = SplitToSix(d);
+ int exp = exp_dig.exponent;
+ const char* digits = exp_dig.digits;
+ out[0] = '0';
+ out[1] = '.';
+ switch (exp) {
+ case 5:
+ memcpy(out, &digits[0], 6), out += 6;
+ *out = 0;
+ return out - buffer;
+ case 4:
+ memcpy(out, &digits[0], 5), out += 5;
+ if (digits[5] != '0') {
+ *out++ = '.';
+ *out++ = digits[5];
+ }
+ *out = 0;
+ return out - buffer;
+ case 3:
+ memcpy(out, &digits[0], 4), out += 4;
+ if ((digits[5] | digits[4]) != '0') {
+ *out++ = '.';
+ *out++ = digits[4];
+ if (digits[5] != '0') *out++ = digits[5];
+ }
+ *out = 0;
+ return out - buffer;
+ case 2:
+ memcpy(out, &digits[0], 3), out += 3;
+ *out++ = '.';
+ memcpy(out, &digits[3], 3);
+ out += 3;
+ while (out[-1] == '0') --out;
+ if (out[-1] == '.') --out;
+ *out = 0;
+ return out - buffer;
+ case 1:
+ memcpy(out, &digits[0], 2), out += 2;
+ *out++ = '.';
+ memcpy(out, &digits[2], 4);
+ out += 4;
+ while (out[-1] == '0') --out;
+ if (out[-1] == '.') --out;
+ *out = 0;
+ return out - buffer;
+ case 0:
+ memcpy(out, &digits[0], 1), out += 1;
+ *out++ = '.';
+ memcpy(out, &digits[1], 5);
+ out += 5;
+ while (out[-1] == '0') --out;
+ if (out[-1] == '.') --out;
+ *out = 0;
+ return out - buffer;
+ case -4:
+ out[2] = '0';
+ ++out;
+ ABSL_FALLTHROUGH_INTENDED;
+ case -3:
+ out[2] = '0';
+ ++out;
+ ABSL_FALLTHROUGH_INTENDED;
+ case -2:
+ out[2] = '0';
+ ++out;
+ ABSL_FALLTHROUGH_INTENDED;
+ case -1:
+ out += 2;
+ memcpy(out, &digits[0], 6);
+ out += 6;
+ while (out[-1] == '0') --out;
+ *out = 0;
+ return out - buffer;
+ }
+ assert(exp < -4 || exp >= 6);
+ out[0] = digits[0];
+ assert(out[1] == '.');
+ out += 2;
+ memcpy(out, &digits[1], 5), out += 5;
+ while (out[-1] == '0') --out;
+ if (out[-1] == '.') --out;
+ *out++ = 'e';
+ if (exp > 0) {
+ *out++ = '+';
+ } else {
+ *out++ = '-';
+ exp = -exp;
+ }
+ if (exp > 99) {
+ int dig1 = exp / 100;
+ exp -= dig1 * 100;
+ *out++ = '0' + dig1;
+ }
+ PutTwoDigits(exp, out);
+ out += 2;
+ *out = 0;
+ return out - buffer;
+}
+
+namespace {
+// Represents integer values of digits.
+// Uses 36 to indicate an invalid character since we support
+// bases up to 36.
+static const int8_t kAsciiToInt[256] = {
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, // 16 36s.
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 0, 1, 2, 3, 4, 5,
+ 6, 7, 8, 9, 36, 36, 36, 36, 36, 36, 36, 10, 11, 12, 13, 14, 15, 16, 17,
+ 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,
+ 36, 36, 36, 36, 36, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
+ 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36,
+ 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36, 36};
+
+// Parse the sign and optional hex or oct prefix in text.
+inline bool safe_parse_sign_and_base(absl::string_view* text /*inout*/,
+ int* base_ptr /*inout*/,
+ bool* negative_ptr /*output*/) {
+ if (text->data() == nullptr) {
+ return false;
+ }
+
+ const char* start = text->data();
+ const char* end = start + text->size();
+ int base = *base_ptr;
+
+ // Consume whitespace.
+ while (start < end && absl::ascii_isspace(start[0])) {
+ ++start;
+ }
+ while (start < end && absl::ascii_isspace(end[-1])) {
+ --end;
+ }
+ if (start >= end) {
+ return false;
+ }
+
+ // Consume sign.
+ *negative_ptr = (start[0] == '-');
+ if (*negative_ptr || start[0] == '+') {
+ ++start;
+ if (start >= end) {
+ return false;
+ }
+ }
+
+ // Consume base-dependent prefix.
+ // base 0: "0x" -> base 16, "0" -> base 8, default -> base 10
+ // base 16: "0x" -> base 16
+ // Also validate the base.
+ if (base == 0) {
+ if (end - start >= 2 && start[0] == '0' &&
+ (start[1] == 'x' || start[1] == 'X')) {
+ base = 16;
+ start += 2;
+ if (start >= end) {
+ // "0x" with no digits after is invalid.
+ return false;
+ }
+ } else if (end - start >= 1 && start[0] == '0') {
+ base = 8;
+ start += 1;
+ } else {
+ base = 10;
+ }
+ } else if (base == 16) {
+ if (end - start >= 2 && start[0] == '0' &&
+ (start[1] == 'x' || start[1] == 'X')) {
+ start += 2;
+ if (start >= end) {
+ // "0x" with no digits after is invalid.
+ return false;
+ }
+ }
+ } else if (base >= 2 && base <= 36) {
+ // okay
+ } else {
+ return false;
+ }
+ *text = absl::string_view(start, end - start);
+ *base_ptr = base;
+ return true;
+}
+
+// Consume digits.
+//
+// The classic loop:
+//
+// for each digit
+// value = value * base + digit
+// value *= sign
+//
+// The classic loop needs overflow checking. It also fails on the most
+// negative integer, -2147483648 in 32-bit two's complement representation.
+//
+// My improved loop:
+//
+// if (!negative)
+// for each digit
+// value = value * base
+// value = value + digit
+// else
+// for each digit
+// value = value * base
+// value = value - digit
+//
+// Overflow checking becomes simple.
+
+// Lookup tables per IntType:
+// vmax/base and vmin/base are precomputed because division costs at least 8ns.
+// TODO(junyer): Doing this per base instead (i.e. an array of structs, not a
+// struct of arrays) would probably be better in terms of d-cache for the most
+// commonly used bases.
+template <typename IntType>
+struct LookupTables {
+ static const IntType kVmaxOverBase[];
+ static const IntType kVminOverBase[];
+};
+
+// An array initializer macro for X/base where base in [0, 36].
+// However, note that lookups for base in [0, 1] should never happen because
+// base has been validated to be in [2, 36] by safe_parse_sign_and_base().
+#define X_OVER_BASE_INITIALIZER(X) \
+ { \
+ 0, 0, X / 2, X / 3, X / 4, X / 5, X / 6, X / 7, X / 8, X / 9, X / 10, \
+ X / 11, X / 12, X / 13, X / 14, X / 15, X / 16, X / 17, X / 18, \
+ X / 19, X / 20, X / 21, X / 22, X / 23, X / 24, X / 25, X / 26, \
+ X / 27, X / 28, X / 29, X / 30, X / 31, X / 32, X / 33, X / 34, \
+ X / 35, X / 36, \
+ }
+
+template <typename IntType>
+const IntType LookupTables<IntType>::kVmaxOverBase[] =
+ X_OVER_BASE_INITIALIZER(std::numeric_limits<IntType>::max());
+
+template <typename IntType>
+const IntType LookupTables<IntType>::kVminOverBase[] =
+ X_OVER_BASE_INITIALIZER(std::numeric_limits<IntType>::min());
+
+#undef X_OVER_BASE_INITIALIZER
+
+template <typename IntType>
+inline bool safe_parse_positive_int(absl::string_view text, int base,
+ IntType* value_p) {
+ IntType value = 0;
+ const IntType vmax = std::numeric_limits<IntType>::max();
+ assert(vmax > 0);
+ assert(base >= 0);
+ assert(vmax >= static_cast<IntType>(base));
+ const IntType vmax_over_base = LookupTables<IntType>::kVmaxOverBase[base];
+ const char* start = text.data();
+ const char* end = start + text.size();
+ // loop over digits
+ for (; start < end; ++start) {
+ unsigned char c = static_cast<unsigned char>(start[0]);
+ int digit = kAsciiToInt[c];
+ if (digit >= base) {
+ *value_p = value;
+ return false;
+ }
+ if (value > vmax_over_base) {
+ *value_p = vmax;
+ return false;
+ }
+ value *= base;
+ if (value > vmax - digit) {
+ *value_p = vmax;
+ return false;
+ }
+ value += digit;
+ }
+ *value_p = value;
+ return true;
+}
+
+template <typename IntType>
+inline bool safe_parse_negative_int(absl::string_view text, int base,
+ IntType* value_p) {
+ IntType value = 0;
+ const IntType vmin = std::numeric_limits<IntType>::min();
+ assert(vmin < 0);
+ assert(vmin <= 0 - base);
+ IntType vmin_over_base = LookupTables<IntType>::kVminOverBase[base];
+ // 2003 c++ standard [expr.mul]
+ // "... the sign of the remainder is implementation-defined."
+ // Although (vmin/base)*base + vmin%base is always vmin.
+ // 2011 c++ standard tightens the spec but we cannot rely on it.
+ // TODO(junyer): Handle this in the lookup table generation.
+ if (vmin % base > 0) {
+ vmin_over_base += 1;
+ }
+ const char* start = text.data();
+ const char* end = start + text.size();
+ // loop over digits
+ for (; start < end; ++start) {
+ unsigned char c = static_cast<unsigned char>(start[0]);
+ int digit = kAsciiToInt[c];
+ if (digit >= base) {
+ *value_p = value;
+ return false;
+ }
+ if (value < vmin_over_base) {
+ *value_p = vmin;
+ return false;
+ }
+ value *= base;
+ if (value < vmin + digit) {
+ *value_p = vmin;
+ return false;
+ }
+ value -= digit;
+ }
+ *value_p = value;
+ return true;
+}
+
+// Input format based on POSIX.1-2008 strtol
+// http://pubs.opengroup.org/onlinepubs/9699919799/functions/strtol.html
+template <typename IntType>
+inline bool safe_int_internal(absl::string_view text, IntType* value_p,
+ int base) {
+ *value_p = 0;
+ bool negative;
+ if (!safe_parse_sign_and_base(&text, &base, &negative)) {
+ return false;
+ }
+ if (!negative) {
+ return safe_parse_positive_int(text, base, value_p);
+ } else {
+ return safe_parse_negative_int(text, base, value_p);
+ }
+}
+
+template <typename IntType>
+inline bool safe_uint_internal(absl::string_view text, IntType* value_p,
+ int base) {
+ *value_p = 0;
+ bool negative;
+ if (!safe_parse_sign_and_base(&text, &base, &negative) || negative) {
+ return false;
+ }
+ return safe_parse_positive_int(text, base, value_p);
+}
+} // anonymous namespace
+
+namespace numbers_internal {
+bool safe_strto32_base(absl::string_view text, int32_t* value, int base) {
+ return safe_int_internal<int32_t>(text, value, base);
+}
+
+bool safe_strto64_base(absl::string_view text, int64_t* value, int base) {
+ return safe_int_internal<int64_t>(text, value, base);
+}
+
+bool safe_strtou32_base(absl::string_view text, uint32_t* value, int base) {
+ return safe_uint_internal<uint32_t>(text, value, base);
+}
+
+bool safe_strtou64_base(absl::string_view text, uint64_t* value, int base) {
+ return safe_uint_internal<uint64_t>(text, value, base);
+}
+} // namespace numbers_internal
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers.h
new file mode 100644
index 0000000..adf706a
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/numbers.h
@@ -0,0 +1,172 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: numbers.h
+// -----------------------------------------------------------------------------
+//
+// This package contains functions for converting strings to numbers. For
+// converting numbers to strings, use `StrCat()` or `StrAppend()` in str_cat.h,
+// which automatically detect and convert most number values appropriately.
+
+#ifndef ABSL_STRINGS_NUMBERS_H_
+#define ABSL_STRINGS_NUMBERS_H_
+
+#include <cstddef>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <limits>
+#include <string>
+#include <type_traits>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/numeric/int128.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+
+// SimpleAtoi()
+//
+// Converts the given std::string into an integer value, returning `true` if
+// successful. The std::string must reflect a base-10 integer (optionally followed or
+// preceded by ASCII whitespace) whose value falls within the range of the
+// integer type,
+template <typename int_type>
+ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view s, int_type* out);
+
+// SimpleAtof()
+//
+// Converts the given std::string (optionally followed or preceded by ASCII
+// whitespace) into a float, which may be rounded on overflow or underflow.
+ABSL_MUST_USE_RESULT bool SimpleAtof(absl::string_view str, float* value);
+
+// SimpleAtod()
+//
+// Converts the given std::string (optionally followed or preceded by ASCII
+// whitespace) into a double, which may be rounded on overflow or underflow.
+ABSL_MUST_USE_RESULT bool SimpleAtod(absl::string_view str, double* value);
+
+// SimpleAtob()
+//
+// Converts the given std::string into a boolean, returning `true` if successful.
+// The following case-insensitive strings are interpreted as boolean `true`:
+// "true", "t", "yes", "y", "1". The following case-insensitive strings
+// are interpreted as boolean `false`: "false", "f", "no", "n", "0".
+ABSL_MUST_USE_RESULT bool SimpleAtob(absl::string_view str, bool* value);
+
+} // namespace absl
+
+// End of public API. Implementation details follow.
+
+namespace absl {
+namespace numbers_internal {
+
+// safe_strto?() functions for implementing SimpleAtoi()
+bool safe_strto32_base(absl::string_view text, int32_t* value, int base);
+bool safe_strto64_base(absl::string_view text, int64_t* value, int base);
+bool safe_strtou32_base(absl::string_view text, uint32_t* value, int base);
+bool safe_strtou64_base(absl::string_view text, uint64_t* value, int base);
+
+static const int kFastToBufferSize = 32;
+static const int kSixDigitsToBufferSize = 16;
+
+// Helper function for fast formatting of floating-point values.
+// The result is the same as printf's "%g", a.k.a. "%.6g"; that is, six
+// significant digits are returned, trailing zeros are removed, and numbers
+// outside the range 0.0001-999999 are output using scientific notation
+// (1.23456e+06). This routine is heavily optimized.
+// Required buffer size is `kSixDigitsToBufferSize`.
+size_t SixDigitsToBuffer(double d, char* buffer);
+
+// These functions are intended for speed. All functions take an output buffer
+// as an argument and return a pointer to the last byte they wrote, which is the
+// terminating '\0'. At most `kFastToBufferSize` bytes are written.
+char* FastIntToBuffer(int32_t, char*);
+char* FastIntToBuffer(uint32_t, char*);
+char* FastIntToBuffer(int64_t, char*);
+char* FastIntToBuffer(uint64_t, char*);
+
+// For enums and integer types that are not an exact match for the types above,
+// use templates to call the appropriate one of the four overloads above.
+template <typename int_type>
+char* FastIntToBuffer(int_type i, char* buffer) {
+ static_assert(sizeof(i) <= 64 / 8,
+ "FastIntToBuffer works only with 64-bit-or-less integers.");
+ // TODO(jorg): This signed-ness check is used because it works correctly
+ // with enums, and it also serves to check that int_type is not a pointer.
+ // If one day something like std::is_signed<enum E> works, switch to it.
+ if (static_cast<int_type>(1) - 2 < 0) { // Signed
+ if (sizeof(i) > 32 / 8) { // 33-bit to 64-bit
+ return FastIntToBuffer(static_cast<int64_t>(i), buffer);
+ } else { // 32-bit or less
+ return FastIntToBuffer(static_cast<int32_t>(i), buffer);
+ }
+ } else { // Unsigned
+ if (sizeof(i) > 32 / 8) { // 33-bit to 64-bit
+ return FastIntToBuffer(static_cast<uint64_t>(i), buffer);
+ } else { // 32-bit or less
+ return FastIntToBuffer(static_cast<uint32_t>(i), buffer);
+ }
+ }
+}
+
+} // namespace numbers_internal
+
+// SimpleAtoi()
+//
+// Converts a std::string to an integer, using `safe_strto?()` functions for actual
+// parsing, returning `true` if successful. The `safe_strto?()` functions apply
+// strict checking; the std::string must be a base-10 integer, optionally followed or
+// preceded by ASCII whitespace, with a value in the range of the corresponding
+// integer type.
+template <typename int_type>
+ABSL_MUST_USE_RESULT bool SimpleAtoi(absl::string_view s, int_type* out) {
+ static_assert(sizeof(*out) == 4 || sizeof(*out) == 8,
+ "SimpleAtoi works only with 32-bit or 64-bit integers.");
+ static_assert(!std::is_floating_point<int_type>::value,
+ "Use SimpleAtof or SimpleAtod instead.");
+ bool parsed;
+ // TODO(jorg): This signed-ness check is used because it works correctly
+ // with enums, and it also serves to check that int_type is not a pointer.
+ // If one day something like std::is_signed<enum E> works, switch to it.
+ if (static_cast<int_type>(1) - 2 < 0) { // Signed
+ if (sizeof(*out) == 64 / 8) { // 64-bit
+ int64_t val;
+ parsed = numbers_internal::safe_strto64_base(s, &val, 10);
+ *out = static_cast<int_type>(val);
+ } else { // 32-bit
+ int32_t val;
+ parsed = numbers_internal::safe_strto32_base(s, &val, 10);
+ *out = static_cast<int_type>(val);
+ }
+ } else { // Unsigned
+ if (sizeof(*out) == 64 / 8) { // 64-bit
+ uint64_t val;
+ parsed = numbers_internal::safe_strtou64_base(s, &val, 10);
+ *out = static_cast<int_type>(val);
+ } else { // 32-bit
+ uint32_t val;
+ parsed = numbers_internal::safe_strtou32_base(s, &val, 10);
+ *out = static_cast<int_type>(val);
+ }
+ }
+ return parsed;
+}
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_NUMBERS_H_
[49/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/container.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/container.h b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/container.h
new file mode 100644
index 0000000..ebe3244
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/container.h
@@ -0,0 +1,1642 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: container.h
+// -----------------------------------------------------------------------------
+//
+// This header file provides Container-based versions of algorithmic functions
+// within the C++ standard library. The following standard library sets of
+// functions are covered within this file:
+//
+// * Algorithmic <iterator> functions
+// * Algorithmic <numeric> functions
+// * <algorithm> functions
+//
+// The standard library functions operate on iterator ranges; the functions
+// within this API operate on containers, though many return iterator ranges.
+//
+// All functions within this API are named with a `c_` prefix. Calls such as
+// `absl::c_xx(container, ...) are equivalent to std:: functions such as
+// `std::xx(std::begin(cont), std::end(cont), ...)`. Functions that act on
+// iterators but not conceptually on iterator ranges (e.g. `std::iter_swap`)
+// have no equivalent here.
+//
+// For template parameter and variable naming, `C` indicates the container type
+// to which the function is applied, `Pred` indicates the predicate object type
+// to be used by the function and `T` indicates the applicable element type.
+//
+
+#ifndef ABSL_ALGORITHM_CONTAINER_H_
+#define ABSL_ALGORITHM_CONTAINER_H_
+
+#include <algorithm>
+#include <cassert>
+#include <iterator>
+#include <numeric>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "absl/algorithm/algorithm.h"
+#include "absl/base/macros.h"
+#include "absl/meta/type_traits.h"
+
+namespace absl {
+
+namespace container_algorithm_internal {
+
+// NOTE: it is important to defer to ADL lookup for building with C++ modules,
+// especially for headers like <valarray> which are not visible from this file
+// but specialize std::begin and std::end.
+using std::begin;
+using std::end;
+
+// The type of the iterator given by begin(c) (possibly std::begin(c)).
+// ContainerIter<const vector<T>> gives vector<T>::const_iterator,
+// while ContainerIter<vector<T>> gives vector<T>::iterator.
+template <typename C>
+using ContainerIter = decltype(begin(std::declval<C&>()));
+
+// An MSVC bug involving template parameter substitution requires us to use
+// decltype() here instead of just std::pair.
+template <typename C1, typename C2>
+using ContainerIterPairType =
+ decltype(std::make_pair(ContainerIter<C1>(), ContainerIter<C2>()));
+
+template <typename C>
+using ContainerDifferenceType =
+ decltype(std::distance(std::declval<ContainerIter<C>>(),
+ std::declval<ContainerIter<C>>()));
+
+template <typename C>
+using ContainerPointerType =
+ typename std::iterator_traits<ContainerIter<C>>::pointer;
+
+// container_algorithm_internal::c_begin and
+// container_algorithm_internal::c_end are abbreviations for proper ADL
+// lookup of std::begin and std::end, i.e.
+// using std::begin;
+// using std::end;
+// std::foo(begin(c), end(c);
+// becomes
+// std::foo(container_algorithm_internal::begin(c),
+// container_algorithm_internal::end(c));
+// These are meant for internal use only.
+
+template <typename C>
+ContainerIter<C> c_begin(C& c) { return begin(c); }
+
+template <typename C>
+ContainerIter<C> c_end(C& c) { return end(c); }
+
+} // namespace container_algorithm_internal
+
+// PUBLIC API
+
+//------------------------------------------------------------------------------
+// Abseil algorithm.h functions
+//------------------------------------------------------------------------------
+
+// c_linear_search()
+//
+// Container-based version of absl::linear_search() for performing a linear
+// search within a container.
+template <typename C, typename EqualityComparable>
+bool c_linear_search(const C& c, EqualityComparable&& value) {
+ return linear_search(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<EqualityComparable>(value));
+}
+
+//------------------------------------------------------------------------------
+// <iterator> algorithms
+//------------------------------------------------------------------------------
+
+// c_distance()
+//
+// Container-based version of the <iterator> `std::distance()` function to
+// return the number of elements within a container.
+template <typename C>
+container_algorithm_internal::ContainerDifferenceType<const C> c_distance(
+ const C& c) {
+ return std::distance(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Non-modifying sequence operations
+//------------------------------------------------------------------------------
+
+// c_all_of()
+//
+// Container-based version of the <algorithm> `std::all_of()` function to
+// test a condition on all elements within a container.
+template <typename C, typename Pred>
+bool c_all_of(const C& c, Pred&& pred) {
+ return std::all_of(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred));
+}
+
+// c_any_of()
+//
+// Container-based version of the <algorithm> `std::any_of()` function to
+// test if any element in a container fulfills a condition.
+template <typename C, typename Pred>
+bool c_any_of(const C& c, Pred&& pred) {
+ return std::any_of(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred));
+}
+
+// c_none_of()
+//
+// Container-based version of the <algorithm> `std::none_of()` function to
+// test if no elements in a container fulfil a condition.
+template <typename C, typename Pred>
+bool c_none_of(const C& c, Pred&& pred) {
+ return std::none_of(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred));
+}
+
+// c_for_each()
+//
+// Container-based version of the <algorithm> `std::for_each()` function to
+// apply a function to a container's elements.
+template <typename C, typename Function>
+decay_t<Function> c_for_each(C&& c, Function&& f) {
+ return std::for_each(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Function>(f));
+}
+
+// c_find()
+//
+// Container-based version of the <algorithm> `std::find()` function to find
+// the first element containing the passed value within a container value.
+template <typename C, typename T>
+container_algorithm_internal::ContainerIter<C> c_find(C& c, T&& value) {
+ return std::find(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<T>(value));
+}
+
+// c_find_if()
+//
+// Container-based version of the <algorithm> `std::find_if()` function to find
+// the first element in a container matching the given condition.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerIter<C> c_find_if(C& c, Pred&& pred) {
+ return std::find_if(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred));
+}
+
+// c_find_if_not()
+//
+// Container-based version of the <algorithm> `std::find_if_not()` function to
+// find the first element in a container not matching the given condition.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerIter<C> c_find_if_not(C& c,
+ Pred&& pred) {
+ return std::find_if_not(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred));
+}
+
+// c_find_end()
+//
+// Container-based version of the <algorithm> `std::find_end()` function to
+// find the last subsequence within a container.
+template <typename Sequence1, typename Sequence2>
+container_algorithm_internal::ContainerIter<Sequence1> c_find_end(
+ Sequence1& sequence, Sequence2& subsequence) {
+ return std::find_end(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ container_algorithm_internal::c_begin(subsequence),
+ container_algorithm_internal::c_end(subsequence));
+}
+
+// Overload of c_find_end() for using a predicate evaluation other than `==` as
+// the function's test condition.
+template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
+container_algorithm_internal::ContainerIter<Sequence1> c_find_end(
+ Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred) {
+ return std::find_end(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ container_algorithm_internal::c_begin(subsequence),
+ container_algorithm_internal::c_end(subsequence),
+ std::forward<BinaryPredicate>(pred));
+}
+
+// c_find_first_of()
+//
+// Container-based version of the <algorithm> `std::find_first_of()` function to
+// find the first elements in an ordered set within a container.
+template <typename C1, typename C2>
+container_algorithm_internal::ContainerIter<C1> c_find_first_of(C1& container,
+ C2& options) {
+ return std::find_first_of(container_algorithm_internal::c_begin(container),
+ container_algorithm_internal::c_end(container),
+ container_algorithm_internal::c_begin(options),
+ container_algorithm_internal::c_end(options));
+}
+
+// Overload of c_find_first_of() for using a predicate evaluation other than
+// `==` as the function's test condition.
+template <typename C1, typename C2, typename BinaryPredicate>
+container_algorithm_internal::ContainerIter<C1> c_find_first_of(
+ C1& container, C2& options, BinaryPredicate&& pred) {
+ return std::find_first_of(container_algorithm_internal::c_begin(container),
+ container_algorithm_internal::c_end(container),
+ container_algorithm_internal::c_begin(options),
+ container_algorithm_internal::c_end(options),
+ std::forward<BinaryPredicate>(pred));
+}
+
+// c_adjacent_find()
+//
+// Container-based version of the <algorithm> `std::adjacent_find()` function to
+// find equal adjacent elements within a container.
+template <typename Sequence>
+container_algorithm_internal::ContainerIter<Sequence> c_adjacent_find(
+ Sequence& sequence) {
+ return std::adjacent_find(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_adjacent_find() for using a predicate evaluation other than
+// `==` as the function's test condition.
+template <typename Sequence, typename BinaryPredicate>
+container_algorithm_internal::ContainerIter<Sequence> c_adjacent_find(
+ Sequence& sequence, BinaryPredicate&& pred) {
+ return std::adjacent_find(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<BinaryPredicate>(pred));
+}
+
+// c_count()
+//
+// Container-based version of the <algorithm> `std::count()` function to count
+// values that match within a container.
+template <typename C, typename T>
+container_algorithm_internal::ContainerDifferenceType<const C> c_count(
+ const C& c, T&& value) {
+ return std::count(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<T>(value));
+}
+
+// c_count_if()
+//
+// Container-based version of the <algorithm> `std::count_if()` function to
+// count values matching a condition within a container.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerDifferenceType<const C> c_count_if(
+ const C& c, Pred&& pred) {
+ return std::count_if(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred));
+}
+
+// c_mismatch()
+//
+// Container-based version of the <algorithm> `std::mismatchf()` function to
+// return the first element where two ordered containers differ.
+template <typename C1, typename C2>
+container_algorithm_internal::ContainerIterPairType<C1, C2>
+c_mismatch(C1& c1, C2& c2) {
+ return std::mismatch(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2));
+}
+
+// Overload of c_mismatch() for using a predicate evaluation other than `==` as
+// the function's test condition.
+template <typename C1, typename C2, typename BinaryPredicate>
+container_algorithm_internal::ContainerIterPairType<C1, C2>
+c_mismatch(C1& c1, C2& c2, BinaryPredicate&& pred) {
+ return std::mismatch(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ std::forward<BinaryPredicate>(pred));
+}
+
+// c_equal()
+//
+// Container-based version of the <algorithm> `std::equal()` function to
+// test whether two containers are equal.
+//
+// NOTE: the semantics of c_equal() are slightly different than those of
+// equal(): while the latter iterates over the second container only up to the
+// size of the first container, c_equal() also checks whether the container
+// sizes are equal. This better matches expectations about c_equal() based on
+// its signature.
+//
+// Example:
+// vector v1 = <1, 2, 3>;
+// vector v2 = <1, 2, 3, 4>;
+// equal(std::begin(v1), std::end(v1), std::begin(v2)) returns true
+// c_equal(v1, v2) returns false
+
+template <typename C1, typename C2>
+bool c_equal(const C1& c1, const C2& c2) {
+ return ((c1.size() == c2.size()) &&
+ std::equal(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2)));
+}
+
+// Overload of c_equal() for using a predicate evaluation other than `==` as
+// the function's test condition.
+template <typename C1, typename C2, typename BinaryPredicate>
+bool c_equal(const C1& c1, const C2& c2, BinaryPredicate&& pred) {
+ return ((c1.size() == c2.size()) &&
+ std::equal(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ std::forward<BinaryPredicate>(pred)));
+}
+
+// c_is_permutation()
+//
+// Container-based version of the <algorithm> `std::is_permutation()` function
+// to test whether a container is a permutation of another.
+template <typename C1, typename C2>
+bool c_is_permutation(const C1& c1, const C2& c2) {
+ using std::begin;
+ using std::end;
+ return c1.size() == c2.size() &&
+ std::is_permutation(begin(c1), end(c1), begin(c2));
+}
+
+// Overload of c_is_permutation() for using a predicate evaluation other than
+// `==` as the function's test condition.
+template <typename C1, typename C2, typename BinaryPredicate>
+bool c_is_permutation(const C1& c1, const C2& c2, BinaryPredicate&& pred) {
+ using std::begin;
+ using std::end;
+ return c1.size() == c2.size() &&
+ std::is_permutation(begin(c1), end(c1), begin(c2),
+ std::forward<BinaryPredicate>(pred));
+}
+
+// c_search()
+//
+// Container-based version of the <algorithm> `std::search()` function to search
+// a container for a subsequence.
+template <typename Sequence1, typename Sequence2>
+container_algorithm_internal::ContainerIter<Sequence1> c_search(
+ Sequence1& sequence, Sequence2& subsequence) {
+ return std::search(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ container_algorithm_internal::c_begin(subsequence),
+ container_algorithm_internal::c_end(subsequence));
+}
+
+// Overload of c_search() for using a predicate evaluation other than
+// `==` as the function's test condition.
+template <typename Sequence1, typename Sequence2, typename BinaryPredicate>
+container_algorithm_internal::ContainerIter<Sequence1> c_search(
+ Sequence1& sequence, Sequence2& subsequence, BinaryPredicate&& pred) {
+ return std::search(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ container_algorithm_internal::c_begin(subsequence),
+ container_algorithm_internal::c_end(subsequence),
+ std::forward<BinaryPredicate>(pred));
+}
+
+// c_search_n()
+//
+// Container-based version of the <algorithm> `std::search_n()` function to
+// search a container for the first sequence of N elements.
+template <typename Sequence, typename Size, typename T>
+container_algorithm_internal::ContainerIter<Sequence> c_search_n(
+ Sequence& sequence, Size count, T&& value) {
+ return std::search_n(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence), count,
+ std::forward<T>(value));
+}
+
+// Overload of c_search_n() for using a predicate evaluation other than
+// `==` as the function's test condition.
+template <typename Sequence, typename Size, typename T,
+ typename BinaryPredicate>
+container_algorithm_internal::ContainerIter<Sequence> c_search_n(
+ Sequence& sequence, Size count, T&& value, BinaryPredicate&& pred) {
+ return std::search_n(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence), count,
+ std::forward<T>(value),
+ std::forward<BinaryPredicate>(pred));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Modifying sequence operations
+//------------------------------------------------------------------------------
+
+// c_copy()
+//
+// Container-based version of the <algorithm> `std::copy()` function to copy a
+// container's elements into an iterator.
+template <typename InputSequence, typename OutputIterator>
+OutputIterator c_copy(const InputSequence& input, OutputIterator output) {
+ return std::copy(container_algorithm_internal::c_begin(input),
+ container_algorithm_internal::c_end(input), output);
+}
+
+// c_copy_n()
+//
+// Container-based version of the <algorithm> `std::copy_n()` function to copy a
+// container's first N elements into an iterator.
+template <typename C, typename Size, typename OutputIterator>
+OutputIterator c_copy_n(const C& input, Size n, OutputIterator output) {
+ return std::copy_n(container_algorithm_internal::c_begin(input), n, output);
+}
+
+// c_copy_if()
+//
+// Container-based version of the <algorithm> `std::copy_if()` function to copy
+// a container's elements satisfying some condition into an iterator.
+template <typename InputSequence, typename OutputIterator, typename Pred>
+OutputIterator c_copy_if(const InputSequence& input, OutputIterator output,
+ Pred&& pred) {
+ return std::copy_if(container_algorithm_internal::c_begin(input),
+ container_algorithm_internal::c_end(input), output,
+ std::forward<Pred>(pred));
+}
+
+// c_copy_backward()
+//
+// Container-based version of the <algorithm> `std::copy_backward()` function to
+// copy a container's elements in reverse order into an iterator.
+template <typename C, typename BidirectionalIterator>
+BidirectionalIterator c_copy_backward(const C& src,
+ BidirectionalIterator dest) {
+ return std::copy_backward(container_algorithm_internal::c_begin(src),
+ container_algorithm_internal::c_end(src), dest);
+}
+
+// c_move()
+//
+// Container-based version of the <algorithm> `std::move()` function to move
+// a container's elements into an iterator.
+template <typename C, typename OutputIterator>
+OutputIterator c_move(C& src, OutputIterator dest) {
+ return std::move(container_algorithm_internal::c_begin(src),
+ container_algorithm_internal::c_end(src), dest);
+}
+
+// c_swap_ranges()
+//
+// Container-based version of the <algorithm> `std::swap_ranges()` function to
+// swap a container's elements with another container's elements.
+template <typename C1, typename C2>
+container_algorithm_internal::ContainerIter<C2> c_swap_ranges(C1& c1, C2& c2) {
+ return std::swap_ranges(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2));
+}
+
+// c_transform()
+//
+// Container-based version of the <algorithm> `std::transform()` function to
+// transform a container's elements using the unary operation, storing the
+// result in an iterator pointing to the last transformed element in the output
+// range.
+template <typename InputSequence, typename OutputIterator, typename UnaryOp>
+OutputIterator c_transform(const InputSequence& input, OutputIterator output,
+ UnaryOp&& unary_op) {
+ return std::transform(container_algorithm_internal::c_begin(input),
+ container_algorithm_internal::c_end(input), output,
+ std::forward<UnaryOp>(unary_op));
+}
+
+// Overload of c_transform() for performing a transformation using a binary
+// predicate.
+template <typename InputSequence1, typename InputSequence2,
+ typename OutputIterator, typename BinaryOp>
+OutputIterator c_transform(const InputSequence1& input1,
+ const InputSequence2& input2, OutputIterator output,
+ BinaryOp&& binary_op) {
+ return std::transform(container_algorithm_internal::c_begin(input1),
+ container_algorithm_internal::c_end(input1),
+ container_algorithm_internal::c_begin(input2), output,
+ std::forward<BinaryOp>(binary_op));
+}
+
+// c_replace()
+//
+// Container-based version of the <algorithm> `std::replace()` function to
+// replace a container's elements of some value with a new value. The container
+// is modified in place.
+template <typename Sequence, typename T>
+void c_replace(Sequence& sequence, const T& old_value, const T& new_value) {
+ std::replace(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence), old_value,
+ new_value);
+}
+
+// c_replace_if()
+//
+// Container-based version of the <algorithm> `std::replace_if()` function to
+// replace a container's elements of some value with a new value based on some
+// condition. The container is modified in place.
+template <typename C, typename Pred, typename T>
+void c_replace_if(C& c, Pred&& pred, T&& new_value) {
+ std::replace_if(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred), std::forward<T>(new_value));
+}
+
+// c_replace_copy()
+//
+// Container-based version of the <algorithm> `std::replace_copy()` function to
+// replace a container's elements of some value with a new value and return the
+// results within an iterator.
+template <typename C, typename OutputIterator, typename T>
+OutputIterator c_replace_copy(const C& c, OutputIterator result, T&& old_value,
+ T&& new_value) {
+ return std::replace_copy(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c), result,
+ std::forward<T>(old_value),
+ std::forward<T>(new_value));
+}
+
+// c_replace_copy_if()
+//
+// Container-based version of the <algorithm> `std::replace_copy_if()` function
+// to replace a container's elements of some value with a new value based on
+// some condition, and return the results within an iterator.
+template <typename C, typename OutputIterator, typename Pred, typename T>
+OutputIterator c_replace_copy_if(const C& c, OutputIterator result, Pred&& pred,
+ T&& new_value) {
+ return std::replace_copy_if(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c), result,
+ std::forward<Pred>(pred),
+ std::forward<T>(new_value));
+}
+
+// c_fill()
+//
+// Container-based version of the <algorithm> `std::fill()` function to fill a
+// container with some value.
+template <typename C, typename T>
+void c_fill(C& c, T&& value) {
+ std::fill(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c), std::forward<T>(value));
+}
+
+// c_fill_n()
+//
+// Container-based version of the <algorithm> `std::fill_n()` function to fill
+// the first N elements in a container with some value.
+template <typename C, typename Size, typename T>
+void c_fill_n(C& c, Size n, T&& value) {
+ std::fill_n(container_algorithm_internal::c_begin(c), n,
+ std::forward<T>(value));
+}
+
+// c_generate()
+//
+// Container-based version of the <algorithm> `std::generate()` function to
+// assign a container's elements to the values provided by the given generator.
+template <typename C, typename Generator>
+void c_generate(C& c, Generator&& gen) {
+ std::generate(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Generator>(gen));
+}
+
+// c_generate_n()
+//
+// Container-based version of the <algorithm> `std::generate_n()` function to
+// assign a container's first N elements to the values provided by the given
+// generator.
+template <typename C, typename Size, typename Generator>
+container_algorithm_internal::ContainerIter<C> c_generate_n(C& c, Size n,
+ Generator&& gen) {
+ return std::generate_n(container_algorithm_internal::c_begin(c), n,
+ std::forward<Generator>(gen));
+}
+
+// Note: `c_xx()` <algorithm> container versions for `remove()`, `remove_if()`,
+// and `unique()` are omitted, because it's not clear whether or not such
+// functions should call erase their supplied sequences afterwards. Either
+// behavior would be surprising for a different set of users.
+//
+
+// c_remove_copy()
+//
+// Container-based version of the <algorithm> `std::remove_copy()` function to
+// copy a container's elements while removing any elements matching the given
+// `value`.
+template <typename C, typename OutputIterator, typename T>
+OutputIterator c_remove_copy(const C& c, OutputIterator result, T&& value) {
+ return std::remove_copy(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c), result,
+ std::forward<T>(value));
+}
+
+// c_remove_copy_if()
+//
+// Container-based version of the <algorithm> `std::remove_copy_if()` function
+// to copy a container's elements while removing any elements matching the given
+// condition.
+template <typename C, typename OutputIterator, typename Pred>
+OutputIterator c_remove_copy_if(const C& c, OutputIterator result,
+ Pred&& pred) {
+ return std::remove_copy_if(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c), result,
+ std::forward<Pred>(pred));
+}
+
+// c_unique_copy()
+//
+// Container-based version of the <algorithm> `std::unique_copy()` function to
+// copy a container's elements while removing any elements containing duplicate
+// values.
+template <typename C, typename OutputIterator>
+OutputIterator c_unique_copy(const C& c, OutputIterator result) {
+ return std::unique_copy(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c), result);
+}
+
+// Overload of c_unique_copy() for using a predicate evaluation other than
+// `==` for comparing uniqueness of the element values.
+template <typename C, typename OutputIterator, typename BinaryPredicate>
+OutputIterator c_unique_copy(const C& c, OutputIterator result,
+ BinaryPredicate&& pred) {
+ return std::unique_copy(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c), result,
+ std::forward<BinaryPredicate>(pred));
+}
+
+// c_reverse()
+//
+// Container-based version of the <algorithm> `std::reverse()` function to
+// reverse a container's elements.
+template <typename Sequence>
+void c_reverse(Sequence& sequence) {
+ std::reverse(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence));
+}
+
+// c_reverse_copy()
+//
+// Container-based version of the <algorithm> `std::reverse()` function to
+// reverse a container's elements and write them to an iterator range.
+template <typename C, typename OutputIterator>
+OutputIterator c_reverse_copy(const C& sequence, OutputIterator result) {
+ return std::reverse_copy(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ result);
+}
+
+// c_rotate()
+//
+// Container-based version of the <algorithm> `std::rotate()` function to
+// shift a container's elements leftward such that the `middle` element becomes
+// the first element in the container.
+template <typename C,
+ typename Iterator = container_algorithm_internal::ContainerIter<C>>
+Iterator c_rotate(C& sequence, Iterator middle) {
+ return absl::rotate(container_algorithm_internal::c_begin(sequence), middle,
+ container_algorithm_internal::c_end(sequence));
+}
+
+// c_rotate_copy()
+//
+// Container-based version of the <algorithm> `std::rotate_copy()` function to
+// shift a container's elements leftward such that the `middle` element becomes
+// the first element in a new iterator range.
+template <typename C, typename OutputIterator>
+OutputIterator c_rotate_copy(
+ const C& sequence,
+ container_algorithm_internal::ContainerIter<const C> middle,
+ OutputIterator result) {
+ return std::rotate_copy(container_algorithm_internal::c_begin(sequence),
+ middle, container_algorithm_internal::c_end(sequence),
+ result);
+}
+
+// c_shuffle()
+//
+// Container-based version of the <algorithm> `std::shuffle()` function to
+// randomly shuffle elements within the container using a `gen()` uniform random
+// number generator.
+template <typename RandomAccessContainer, typename UniformRandomBitGenerator>
+void c_shuffle(RandomAccessContainer& c, UniformRandomBitGenerator&& gen) {
+ std::shuffle(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<UniformRandomBitGenerator>(gen));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Partition functions
+//------------------------------------------------------------------------------
+
+// c_is_partitioned()
+//
+// Container-based version of the <algorithm> `std::is_partitioned()` function
+// to test whether all elements in the container for which `pred` returns `true`
+// precede those for which `pred` is `false`.
+template <typename C, typename Pred>
+bool c_is_partitioned(const C& c, Pred&& pred) {
+ return std::is_partitioned(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred));
+}
+
+// c_partition()
+//
+// Container-based version of the <algorithm> `std::partition()` function
+// to rearrange all elements in a container in such a way that all elements for
+// which `pred` returns `true` precede all those for which it returns `false`,
+// returning an iterator to the first element of the second group.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerIter<C> c_partition(C& c, Pred&& pred) {
+ return std::partition(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred));
+}
+
+// c_stable_partition()
+//
+// Container-based version of the <algorithm> `std::stable_partition()` function
+// to rearrange all elements in a container in such a way that all elements for
+// which `pred` returns `true` precede all those for which it returns `false`,
+// preserving the relative ordering between the two groups. The function returns
+// an iterator to the first element of the second group.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerIter<C> c_stable_partition(C& c,
+ Pred&& pred) {
+ return std::stable_partition(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred));
+}
+
+// c_partition_copy()
+//
+// Container-based version of the <algorithm> `std::partition_copy()` function
+// to partition a container's elements and return them into two iterators: one
+// for which `pred` returns `true`, and one for which `pred` returns `false.`
+
+template <typename C, typename OutputIterator1, typename OutputIterator2,
+ typename Pred>
+std::pair<OutputIterator1, OutputIterator2> c_partition_copy(
+ const C& c, OutputIterator1 out_true, OutputIterator2 out_false,
+ Pred&& pred) {
+ return std::partition_copy(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c), out_true,
+ out_false, std::forward<Pred>(pred));
+}
+
+// c_partition_point()
+//
+// Container-based version of the <algorithm> `std::partition_point()` function
+// to return the first element of an already partitioned container for which
+// the given `pred` is not `true`.
+template <typename C, typename Pred>
+container_algorithm_internal::ContainerIter<C> c_partition_point(C& c,
+ Pred&& pred) {
+ return std::partition_point(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Pred>(pred));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Sorting functions
+//------------------------------------------------------------------------------
+
+// c_sort()
+//
+// Container-based version of the <algorithm> `std::sort()` function
+// to sort elements in ascending order of their values.
+template <typename C>
+void c_sort(C& c) {
+ std::sort(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_sort() for performing a `comp` comparison other than the
+// default `operator<`.
+template <typename C, typename Compare>
+void c_sort(C& c, Compare&& comp) {
+ std::sort(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Compare>(comp));
+}
+
+// c_stable_sort()
+//
+// Container-based version of the <algorithm> `std::stable_sort()` function
+// to sort elements in ascending order of their values, preserving the order
+// of equivalents.
+template <typename C>
+void c_stable_sort(C& c) {
+ std::stable_sort(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_stable_sort() for performing a `comp` comparison other than the
+// default `operator<`.
+template <typename C, typename Compare>
+void c_stable_sort(C& c, Compare&& comp) {
+ std::stable_sort(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Compare>(comp));
+}
+
+// c_is_sorted()
+//
+// Container-based version of the <algorithm> `std::is_sorted()` function
+// to evaluate whether the given container is sorted in ascending order.
+template <typename C>
+bool c_is_sorted(const C& c) {
+ return std::is_sorted(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c));
+}
+
+// c_is_sorted() overload for performing a `comp` comparison other than the
+// default `operator<`.
+template <typename C, typename Compare>
+bool c_is_sorted(const C& c, Compare&& comp) {
+ return std::is_sorted(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Compare>(comp));
+}
+
+// c_partial_sort()
+//
+// Container-based version of the <algorithm> `std::partial_sort()` function
+// to rearrange elements within a container such that elements before `middle`
+// are sorted in ascending order.
+template <typename RandomAccessContainer>
+void c_partial_sort(
+ RandomAccessContainer& sequence,
+ container_algorithm_internal::ContainerIter<RandomAccessContainer> middle) {
+ std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_partial_sort() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename RandomAccessContainer, typename Compare>
+void c_partial_sort(
+ RandomAccessContainer& sequence,
+ container_algorithm_internal::ContainerIter<RandomAccessContainer> middle,
+ Compare&& comp) {
+ std::partial_sort(container_algorithm_internal::c_begin(sequence), middle,
+ container_algorithm_internal::c_end(sequence),
+ std::forward<Compare>(comp));
+}
+
+// c_partial_sort_copy()
+//
+// Container-based version of the <algorithm> `std::partial_sort_copy()`
+// function to sort elements within a container such that elements before
+// `middle` are sorted in ascending order, and return the result within an
+// iterator.
+template <typename C, typename RandomAccessContainer>
+container_algorithm_internal::ContainerIter<RandomAccessContainer>
+c_partial_sort_copy(const C& sequence, RandomAccessContainer& result) {
+ return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ container_algorithm_internal::c_begin(result),
+ container_algorithm_internal::c_end(result));
+}
+
+// Overload of c_partial_sort_copy() for performing a `comp` comparison other
+// than the default `operator<`.
+template <typename C, typename RandomAccessContainer, typename Compare>
+container_algorithm_internal::ContainerIter<RandomAccessContainer>
+c_partial_sort_copy(const C& sequence, RandomAccessContainer& result,
+ Compare&& comp) {
+ return std::partial_sort_copy(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ container_algorithm_internal::c_begin(result),
+ container_algorithm_internal::c_end(result),
+ std::forward<Compare>(comp));
+}
+
+// c_is_sorted_until()
+//
+// Container-based version of the <algorithm> `std::is_sorted_until()` function
+// to return the first element within a container that is not sorted in
+// ascending order as an iterator.
+template <typename C>
+container_algorithm_internal::ContainerIter<C> c_is_sorted_until(C& c) {
+ return std::is_sorted_until(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_is_sorted_until() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename C, typename Compare>
+container_algorithm_internal::ContainerIter<C> c_is_sorted_until(
+ C& c, Compare&& comp) {
+ return std::is_sorted_until(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Compare>(comp));
+}
+
+// c_nth_element()
+//
+// Container-based version of the <algorithm> `std::nth_element()` function
+// to rearrange the elements within a container such that the `nth` element
+// would be in that position in an ordered sequence; other elements may be in
+// any order, except that all preceding `nth` will be less than that element,
+// and all following `nth` will be greater than that element.
+template <typename RandomAccessContainer>
+void c_nth_element(
+ RandomAccessContainer& sequence,
+ container_algorithm_internal::ContainerIter<RandomAccessContainer> nth) {
+ std::nth_element(container_algorithm_internal::c_begin(sequence), nth,
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_nth_element() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename RandomAccessContainer, typename Compare>
+void c_nth_element(
+ RandomAccessContainer& sequence,
+ container_algorithm_internal::ContainerIter<RandomAccessContainer> nth,
+ Compare&& comp) {
+ std::nth_element(container_algorithm_internal::c_begin(sequence), nth,
+ container_algorithm_internal::c_end(sequence),
+ std::forward<Compare>(comp));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Binary Search
+//------------------------------------------------------------------------------
+
+// c_lower_bound()
+//
+// Container-based version of the <algorithm> `std::lower_bound()` function
+// to return an iterator pointing to the first element in a sorted container
+// which does not compare less than `value`.
+template <typename Sequence, typename T>
+container_algorithm_internal::ContainerIter<Sequence> c_lower_bound(
+ Sequence& sequence, T&& value) {
+ return std::lower_bound(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(value));
+}
+
+// Overload of c_lower_bound() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename Sequence, typename T, typename Compare>
+container_algorithm_internal::ContainerIter<Sequence> c_lower_bound(
+ Sequence& sequence, T&& value, Compare&& comp) {
+ return std::lower_bound(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(value), std::forward<Compare>(comp));
+}
+
+// c_upper_bound()
+//
+// Container-based version of the <algorithm> `std::upper_bound()` function
+// to return an iterator pointing to the first element in a sorted container
+// which is greater than `value`.
+template <typename Sequence, typename T>
+container_algorithm_internal::ContainerIter<Sequence> c_upper_bound(
+ Sequence& sequence, T&& value) {
+ return std::upper_bound(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(value));
+}
+
+// Overload of c_upper_bound() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename Sequence, typename T, typename Compare>
+container_algorithm_internal::ContainerIter<Sequence> c_upper_bound(
+ Sequence& sequence, T&& value, Compare&& comp) {
+ return std::upper_bound(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(value), std::forward<Compare>(comp));
+}
+
+// c_equal_range()
+//
+// Container-based version of the <algorithm> `std::equal_range()` function
+// to return an iterator pair pointing to the first and last elements in a
+// sorted container which compare equal to `value`.
+template <typename Sequence, typename T>
+container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
+c_equal_range(Sequence& sequence, T&& value) {
+ return std::equal_range(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(value));
+}
+
+// Overload of c_equal_range() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename Sequence, typename T, typename Compare>
+container_algorithm_internal::ContainerIterPairType<Sequence, Sequence>
+c_equal_range(Sequence& sequence, T&& value, Compare&& comp) {
+ return std::equal_range(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(value), std::forward<Compare>(comp));
+}
+
+// c_binary_search()
+//
+// Container-based version of the <algorithm> `std::binary_search()` function
+// to test if any element in the sorted container contains a value equivalent to
+// 'value'.
+template <typename Sequence, typename T>
+bool c_binary_search(Sequence&& sequence, T&& value) {
+ return std::binary_search(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(value));
+}
+
+// Overload of c_binary_search() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename Sequence, typename T, typename Compare>
+bool c_binary_search(Sequence&& sequence, T&& value, Compare&& comp) {
+ return std::binary_search(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(value),
+ std::forward<Compare>(comp));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Merge functions
+//------------------------------------------------------------------------------
+
+// c_merge()
+//
+// Container-based version of the <algorithm> `std::merge()` function
+// to merge two sorted containers into a single sorted iterator.
+template <typename C1, typename C2, typename OutputIterator>
+OutputIterator c_merge(const C1& c1, const C2& c2, OutputIterator result) {
+ return std::merge(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2), result);
+}
+
+// Overload of c_merge() for performing a `comp` comparison other than
+// the default `operator<`.
+template <typename C1, typename C2, typename OutputIterator, typename Compare>
+OutputIterator c_merge(const C1& c1, const C2& c2, OutputIterator result,
+ Compare&& comp) {
+ return std::merge(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2), result,
+ std::forward<Compare>(comp));
+}
+
+// c_inplace_merge()
+//
+// Container-based version of the <algorithm> `std::inplace_merge()` function
+// to merge a supplied iterator `middle` into a container.
+template <typename C>
+void c_inplace_merge(C& c,
+ container_algorithm_internal::ContainerIter<C> middle) {
+ std::inplace_merge(container_algorithm_internal::c_begin(c), middle,
+ container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_inplace_merge() for performing a merge using a `comp` other
+// than `operator<`.
+template <typename C, typename Compare>
+void c_inplace_merge(C& c,
+ container_algorithm_internal::ContainerIter<C> middle,
+ Compare&& comp) {
+ std::inplace_merge(container_algorithm_internal::c_begin(c), middle,
+ container_algorithm_internal::c_end(c),
+ std::forward<Compare>(comp));
+}
+
+// c_includes()
+//
+// Container-based version of the <algorithm> `std::includes()` function
+// to test whether a sorted container `c1` entirely contains another sorted
+// container `c2`.
+template <typename C1, typename C2>
+bool c_includes(const C1& c1, const C2& c2) {
+ return std::includes(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2));
+}
+
+// Overload of c_includes() for performing a merge using a `comp` other than
+// `operator<`.
+template <typename C1, typename C2, typename Compare>
+bool c_includes(const C1& c1, const C2& c2, Compare&& comp) {
+ return std::includes(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2),
+ std::forward<Compare>(comp));
+}
+
+// c_set_union()
+//
+// Container-based version of the <algorithm> `std::set_union()` function
+// to return an iterator containing the union of two containers; duplicate
+// values are not copied into the output.
+template <typename C1, typename C2, typename OutputIterator>
+OutputIterator c_set_union(const C1& c1, const C2& c2, OutputIterator output) {
+ return std::set_union(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2), output);
+}
+
+// Overload of c_set_union() for performing a merge using a `comp` other than
+// `operator<`.
+template <typename C1, typename C2, typename OutputIterator, typename Compare>
+OutputIterator c_set_union(const C1& c1, const C2& c2, OutputIterator output,
+ Compare&& comp) {
+ return std::set_union(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2), output,
+ std::forward<Compare>(comp));
+}
+
+// c_set_intersection()
+//
+// Container-based version of the <algorithm> `std::set_intersection()` function
+// to return an iterator containing the intersection of two containers.
+template <typename C1, typename C2, typename OutputIterator>
+OutputIterator c_set_intersection(const C1& c1, const C2& c2,
+ OutputIterator output) {
+ return std::set_intersection(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2), output);
+}
+
+// Overload of c_set_intersection() for performing a merge using a `comp` other
+// than `operator<`.
+template <typename C1, typename C2, typename OutputIterator, typename Compare>
+OutputIterator c_set_intersection(const C1& c1, const C2& c2,
+ OutputIterator output, Compare&& comp) {
+ return std::set_intersection(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2), output,
+ std::forward<Compare>(comp));
+}
+
+// c_set_difference()
+//
+// Container-based version of the <algorithm> `std::set_difference()` function
+// to return an iterator containing elements present in the first container but
+// not in the second.
+template <typename C1, typename C2, typename OutputIterator>
+OutputIterator c_set_difference(const C1& c1, const C2& c2,
+ OutputIterator output) {
+ return std::set_difference(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2), output);
+}
+
+// Overload of c_set_difference() for performing a merge using a `comp` other
+// than `operator<`.
+template <typename C1, typename C2, typename OutputIterator, typename Compare>
+OutputIterator c_set_difference(const C1& c1, const C2& c2,
+ OutputIterator output, Compare&& comp) {
+ return std::set_difference(container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2), output,
+ std::forward<Compare>(comp));
+}
+
+// c_set_symmetric_difference()
+//
+// Container-based version of the <algorithm> `std::set_symmetric_difference()`
+// function to return an iterator containing elements present in either one
+// container or the other, but not both.
+template <typename C1, typename C2, typename OutputIterator>
+OutputIterator c_set_symmetric_difference(const C1& c1, const C2& c2,
+ OutputIterator output) {
+ return std::set_symmetric_difference(
+ container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2), output);
+}
+
+// Overload of c_set_symmetric_difference() for performing a merge using a
+// `comp` other than `operator<`.
+template <typename C1, typename C2, typename OutputIterator, typename Compare>
+OutputIterator c_set_symmetric_difference(const C1& c1, const C2& c2,
+ OutputIterator output,
+ Compare&& comp) {
+ return std::set_symmetric_difference(
+ container_algorithm_internal::c_begin(c1),
+ container_algorithm_internal::c_end(c1),
+ container_algorithm_internal::c_begin(c2),
+ container_algorithm_internal::c_end(c2), output,
+ std::forward<Compare>(comp));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Heap functions
+//------------------------------------------------------------------------------
+
+// c_push_heap()
+//
+// Container-based version of the <algorithm> `std::push_heap()` function
+// to push a value onto a container heap.
+template <typename RandomAccessContainer>
+void c_push_heap(RandomAccessContainer& sequence) {
+ std::push_heap(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_push_heap() for performing a push operation on a heap using a
+// `comp` other than `operator<`.
+template <typename RandomAccessContainer, typename Compare>
+void c_push_heap(RandomAccessContainer& sequence, Compare&& comp) {
+ std::push_heap(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<Compare>(comp));
+}
+
+// c_pop_heap()
+//
+// Container-based version of the <algorithm> `std::pop_heap()` function
+// to pop a value from a heap container.
+template <typename RandomAccessContainer>
+void c_pop_heap(RandomAccessContainer& sequence) {
+ std::pop_heap(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_pop_heap() for performing a pop operation on a heap using a
+// `comp` other than `operator<`.
+template <typename RandomAccessContainer, typename Compare>
+void c_pop_heap(RandomAccessContainer& sequence, Compare&& comp) {
+ std::pop_heap(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<Compare>(comp));
+}
+
+// c_make_heap()
+//
+// Container-based version of the <algorithm> `std::make_heap()` function
+// to make a container a heap.
+template <typename RandomAccessContainer>
+void c_make_heap(RandomAccessContainer& sequence) {
+ std::make_heap(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_make_heap() for performing heap comparisons using a
+// `comp` other than `operator<`
+template <typename RandomAccessContainer, typename Compare>
+void c_make_heap(RandomAccessContainer& sequence, Compare&& comp) {
+ std::make_heap(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<Compare>(comp));
+}
+
+// c_sort_heap()
+//
+// Container-based version of the <algorithm> `std::sort_heap()` function
+// to sort a heap into ascending order (after which it is no longer a heap).
+template <typename RandomAccessContainer>
+void c_sort_heap(RandomAccessContainer& sequence) {
+ std::sort_heap(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_sort_heap() for performing heap comparisons using a
+// `comp` other than `operator<`
+template <typename RandomAccessContainer, typename Compare>
+void c_sort_heap(RandomAccessContainer& sequence, Compare&& comp) {
+ std::sort_heap(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<Compare>(comp));
+}
+
+// c_is_heap()
+//
+// Container-based version of the <algorithm> `std::is_heap()` function
+// to check whether the given container is a heap.
+template <typename RandomAccessContainer>
+bool c_is_heap(const RandomAccessContainer& sequence) {
+ return std::is_heap(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_is_heap() for performing heap comparisons using a
+// `comp` other than `operator<`
+template <typename RandomAccessContainer, typename Compare>
+bool c_is_heap(const RandomAccessContainer& sequence, Compare&& comp) {
+ return std::is_heap(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<Compare>(comp));
+}
+
+// c_is_heap_until()
+//
+// Container-based version of the <algorithm> `std::is_heap_until()` function
+// to find the first element in a given container which is not in heap order.
+template <typename RandomAccessContainer>
+container_algorithm_internal::ContainerIter<RandomAccessContainer>
+c_is_heap_until(RandomAccessContainer& sequence) {
+ return std::is_heap_until(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_is_heap_until() for performing heap comparisons using a
+// `comp` other than `operator<`
+template <typename RandomAccessContainer, typename Compare>
+container_algorithm_internal::ContainerIter<RandomAccessContainer>
+c_is_heap_until(RandomAccessContainer& sequence, Compare&& comp) {
+ return std::is_heap_until(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<Compare>(comp));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Min/max
+//------------------------------------------------------------------------------
+
+// c_min_element()
+//
+// Container-based version of the <algorithm> `std::min_element()` function
+// to return an iterator pointing to the element with the smallest value, using
+// `operator<` to make the comparisons.
+template <typename Sequence>
+container_algorithm_internal::ContainerIter<Sequence> c_min_element(
+ Sequence& sequence) {
+ return std::min_element(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_min_element() for performing a `comp` comparison other than
+// `operator<`.
+template <typename Sequence, typename Compare>
+container_algorithm_internal::ContainerIter<Sequence> c_min_element(
+ Sequence& sequence, Compare&& comp) {
+ return std::min_element(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<Compare>(comp));
+}
+
+// c_max_element()
+//
+// Container-based version of the <algorithm> `std::max_element()` function
+// to return an iterator pointing to the element with the largest value, using
+// `operator<` to make the comparisons.
+template <typename Sequence>
+container_algorithm_internal::ContainerIter<Sequence> c_max_element(
+ Sequence& sequence) {
+ return std::max_element(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence));
+}
+
+// Overload of c_max_element() for performing a `comp` comparison other than
+// `operator<`.
+template <typename Sequence, typename Compare>
+container_algorithm_internal::ContainerIter<Sequence> c_max_element(
+ Sequence& sequence, Compare&& comp) {
+ return std::max_element(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<Compare>(comp));
+}
+
+// c_minmax_element()
+//
+// Container-based version of the <algorithm> `std::minmax_element()` function
+// to return a pair of iterators pointing to the elements containing the
+// smallest and largest values, respectively, using `operator<` to make the
+// comparisons.
+template <typename C>
+container_algorithm_internal::ContainerIterPairType<C, C>
+c_minmax_element(C& c) {
+ return std::minmax_element(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_minmax_element() for performing `comp` comparisons other than
+// `operator<`.
+template <typename C, typename Compare>
+container_algorithm_internal::ContainerIterPairType<C, C>
+c_minmax_element(C& c, Compare&& comp) {
+ return std::minmax_element(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Compare>(comp));
+}
+
+//------------------------------------------------------------------------------
+// <algorithm> Lexicographical Comparisons
+//------------------------------------------------------------------------------
+
+// c_lexicographical_compare()
+//
+// Container-based version of the <algorithm> `std::lexicographical_compare()`
+// function to lexicographically compare (e.g. sort words alphabetically) two
+// container sequences. The comparison is performed using `operator<`. Note
+// that capital letters ("A-Z") have ASCII values less than lowercase letters
+// ("a-z").
+template <typename Sequence1, typename Sequence2>
+bool c_lexicographical_compare(Sequence1&& sequence1, Sequence2&& sequence2) {
+ return std::lexicographical_compare(
+ container_algorithm_internal::c_begin(sequence1),
+ container_algorithm_internal::c_end(sequence1),
+ container_algorithm_internal::c_begin(sequence2),
+ container_algorithm_internal::c_end(sequence2));
+}
+
+// Overload of c_lexicographical_compare() for performing a lexicographical
+// comparison using a `comp` operator instead of `operator<`.
+template <typename Sequence1, typename Sequence2, typename Compare>
+bool c_lexicographical_compare(Sequence1&& sequence1, Sequence2&& sequence2,
+ Compare&& comp) {
+ return std::lexicographical_compare(
+ container_algorithm_internal::c_begin(sequence1),
+ container_algorithm_internal::c_end(sequence1),
+ container_algorithm_internal::c_begin(sequence2),
+ container_algorithm_internal::c_end(sequence2),
+ std::forward<Compare>(comp));
+}
+
+// c_next_permutation()
+//
+// Container-based version of the <algorithm> `std::next_permutation()` function
+// to rearrange a container's elements into the next lexicographically greater
+// permutation.
+template <typename C>
+bool c_next_permutation(C& c) {
+ return std::next_permutation(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_next_permutation() for performing a lexicographical
+// comparison using a `comp` operator instead of `operator<`.
+template <typename C, typename Compare>
+bool c_next_permutation(C& c, Compare&& comp) {
+ return std::next_permutation(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Compare>(comp));
+}
+
+// c_prev_permutation()
+//
+// Container-based version of the <algorithm> `std::prev_permutation()` function
+// to rearrange a container's elements into the next lexicographically lesser
+// permutation.
+template <typename C>
+bool c_prev_permutation(C& c) {
+ return std::prev_permutation(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c));
+}
+
+// Overload of c_prev_permutation() for performing a lexicographical
+// comparison using a `comp` operator instead of `operator<`.
+template <typename C, typename Compare>
+bool c_prev_permutation(C& c, Compare&& comp) {
+ return std::prev_permutation(container_algorithm_internal::c_begin(c),
+ container_algorithm_internal::c_end(c),
+ std::forward<Compare>(comp));
+}
+
+//------------------------------------------------------------------------------
+// <numeric> algorithms
+//------------------------------------------------------------------------------
+
+// c_iota()
+//
+// Container-based version of the <algorithm> `std::iota()` function
+// to compute successive values of `value`, as if incremented with `++value`
+// after each element is written. and write them to the container.
+template <typename Sequence, typename T>
+void c_iota(Sequence& sequence, T&& value) {
+ std::iota(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(value));
+}
+// c_accumulate()
+//
+// Container-based version of the <algorithm> `std::accumulate()` function
+// to accumulate the element values of a container to `init` and return that
+// accumulation by value.
+//
+// Note: Due to a language technicality this function has return type
+// absl::decay_t<T>. As a user of this function you can casually read
+// this as "returns T by value" and assume it does the right thing.
+template <typename Sequence, typename T>
+decay_t<T> c_accumulate(const Sequence& sequence, T&& init) {
+ return std::accumulate(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(init));
+}
+
+// Overload of c_accumulate() for using a binary operations other than
+// addition for computing the accumulation.
+template <typename Sequence, typename T, typename BinaryOp>
+decay_t<T> c_accumulate(const Sequence& sequence, T&& init,
+ BinaryOp&& binary_op) {
+ return std::accumulate(container_algorithm_internal::c_begin(sequence),
+ container_algorithm_internal::c_end(sequence),
+ std::forward<T>(init),
+ std::forward<BinaryOp>(binary_op));
+}
+
+// c_inner_product()
+//
+// Container-based version of the <algorithm> `std::inner_product()` function
+// to compute the cumulative inner product of container element pairs.
+//
+// Note: Due to a language technicality this function has return type
+// absl::decay_t<T>. As a user of this function you can casually read
+// this as "returns T by value" and assume it does the right thing.
+template <typename Sequence1, typename Sequence2, typename T>
+decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2,
+ T&& sum) {
+ return std::inner_product(container_algorithm_internal::c_begin(factors1),
+ container_algorithm_internal::c_end(factors1),
+ container_algorithm_internal::c_begin(factors2),
+ std::forward<T>(sum));
+}
+
+// Overload of c_inner_product() for using binary operations other than
+// `operator+` (for computing the accumulation) and `operator*` (for computing
+// the product between the two container's element pair).
+template <typename Sequence1, typename Sequence2, typename T,
+ typename BinaryOp1, typename BinaryOp2>
+decay_t<T> c_inner_product(const Sequence1& factors1, const Sequence2& factors2,
+ T&& sum, BinaryOp1&& op1, BinaryOp2&& op2) {
+ return std::inner_product(container_algorithm_internal::c_begin(factors1),
+ container_algorithm_internal::c_end(factors1),
+ container_algorithm_internal::c_begin(factors2),
+ std::forward<T>(sum), std::forward<BinaryOp1>(op1),
+ std::forward<BinaryOp2>(op2));
+}
+
+// c_adjacent_difference()
+//
+// Container-based version of the <algorithm> `std::adjacent_difference()`
+// function to compute the difference between each element and the one preceding
+// it and write it to an iterator.
+template <typename InputSequence, typename OutputIt>
+OutputIt c_adjacent_difference(const InputSequence& input,
+ OutputIt output_first) {
+ return std::adjacent_difference(container_algorithm_internal::c_begin(input),
+ container_algorithm_internal::c_end(input),
+ output_first);
+}
+
+// Overload of c_adjacent_difference() for using a binary operation other than
+// subtraction to compute the adjacent difference.
+template <typename InputSequence, typename OutputIt, typename BinaryOp>
+OutputIt c_adjacent_difference(const InputSequence& input,
+ OutputIt output_first, BinaryOp&& op) {
+ return std::adjacent_difference(container_algorithm_internal::c_begin(input),
+ container_algorithm_internal::c_end(input),
+ output_first, std::forward<BinaryOp>(op));
+}
+
+// c_partial_sum()
+//
+// Container-based version of the <algorithm> `std::partial_sum()` function
+// to compute the partial sum of the elements in a sequence and write them
+// to an iterator. The partial sum is the sum of all element values so far in
+// the sequence.
+template <typename InputSequence, typename OutputIt>
+OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first) {
+ return std::partial_sum(container_algorithm_internal::c_begin(input),
+ container_algorithm_internal::c_end(input),
+ output_first);
+}
+
+// Overload of c_partial_sum() for using a binary operation other than addition
+// to compute the "partial sum".
+template <typename InputSequence, typename OutputIt, typename BinaryOp>
+OutputIt c_partial_sum(const InputSequence& input, OutputIt output_first,
+ BinaryOp&& op) {
+ return std::partial_sum(container_algorithm_internal::c_begin(input),
+ container_algorithm_internal::c_end(input),
+ output_first, std::forward<BinaryOp>(op));
+}
+
+} // namespace absl
+
+#endif // ABSL_ALGORITHM_CONTAINER_H_
[40/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/CMakeLists.txt
new file mode 100644
index 0000000..ca6abc1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/CMakeLists.txt
@@ -0,0 +1,193 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+list(APPEND DEBUGGING_PUBLIC_HEADERS
+ "failure_signal_handler.h"
+ "leak_check.h"
+ "stacktrace.h"
+ "symbolize.h"
+)
+
+
+list(APPEND DEBUGGING_INTERNAL_HEADERS
+ "internal/address_is_readable.h"
+ "internal/demangle.h"
+ "internal/elf_mem_image.h"
+ "internal/examine_stack.h"
+ "internal/stacktrace_config.h"
+ "internal/symbolize.h"
+ "internal/vdso_support.h"
+)
+
+
+list(APPEND STACKTRACE_SRC
+ "stacktrace.cc"
+ "internal/address_is_readable.cc"
+ "internal/elf_mem_image.cc"
+ "internal/vdso_support.cc"
+ ${DEBUGGING_PUBLIC_HEADERS}
+ ${DEBUGGING_INTERNAL_HEADERS}
+)
+
+list(APPEND SYMBOLIZE_SRC
+ "symbolize.cc"
+ "symbolize_elf.inc"
+ "symbolize_unimplemented.inc"
+ "symbolize_win32.inc"
+ "internal/demangle.cc"
+ ${DEBUGGING_PUBLIC_HEADERS}
+ ${DEBUGGING_INTERNAL_HEADERS}
+)
+
+list(APPEND FAILURE_SIGNAL_HANDLER_SRC
+ "failure_signal_handler.cc"
+ ${DEBUGGING_PUBLIC_HEADERS}
+)
+
+list(APPEND EXAMINE_STACK_SRC
+ "internal/examine_stack.cc"
+ ${DEBUGGING_PUBLIC_HEADERS}
+ ${DEBUGGING_INTERNAL_HEADERS}
+)
+
+absl_library(
+ TARGET
+ absl_stacktrace
+ SOURCES
+ ${STACKTRACE_SRC}
+ EXPORT_NAME
+ stacktrace
+)
+
+absl_library(
+ TARGET
+ absl_symbolize
+ SOURCES
+ ${SYMBOLIZE_SRC}
+ EXPORT_NAME
+ symbolize
+)
+
+absl_library(
+ TARGET
+ absl_failure_signal_handler
+ SOURCES
+ ${FAILURE_SIGNAL_HANDLER_SRC}
+ PUBLIC_LIBRARIES
+ absl_base absl_synchronization
+ EXPORT_NAME
+ failure_signal_handler
+)
+
+# Internal-only. Projects external to Abseil should not depend
+# directly on this library.
+absl_library(
+ TARGET
+ absl_examine_stack
+ SOURCES
+ ${EXAMINE_STACK_SRC}
+ EXPORT_NAME
+ examine_stack
+)
+
+list(APPEND LEAK_CHECK_SRC
+ "leak_check.cc"
+)
+
+
+# leak_check library
+absl_library(
+ TARGET
+ absl_leak_check
+ SOURCES
+ ${LEAK_CHECK_SRC}
+ PUBLIC_LIBRARIES
+ absl_base
+ EXPORT_NAME
+ leak_check
+)
+
+
+# component target
+absl_header_library(
+ TARGET
+ absl_debugging
+ PUBLIC_LIBRARIES
+ absl_stacktrace absl_leak_check
+ EXPORT_NAME
+ debugging
+)
+
+#
+## TESTS
+#
+
+list(APPEND DEBUGGING_INTERNAL_TEST_HEADERS
+ "internal/stack_consumption.h"
+)
+
+list(APPEND STACK_CONSUMPTION_SRC
+ "internal/stack_consumption.cc"
+ ${DEBUGGING_INTERNAL_TEST_HEADERS}
+)
+
+absl_library(
+ TARGET
+ absl_stack_consumption
+ SOURCES
+ ${STACK_CONSUMPTION_SRC}
+)
+
+absl_test(
+ TARGET
+ absl_stack_consumption_test
+ SOURCES
+ ${STACK_CONSUMPTION_SRC}
+)
+
+list(APPEND SYMBOLIZE_TEST_SRC "symbolize_test.cc")
+
+absl_test(
+ TARGET
+ symbolize_test
+ SOURCES
+ ${SYMBOLIZE_TEST_SRC}
+ PUBLIC_LIBRARIES
+ absl_symbolize absl_stack_consumption
+)
+
+list(APPEND FAILURE_SIGNAL_HANDLER_TEST_SRC "failure_signal_handler_test.cc")
+
+absl_test(
+ TARGET
+ failure_signal_handler_test
+ SOURCES
+ ${FAILURE_SIGNAL_HANDLER_TEST_SRC}
+ PUBLIC_LIBRARIES
+ absl_examine_stack absl_stacktrace absl_symbolize
+)
+
+# test leak_check_test
+list(APPEND LEAK_CHECK_TEST_SRC "leak_check_test.cc")
+
+absl_test(
+ TARGET
+ leak_check_test
+ SOURCES
+ ${LEAK_CHECK_TEST_SRC}
+ PUBLIC_LIBRARIES
+ absl_leak_check
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler.cc
new file mode 100644
index 0000000..597ad14
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler.cc
@@ -0,0 +1,351 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "absl/debugging/failure_signal_handler.h"
+
+#include "absl/base/config.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <unistd.h>
+#endif
+
+#ifdef ABSL_HAVE_MMAP
+#include <sys/mman.h>
+#endif
+
+#include <algorithm>
+#include <atomic>
+#include <cerrno>
+#include <csignal>
+#include <cstring>
+#include <ctime>
+
+#include "absl/base/attributes.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/sysinfo.h"
+#include "absl/debugging/internal/examine_stack.h"
+#include "absl/debugging/stacktrace.h"
+
+#ifndef _WIN32
+#define ABSL_HAVE_SIGACTION
+#endif
+
+namespace absl {
+
+ABSL_CONST_INIT static FailureSignalHandlerOptions fsh_options;
+
+// Resets the signal handler for signo to the default action for that
+// signal, then raises the signal.
+static void RaiseToDefaultHandler(int signo) {
+ signal(signo, SIG_DFL);
+ raise(signo);
+}
+
+struct FailureSignalData {
+ const int signo;
+ const char* const as_string;
+#ifdef ABSL_HAVE_SIGACTION
+ struct sigaction previous_action;
+ // StructSigaction is used to silence -Wmissing-field-initializers.
+ using StructSigaction = struct sigaction;
+ #define FSD_PREVIOUS_INIT FailureSignalData::StructSigaction()
+#else
+ void (*previous_handler)(int);
+ #define FSD_PREVIOUS_INIT SIG_DFL
+#endif
+};
+
+ABSL_CONST_INIT static FailureSignalData failure_signal_data[] = {
+ {SIGSEGV, "SIGSEGV", FSD_PREVIOUS_INIT},
+ {SIGILL, "SIGILL", FSD_PREVIOUS_INIT},
+ {SIGFPE, "SIGFPE", FSD_PREVIOUS_INIT},
+ {SIGABRT, "SIGABRT", FSD_PREVIOUS_INIT},
+ {SIGTERM, "SIGTERM", FSD_PREVIOUS_INIT},
+#ifndef _WIN32
+ {SIGBUS, "SIGBUS", FSD_PREVIOUS_INIT},
+ {SIGTRAP, "SIGTRAP", FSD_PREVIOUS_INIT},
+#endif
+};
+
+#undef FSD_PREVIOUS_INIT
+
+static void RaiseToPreviousHandler(int signo) {
+ // Search for the previous handler.
+ for (const auto& it : failure_signal_data) {
+ if (it.signo == signo) {
+#ifdef ABSL_HAVE_SIGACTION
+ sigaction(signo, &it.previous_action, nullptr);
+#else
+ signal(signo, it.previous_handler);
+#endif
+ raise(signo);
+ return;
+ }
+ }
+
+ // Not found, use the default handler.
+ RaiseToDefaultHandler(signo);
+}
+
+namespace debugging_internal {
+
+const char* FailureSignalToString(int signo) {
+ for (const auto& it : failure_signal_data) {
+ if (it.signo == signo) {
+ return it.as_string;
+ }
+ }
+ return "";
+}
+
+} // namespace debugging_internal
+
+#ifndef _WIN32
+
+static bool SetupAlternateStackOnce() {
+ const size_t page_mask = getpagesize() - 1;
+ size_t stack_size = (std::max(SIGSTKSZ, 65536) + page_mask) & ~page_mask;
+#if defined(ADDRESS_SANITIZER) || defined(MEMORY_SANITIZER) || \
+ defined(THREAD_SANITIZER)
+ // Account for sanitizer instrumentation requiring additional stack space.
+ stack_size *= 5;
+#endif
+
+ stack_t sigstk;
+ memset(&sigstk, 0, sizeof(sigstk));
+ sigstk.ss_size = stack_size;
+
+#ifdef ABSL_HAVE_MMAP
+#ifndef MAP_STACK
+#define MAP_STACK 0
+#endif
+ sigstk.ss_sp = mmap(nullptr, sigstk.ss_size, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, -1, 0);
+ if (sigstk.ss_sp == MAP_FAILED) {
+ ABSL_RAW_LOG(FATAL, "mmap() for alternate signal stack failed");
+ }
+#else
+ sigstk.ss_sp = malloc(sigstk.ss_size);
+ if (sigstk.ss_sp == nullptr) {
+ ABSL_RAW_LOG(FATAL, "malloc() for alternate signal stack failed");
+ }
+#endif
+
+ if (sigaltstack(&sigstk, nullptr) != 0) {
+ ABSL_RAW_LOG(FATAL, "sigaltstack() failed with errno=%d", errno);
+ }
+ return true;
+}
+
+#endif
+
+// Sets up an alternate stack for signal handlers once.
+// Returns the appropriate flag for sig_action.sa_flags
+// if the system supports using an alternate stack.
+static int MaybeSetupAlternateStack() {
+#ifndef _WIN32
+ ABSL_ATTRIBUTE_UNUSED static const bool kOnce = SetupAlternateStackOnce();
+ return SA_ONSTACK;
+#endif
+ return 0;
+}
+
+#ifdef ABSL_HAVE_SIGACTION
+
+static void InstallOneFailureHandler(FailureSignalData* data,
+ void (*handler)(int, siginfo_t*, void*)) {
+ struct sigaction act;
+ memset(&act, 0, sizeof(act));
+ sigemptyset(&act.sa_mask);
+ act.sa_flags |= SA_SIGINFO;
+ // SA_NODEFER is required to handle SIGABRT from
+ // ImmediateAbortSignalHandler().
+ act.sa_flags |= SA_NODEFER;
+ if (fsh_options.use_alternate_stack) {
+ act.sa_flags |= MaybeSetupAlternateStack();
+ }
+ act.sa_sigaction = handler;
+ ABSL_RAW_CHECK(sigaction(data->signo, &act, &data->previous_action) == 0,
+ "sigaction() failed");
+}
+
+#else
+
+static void InstallOneFailureHandler(FailureSignalData* data,
+ void (*handler)(int)) {
+ data->previous_handler = signal(data->signo, handler);
+ ABSL_RAW_CHECK(data->previous_handler != SIG_ERR, "signal() failed");
+}
+
+#endif
+
+static void WriteToStderr(const char* data) {
+ int old_errno = errno;
+ absl::raw_logging_internal::SafeWriteToStderr(data, strlen(data));
+ errno = old_errno;
+}
+
+static void WriteSignalMessage(int signo, void (*writerfn)(const char*)) {
+ char buf[64];
+ const char* const signal_string =
+ debugging_internal::FailureSignalToString(signo);
+ if (signal_string != nullptr && signal_string[0] != '\0') {
+ snprintf(buf, sizeof(buf), "*** %s received at time=%ld ***\n",
+ signal_string,
+ static_cast<long>(time(nullptr))); // NOLINT(runtime/int)
+ } else {
+ snprintf(buf, sizeof(buf), "*** Signal %d received at time=%ld ***\n",
+ signo, static_cast<long>(time(nullptr))); // NOLINT(runtime/int)
+ }
+ writerfn(buf);
+}
+
+// `void*` might not be big enough to store `void(*)(const char*)`.
+struct WriterFnStruct {
+ void (*writerfn)(const char*);
+};
+
+// Many of the absl::debugging_internal::Dump* functions in
+// examine_stack.h take a writer function pointer that has a void* arg
+// for historical reasons. failure_signal_handler_writer only takes a
+// data pointer. This function converts between these types.
+static void WriterFnWrapper(const char* data, void* arg) {
+ static_cast<WriterFnStruct*>(arg)->writerfn(data);
+}
+
+// Convenient wrapper around DumpPCAndFrameSizesAndStackTrace() for signal
+// handlers. "noinline" so that GetStackFrames() skips the top-most stack
+// frame for this function.
+ABSL_ATTRIBUTE_NOINLINE static void WriteStackTrace(
+ void* ucontext, bool symbolize_stacktrace,
+ void (*writerfn)(const char*, void*), void* writerfn_arg) {
+ constexpr int kNumStackFrames = 32;
+ void* stack[kNumStackFrames];
+ int frame_sizes[kNumStackFrames];
+ int min_dropped_frames;
+ int depth = absl::GetStackFramesWithContext(
+ stack, frame_sizes, kNumStackFrames,
+ 1, // Do not include this function in stack trace.
+ ucontext, &min_dropped_frames);
+ absl::debugging_internal::DumpPCAndFrameSizesAndStackTrace(
+ absl::debugging_internal::GetProgramCounter(ucontext), stack, frame_sizes,
+ depth, min_dropped_frames, symbolize_stacktrace, writerfn, writerfn_arg);
+}
+
+// Called by FailureSignalHandler() to write the failure info. It is
+// called once with writerfn set to WriteToStderr() and then possibly
+// with writerfn set to the user provided function.
+static void WriteFailureInfo(int signo, void* ucontext,
+ void (*writerfn)(const char*)) {
+ WriterFnStruct writerfn_struct{writerfn};
+ WriteSignalMessage(signo, writerfn);
+ WriteStackTrace(ucontext, fsh_options.symbolize_stacktrace, WriterFnWrapper,
+ &writerfn_struct);
+}
+
+// absl::SleepFor() can't be used here since AbslInternalSleepFor()
+// may be overridden to do something that isn't async-signal-safe on
+// some platforms.
+static void PortableSleepForSeconds(int seconds) {
+#ifdef _WIN32
+ Sleep(seconds * 1000);
+#else
+ struct timespec sleep_time;
+ sleep_time.tv_sec = seconds;
+ sleep_time.tv_nsec = 0;
+ while (nanosleep(&sleep_time, &sleep_time) != 0 && errno == EINTR) {}
+#endif
+}
+
+#ifdef ABSL_HAVE_ALARM
+// FailureSignalHandler() installs this as a signal handler for
+// SIGALRM, then sets an alarm to be delivered to the program after a
+// set amount of time. If FailureSignalHandler() hangs for more than
+// the alarm timeout, ImmediateAbortSignalHandler() will abort the
+// program.
+static void ImmediateAbortSignalHandler(int) {
+ RaiseToDefaultHandler(SIGABRT);
+}
+#endif
+
+// absl::base_internal::GetTID() returns pid_t on most platforms, but
+// returns absl::base_internal::pid_t on Windows.
+using GetTidType = decltype(absl::base_internal::GetTID());
+ABSL_CONST_INIT static std::atomic<GetTidType> failed_tid(0);
+
+#ifndef ABSL_HAVE_SIGACTION
+static void FailureSignalHandler(int signo) {
+ void* ucontext = nullptr;
+#else
+static void FailureSignalHandler(int signo, siginfo_t*,
+ void* ucontext) {
+#endif
+
+ const GetTidType this_tid = absl::base_internal::GetTID();
+ GetTidType previous_failed_tid = 0;
+ if (!failed_tid.compare_exchange_strong(
+ previous_failed_tid, static_cast<intptr_t>(this_tid),
+ std::memory_order_acq_rel, std::memory_order_relaxed)) {
+ ABSL_RAW_LOG(
+ ERROR,
+ "Signal %d raised at PC=%p while already in FailureSignalHandler()",
+ signo, absl::debugging_internal::GetProgramCounter(ucontext));
+ if (this_tid != previous_failed_tid) {
+ // Another thread is already in FailureSignalHandler(), so wait
+ // a bit for it to finish. If the other thread doesn't kill us,
+ // we do so after sleeping.
+ PortableSleepForSeconds(3);
+ RaiseToDefaultHandler(signo);
+ // The recursively raised signal may be blocked until we return.
+ return;
+ }
+ }
+
+#ifdef ABSL_HAVE_ALARM
+ // Set an alarm to abort the program in case this code hangs or deadlocks.
+ if (fsh_options.alarm_on_failure_secs > 0) {
+ alarm(0); // Cancel any existing alarms.
+ signal(SIGALRM, ImmediateAbortSignalHandler);
+ alarm(fsh_options.alarm_on_failure_secs);
+ }
+#endif
+
+ // First write to stderr.
+ WriteFailureInfo(signo, ucontext, WriteToStderr);
+
+ // Riskier code (because it is less likely to be async-signal-safe)
+ // goes after this point.
+ if (fsh_options.writerfn != nullptr) {
+ WriteFailureInfo(signo, ucontext, fsh_options.writerfn);
+ }
+
+ if (fsh_options.call_previous_handler) {
+ RaiseToPreviousHandler(signo);
+ } else {
+ RaiseToDefaultHandler(signo);
+ }
+}
+
+void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options) {
+ fsh_options = options;
+ for (auto& it : failure_signal_data) {
+ InstallOneFailureHandler(&it, FailureSignalHandler);
+ }
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler.h
new file mode 100644
index 0000000..17522f0
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler.h
@@ -0,0 +1,103 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// This module allows the programmer to install a signal handler that
+// dumps useful debugging information (like a stacktrace) on program
+// failure. To use this functionality, call
+// absl::InstallFailureSignalHandler() very early in your program,
+// usually in the first few lines of main():
+//
+// int main(int argc, char** argv) {
+// absl::InitializeSymbolizer(argv[0]);
+// absl::FailureSignalHandlerOptions options;
+// absl::InstallFailureSignalHandler(options);
+// DoSomethingInteresting();
+// return 0;
+// }
+
+#ifndef ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
+#define ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
+
+namespace absl {
+
+// Options struct for absl::InstallFailureSignalHandler().
+struct FailureSignalHandlerOptions {
+ // If true, try to symbolize the stacktrace emitted on failure.
+ bool symbolize_stacktrace = true;
+
+ // If true, try to run signal handlers on an alternate stack (if
+ // supported on the given platform). This is useful in the case
+ // where the program crashes due to a stack overflow. By running on
+ // a alternate stack, the signal handler might be able to run even
+ // when the normal stack space has been exausted. The downside of
+ // using an alternate stack is that extra memory for the alternate
+ // stack needs to be pre-allocated.
+ bool use_alternate_stack = true;
+
+ // If positive, FailureSignalHandler() sets an alarm to be delivered
+ // to the program after this many seconds, which will immediately
+ // abort the program. This is useful in the potential case where
+ // FailureSignalHandler() itself is hung or deadlocked.
+ int alarm_on_failure_secs = 3;
+
+ // If false, after absl::FailureSignalHandler() runs, the signal is
+ // raised to the default handler for that signal (which normally
+ // terminates the program).
+ //
+ // If true, after absl::FailureSignalHandler() runs, it will call
+ // the previously registered signal handler for the signal that was
+ // received (if one was registered). This can be used to chain
+ // signal handlers.
+ //
+ // IMPORTANT: If true, the chained fatal signal handlers must not
+ // try to recover from the fatal signal. Instead, they should
+ // terminate the program via some mechanism, like raising the
+ // default handler for the signal, or by calling _exit().
+ // absl::FailureSignalHandler() may put parts of the Abseil
+ // library into a state that cannot be recovered from.
+ bool call_previous_handler = false;
+
+ // If not null, this function may be called with a std::string argument
+ // containing failure data. This function is used as a hook to write
+ // the failure data to a secondary location, for instance, to a log
+ // file. This function may also be called with a null data
+ // argument. This is a hint that this is a good time to flush any
+ // buffered data before the program may be terminated. Consider
+ // flushing any buffered data in all calls to this function.
+ //
+ // Since this function runs in a signal handler, it should be
+ // async-signal-safe if possible.
+ // See http://man7.org/linux/man-pages/man7/signal-safety.7.html
+ void (*writerfn)(const char*) = nullptr;
+};
+
+// Installs a signal handler for the common failure signals SIGSEGV,
+// SIGILL, SIGFPE, SIGABRT, SIGTERM, SIGBUG, and SIGTRAP (if they
+// exist on the given platform). The signal handler dumps program
+// failure data in a unspecified format to stderr. The data dumped by
+// the signal handler includes information that may be useful in
+// debugging the failure. This may include the program counter, a
+// stacktrace, and register information on some systems. Do not rely
+// on the exact format of the output; it is subject to change.
+void InstallFailureSignalHandler(const FailureSignalHandlerOptions& options);
+
+namespace debugging_internal {
+const char* FailureSignalToString(int signo);
+} // namespace debugging_internal
+
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_FAILURE_SIGNAL_HANDLER_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler_test.cc
new file mode 100644
index 0000000..33170da
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/failure_signal_handler_test.cc
@@ -0,0 +1,146 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "absl/debugging/failure_signal_handler.h"
+
+#include <csignal>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <fstream>
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/debugging/stacktrace.h"
+#include "absl/debugging/symbolize.h"
+#include "absl/strings/match.h"
+#include "absl/strings/str_cat.h"
+
+namespace {
+
+#if GTEST_HAS_DEATH_TEST
+
+// For the parameterized death tests. GetParam() returns the signal number.
+using FailureSignalHandlerDeathTest = ::testing::TestWithParam<int>;
+
+// This function runs in a fork()ed process on most systems.
+void InstallHandlerAndRaise(int signo) {
+ absl::InstallFailureSignalHandler(absl::FailureSignalHandlerOptions());
+ raise(signo);
+}
+
+TEST_P(FailureSignalHandlerDeathTest, AbslFailureSignal) {
+ const int signo = GetParam();
+ std::string exit_regex = absl::StrCat(
+ "\\*\\*\\* ", absl::debugging_internal::FailureSignalToString(signo),
+ " received at time=");
+#ifndef _WIN32
+ EXPECT_EXIT(InstallHandlerAndRaise(signo), testing::KilledBySignal(signo),
+ exit_regex);
+#else
+ // Windows doesn't have testing::KilledBySignal().
+ EXPECT_DEATH(InstallHandlerAndRaise(signo), exit_regex);
+#endif
+}
+
+ABSL_CONST_INIT FILE* error_file = nullptr;
+
+void WriteToErrorFile(const char* msg) {
+ if (msg != nullptr) {
+ ABSL_RAW_CHECK(fwrite(msg, strlen(msg), 1, error_file) == 1,
+ "fwrite() failed");
+ }
+ ABSL_RAW_CHECK(fflush(error_file) == 0, "fflush() failed");
+}
+
+std::string GetTmpDir() {
+ // TEST_TMPDIR is set by Bazel. Try the others when not running under Bazel.
+ static const char* const kTmpEnvVars[] = {"TEST_TMPDIR", "TMPDIR", "TEMP",
+ "TEMPDIR", "TMP"};
+ for (const char* const var : kTmpEnvVars) {
+ const char* tmp_dir = std::getenv(var);
+ if (tmp_dir != nullptr) {
+ return tmp_dir;
+ }
+ }
+
+ // Try something reasonable.
+ return "/tmp";
+}
+
+// This function runs in a fork()ed process on most systems.
+void InstallHandlerWithWriteToFileAndRaise(const char* file, int signo) {
+ error_file = fopen(file, "w");
+ ABSL_RAW_CHECK(error_file != nullptr, "Failed create error_file");
+ absl::FailureSignalHandlerOptions options;
+ options.writerfn = WriteToErrorFile;
+ absl::InstallFailureSignalHandler(options);
+ raise(signo);
+}
+
+TEST_P(FailureSignalHandlerDeathTest, AbslFatalSignalsWithWriterFn) {
+ const int signo = GetParam();
+ std::string tmp_dir = GetTmpDir();
+ std::string file = absl::StrCat(tmp_dir, "/signo_", signo);
+
+ std::string exit_regex = absl::StrCat(
+ "\\*\\*\\* ", absl::debugging_internal::FailureSignalToString(signo),
+ " received at time=");
+#ifndef _WIN32
+ EXPECT_EXIT(InstallHandlerWithWriteToFileAndRaise(file.c_str(), signo),
+ testing::KilledBySignal(signo), exit_regex);
+#else
+ // Windows doesn't have testing::KilledBySignal().
+ EXPECT_DEATH(InstallHandlerWithWriteToFileAndRaise(file.c_str(), signo),
+ exit_regex);
+#endif
+
+ // Open the file in this process and check its contents.
+ std::fstream error_output(file);
+ ASSERT_TRUE(error_output.is_open()) << file;
+ std::string error_line;
+ std::getline(error_output, error_line);
+ EXPECT_TRUE(absl::StartsWith(
+ error_line,
+ absl::StrCat("*** ",
+ absl::debugging_internal::FailureSignalToString(signo),
+ " received at ")));
+
+ if (absl::debugging_internal::StackTraceWorksForTest()) {
+ std::getline(error_output, error_line);
+ EXPECT_TRUE(absl::StartsWith(error_line, "PC: "));
+ }
+}
+
+constexpr int kFailureSignals[] = {
+ SIGSEGV, SIGILL, SIGFPE, SIGABRT, SIGTERM,
+#ifndef _WIN32
+ SIGBUS, SIGTRAP,
+#endif
+};
+
+INSTANTIATE_TEST_CASE_P(AbslDeathTest, FailureSignalHandlerDeathTest,
+ ::testing::ValuesIn(kFailureSignals));
+
+#endif // GTEST_HAS_DEATH_TEST
+
+} // namespace
+
+int main(int argc, char** argv) {
+ absl::InitializeSymbolizer(argv[0]);
+ testing::InitGoogleTest(&argc, argv);
+ return RUN_ALL_TESTS();
+}
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/address_is_readable.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/address_is_readable.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/address_is_readable.cc
new file mode 100644
index 0000000..7455aa0
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/address_is_readable.cc
@@ -0,0 +1,133 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// base::AddressIsReadable() probes an address to see whether it is readable,
+// without faulting.
+
+#include "absl/debugging/internal/address_is_readable.h"
+
+#if !defined(__linux__) || defined(__ANDROID__)
+
+namespace absl {
+namespace debugging_internal {
+
+// On platforms other than Linux, just return true.
+bool AddressIsReadable(const void* /* addr */) { return true; }
+
+} // namespace debugging_internal
+} // namespace absl
+
+#else
+
+#include <fcntl.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#include <atomic>
+#include <cerrno>
+#include <cstdint>
+
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+namespace debugging_internal {
+
+// Pack a pid and two file descriptors into a 64-bit word,
+// using 16, 24, and 24 bits for each respectively.
+static uint64_t Pack(uint64_t pid, uint64_t read_fd, uint64_t write_fd) {
+ ABSL_RAW_CHECK((read_fd >> 24) == 0 && (write_fd >> 24) == 0,
+ "fd out of range");
+ return (pid << 48) | ((read_fd & 0xffffff) << 24) | (write_fd & 0xffffff);
+}
+
+// Unpack x into a pid and two file descriptors, where x was created with
+// Pack().
+static void Unpack(uint64_t x, int *pid, int *read_fd, int *write_fd) {
+ *pid = x >> 48;
+ *read_fd = (x >> 24) & 0xffffff;
+ *write_fd = x & 0xffffff;
+}
+
+// Return whether the byte at *addr is readable, without faulting.
+// Save and restores errno. Returns true on systems where
+// unimplemented.
+// This is a namespace-scoped variable for correct zero-initialization.
+static std::atomic<uint64_t> pid_and_fds; // initially 0, an invalid pid.
+bool AddressIsReadable(const void *addr) {
+ int save_errno = errno;
+ // We test whether a byte is readable by using write(). Normally, this would
+ // be done via a cached file descriptor to /dev/null, but linux fails to
+ // check whether the byte is readable when the destination is /dev/null, so
+ // we use a cached pipe. We store the pid of the process that created the
+ // pipe to handle the case where a process forks, and the child closes all
+ // the file descriptors and then calls this routine. This is not perfect:
+ // the child could use the routine, then close all file descriptors and then
+ // use this routine again. But the likely use of this routine is when
+ // crashing, to test the validity of pages when dumping the stack. Beware
+ // that we may leak file descriptors, but we're unlikely to leak many.
+ int bytes_written;
+ int current_pid = getpid() & 0xffff; // we use only the low order 16 bits
+ do { // until we do not get EBADF trying to use file descriptors
+ int pid;
+ int read_fd;
+ int write_fd;
+ uint64_t local_pid_and_fds = pid_and_fds.load(std::memory_order_relaxed);
+ Unpack(local_pid_and_fds, &pid, &read_fd, &write_fd);
+ while (current_pid != pid) {
+ int p[2];
+ // new pipe
+ if (pipe(p) != 0) {
+ ABSL_RAW_LOG(FATAL, "Failed to create pipe, errno=%d", errno);
+ }
+ fcntl(p[0], F_SETFD, FD_CLOEXEC);
+ fcntl(p[1], F_SETFD, FD_CLOEXEC);
+ uint64_t new_pid_and_fds = Pack(current_pid, p[0], p[1]);
+ if (pid_and_fds.compare_exchange_strong(
+ local_pid_and_fds, new_pid_and_fds, std::memory_order_relaxed,
+ std::memory_order_relaxed)) {
+ local_pid_and_fds = new_pid_and_fds; // fds exposed to other threads
+ } else { // fds not exposed to other threads; we can close them.
+ close(p[0]);
+ close(p[1]);
+ local_pid_and_fds = pid_and_fds.load(std::memory_order_relaxed);
+ }
+ Unpack(local_pid_and_fds, &pid, &read_fd, &write_fd);
+ }
+ errno = 0;
+ // Use syscall(SYS_write, ...) instead of write() to prevent ASAN
+ // and other checkers from complaining about accesses to arbitrary
+ // memory.
+ do {
+ bytes_written = syscall(SYS_write, write_fd, addr, 1);
+ } while (bytes_written == -1 && errno == EINTR);
+ if (bytes_written == 1) { // remove the byte from the pipe
+ char c;
+ while (read(read_fd, &c, 1) == -1 && errno == EINTR) {
+ }
+ }
+ if (errno == EBADF) { // Descriptors invalid.
+ // If pid_and_fds contains the problematic file descriptors we just used,
+ // this call will forget them, and the loop will try again.
+ pid_and_fds.compare_exchange_strong(local_pid_and_fds, 0,
+ std::memory_order_relaxed,
+ std::memory_order_relaxed);
+ }
+ } while (errno == EBADF);
+ errno = save_errno;
+ return bytes_written == 1;
+}
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/address_is_readable.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/address_is_readable.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/address_is_readable.h
new file mode 100644
index 0000000..9d48030
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/address_is_readable.h
@@ -0,0 +1,29 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
+#define ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
+
+namespace absl {
+namespace debugging_internal {
+
+// Return whether the byte at *addr is readable, without faulting.
+// Save and restores errno.
+bool AddressIsReadable(const void *addr);
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_ADDRESS_IS_READABLE_H_
[48/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/container_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/container_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/container_test.cc
new file mode 100644
index 0000000..de66f14
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/container_test.cc
@@ -0,0 +1,997 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/algorithm/container.h"
+
+#include <functional>
+#include <initializer_list>
+#include <iterator>
+#include <list>
+#include <memory>
+#include <ostream>
+#include <random>
+#include <set>
+#include <unordered_set>
+#include <utility>
+#include <valarray>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/casts.h"
+#include "absl/base/macros.h"
+#include "absl/memory/memory.h"
+#include "absl/types/span.h"
+
+namespace {
+
+using ::testing::Each;
+using ::testing::ElementsAre;
+using ::testing::Gt;
+using ::testing::IsNull;
+using ::testing::Lt;
+using ::testing::Pointee;
+using ::testing::Truly;
+using ::testing::UnorderedElementsAre;
+
+// Most of these tests just check that the code compiles, not that it
+// does the right thing. That's fine since the functions just forward
+// to the STL implementation.
+class NonMutatingTest : public testing::Test {
+ protected:
+ std::unordered_set<int> container_ = {1, 2, 3};
+ std::list<int> sequence_ = {1, 2, 3};
+ std::vector<int> vector_ = {1, 2, 3};
+ int array_[3] = {1, 2, 3};
+};
+
+struct AccumulateCalls {
+ void operator()(int value) {
+ calls.push_back(value);
+ }
+ std::vector<int> calls;
+};
+
+bool Predicate(int value) { return value < 3; }
+bool BinPredicate(int v1, int v2) { return v1 < v2; }
+bool Equals(int v1, int v2) { return v1 == v2; }
+bool IsOdd(int x) { return x % 2 != 0; }
+
+
+TEST_F(NonMutatingTest, Distance) {
+ EXPECT_EQ(container_.size(), absl::c_distance(container_));
+ EXPECT_EQ(sequence_.size(), absl::c_distance(sequence_));
+ EXPECT_EQ(vector_.size(), absl::c_distance(vector_));
+ EXPECT_EQ(ABSL_ARRAYSIZE(array_), absl::c_distance(array_));
+
+ // Works with a temporary argument.
+ EXPECT_EQ(vector_.size(), absl::c_distance(std::vector<int>(vector_)));
+}
+
+TEST_F(NonMutatingTest, Distance_OverloadedBeginEnd) {
+ // Works with classes which have custom ADL-selected overloads of std::begin
+ // and std::end.
+ std::initializer_list<int> a = {1, 2, 3};
+ std::valarray<int> b = {1, 2, 3};
+ EXPECT_EQ(3, absl::c_distance(a));
+ EXPECT_EQ(3, absl::c_distance(b));
+
+ // It is assumed that other c_* functions use the same mechanism for
+ // ADL-selecting begin/end overloads.
+}
+
+TEST_F(NonMutatingTest, ForEach) {
+ AccumulateCalls c = absl::c_for_each(container_, AccumulateCalls());
+ // Don't rely on the unordered_set's order.
+ std::sort(c.calls.begin(), c.calls.end());
+ EXPECT_EQ(vector_, c.calls);
+
+ // Works with temporary container, too.
+ AccumulateCalls c2 =
+ absl::c_for_each(std::unordered_set<int>(container_), AccumulateCalls());
+ std::sort(c2.calls.begin(), c2.calls.end());
+ EXPECT_EQ(vector_, c2.calls);
+}
+
+TEST_F(NonMutatingTest, FindReturnsCorrectType) {
+ auto it = absl::c_find(container_, 3);
+ EXPECT_EQ(3, *it);
+ absl::c_find(absl::implicit_cast<const std::list<int>&>(sequence_), 3);
+}
+
+TEST_F(NonMutatingTest, FindIf) { absl::c_find_if(container_, Predicate); }
+
+TEST_F(NonMutatingTest, FindIfNot) {
+ absl::c_find_if_not(container_, Predicate);
+}
+
+TEST_F(NonMutatingTest, FindEnd) {
+ absl::c_find_end(sequence_, vector_);
+ absl::c_find_end(vector_, sequence_);
+}
+
+TEST_F(NonMutatingTest, FindEndWithPredicate) {
+ absl::c_find_end(sequence_, vector_, BinPredicate);
+ absl::c_find_end(vector_, sequence_, BinPredicate);
+}
+
+TEST_F(NonMutatingTest, FindFirstOf) {
+ absl::c_find_first_of(container_, sequence_);
+ absl::c_find_first_of(sequence_, container_);
+}
+
+TEST_F(NonMutatingTest, FindFirstOfWithPredicate) {
+ absl::c_find_first_of(container_, sequence_, BinPredicate);
+ absl::c_find_first_of(sequence_, container_, BinPredicate);
+}
+
+TEST_F(NonMutatingTest, AdjacentFind) { absl::c_adjacent_find(sequence_); }
+
+TEST_F(NonMutatingTest, AdjacentFindWithPredicate) {
+ absl::c_adjacent_find(sequence_, BinPredicate);
+}
+
+TEST_F(NonMutatingTest, Count) { EXPECT_EQ(1, absl::c_count(container_, 3)); }
+
+TEST_F(NonMutatingTest, CountIf) {
+ EXPECT_EQ(2, absl::c_count_if(container_, Predicate));
+ const std::unordered_set<int>& const_container = container_;
+ EXPECT_EQ(2, absl::c_count_if(const_container, Predicate));
+}
+
+TEST_F(NonMutatingTest, Mismatch) {
+ absl::c_mismatch(container_, sequence_);
+ absl::c_mismatch(sequence_, container_);
+}
+
+TEST_F(NonMutatingTest, MismatchWithPredicate) {
+ absl::c_mismatch(container_, sequence_, BinPredicate);
+ absl::c_mismatch(sequence_, container_, BinPredicate);
+}
+
+TEST_F(NonMutatingTest, Equal) {
+ EXPECT_TRUE(absl::c_equal(vector_, sequence_));
+ EXPECT_TRUE(absl::c_equal(sequence_, vector_));
+
+ // Test that behavior appropriately differs from that of equal().
+ std::vector<int> vector_plus = {1, 2, 3};
+ vector_plus.push_back(4);
+ EXPECT_FALSE(absl::c_equal(vector_plus, sequence_));
+ EXPECT_FALSE(absl::c_equal(sequence_, vector_plus));
+}
+
+TEST_F(NonMutatingTest, EqualWithPredicate) {
+ EXPECT_TRUE(absl::c_equal(vector_, sequence_, Equals));
+ EXPECT_TRUE(absl::c_equal(sequence_, vector_, Equals));
+
+ // Test that behavior appropriately differs from that of equal().
+ std::vector<int> vector_plus = {1, 2, 3};
+ vector_plus.push_back(4);
+ EXPECT_FALSE(absl::c_equal(vector_plus, sequence_, Equals));
+ EXPECT_FALSE(absl::c_equal(sequence_, vector_plus, Equals));
+}
+
+TEST_F(NonMutatingTest, IsPermutation) {
+ auto vector_permut_ = vector_;
+ std::next_permutation(vector_permut_.begin(), vector_permut_.end());
+ EXPECT_TRUE(absl::c_is_permutation(vector_permut_, sequence_));
+ EXPECT_TRUE(absl::c_is_permutation(sequence_, vector_permut_));
+
+ // Test that behavior appropriately differs from that of is_permutation().
+ std::vector<int> vector_plus = {1, 2, 3};
+ vector_plus.push_back(4);
+ EXPECT_FALSE(absl::c_is_permutation(vector_plus, sequence_));
+ EXPECT_FALSE(absl::c_is_permutation(sequence_, vector_plus));
+}
+
+TEST_F(NonMutatingTest, IsPermutationWithPredicate) {
+ auto vector_permut_ = vector_;
+ std::next_permutation(vector_permut_.begin(), vector_permut_.end());
+ EXPECT_TRUE(absl::c_is_permutation(vector_permut_, sequence_, Equals));
+ EXPECT_TRUE(absl::c_is_permutation(sequence_, vector_permut_, Equals));
+
+ // Test that behavior appropriately differs from that of is_permutation().
+ std::vector<int> vector_plus = {1, 2, 3};
+ vector_plus.push_back(4);
+ EXPECT_FALSE(absl::c_is_permutation(vector_plus, sequence_, Equals));
+ EXPECT_FALSE(absl::c_is_permutation(sequence_, vector_plus, Equals));
+}
+
+TEST_F(NonMutatingTest, Search) {
+ absl::c_search(sequence_, vector_);
+ absl::c_search(vector_, sequence_);
+ absl::c_search(array_, sequence_);
+}
+
+TEST_F(NonMutatingTest, SearchWithPredicate) {
+ absl::c_search(sequence_, vector_, BinPredicate);
+ absl::c_search(vector_, sequence_, BinPredicate);
+}
+
+TEST_F(NonMutatingTest, SearchN) { absl::c_search_n(sequence_, 3, 1); }
+
+TEST_F(NonMutatingTest, SearchNWithPredicate) {
+ absl::c_search_n(sequence_, 3, 1, BinPredicate);
+}
+
+TEST_F(NonMutatingTest, LowerBound) {
+ std::list<int>::iterator i = absl::c_lower_bound(sequence_, 3);
+ ASSERT_TRUE(i != sequence_.end());
+ EXPECT_EQ(2, std::distance(sequence_.begin(), i));
+ EXPECT_EQ(3, *i);
+}
+
+TEST_F(NonMutatingTest, LowerBoundWithPredicate) {
+ std::vector<int> v(vector_);
+ std::sort(v.begin(), v.end(), std::greater<int>());
+ std::vector<int>::iterator i = absl::c_lower_bound(v, 3, std::greater<int>());
+ EXPECT_TRUE(i == v.begin());
+ EXPECT_EQ(3, *i);
+}
+
+TEST_F(NonMutatingTest, UpperBound) {
+ std::list<int>::iterator i = absl::c_upper_bound(sequence_, 1);
+ ASSERT_TRUE(i != sequence_.end());
+ EXPECT_EQ(1, std::distance(sequence_.begin(), i));
+ EXPECT_EQ(2, *i);
+}
+
+TEST_F(NonMutatingTest, UpperBoundWithPredicate) {
+ std::vector<int> v(vector_);
+ std::sort(v.begin(), v.end(), std::greater<int>());
+ std::vector<int>::iterator i = absl::c_upper_bound(v, 1, std::greater<int>());
+ EXPECT_EQ(3, i - v.begin());
+ EXPECT_TRUE(i == v.end());
+}
+
+TEST_F(NonMutatingTest, EqualRange) {
+ std::pair<std::list<int>::iterator, std::list<int>::iterator> p =
+ absl::c_equal_range(sequence_, 2);
+ EXPECT_EQ(1, std::distance(sequence_.begin(), p.first));
+ EXPECT_EQ(2, std::distance(sequence_.begin(), p.second));
+}
+
+TEST_F(NonMutatingTest, EqualRangeArray) {
+ auto p = absl::c_equal_range(array_, 2);
+ EXPECT_EQ(1, std::distance(std::begin(array_), p.first));
+ EXPECT_EQ(2, std::distance(std::begin(array_), p.second));
+}
+
+TEST_F(NonMutatingTest, EqualRangeWithPredicate) {
+ std::vector<int> v(vector_);
+ std::sort(v.begin(), v.end(), std::greater<int>());
+ std::pair<std::vector<int>::iterator, std::vector<int>::iterator> p =
+ absl::c_equal_range(v, 2, std::greater<int>());
+ EXPECT_EQ(1, std::distance(v.begin(), p.first));
+ EXPECT_EQ(2, std::distance(v.begin(), p.second));
+}
+
+TEST_F(NonMutatingTest, BinarySearch) {
+ EXPECT_TRUE(absl::c_binary_search(vector_, 2));
+ EXPECT_TRUE(absl::c_binary_search(std::vector<int>(vector_), 2));
+}
+
+TEST_F(NonMutatingTest, BinarySearchWithPredicate) {
+ std::vector<int> v(vector_);
+ std::sort(v.begin(), v.end(), std::greater<int>());
+ EXPECT_TRUE(absl::c_binary_search(v, 2, std::greater<int>()));
+ EXPECT_TRUE(
+ absl::c_binary_search(std::vector<int>(v), 2, std::greater<int>()));
+}
+
+TEST_F(NonMutatingTest, MinElement) {
+ std::list<int>::iterator i = absl::c_min_element(sequence_);
+ ASSERT_TRUE(i != sequence_.end());
+ EXPECT_EQ(*i, 1);
+}
+
+TEST_F(NonMutatingTest, MinElementWithPredicate) {
+ std::list<int>::iterator i =
+ absl::c_min_element(sequence_, std::greater<int>());
+ ASSERT_TRUE(i != sequence_.end());
+ EXPECT_EQ(*i, 3);
+}
+
+TEST_F(NonMutatingTest, MaxElement) {
+ std::list<int>::iterator i = absl::c_max_element(sequence_);
+ ASSERT_TRUE(i != sequence_.end());
+ EXPECT_EQ(*i, 3);
+}
+
+TEST_F(NonMutatingTest, MaxElementWithPredicate) {
+ std::list<int>::iterator i =
+ absl::c_max_element(sequence_, std::greater<int>());
+ ASSERT_TRUE(i != sequence_.end());
+ EXPECT_EQ(*i, 1);
+}
+
+TEST_F(NonMutatingTest, LexicographicalCompare) {
+ EXPECT_FALSE(absl::c_lexicographical_compare(sequence_, sequence_));
+
+ std::vector<int> v;
+ v.push_back(1);
+ v.push_back(2);
+ v.push_back(4);
+
+ EXPECT_TRUE(absl::c_lexicographical_compare(sequence_, v));
+ EXPECT_TRUE(absl::c_lexicographical_compare(std::list<int>(sequence_), v));
+}
+
+TEST_F(NonMutatingTest, LexicographicalCopmareWithPredicate) {
+ EXPECT_FALSE(absl::c_lexicographical_compare(sequence_, sequence_,
+ std::greater<int>()));
+
+ std::vector<int> v;
+ v.push_back(1);
+ v.push_back(2);
+ v.push_back(4);
+
+ EXPECT_TRUE(
+ absl::c_lexicographical_compare(v, sequence_, std::greater<int>()));
+ EXPECT_TRUE(absl::c_lexicographical_compare(
+ std::vector<int>(v), std::list<int>(sequence_), std::greater<int>()));
+}
+
+TEST_F(NonMutatingTest, Includes) {
+ std::set<int> s(vector_.begin(), vector_.end());
+ s.insert(4);
+ EXPECT_TRUE(absl::c_includes(s, vector_));
+}
+
+TEST_F(NonMutatingTest, IncludesWithPredicate) {
+ std::vector<int> v = {3, 2, 1};
+ std::set<int, std::greater<int>> s(v.begin(), v.end());
+ s.insert(4);
+ EXPECT_TRUE(absl::c_includes(s, v, std::greater<int>()));
+}
+
+class NumericMutatingTest : public testing::Test {
+ protected:
+ std::list<int> list_ = {1, 2, 3};
+ std::vector<int> output_;
+};
+
+TEST_F(NumericMutatingTest, Iota) {
+ absl::c_iota(list_, 5);
+ std::list<int> expected{5, 6, 7};
+ EXPECT_EQ(list_, expected);
+}
+
+TEST_F(NonMutatingTest, Accumulate) {
+ EXPECT_EQ(absl::c_accumulate(sequence_, 4), 1 + 2 + 3 + 4);
+}
+
+TEST_F(NonMutatingTest, AccumulateWithBinaryOp) {
+ EXPECT_EQ(absl::c_accumulate(sequence_, 4, std::multiplies<int>()),
+ 1 * 2 * 3 * 4);
+}
+
+TEST_F(NonMutatingTest, AccumulateLvalueInit) {
+ int lvalue = 4;
+ EXPECT_EQ(absl::c_accumulate(sequence_, lvalue), 1 + 2 + 3 + 4);
+}
+
+TEST_F(NonMutatingTest, AccumulateWithBinaryOpLvalueInit) {
+ int lvalue = 4;
+ EXPECT_EQ(absl::c_accumulate(sequence_, lvalue, std::multiplies<int>()),
+ 1 * 2 * 3 * 4);
+}
+
+TEST_F(NonMutatingTest, InnerProduct) {
+ EXPECT_EQ(absl::c_inner_product(sequence_, vector_, 1000),
+ 1000 + 1 * 1 + 2 * 2 + 3 * 3);
+}
+
+TEST_F(NonMutatingTest, InnerProductWithBinaryOps) {
+ EXPECT_EQ(absl::c_inner_product(sequence_, vector_, 10,
+ std::multiplies<int>(), std::plus<int>()),
+ 10 * (1 + 1) * (2 + 2) * (3 + 3));
+}
+
+TEST_F(NonMutatingTest, InnerProductLvalueInit) {
+ int lvalue = 1000;
+ EXPECT_EQ(absl::c_inner_product(sequence_, vector_, lvalue),
+ 1000 + 1 * 1 + 2 * 2 + 3 * 3);
+}
+
+TEST_F(NonMutatingTest, InnerProductWithBinaryOpsLvalueInit) {
+ int lvalue = 10;
+ EXPECT_EQ(absl::c_inner_product(sequence_, vector_, lvalue,
+ std::multiplies<int>(), std::plus<int>()),
+ 10 * (1 + 1) * (2 + 2) * (3 + 3));
+}
+
+TEST_F(NumericMutatingTest, AdjacentDifference) {
+ auto last = absl::c_adjacent_difference(list_, std::back_inserter(output_));
+ *last = 1000;
+ std::vector<int> expected{1, 2 - 1, 3 - 2, 1000};
+ EXPECT_EQ(output_, expected);
+}
+
+TEST_F(NumericMutatingTest, AdjacentDifferenceWithBinaryOp) {
+ auto last = absl::c_adjacent_difference(list_, std::back_inserter(output_),
+ std::multiplies<int>());
+ *last = 1000;
+ std::vector<int> expected{1, 2 * 1, 3 * 2, 1000};
+ EXPECT_EQ(output_, expected);
+}
+
+TEST_F(NumericMutatingTest, PartialSum) {
+ auto last = absl::c_partial_sum(list_, std::back_inserter(output_));
+ *last = 1000;
+ std::vector<int> expected{1, 1 + 2, 1 + 2 + 3, 1000};
+ EXPECT_EQ(output_, expected);
+}
+
+TEST_F(NumericMutatingTest, PartialSumWithBinaryOp) {
+ auto last = absl::c_partial_sum(list_, std::back_inserter(output_),
+ std::multiplies<int>());
+ *last = 1000;
+ std::vector<int> expected{1, 1 * 2, 1 * 2 * 3, 1000};
+ EXPECT_EQ(output_, expected);
+}
+
+TEST_F(NonMutatingTest, LinearSearch) {
+ EXPECT_TRUE(absl::c_linear_search(container_, 3));
+ EXPECT_FALSE(absl::c_linear_search(container_, 4));
+}
+
+TEST_F(NonMutatingTest, AllOf) {
+ const std::vector<int>& v = vector_;
+ EXPECT_FALSE(absl::c_all_of(v, [](int x) { return x > 1; }));
+ EXPECT_TRUE(absl::c_all_of(v, [](int x) { return x > 0; }));
+}
+
+TEST_F(NonMutatingTest, AnyOf) {
+ const std::vector<int>& v = vector_;
+ EXPECT_TRUE(absl::c_any_of(v, [](int x) { return x > 2; }));
+ EXPECT_FALSE(absl::c_any_of(v, [](int x) { return x > 5; }));
+}
+
+TEST_F(NonMutatingTest, NoneOf) {
+ const std::vector<int>& v = vector_;
+ EXPECT_FALSE(absl::c_none_of(v, [](int x) { return x > 2; }));
+ EXPECT_TRUE(absl::c_none_of(v, [](int x) { return x > 5; }));
+}
+
+TEST_F(NonMutatingTest, MinMaxElementLess) {
+ std::pair<std::vector<int>::const_iterator, std::vector<int>::const_iterator>
+ p = absl::c_minmax_element(vector_, std::less<int>());
+ EXPECT_TRUE(p.first == vector_.begin());
+ EXPECT_TRUE(p.second == vector_.begin() + 2);
+}
+
+TEST_F(NonMutatingTest, MinMaxElementGreater) {
+ std::pair<std::vector<int>::const_iterator, std::vector<int>::const_iterator>
+ p = absl::c_minmax_element(vector_, std::greater<int>());
+ EXPECT_TRUE(p.first == vector_.begin() + 2);
+ EXPECT_TRUE(p.second == vector_.begin());
+}
+
+TEST_F(NonMutatingTest, MinMaxElementNoPredicate) {
+ std::pair<std::vector<int>::const_iterator, std::vector<int>::const_iterator>
+ p = absl::c_minmax_element(vector_);
+ EXPECT_TRUE(p.first == vector_.begin());
+ EXPECT_TRUE(p.second == vector_.begin() + 2);
+}
+
+class SortingTest : public testing::Test {
+ protected:
+ std::list<int> sorted_ = {1, 2, 3, 4};
+ std::list<int> unsorted_ = {2, 4, 1, 3};
+ std::list<int> reversed_ = {4, 3, 2, 1};
+};
+
+TEST_F(SortingTest, IsSorted) {
+ EXPECT_TRUE(absl::c_is_sorted(sorted_));
+ EXPECT_FALSE(absl::c_is_sorted(unsorted_));
+ EXPECT_FALSE(absl::c_is_sorted(reversed_));
+}
+
+TEST_F(SortingTest, IsSortedWithPredicate) {
+ EXPECT_FALSE(absl::c_is_sorted(sorted_, std::greater<int>()));
+ EXPECT_FALSE(absl::c_is_sorted(unsorted_, std::greater<int>()));
+ EXPECT_TRUE(absl::c_is_sorted(reversed_, std::greater<int>()));
+}
+
+TEST_F(SortingTest, IsSortedUntil) {
+ EXPECT_EQ(1, *absl::c_is_sorted_until(unsorted_));
+ EXPECT_EQ(4, *absl::c_is_sorted_until(unsorted_, std::greater<int>()));
+}
+
+TEST_F(SortingTest, NthElement) {
+ std::vector<int> unsorted = {2, 4, 1, 3};
+ absl::c_nth_element(unsorted, unsorted.begin() + 2);
+ EXPECT_THAT(unsorted,
+ ElementsAre(Lt(3), Lt(3), 3, Gt(3)));
+ absl::c_nth_element(unsorted, unsorted.begin() + 2, std::greater<int>());
+ EXPECT_THAT(unsorted,
+ ElementsAre(Gt(2), Gt(2), 2, Lt(2)));
+}
+
+TEST(MutatingTest, IsPartitioned) {
+ EXPECT_TRUE(
+ absl::c_is_partitioned(std::vector<int>{1, 3, 5, 2, 4, 6}, IsOdd));
+ EXPECT_FALSE(
+ absl::c_is_partitioned(std::vector<int>{1, 2, 3, 4, 5, 6}, IsOdd));
+ EXPECT_FALSE(
+ absl::c_is_partitioned(std::vector<int>{2, 4, 6, 1, 3, 5}, IsOdd));
+}
+
+TEST(MutatingTest, Partition) {
+ std::vector<int> actual = {1, 2, 3, 4, 5};
+ absl::c_partition(actual, IsOdd);
+ EXPECT_THAT(actual, Truly([](const std::vector<int>& c) {
+ return absl::c_is_partitioned(c, IsOdd);
+ }));
+}
+
+TEST(MutatingTest, StablePartition) {
+ std::vector<int> actual = {1, 2, 3, 4, 5};
+ absl::c_stable_partition(actual, IsOdd);
+ EXPECT_THAT(actual, ElementsAre(1, 3, 5, 2, 4));
+}
+
+TEST(MutatingTest, PartitionCopy) {
+ const std::vector<int> initial = {1, 2, 3, 4, 5};
+ std::vector<int> odds, evens;
+ auto ends = absl::c_partition_copy(initial, back_inserter(odds),
+ back_inserter(evens), IsOdd);
+ *ends.first = 7;
+ *ends.second = 6;
+ EXPECT_THAT(odds, ElementsAre(1, 3, 5, 7));
+ EXPECT_THAT(evens, ElementsAre(2, 4, 6));
+}
+
+TEST(MutatingTest, PartitionPoint) {
+ const std::vector<int> initial = {1, 3, 5, 2, 4};
+ auto middle = absl::c_partition_point(initial, IsOdd);
+ EXPECT_EQ(2, *middle);
+}
+
+TEST(MutatingTest, CopyMiddle) {
+ const std::vector<int> initial = {4, -1, -2, -3, 5};
+ const std::list<int> input = {1, 2, 3};
+ const std::vector<int> expected = {4, 1, 2, 3, 5};
+
+ std::list<int> test_list(initial.begin(), initial.end());
+ absl::c_copy(input, ++test_list.begin());
+ EXPECT_EQ(std::list<int>(expected.begin(), expected.end()), test_list);
+
+ std::vector<int> test_vector = initial;
+ absl::c_copy(input, test_vector.begin() + 1);
+ EXPECT_EQ(expected, test_vector);
+}
+
+TEST(MutatingTest, CopyFrontInserter) {
+ const std::list<int> initial = {4, 5};
+ const std::list<int> input = {1, 2, 3};
+ const std::list<int> expected = {3, 2, 1, 4, 5};
+
+ std::list<int> test_list = initial;
+ absl::c_copy(input, std::front_inserter(test_list));
+ EXPECT_EQ(expected, test_list);
+}
+
+TEST(MutatingTest, CopyBackInserter) {
+ const std::vector<int> initial = {4, 5};
+ const std::list<int> input = {1, 2, 3};
+ const std::vector<int> expected = {4, 5, 1, 2, 3};
+
+ std::list<int> test_list(initial.begin(), initial.end());
+ absl::c_copy(input, std::back_inserter(test_list));
+ EXPECT_EQ(std::list<int>(expected.begin(), expected.end()), test_list);
+
+ std::vector<int> test_vector = initial;
+ absl::c_copy(input, std::back_inserter(test_vector));
+ EXPECT_EQ(expected, test_vector);
+}
+
+TEST(MutatingTest, CopyN) {
+ const std::vector<int> initial = {1, 2, 3, 4, 5};
+ const std::vector<int> expected = {1, 2};
+ std::vector<int> actual;
+ absl::c_copy_n(initial, 2, back_inserter(actual));
+ EXPECT_EQ(expected, actual);
+}
+
+TEST(MutatingTest, CopyIf) {
+ const std::list<int> input = {1, 2, 3};
+ std::vector<int> output;
+ absl::c_copy_if(input, std::back_inserter(output),
+ [](int i) { return i != 2; });
+ EXPECT_THAT(output, ElementsAre(1, 3));
+}
+
+TEST(MutatingTest, CopyBackward) {
+ std::vector<int> actual = {1, 2, 3, 4, 5};
+ std::vector<int> expected = {1, 2, 1, 2, 3};
+ absl::c_copy_backward(absl::MakeSpan(actual.data(), 3), actual.end());
+ EXPECT_EQ(expected, actual);
+}
+
+TEST(MutatingTest, Move) {
+ std::vector<std::unique_ptr<int>> src;
+ src.emplace_back(absl::make_unique<int>(1));
+ src.emplace_back(absl::make_unique<int>(2));
+ src.emplace_back(absl::make_unique<int>(3));
+ src.emplace_back(absl::make_unique<int>(4));
+ src.emplace_back(absl::make_unique<int>(5));
+
+ std::vector<std::unique_ptr<int>> dest = {};
+ absl::c_move(src, std::back_inserter(dest));
+ EXPECT_THAT(src, Each(IsNull()));
+ EXPECT_THAT(dest, ElementsAre(Pointee(1), Pointee(2), Pointee(3), Pointee(4),
+ Pointee(5)));
+}
+
+TEST(MutatingTest, SwapRanges) {
+ std::vector<int> odds = {2, 4, 6};
+ std::vector<int> evens = {1, 3, 5};
+ absl::c_swap_ranges(odds, evens);
+ EXPECT_THAT(odds, ElementsAre(1, 3, 5));
+ EXPECT_THAT(evens, ElementsAre(2, 4, 6));
+}
+
+TEST_F(NonMutatingTest, Transform) {
+ std::vector<int> x{0, 2, 4}, y, z;
+ auto end = absl::c_transform(x, back_inserter(y), std::negate<int>());
+ EXPECT_EQ(std::vector<int>({0, -2, -4}), y);
+ *end = 7;
+ EXPECT_EQ(std::vector<int>({0, -2, -4, 7}), y);
+
+ y = {1, 3, 0};
+ end = absl::c_transform(x, y, back_inserter(z), std::plus<int>());
+ EXPECT_EQ(std::vector<int>({1, 5, 4}), z);
+ *end = 7;
+ EXPECT_EQ(std::vector<int>({1, 5, 4, 7}), z);
+}
+
+TEST(MutatingTest, Replace) {
+ const std::vector<int> initial = {1, 2, 3, 1, 4, 5};
+ const std::vector<int> expected = {4, 2, 3, 4, 4, 5};
+
+ std::vector<int> test_vector = initial;
+ absl::c_replace(test_vector, 1, 4);
+ EXPECT_EQ(expected, test_vector);
+
+ std::list<int> test_list(initial.begin(), initial.end());
+ absl::c_replace(test_list, 1, 4);
+ EXPECT_EQ(std::list<int>(expected.begin(), expected.end()), test_list);
+}
+
+TEST(MutatingTest, ReplaceIf) {
+ std::vector<int> actual = {1, 2, 3, 4, 5};
+ const std::vector<int> expected = {0, 2, 0, 4, 0};
+
+ absl::c_replace_if(actual, IsOdd, 0);
+ EXPECT_EQ(expected, actual);
+}
+
+TEST(MutatingTest, ReplaceCopy) {
+ const std::vector<int> initial = {1, 2, 3, 1, 4, 5};
+ const std::vector<int> expected = {4, 2, 3, 4, 4, 5};
+
+ std::vector<int> actual;
+ absl::c_replace_copy(initial, back_inserter(actual), 1, 4);
+ EXPECT_EQ(expected, actual);
+}
+
+TEST(MutatingTest, Sort) {
+ std::vector<int> test_vector = {2, 3, 1, 4};
+ absl::c_sort(test_vector);
+ EXPECT_THAT(test_vector, ElementsAre(1, 2, 3, 4));
+}
+
+TEST(MutatingTest, SortWithPredicate) {
+ std::vector<int> test_vector = {2, 3, 1, 4};
+ absl::c_sort(test_vector, std::greater<int>());
+ EXPECT_THAT(test_vector, ElementsAre(4, 3, 2, 1));
+}
+
+// For absl::c_stable_sort tests. Needs an operator< that does not cover all
+// fields so that the test can check the sort preserves order of equal elements.
+struct Element {
+ int key;
+ int value;
+ friend bool operator<(const Element& e1, const Element& e2) {
+ return e1.key < e2.key;
+ }
+ // Make gmock print useful diagnostics.
+ friend std::ostream& operator<<(std::ostream& o, const Element& e) {
+ return o << "{" << e.key << ", " << e.value << "}";
+ }
+};
+
+MATCHER_P2(IsElement, key, value, "") {
+ return arg.key == key && arg.value == value;
+}
+
+TEST(MutatingTest, StableSort) {
+ std::vector<Element> test_vector = {{1, 1}, {2, 1}, {2, 0}, {1, 0}, {2, 2}};
+ absl::c_stable_sort(test_vector);
+ EXPECT_THAT(
+ test_vector,
+ ElementsAre(IsElement(1, 1), IsElement(1, 0), IsElement(2, 1),
+ IsElement(2, 0), IsElement(2, 2)));
+}
+
+TEST(MutatingTest, StableSortWithPredicate) {
+ std::vector<Element> test_vector = {{1, 1}, {2, 1}, {2, 0}, {1, 0}, {2, 2}};
+ absl::c_stable_sort(test_vector, [](const Element& e1, const Element& e2) {
+ return e2 < e1;
+ });
+ EXPECT_THAT(
+ test_vector,
+ ElementsAre(IsElement(2, 1), IsElement(2, 0), IsElement(2, 2),
+ IsElement(1, 1), IsElement(1, 0)));
+}
+
+TEST(MutatingTest, ReplaceCopyIf) {
+ const std::vector<int> initial = {1, 2, 3, 4, 5};
+ const std::vector<int> expected = {0, 2, 0, 4, 0};
+
+ std::vector<int> actual;
+ absl::c_replace_copy_if(initial, back_inserter(actual), IsOdd, 0);
+ EXPECT_EQ(expected, actual);
+}
+
+TEST(MutatingTest, Fill) {
+ std::vector<int> actual(5);
+ absl::c_fill(actual, 1);
+ EXPECT_THAT(actual, ElementsAre(1, 1, 1, 1, 1));
+}
+
+TEST(MutatingTest, FillN) {
+ std::vector<int> actual(5, 0);
+ absl::c_fill_n(actual, 2, 1);
+ EXPECT_THAT(actual, ElementsAre(1, 1, 0, 0, 0));
+}
+
+TEST(MutatingTest, Generate) {
+ std::vector<int> actual(5);
+ int x = 0;
+ absl::c_generate(actual, [&x]() { return ++x; });
+ EXPECT_THAT(actual, ElementsAre(1, 2, 3, 4, 5));
+}
+
+TEST(MutatingTest, GenerateN) {
+ std::vector<int> actual(5, 0);
+ int x = 0;
+ absl::c_generate_n(actual, 3, [&x]() { return ++x; });
+ EXPECT_THAT(actual, ElementsAre(1, 2, 3, 0, 0));
+}
+
+TEST(MutatingTest, RemoveCopy) {
+ std::vector<int> actual;
+ absl::c_remove_copy(std::vector<int>{1, 2, 3}, back_inserter(actual), 2);
+ EXPECT_THAT(actual, ElementsAre(1, 3));
+}
+
+TEST(MutatingTest, RemoveCopyIf) {
+ std::vector<int> actual;
+ absl::c_remove_copy_if(std::vector<int>{1, 2, 3}, back_inserter(actual),
+ IsOdd);
+ EXPECT_THAT(actual, ElementsAre(2));
+}
+
+TEST(MutatingTest, UniqueCopy) {
+ std::vector<int> actual;
+ absl::c_unique_copy(std::vector<int>{1, 2, 2, 2, 3, 3, 2},
+ back_inserter(actual));
+ EXPECT_THAT(actual, ElementsAre(1, 2, 3, 2));
+}
+
+TEST(MutatingTest, UniqueCopyWithPredicate) {
+ std::vector<int> actual;
+ absl::c_unique_copy(std::vector<int>{1, 2, 3, -1, -2, -3, 1},
+ back_inserter(actual),
+ [](int x, int y) { return (x < 0) == (y < 0); });
+ EXPECT_THAT(actual, ElementsAre(1, -1, 1));
+}
+
+TEST(MutatingTest, Reverse) {
+ std::vector<int> test_vector = {1, 2, 3, 4};
+ absl::c_reverse(test_vector);
+ EXPECT_THAT(test_vector, ElementsAre(4, 3, 2, 1));
+
+ std::list<int> test_list = {1, 2, 3, 4};
+ absl::c_reverse(test_list);
+ EXPECT_THAT(test_list, ElementsAre(4, 3, 2, 1));
+}
+
+TEST(MutatingTest, ReverseCopy) {
+ std::vector<int> actual;
+ absl::c_reverse_copy(std::vector<int>{1, 2, 3, 4}, back_inserter(actual));
+ EXPECT_THAT(actual, ElementsAre(4, 3, 2, 1));
+}
+
+TEST(MutatingTest, Rotate) {
+ std::vector<int> actual = {1, 2, 3, 4};
+ auto it = absl::c_rotate(actual, actual.begin() + 2);
+ EXPECT_THAT(actual, testing::ElementsAreArray({3, 4, 1, 2}));
+ EXPECT_EQ(*it, 1);
+}
+
+TEST(MutatingTest, RotateCopy) {
+ std::vector<int> initial = {1, 2, 3, 4};
+ std::vector<int> actual;
+ auto end =
+ absl::c_rotate_copy(initial, initial.begin() + 2, back_inserter(actual));
+ *end = 5;
+ EXPECT_THAT(actual, ElementsAre(3, 4, 1, 2, 5));
+}
+
+TEST(MutatingTest, Shuffle) {
+ std::vector<int> actual = {1, 2, 3, 4, 5};
+ absl::c_shuffle(actual, std::random_device());
+ EXPECT_THAT(actual, UnorderedElementsAre(1, 2, 3, 4, 5));
+}
+
+TEST(MutatingTest, PartialSort) {
+ std::vector<int> sequence{5, 3, 42, 0};
+ absl::c_partial_sort(sequence, sequence.begin() + 2);
+ EXPECT_THAT(absl::MakeSpan(sequence.data(), 2), ElementsAre(0, 3));
+ absl::c_partial_sort(sequence, sequence.begin() + 2, std::greater<int>());
+ EXPECT_THAT(absl::MakeSpan(sequence.data(), 2), ElementsAre(42, 5));
+}
+
+TEST(MutatingTest, PartialSortCopy) {
+ const std::vector<int> initial = {5, 3, 42, 0};
+ std::vector<int> actual(2);
+ absl::c_partial_sort_copy(initial, actual);
+ EXPECT_THAT(actual, ElementsAre(0, 3));
+ absl::c_partial_sort_copy(initial, actual, std::greater<int>());
+ EXPECT_THAT(actual, ElementsAre(42, 5));
+}
+
+TEST(MutatingTest, Merge) {
+ std::vector<int> actual;
+ absl::c_merge(std::vector<int>{1, 3, 5}, std::vector<int>{2, 4},
+ back_inserter(actual));
+ EXPECT_THAT(actual, ElementsAre(1, 2, 3, 4, 5));
+}
+
+TEST(MutatingTest, MergeWithComparator) {
+ std::vector<int> actual;
+ absl::c_merge(std::vector<int>{5, 3, 1}, std::vector<int>{4, 2},
+ back_inserter(actual), std::greater<int>());
+ EXPECT_THAT(actual, ElementsAre(5, 4, 3, 2, 1));
+}
+
+TEST(MutatingTest, InplaceMerge) {
+ std::vector<int> actual = {1, 3, 5, 2, 4};
+ absl::c_inplace_merge(actual, actual.begin() + 3);
+ EXPECT_THAT(actual, ElementsAre(1, 2, 3, 4, 5));
+}
+
+TEST(MutatingTest, InplaceMergeWithComparator) {
+ std::vector<int> actual = {5, 3, 1, 4, 2};
+ absl::c_inplace_merge(actual, actual.begin() + 3, std::greater<int>());
+ EXPECT_THAT(actual, ElementsAre(5, 4, 3, 2, 1));
+}
+
+class SetOperationsTest : public testing::Test {
+ protected:
+ std::vector<int> a_ = {1, 2, 3};
+ std::vector<int> b_ = {1, 3, 5};
+
+ std::vector<int> a_reversed_ = {3, 2, 1};
+ std::vector<int> b_reversed_ = {5, 3, 1};
+};
+
+TEST_F(SetOperationsTest, SetUnion) {
+ std::vector<int> actual;
+ absl::c_set_union(a_, b_, back_inserter(actual));
+ EXPECT_THAT(actual, ElementsAre(1, 2, 3, 5));
+}
+
+TEST_F(SetOperationsTest, SetUnionWithComparator) {
+ std::vector<int> actual;
+ absl::c_set_union(a_reversed_, b_reversed_, back_inserter(actual),
+ std::greater<int>());
+ EXPECT_THAT(actual, ElementsAre(5, 3, 2, 1));
+}
+
+TEST_F(SetOperationsTest, SetIntersection) {
+ std::vector<int> actual;
+ absl::c_set_intersection(a_, b_, back_inserter(actual));
+ EXPECT_THAT(actual, ElementsAre(1, 3));
+}
+
+TEST_F(SetOperationsTest, SetIntersectionWithComparator) {
+ std::vector<int> actual;
+ absl::c_set_intersection(a_reversed_, b_reversed_, back_inserter(actual),
+ std::greater<int>());
+ EXPECT_THAT(actual, ElementsAre(3, 1));
+}
+
+TEST_F(SetOperationsTest, SetDifference) {
+ std::vector<int> actual;
+ absl::c_set_difference(a_, b_, back_inserter(actual));
+ EXPECT_THAT(actual, ElementsAre(2));
+}
+
+TEST_F(SetOperationsTest, SetDifferenceWithComparator) {
+ std::vector<int> actual;
+ absl::c_set_difference(a_reversed_, b_reversed_, back_inserter(actual),
+ std::greater<int>());
+ EXPECT_THAT(actual, ElementsAre(2));
+}
+
+TEST_F(SetOperationsTest, SetSymmetricDifference) {
+ std::vector<int> actual;
+ absl::c_set_symmetric_difference(a_, b_, back_inserter(actual));
+ EXPECT_THAT(actual, ElementsAre(2, 5));
+}
+
+TEST_F(SetOperationsTest, SetSymmetricDifferenceWithComparator) {
+ std::vector<int> actual;
+ absl::c_set_symmetric_difference(a_reversed_, b_reversed_,
+ back_inserter(actual), std::greater<int>());
+ EXPECT_THAT(actual, ElementsAre(5, 2));
+}
+
+TEST(HeapOperationsTest, WithoutComparator) {
+ std::vector<int> heap = {1, 2, 3};
+ EXPECT_FALSE(absl::c_is_heap(heap));
+ absl::c_make_heap(heap);
+ EXPECT_TRUE(absl::c_is_heap(heap));
+ heap.push_back(4);
+ EXPECT_EQ(3, absl::c_is_heap_until(heap) - heap.begin());
+ absl::c_push_heap(heap);
+ EXPECT_EQ(4, heap[0]);
+ absl::c_pop_heap(heap);
+ EXPECT_EQ(4, heap[3]);
+ absl::c_make_heap(heap);
+ absl::c_sort_heap(heap);
+ EXPECT_THAT(heap, ElementsAre(1, 2, 3, 4));
+ EXPECT_FALSE(absl::c_is_heap(heap));
+}
+
+TEST(HeapOperationsTest, WithComparator) {
+ using greater = std::greater<int>;
+ std::vector<int> heap = {3, 2, 1};
+ EXPECT_FALSE(absl::c_is_heap(heap, greater()));
+ absl::c_make_heap(heap, greater());
+ EXPECT_TRUE(absl::c_is_heap(heap, greater()));
+ heap.push_back(0);
+ EXPECT_EQ(3, absl::c_is_heap_until(heap, greater()) - heap.begin());
+ absl::c_push_heap(heap, greater());
+ EXPECT_EQ(0, heap[0]);
+ absl::c_pop_heap(heap, greater());
+ EXPECT_EQ(0, heap[3]);
+ absl::c_make_heap(heap, greater());
+ absl::c_sort_heap(heap, greater());
+ EXPECT_THAT(heap, ElementsAre(3, 2, 1, 0));
+ EXPECT_FALSE(absl::c_is_heap(heap, greater()));
+}
+
+TEST(MutatingTest, PermutationOperations) {
+ std::vector<int> initial = {1, 2, 3, 4};
+ std::vector<int> permuted = initial;
+
+ absl::c_next_permutation(permuted);
+ EXPECT_TRUE(absl::c_is_permutation(initial, permuted));
+ EXPECT_TRUE(absl::c_is_permutation(initial, permuted, std::equal_to<int>()));
+
+ std::vector<int> permuted2 = initial;
+ absl::c_prev_permutation(permuted2, std::greater<int>());
+ EXPECT_EQ(permuted, permuted2);
+
+ absl::c_prev_permutation(permuted);
+ EXPECT_EQ(initial, permuted);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/base/BUILD.bazel
new file mode 100644
index 0000000..f9aac5a
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/BUILD.bazel
@@ -0,0 +1,395 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+ "ABSL_EXCEPTIONS_FLAG",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "spinlock_wait",
+ srcs = [
+ "internal/spinlock_akaros.inc",
+ "internal/spinlock_posix.inc",
+ "internal/spinlock_wait.cc",
+ "internal/spinlock_win32.inc",
+ ],
+ hdrs = [
+ "internal/scheduling_mode.h",
+ "internal/spinlock_wait.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ visibility = [
+ "//absl/base:__pkg__",
+ ],
+ deps = [":core_headers"],
+)
+
+cc_library(
+ name = "config",
+ hdrs = [
+ "config.h",
+ "policy_checks.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+)
+
+cc_library(
+ name = "dynamic_annotations",
+ srcs = ["dynamic_annotations.cc"],
+ hdrs = ["dynamic_annotations.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ defines = ["__CLANG_SUPPORT_DYN_ANNOTATION__"],
+)
+
+cc_library(
+ name = "core_headers",
+ hdrs = [
+ "attributes.h",
+ "macros.h",
+ "optimization.h",
+ "port.h",
+ "thread_annotations.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":config",
+ ":dynamic_annotations",
+ ],
+)
+
+cc_library(
+ name = "malloc_internal",
+ srcs = [
+ "internal/low_level_alloc.cc",
+ ],
+ hdrs = [
+ "internal/direct_mmap.h",
+ "internal/low_level_alloc.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ visibility = [
+ "//absl:__subpackages__",
+ ],
+ deps = [
+ ":base",
+ ":config",
+ ":core_headers",
+ ":dynamic_annotations",
+ ":spinlock_wait",
+ ],
+)
+
+cc_library(
+ name = "base_internal",
+ hdrs = [
+ "internal/identity.h",
+ "internal/inline_variable.h",
+ "internal/invoke.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ visibility = [
+ "//absl:__subpackages__",
+ ],
+)
+
+cc_library(
+ name = "base",
+ srcs = [
+ "internal/cycleclock.cc",
+ "internal/raw_logging.cc",
+ "internal/spinlock.cc",
+ "internal/sysinfo.cc",
+ "internal/thread_identity.cc",
+ "internal/unscaledcycleclock.cc",
+ ],
+ hdrs = [
+ "call_once.h",
+ "casts.h",
+ "internal/atomic_hook.h",
+ "internal/cycleclock.h",
+ "internal/low_level_scheduling.h",
+ "internal/per_thread_tls.h",
+ "internal/raw_logging.h",
+ "internal/spinlock.h",
+ "internal/sysinfo.h",
+ "internal/thread_identity.h",
+ "internal/tsan_mutex_interface.h",
+ "internal/unscaledcycleclock.h",
+ "log_severity.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":base_internal",
+ ":config",
+ ":core_headers",
+ ":dynamic_annotations",
+ ":spinlock_wait",
+ ],
+)
+
+cc_test(
+ name = "bit_cast_test",
+ size = "small",
+ srcs = [
+ "bit_cast_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":base",
+ ":core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "throw_delegate",
+ srcs = ["internal/throw_delegate.cc"],
+ hdrs = ["internal/throw_delegate.h"],
+ copts = ABSL_DEFAULT_COPTS + ABSL_EXCEPTIONS_FLAG,
+ visibility = [
+ "//absl:__subpackages__",
+ ],
+ deps = [
+ ":base",
+ ":config",
+ ":core_headers",
+ ],
+)
+
+cc_test(
+ name = "throw_delegate_test",
+ srcs = ["throw_delegate_test.cc"],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":throw_delegate",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "exception_testing",
+ testonly = 1,
+ hdrs = ["internal/exception_testing.h"],
+ copts = ABSL_TEST_COPTS,
+ visibility = [
+ "//absl:__subpackages__",
+ ],
+ deps = [
+ ":config",
+ "@com_google_googletest//:gtest",
+ ],
+)
+
+cc_library(
+ name = "pretty_function",
+ hdrs = ["internal/pretty_function.h"],
+ visibility = ["//absl:__subpackages__"],
+)
+
+cc_library(
+ name = "exception_safety_testing",
+ testonly = 1,
+ srcs = ["internal/exception_safety_testing.cc"],
+ hdrs = ["internal/exception_safety_testing.h"],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":base",
+ ":config",
+ ":pretty_function",
+ "//absl/memory",
+ "//absl/meta:type_traits",
+ "//absl/strings",
+ "//absl/types:optional",
+ "@com_google_googletest//:gtest",
+ ],
+)
+
+cc_test(
+ name = "exception_safety_testing_test",
+ srcs = ["exception_safety_testing_test.cc"],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":exception_safety_testing",
+ "//absl/memory",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "inline_variable_test",
+ size = "small",
+ srcs = [
+ "inline_variable_test.cc",
+ "inline_variable_test_a.cc",
+ "inline_variable_test_b.cc",
+ "internal/inline_variable_testing.h",
+ ],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":base_internal",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "invoke_test",
+ size = "small",
+ srcs = ["invoke_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":base_internal",
+ "//absl/memory",
+ "//absl/strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+# Common test library made available for use in non-absl code that overrides
+# AbslInternalSpinLockDelay and AbslInternalSpinLockWake.
+cc_library(
+ name = "spinlock_test_common",
+ testonly = 1,
+ srcs = ["spinlock_test_common.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":base",
+ ":core_headers",
+ ":spinlock_wait",
+ "//absl/synchronization",
+ "@com_google_googletest//:gtest",
+ ],
+ alwayslink = 1,
+)
+
+cc_test(
+ name = "spinlock_test",
+ size = "medium",
+ srcs = ["spinlock_test_common.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":base",
+ ":core_headers",
+ ":spinlock_wait",
+ "//absl/synchronization",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "endian",
+ hdrs = [
+ "internal/endian.h",
+ "internal/unaligned_access.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":config",
+ ":core_headers",
+ ],
+)
+
+cc_test(
+ name = "endian_test",
+ srcs = ["internal/endian_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":base",
+ ":config",
+ ":endian",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "config_test",
+ srcs = ["config_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":config",
+ "//absl/synchronization:thread_pool",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "call_once_test",
+ srcs = ["call_once_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":base",
+ ":core_headers",
+ "//absl/synchronization",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "raw_logging_test",
+ srcs = ["raw_logging_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":base",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "sysinfo_test",
+ size = "small",
+ srcs = ["internal/sysinfo_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":base",
+ "//absl/synchronization",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "low_level_alloc_test",
+ size = "small",
+ srcs = ["internal/low_level_alloc_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ linkopts = select({
+ "//absl:windows": [],
+ "//conditions:default": ["-pthread"],
+ }),
+ deps = [":malloc_internal"],
+)
+
+cc_test(
+ name = "thread_identity_test",
+ size = "small",
+ srcs = ["internal/thread_identity_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ linkopts = select({
+ "//absl:windows": [],
+ "//conditions:default": ["-pthread"],
+ }),
+ deps = [
+ ":base",
+ ":core_headers",
+ "//absl/synchronization",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/base/CMakeLists.txt
new file mode 100644
index 0000000..329a3d0
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/CMakeLists.txt
@@ -0,0 +1,358 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+list(APPEND BASE_PUBLIC_HEADERS
+ "attributes.h"
+ "call_once.h"
+ "casts.h"
+ "config.h"
+ "dynamic_annotations.h"
+ "log_severity.h"
+ "macros.h"
+ "optimization.h"
+ "policy_checks.h"
+ "port.h"
+ "thread_annotations.h"
+)
+
+
+list(APPEND BASE_INTERNAL_HEADERS
+ "internal/atomic_hook.h"
+ "internal/cycleclock.h"
+ "internal/direct_mmap.h"
+ "internal/endian.h"
+ "internal/exception_testing.h"
+ "internal/exception_safety_testing.h"
+ "internal/identity.h"
+ "internal/invoke.h"
+ "internal/inline_variable.h"
+ "internal/low_level_alloc.h"
+ "internal/low_level_scheduling.h"
+ "internal/per_thread_tls.h"
+ "internal/pretty_function.h"
+ "internal/raw_logging.h"
+ "internal/scheduling_mode.h"
+ "internal/spinlock.h"
+ "internal/spinlock_wait.h"
+ "internal/sysinfo.h"
+ "internal/thread_identity.h"
+ "internal/throw_delegate.h"
+ "internal/tsan_mutex_interface.h"
+ "internal/unaligned_access.h"
+ "internal/unscaledcycleclock.h"
+)
+
+
+# absl_base main library
+list(APPEND BASE_SRC
+ "internal/cycleclock.cc"
+ "internal/raw_logging.cc"
+ "internal/spinlock.cc"
+ "internal/sysinfo.cc"
+ "internal/thread_identity.cc"
+ "internal/unscaledcycleclock.cc"
+ "internal/low_level_alloc.cc"
+ ${BASE_PUBLIC_HEADERS}
+ ${BASE_INTERNAL_HEADERS}
+)
+
+absl_library(
+ TARGET
+ absl_base
+ SOURCES
+ ${BASE_SRC}
+ PUBLIC_LIBRARIES
+ absl_dynamic_annotations
+ absl_spinlock_wait
+ EXPORT_NAME
+ base
+)
+
+# throw delegate library
+set(THROW_DELEGATE_SRC "internal/throw_delegate.cc")
+
+absl_library(
+ TARGET
+ absl_throw_delegate
+ SOURCES
+ ${THROW_DELEGATE_SRC}
+ PUBLIC_LIBRARIES
+ ${THROW_DELEGATE_PUBLIC_LIBRARIES}
+ PRIVATE_COMPILE_FLAGS
+ ${ABSL_EXCEPTIONS_FLAG}
+ EXPORT_NAME
+ throw_delegate
+)
+
+if(BUILD_TESTING)
+ # exception-safety testing library
+ set(EXCEPTION_SAFETY_TESTING_SRC "internal/exception_safety_testing.cc")
+ set(EXCEPTION_SAFETY_TESTING_PUBLIC_LIBRARIES
+ ${ABSL_TEST_COMMON_LIBRARIES}
+ absl::base
+ absl::memory
+ absl::meta
+ absl::strings
+ absl::types
+ )
+
+absl_library(
+ TARGET
+ absl_base_internal_exception_safety_testing
+ SOURCES
+ ${EXCEPTION_SAFETY_TESTING_SRC}
+ PUBLIC_LIBRARIES
+ ${EXCEPTION_SAFETY_TESTING_PUBLIC_LIBRARIES}
+)
+endif()
+
+
+# dynamic_annotations library
+set(DYNAMIC_ANNOTATIONS_SRC "dynamic_annotations.cc")
+
+absl_library(
+ TARGET
+ absl_dynamic_annotations
+ SOURCES
+ ${DYNAMIC_ANNOTATIONS_SRC}
+)
+
+
+# spinlock_wait library
+set(SPINLOCK_WAIT_SRC "internal/spinlock_wait.cc")
+
+absl_library(
+ TARGET
+ absl_spinlock_wait
+ SOURCES
+ ${SPINLOCK_WAIT_SRC}
+)
+
+
+# malloc_internal library
+list(APPEND MALLOC_INTERNAL_SRC
+ "internal/low_level_alloc.cc"
+)
+
+absl_library(
+ TARGET
+ absl_malloc_internal
+ SOURCES
+ ${MALLOC_INTERNAL_SRC}
+ PUBLIC_LIBRARIES
+ absl_dynamic_annotations
+)
+
+
+
+#
+## TESTS
+#
+
+# call once test
+set(CALL_ONCE_TEST_SRC "call_once_test.cc")
+set(CALL_ONCE_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
+
+absl_test(
+ TARGET
+ call_once_test
+ SOURCES
+ ${CALL_ONCE_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${CALL_ONCE_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test bit_cast_test
+set(BIT_CAST_TEST_SRC "bit_cast_test.cc")
+
+absl_test(
+ TARGET
+ bit_cast_test
+ SOURCES
+ ${BIT_CAST_TEST_SRC}
+)
+
+
+# test absl_throw_delegate_test
+set(THROW_DELEGATE_TEST_SRC "throw_delegate_test.cc")
+set(THROW_DELEGATE_TEST_PUBLIC_LIBRARIES absl::base absl_throw_delegate)
+
+absl_test(
+ TARGET
+ throw_delegate_test
+ SOURCES
+ ${THROW_DELEGATE_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${THROW_DELEGATE_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test invoke_test
+set(INVOKE_TEST_SRC "invoke_test.cc")
+set(INVOKE_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+ TARGET
+ invoke_test
+ SOURCES
+ ${INVOKE_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${INVOKE_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test inline_variable_test
+list(APPEND INLINE_VARIABLE_TEST_SRC
+ "internal/inline_variable_testing.h"
+ "inline_variable_test.cc"
+ "inline_variable_test_a.cc"
+ "inline_variable_test_b.cc"
+)
+
+set(INLINE_VARIABLE_TEST_PUBLIC_LIBRARIES absl::base)
+
+absl_test(
+ TARGET
+ inline_variable_test
+ SOURCES
+ ${INLINE_VARIABLE_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${INLINE_VARIABLE_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test spinlock_test_common
+set(SPINLOCK_TEST_COMMON_SRC "spinlock_test_common.cc")
+set(SPINLOCK_TEST_COMMON_PUBLIC_LIBRARIES absl::base absl::synchronization)
+
+absl_test(
+ TARGET
+ spinlock_test_common
+ SOURCES
+ ${SPINLOCK_TEST_COMMON_SRC}
+ PUBLIC_LIBRARIES
+ ${SPINLOCK_TEST_COMMON_PUBLIC_LIBRARIES}
+)
+
+
+# test spinlock_test
+set(SPINLOCK_TEST_SRC "spinlock_test_common.cc")
+set(SPINLOCK_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
+
+absl_test(
+ TARGET
+ spinlock_test
+ SOURCES
+ ${SPINLOCK_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${SPINLOCK_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test endian_test
+set(ENDIAN_TEST_SRC "internal/endian_test.cc")
+
+absl_test(
+ TARGET
+ endian_test
+ SOURCES
+ ${ENDIAN_TEST_SRC}
+)
+
+
+# test config_test
+set(CONFIG_TEST_SRC "config_test.cc")
+set(CONFIG_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
+absl_test(
+ TARGET
+ config_test
+ SOURCES
+ ${CONFIG_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${CONFIG_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test raw_logging_test
+set(RAW_LOGGING_TEST_SRC "raw_logging_test.cc")
+set(RAW_LOGGING_TEST_PUBLIC_LIBRARIES absl::base)
+
+absl_test(
+ TARGET
+ raw_logging_test
+ SOURCES
+ ${RAW_LOGGING_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${RAW_LOGGING_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test sysinfo_test
+set(SYSINFO_TEST_SRC "internal/sysinfo_test.cc")
+set(SYSINFO_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
+
+absl_test(
+ TARGET
+ sysinfo_test
+ SOURCES
+ ${SYSINFO_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${SYSINFO_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test low_level_alloc_test
+set(LOW_LEVEL_ALLOC_TEST_SRC "internal/low_level_alloc_test.cc")
+set(LOW_LEVEL_ALLOC_TEST_PUBLIC_LIBRARIES absl::base)
+
+absl_test(
+ TARGET
+ low_level_alloc_test
+ SOURCES
+ ${LOW_LEVEL_ALLOC_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${LOW_LEVEL_ALLOC_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test thread_identity_test
+set(THREAD_IDENTITY_TEST_SRC "internal/thread_identity_test.cc")
+set(THREAD_IDENTITY_TEST_PUBLIC_LIBRARIES absl::base absl::synchronization)
+
+absl_test(
+ TARGET
+ thread_identity_test
+ SOURCES
+ ${THREAD_IDENTITY_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${THREAD_IDENTITY_TEST_PUBLIC_LIBRARIES}
+)
+
+#test exceptions_safety_testing_test
+set(EXCEPTION_SAFETY_TESTING_TEST_SRC "exception_safety_testing_test.cc")
+set(EXCEPTION_SAFETY_TESTING_TEST_PUBLIC_LIBRARIES absl::base absl::memory absl::meta absl::strings absl::optional)
+
+absl_test(
+ TARGET
+ absl_exception_safety_testing_test
+ SOURCES
+ ${EXCEPTION_SAFETY_TESTING_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${EXCEPTION_SAFETY_TESTING_TEST_PUBLIC_LIBRARIES}
+ PRIVATE_COMPILE_FLAGS
+ ${ABSL_EXCEPTIONS_FLAG}
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/attributes.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/attributes.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/attributes.h
new file mode 100644
index 0000000..a4ec7e7
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/attributes.h
@@ -0,0 +1,567 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This header file defines macros for declaring attributes for functions,
+// types, and variables.
+//
+// These macros are used within Abseil and allow the compiler to optimize, where
+// applicable, certain function calls.
+//
+// This file is used for both C and C++!
+//
+// Most macros here are exposing GCC or Clang features, and are stubbed out for
+// other compilers.
+//
+// GCC attributes documentation:
+// https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html
+// https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Variable-Attributes.html
+// https://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Type-Attributes.html
+//
+// Most attributes in this file are already supported by GCC 4.7. However, some
+// of them are not supported in older version of Clang. Thus, we check
+// `__has_attribute()` first. If the check fails, we check if we are on GCC and
+// assume the attribute exists on GCC (which is verified on GCC 4.7).
+//
+// -----------------------------------------------------------------------------
+// Sanitizer Attributes
+// -----------------------------------------------------------------------------
+//
+// Sanitizer-related attributes are not "defined" in this file (and indeed
+// are not defined as such in any file). To utilize the following
+// sanitizer-related attributes within your builds, define the following macros
+// within your build using a `-D` flag, along with the given value for
+// `-fsanitize`:
+//
+// * `ADDRESS_SANITIZER` + `-fsanitize=address` (Clang, GCC 4.8)
+// * `MEMORY_SANITIZER` + `-fsanitize=memory` (Clang-only)
+// * `THREAD_SANITIZER + `-fsanitize=thread` (Clang, GCC 4.8+)
+// * `UNDEFINED_BEHAVIOR_SANITIZER` + `-fsanitize=undefined` (Clang, GCC 4.9+)
+// * `CONTROL_FLOW_INTEGRITY` + -fsanitize=cfi (Clang-only)
+//
+// Example:
+//
+// // Enable branches in the Abseil code that are tagged for ASan:
+// $ bazel -D ADDRESS_SANITIZER -fsanitize=address *target*
+//
+// Since these macro names are only supported by GCC and Clang, we only check
+// for `__GNUC__` (GCC or Clang) and the above macros.
+#ifndef ABSL_BASE_ATTRIBUTES_H_
+#define ABSL_BASE_ATTRIBUTES_H_
+
+// ABSL_HAVE_ATTRIBUTE
+//
+// A function-like feature checking macro that is a wrapper around
+// `__has_attribute`, which is defined by GCC 5+ and Clang and evaluates to a
+// nonzero constant integer if the attribute is supported or 0 if not.
+//
+// It evaluates to zero if `__has_attribute` is not defined by the compiler.
+//
+// GCC: https://gcc.gnu.org/gcc-5/changes.html
+// Clang: https://clang.llvm.org/docs/LanguageExtensions.html
+#ifdef __has_attribute
+#define ABSL_HAVE_ATTRIBUTE(x) __has_attribute(x)
+#else
+#define ABSL_HAVE_ATTRIBUTE(x) 0
+#endif
+
+// ABSL_HAVE_CPP_ATTRIBUTE
+//
+// A function-like feature checking macro that accepts C++11 style attributes.
+// It's a wrapper around `__has_cpp_attribute`, defined by ISO C++ SD-6
+// (http://en.cppreference.com/w/cpp/experimental/feature_test). If we don't
+// find `__has_cpp_attribute`, will evaluate to 0.
+#if defined(__cplusplus) && defined(__has_cpp_attribute)
+// NOTE: requiring __cplusplus above should not be necessary, but
+// works around https://bugs.llvm.org/show_bug.cgi?id=23435.
+#define ABSL_HAVE_CPP_ATTRIBUTE(x) __has_cpp_attribute(x)
+#else
+#define ABSL_HAVE_CPP_ATTRIBUTE(x) 0
+#endif
+
+// -----------------------------------------------------------------------------
+// Function Attributes
+// -----------------------------------------------------------------------------
+//
+// GCC: https://gcc.gnu.org/onlinedocs/gcc/Function-Attributes.html
+// Clang: https://clang.llvm.org/docs/AttributeReference.html
+
+// ABSL_PRINTF_ATTRIBUTE
+// ABSL_SCANF_ATTRIBUTE
+//
+// Tells the compiler to perform `printf` format std::string checking if the
+// compiler supports it; see the 'format' attribute in
+// <http://gcc.gnu.org/onlinedocs/gcc-4.7.0/gcc/Function-Attributes.html>.
+//
+// Note: As the GCC manual states, "[s]ince non-static C++ methods
+// have an implicit 'this' argument, the arguments of such methods
+// should be counted from two, not one."
+#if ABSL_HAVE_ATTRIBUTE(format) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check) \
+ __attribute__((__format__(__printf__, string_index, first_to_check)))
+#define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check) \
+ __attribute__((__format__(__scanf__, string_index, first_to_check)))
+#else
+#define ABSL_PRINTF_ATTRIBUTE(string_index, first_to_check)
+#define ABSL_SCANF_ATTRIBUTE(string_index, first_to_check)
+#endif
+
+// ABSL_ATTRIBUTE_ALWAYS_INLINE
+// ABSL_ATTRIBUTE_NOINLINE
+//
+// Forces functions to either inline or not inline. Introduced in gcc 3.1.
+#if ABSL_HAVE_ATTRIBUTE(always_inline) || \
+ (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_ALWAYS_INLINE __attribute__((always_inline))
+#define ABSL_HAVE_ATTRIBUTE_ALWAYS_INLINE 1
+#else
+#define ABSL_ATTRIBUTE_ALWAYS_INLINE
+#endif
+
+#if ABSL_HAVE_ATTRIBUTE(noinline) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_NOINLINE __attribute__((noinline))
+#define ABSL_HAVE_ATTRIBUTE_NOINLINE 1
+#else
+#define ABSL_ATTRIBUTE_NOINLINE
+#endif
+
+// ABSL_ATTRIBUTE_NO_TAIL_CALL
+//
+// Prevents the compiler from optimizing away stack frames for functions which
+// end in a call to another function.
+#if ABSL_HAVE_ATTRIBUTE(disable_tail_calls)
+#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
+#define ABSL_ATTRIBUTE_NO_TAIL_CALL __attribute__((disable_tail_calls))
+#elif defined(__GNUC__) && !defined(__clang__)
+#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 1
+#define ABSL_ATTRIBUTE_NO_TAIL_CALL \
+ __attribute__((optimize("no-optimize-sibling-calls")))
+#else
+#define ABSL_ATTRIBUTE_NO_TAIL_CALL
+#define ABSL_HAVE_ATTRIBUTE_NO_TAIL_CALL 0
+#endif
+
+// ABSL_ATTRIBUTE_WEAK
+//
+// Tags a function as weak for the purposes of compilation and linking.
+#if ABSL_HAVE_ATTRIBUTE(weak) || (defined(__GNUC__) && !defined(__clang__))
+#undef ABSL_ATTRIBUTE_WEAK
+#define ABSL_ATTRIBUTE_WEAK __attribute__((weak))
+#define ABSL_HAVE_ATTRIBUTE_WEAK 1
+#else
+#define ABSL_ATTRIBUTE_WEAK
+#define ABSL_HAVE_ATTRIBUTE_WEAK 0
+#endif
+
+// ABSL_ATTRIBUTE_NONNULL
+//
+// Tells the compiler either (a) that a particular function parameter
+// should be a non-null pointer, or (b) that all pointer arguments should
+// be non-null.
+//
+// Note: As the GCC manual states, "[s]ince non-static C++ methods
+// have an implicit 'this' argument, the arguments of such methods
+// should be counted from two, not one."
+//
+// Args are indexed starting at 1.
+//
+// For non-static class member functions, the implicit `this` argument
+// is arg 1, and the first explicit argument is arg 2. For static class member
+// functions, there is no implicit `this`, and the first explicit argument is
+// arg 1.
+//
+// Example:
+//
+// /* arg_a cannot be null, but arg_b can */
+// void Function(void* arg_a, void* arg_b) ABSL_ATTRIBUTE_NONNULL(1);
+//
+// class C {
+// /* arg_a cannot be null, but arg_b can */
+// void Method(void* arg_a, void* arg_b) ABSL_ATTRIBUTE_NONNULL(2);
+//
+// /* arg_a cannot be null, but arg_b can */
+// static void StaticMethod(void* arg_a, void* arg_b)
+// ABSL_ATTRIBUTE_NONNULL(1);
+// };
+//
+// If no arguments are provided, then all pointer arguments should be non-null.
+//
+// /* No pointer arguments may be null. */
+// void Function(void* arg_a, void* arg_b, int arg_c) ABSL_ATTRIBUTE_NONNULL();
+//
+// NOTE: The GCC nonnull attribute actually accepts a list of arguments, but
+// ABSL_ATTRIBUTE_NONNULL does not.
+#if ABSL_HAVE_ATTRIBUTE(nonnull) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_NONNULL(arg_index) __attribute__((nonnull(arg_index)))
+#else
+#define ABSL_ATTRIBUTE_NONNULL(...)
+#endif
+
+// ABSL_ATTRIBUTE_NORETURN
+//
+// Tells the compiler that a given function never returns.
+#if ABSL_HAVE_ATTRIBUTE(noreturn) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_NORETURN __attribute__((noreturn))
+#elif defined(_MSC_VER)
+#define ABSL_ATTRIBUTE_NORETURN __declspec(noreturn)
+#else
+#define ABSL_ATTRIBUTE_NORETURN
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
+//
+// Tells the AddressSanitizer (or other memory testing tools) to ignore a given
+// function. Useful for cases when a function reads random locations on stack,
+// calls _exit from a cloned subprocess, deliberately accesses buffer
+// out of bounds or does other scary things with memory.
+// NOTE: GCC supports AddressSanitizer(asan) since 4.8.
+// https://gcc.gnu.org/gcc-4.8/changes.html
+#if defined(__GNUC__) && defined(ADDRESS_SANITIZER)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS __attribute__((no_sanitize_address))
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
+//
+// Tells the MemorySanitizer to relax the handling of a given function. All
+// "Use of uninitialized value" warnings from such functions will be suppressed,
+// and all values loaded from memory will be considered fully initialized.
+// This attribute is similar to the ADDRESS_SANITIZER attribute above, but deals
+// with initialized-ness rather than addressability issues.
+// NOTE: MemorySanitizer(msan) is supported by Clang but not GCC.
+#if defined(__GNUC__) && defined(MEMORY_SANITIZER)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY __attribute__((no_sanitize_memory))
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
+//
+// Tells the ThreadSanitizer to not instrument a given function.
+// NOTE: GCC supports ThreadSanitizer(tsan) since 4.8.
+// https://gcc.gnu.org/gcc-4.8/changes.html
+#if defined(__GNUC__) && defined(THREAD_SANITIZER)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD __attribute__((no_sanitize_thread))
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_THREAD
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
+//
+// Tells the UndefinedSanitizer to ignore a given function. Useful for cases
+// where certain behavior (eg. division by zero) is being used intentionally.
+// NOTE: GCC supports UndefinedBehaviorSanitizer(ubsan) since 4.9.
+// https://gcc.gnu.org/gcc-4.9/changes.html
+#if defined(__GNUC__) && \
+ (defined(UNDEFINED_BEHAVIOR_SANITIZER) || defined(ADDRESS_SANITIZER))
+#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED \
+ __attribute__((no_sanitize("undefined")))
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_UNDEFINED
+#endif
+
+// ABSL_ATTRIBUTE_NO_SANITIZE_CFI
+//
+// Tells the ControlFlowIntegrity sanitizer to not instrument a given function.
+// See https://clang.llvm.org/docs/ControlFlowIntegrity.html for details.
+#if defined(__GNUC__) && defined(CONTROL_FLOW_INTEGRITY)
+#define ABSL_ATTRIBUTE_NO_SANITIZE_CFI __attribute__((no_sanitize("cfi")))
+#else
+#define ABSL_ATTRIBUTE_NO_SANITIZE_CFI
+#endif
+
+// ABSL_ATTRIBUTE_RETURNS_NONNULL
+//
+// Tells the compiler that a particular function never returns a null pointer.
+#if ABSL_HAVE_ATTRIBUTE(returns_nonnull) || \
+ (defined(__GNUC__) && \
+ (__GNUC__ > 5 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9)) && \
+ !defined(__clang__))
+#define ABSL_ATTRIBUTE_RETURNS_NONNULL __attribute__((returns_nonnull))
+#else
+#define ABSL_ATTRIBUTE_RETURNS_NONNULL
+#endif
+
+// ABSL_HAVE_ATTRIBUTE_SECTION
+//
+// Indicates whether labeled sections are supported. Labeled sections are not
+// supported on Darwin/iOS.
+#ifdef ABSL_HAVE_ATTRIBUTE_SECTION
+#error ABSL_HAVE_ATTRIBUTE_SECTION cannot be directly set
+#elif (ABSL_HAVE_ATTRIBUTE(section) || \
+ (defined(__GNUC__) && !defined(__clang__))) && \
+ !defined(__APPLE__)
+#define ABSL_HAVE_ATTRIBUTE_SECTION 1
+
+// ABSL_ATTRIBUTE_SECTION
+//
+// Tells the compiler/linker to put a given function into a section and define
+// `__start_ ## name` and `__stop_ ## name` symbols to bracket the section.
+// This functionality is supported by GNU linker. Any function annotated with
+// `ABSL_ATTRIBUTE_SECTION` must not be inlined, or it will be placed into
+// whatever section its caller is placed into.
+//
+#ifndef ABSL_ATTRIBUTE_SECTION
+#define ABSL_ATTRIBUTE_SECTION(name) \
+ __attribute__((section(#name))) __attribute__((noinline))
+#endif
+
+
+// ABSL_ATTRIBUTE_SECTION_VARIABLE
+//
+// Tells the compiler/linker to put a given variable into a section and define
+// `__start_ ## name` and `__stop_ ## name` symbols to bracket the section.
+// This functionality is supported by GNU linker.
+#ifndef ABSL_ATTRIBUTE_SECTION_VARIABLE
+#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name) __attribute__((section(#name)))
+#endif
+
+// ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
+//
+// A weak section declaration to be used as a global declaration
+// for ABSL_ATTRIBUTE_SECTION_START|STOP(name) to compile and link
+// even without functions with ABSL_ATTRIBUTE_SECTION(name).
+// ABSL_DEFINE_ATTRIBUTE_SECTION should be in the exactly one file; it's
+// a no-op on ELF but not on Mach-O.
+//
+#ifndef ABSL_DECLARE_ATTRIBUTE_SECTION_VARS
+#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) \
+ extern char __start_##name[] ABSL_ATTRIBUTE_WEAK; \
+ extern char __stop_##name[] ABSL_ATTRIBUTE_WEAK
+#endif
+#ifndef ABSL_DEFINE_ATTRIBUTE_SECTION_VARS
+#define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
+#define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
+#endif
+
+// ABSL_ATTRIBUTE_SECTION_START
+//
+// Returns `void*` pointers to start/end of a section of code with
+// functions having ABSL_ATTRIBUTE_SECTION(name).
+// Returns 0 if no such functions exist.
+// One must ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name) for this to compile and
+// link.
+//
+#define ABSL_ATTRIBUTE_SECTION_START(name) \
+ (reinterpret_cast<void *>(__start_##name))
+#define ABSL_ATTRIBUTE_SECTION_STOP(name) \
+ (reinterpret_cast<void *>(__stop_##name))
+
+#else // !ABSL_HAVE_ATTRIBUTE_SECTION
+
+#define ABSL_HAVE_ATTRIBUTE_SECTION 0
+
+// provide dummy definitions
+#define ABSL_ATTRIBUTE_SECTION(name)
+#define ABSL_ATTRIBUTE_SECTION_VARIABLE(name)
+#define ABSL_INIT_ATTRIBUTE_SECTION_VARS(name)
+#define ABSL_DEFINE_ATTRIBUTE_SECTION_VARS(name)
+#define ABSL_DECLARE_ATTRIBUTE_SECTION_VARS(name)
+#define ABSL_ATTRIBUTE_SECTION_START(name) (reinterpret_cast<void *>(0))
+#define ABSL_ATTRIBUTE_SECTION_STOP(name) (reinterpret_cast<void *>(0))
+
+#endif // ABSL_ATTRIBUTE_SECTION
+
+// ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+//
+// Support for aligning the stack on 32-bit x86.
+#if ABSL_HAVE_ATTRIBUTE(force_align_arg_pointer) || \
+ (defined(__GNUC__) && !defined(__clang__))
+#if defined(__i386__)
+#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC \
+ __attribute__((force_align_arg_pointer))
+#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#elif defined(__x86_64__)
+#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (1)
+#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+#else // !__i386__ && !__x86_64
+#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+#endif // __i386__
+#else
+#define ABSL_ATTRIBUTE_STACK_ALIGN_FOR_OLD_LIBC
+#define ABSL_REQUIRE_STACK_ALIGN_TRAMPOLINE (0)
+#endif
+
+// ABSL_MUST_USE_RESULT
+//
+// Tells the compiler to warn about unused return values for functions declared
+// with this macro. The macro must appear as the very first part of a function
+// declaration or definition:
+//
+// Example:
+//
+// ABSL_MUST_USE_RESULT Sprocket* AllocateSprocket();
+//
+// This placement has the broadest compatibility with GCC, Clang, and MSVC, with
+// both defs and decls, and with GCC-style attributes, MSVC declspec, C++11
+// and C++17 attributes.
+//
+// ABSL_MUST_USE_RESULT allows using cast-to-void to suppress the unused result
+// warning. For that, warn_unused_result is used only for clang but not for gcc.
+// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=66425
+//
+// Note: past advice was to place the macro after the argument list.
+#if ABSL_HAVE_ATTRIBUTE(nodiscard)
+#define ABSL_MUST_USE_RESULT [[nodiscard]]
+#elif defined(__clang__) && ABSL_HAVE_ATTRIBUTE(warn_unused_result)
+#define ABSL_MUST_USE_RESULT __attribute__((warn_unused_result))
+#else
+#define ABSL_MUST_USE_RESULT
+#endif
+
+// ABSL_ATTRIBUTE_HOT, ABSL_ATTRIBUTE_COLD
+//
+// Tells GCC that a function is hot or cold. GCC can use this information to
+// improve static analysis, i.e. a conditional branch to a cold function
+// is likely to be not-taken.
+// This annotation is used for function declarations.
+//
+// Example:
+//
+// int foo() ABSL_ATTRIBUTE_HOT;
+#if ABSL_HAVE_ATTRIBUTE(hot) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_HOT __attribute__((hot))
+#else
+#define ABSL_ATTRIBUTE_HOT
+#endif
+
+#if ABSL_HAVE_ATTRIBUTE(cold) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_COLD __attribute__((cold))
+#else
+#define ABSL_ATTRIBUTE_COLD
+#endif
+
+// ABSL_XRAY_ALWAYS_INSTRUMENT, ABSL_XRAY_NEVER_INSTRUMENT, ABSL_XRAY_LOG_ARGS
+//
+// We define the ABSL_XRAY_ALWAYS_INSTRUMENT and ABSL_XRAY_NEVER_INSTRUMENT
+// macro used as an attribute to mark functions that must always or never be
+// instrumented by XRay. Currently, this is only supported in Clang/LLVM.
+//
+// For reference on the LLVM XRay instrumentation, see
+// http://llvm.org/docs/XRay.html.
+//
+// A function with the XRAY_ALWAYS_INSTRUMENT macro attribute in its declaration
+// will always get the XRay instrumentation sleds. These sleds may introduce
+// some binary size and runtime overhead and must be used sparingly.
+//
+// These attributes only take effect when the following conditions are met:
+//
+// * The file/target is built in at least C++11 mode, with a Clang compiler
+// that supports XRay attributes.
+// * The file/target is built with the -fxray-instrument flag set for the
+// Clang/LLVM compiler.
+// * The function is defined in the translation unit (the compiler honors the
+// attribute in either the definition or the declaration, and must match).
+//
+// There are cases when, even when building with XRay instrumentation, users
+// might want to control specifically which functions are instrumented for a
+// particular build using special-case lists provided to the compiler. These
+// special case lists are provided to Clang via the
+// -fxray-always-instrument=... and -fxray-never-instrument=... flags. The
+// attributes in source take precedence over these special-case lists.
+//
+// To disable the XRay attributes at build-time, users may define
+// ABSL_NO_XRAY_ATTRIBUTES. Do NOT define ABSL_NO_XRAY_ATTRIBUTES on specific
+// packages/targets, as this may lead to conflicting definitions of functions at
+// link-time.
+//
+#if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_always_instrument) && \
+ !defined(ABSL_NO_XRAY_ATTRIBUTES)
+#define ABSL_XRAY_ALWAYS_INSTRUMENT [[clang::xray_always_instrument]]
+#define ABSL_XRAY_NEVER_INSTRUMENT [[clang::xray_never_instrument]]
+#if ABSL_HAVE_CPP_ATTRIBUTE(clang::xray_log_args)
+#define ABSL_XRAY_LOG_ARGS(N) \
+ [[clang::xray_always_instrument, clang::xray_log_args(N)]]
+#else
+#define ABSL_XRAY_LOG_ARGS(N) [[clang::xray_always_instrument]]
+#endif
+#else
+#define ABSL_XRAY_ALWAYS_INSTRUMENT
+#define ABSL_XRAY_NEVER_INSTRUMENT
+#define ABSL_XRAY_LOG_ARGS(N)
+#endif
+
+// -----------------------------------------------------------------------------
+// Variable Attributes
+// -----------------------------------------------------------------------------
+
+// ABSL_ATTRIBUTE_UNUSED
+//
+// Prevents the compiler from complaining about or optimizing away variables
+// that appear unused.
+#if ABSL_HAVE_ATTRIBUTE(unused) || (defined(__GNUC__) && !defined(__clang__))
+#undef ABSL_ATTRIBUTE_UNUSED
+#define ABSL_ATTRIBUTE_UNUSED __attribute__((__unused__))
+#else
+#define ABSL_ATTRIBUTE_UNUSED
+#endif
+
+// ABSL_ATTRIBUTE_INITIAL_EXEC
+//
+// Tells the compiler to use "initial-exec" mode for a thread-local variable.
+// See http://people.redhat.com/drepper/tls.pdf for the gory details.
+#if ABSL_HAVE_ATTRIBUTE(tls_model) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_INITIAL_EXEC __attribute__((tls_model("initial-exec")))
+#else
+#define ABSL_ATTRIBUTE_INITIAL_EXEC
+#endif
+
+// ABSL_ATTRIBUTE_PACKED
+//
+// Prevents the compiler from padding a structure to natural alignment
+#if ABSL_HAVE_ATTRIBUTE(packed) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_PACKED __attribute__((__packed__))
+#else
+#define ABSL_ATTRIBUTE_PACKED
+#endif
+
+// ABSL_ATTRIBUTE_FUNC_ALIGN
+//
+// Tells the compiler to align the function start at least to certain
+// alignment boundary
+#if ABSL_HAVE_ATTRIBUTE(aligned) || (defined(__GNUC__) && !defined(__clang__))
+#define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes) __attribute__((aligned(bytes)))
+#else
+#define ABSL_ATTRIBUTE_FUNC_ALIGN(bytes)
+#endif
+
+// ABSL_CONST_INIT
+//
+// A variable declaration annotated with the `ABSL_CONST_INIT` attribute will
+// not compile (on supported platforms) unless the variable has a constant
+// initializer. This is useful for variables with static and thread storage
+// duration, because it guarantees that they will not suffer from the so-called
+// "static init order fiasco". Prefer to put this attribute on the most visible
+// declaration of the variable, if there's more than one, because code that
+// accesses the variable can then use the attribute for optimization.
+//
+// Example:
+//
+// class MyClass {
+// public:
+// ABSL_CONST_INIT static MyType my_var;
+// };
+//
+// MyType MyClass::my_var = MakeMyType(...);
+//
+// Note that this attribute is redundant if the variable is declared constexpr.
+#if ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
+// NOLINTNEXTLINE(whitespace/braces)
+#define ABSL_CONST_INIT [[clang::require_constant_initialization]]
+#else
+#define ABSL_CONST_INIT
+#endif // ABSL_HAVE_CPP_ATTRIBUTE(clang::require_constant_initialization)
+
+#endif // ABSL_BASE_ATTRIBUTES_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/bit_cast_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/bit_cast_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/bit_cast_test.cc
new file mode 100644
index 0000000..8cd878d
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/bit_cast_test.cc
@@ -0,0 +1,107 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Unit test for bit_cast template.
+
+#include <cstdint>
+#include <cstring>
+
+#include "gtest/gtest.h"
+#include "absl/base/casts.h"
+#include "absl/base/macros.h"
+
+namespace absl {
+namespace {
+
+template <int N>
+struct marshall { char buf[N]; };
+
+template <typename T>
+void TestMarshall(const T values[], int num_values) {
+ for (int i = 0; i < num_values; ++i) {
+ T t0 = values[i];
+ marshall<sizeof(T)> m0 = absl::bit_cast<marshall<sizeof(T)> >(t0);
+ T t1 = absl::bit_cast<T>(m0);
+ marshall<sizeof(T)> m1 = absl::bit_cast<marshall<sizeof(T)> >(t1);
+ ASSERT_EQ(0, memcmp(&t0, &t1, sizeof(T)));
+ ASSERT_EQ(0, memcmp(&m0, &m1, sizeof(T)));
+ }
+}
+
+// Convert back and forth to an integral type. The C++ standard does
+// not guarantee this will work, but we test that this works on all the
+// platforms we support.
+//
+// Likewise, we below make assumptions about sizeof(float) and
+// sizeof(double) which the standard does not guarantee, but which hold on the
+// platforms we support.
+
+template <typename T, typename I>
+void TestIntegral(const T values[], int num_values) {
+ for (int i = 0; i < num_values; ++i) {
+ T t0 = values[i];
+ I i0 = absl::bit_cast<I>(t0);
+ T t1 = absl::bit_cast<T>(i0);
+ I i1 = absl::bit_cast<I>(t1);
+ ASSERT_EQ(0, memcmp(&t0, &t1, sizeof(T)));
+ ASSERT_EQ(i0, i1);
+ }
+}
+
+TEST(BitCast, Bool) {
+ static const bool bool_list[] = { false, true };
+ TestMarshall<bool>(bool_list, ABSL_ARRAYSIZE(bool_list));
+}
+
+TEST(BitCast, Int32) {
+ static const int32_t int_list[] =
+ { 0, 1, 100, 2147483647, -1, -100, -2147483647, -2147483647-1 };
+ TestMarshall<int32_t>(int_list, ABSL_ARRAYSIZE(int_list));
+}
+
+TEST(BitCast, Int64) {
+ static const int64_t int64_list[] =
+ { 0, 1, 1LL << 40, -1, -(1LL<<40) };
+ TestMarshall<int64_t>(int64_list, ABSL_ARRAYSIZE(int64_list));
+}
+
+TEST(BitCast, Uint64) {
+ static const uint64_t uint64_list[] =
+ { 0, 1, 1LLU << 40, 1LLU << 63 };
+ TestMarshall<uint64_t>(uint64_list, ABSL_ARRAYSIZE(uint64_list));
+}
+
+TEST(BitCast, Float) {
+ static const float float_list[] =
+ { 0.0f, 1.0f, -1.0f, 10.0f, -10.0f,
+ 1e10f, 1e20f, 1e-10f, 1e-20f,
+ 2.71828f, 3.14159f };
+ TestMarshall<float>(float_list, ABSL_ARRAYSIZE(float_list));
+ TestIntegral<float, int>(float_list, ABSL_ARRAYSIZE(float_list));
+ TestIntegral<float, unsigned>(float_list, ABSL_ARRAYSIZE(float_list));
+}
+
+TEST(BitCast, Double) {
+ static const double double_list[] =
+ { 0.0, 1.0, -1.0, 10.0, -10.0,
+ 1e10, 1e100, 1e-10, 1e-100,
+ 2.718281828459045,
+ 3.141592653589793238462643383279502884197169399375105820974944 };
+ TestMarshall<double>(double_list, ABSL_ARRAYSIZE(double_list));
+ TestIntegral<double, int64_t>(double_list, ABSL_ARRAYSIZE(double_list));
+ TestIntegral<double, uint64_t>(double_list, ABSL_ARRAYSIZE(double_list));
+}
+
+} // namespace
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/call_once.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/call_once.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/call_once.h
new file mode 100644
index 0000000..532ee2e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/call_once.h
@@ -0,0 +1,216 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: call_once.h
+// -----------------------------------------------------------------------------
+//
+// This header file provides an Abseil version of `std::call_once` for invoking
+// a given function at most once, across all threads. This Abseil version is
+// faster than the C++11 version and incorporates the C++17 argument-passing
+// fix, so that (for example) non-const references may be passed to the invoked
+// function.
+
+#ifndef ABSL_BASE_CALL_ONCE_H_
+#define ABSL_BASE_CALL_ONCE_H_
+
+#include <algorithm>
+#include <atomic>
+#include <cstdint>
+#include <type_traits>
+
+#include "absl/base/internal/invoke.h"
+#include "absl/base/internal/low_level_scheduling.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/internal/spinlock_wait.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+
+namespace absl {
+
+class once_flag;
+
+namespace base_internal {
+std::atomic<uint32_t>* ControlWord(absl::once_flag* flag);
+} // namespace base_internal
+
+// call_once()
+//
+// For all invocations using a given `once_flag`, invokes a given `fn` exactly
+// once across all threads. The first call to `call_once()` with a particular
+// `once_flag` argument (that does not throw an exception) will run the
+// specified function with the provided `args`; other calls with the same
+// `once_flag` argument will not run the function, but will wait
+// for the provided function to finish running (if it is still running).
+//
+// This mechanism provides a safe, simple, and fast mechanism for one-time
+// initialization in a multi-threaded process.
+//
+// Example:
+//
+// class MyInitClass {
+// public:
+// ...
+// mutable absl::once_flag once_;
+//
+// MyInitClass* init() const {
+// absl::call_once(once_, &MyInitClass::Init, this);
+// return ptr_;
+// }
+//
+template <typename Callable, typename... Args>
+void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args);
+
+// once_flag
+//
+// Objects of this type are used to distinguish calls to `call_once()` and
+// ensure the provided function is only invoked once across all threads. This
+// type is not copyable or movable. However, it has a `constexpr`
+// constructor, and is safe to use as a namespace-scoped global variable.
+class once_flag {
+ public:
+ constexpr once_flag() : control_(0) {}
+ once_flag(const once_flag&) = delete;
+ once_flag& operator=(const once_flag&) = delete;
+
+ private:
+ friend std::atomic<uint32_t>* base_internal::ControlWord(once_flag* flag);
+ std::atomic<uint32_t> control_;
+};
+
+//------------------------------------------------------------------------------
+// End of public interfaces.
+// Implementation details follow.
+//------------------------------------------------------------------------------
+
+namespace base_internal {
+
+// Like call_once, but uses KERNEL_ONLY scheduling. Intended to be used to
+// initialize entities used by the scheduler implementation.
+template <typename Callable, typename... Args>
+void LowLevelCallOnce(absl::once_flag* flag, Callable&& fn, Args&&... args);
+
+// Disables scheduling while on stack when scheduling mode is non-cooperative.
+// No effect for cooperative scheduling modes.
+class SchedulingHelper {
+ public:
+ explicit SchedulingHelper(base_internal::SchedulingMode mode) : mode_(mode) {
+ if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
+ guard_result_ = base_internal::SchedulingGuard::DisableRescheduling();
+ }
+ }
+
+ ~SchedulingHelper() {
+ if (mode_ == base_internal::SCHEDULE_KERNEL_ONLY) {
+ base_internal::SchedulingGuard::EnableRescheduling(guard_result_);
+ }
+ }
+
+ private:
+ base_internal::SchedulingMode mode_;
+ bool guard_result_;
+};
+
+// Bit patterns for call_once state machine values. Internal implementation
+// detail, not for use by clients.
+//
+// The bit patterns are arbitrarily chosen from unlikely values, to aid in
+// debugging. However, kOnceInit must be 0, so that a zero-initialized
+// once_flag will be valid for immediate use.
+enum {
+ kOnceInit = 0,
+ kOnceRunning = 0x65C2937B,
+ kOnceWaiter = 0x05A308D2,
+ // A very small constant is chosen for kOnceDone so that it fit in a single
+ // compare with immediate instruction for most common ISAs. This is verified
+ // for x86, POWER and ARM.
+ kOnceDone = 221, // Random Number
+};
+
+template <typename Callable, typename... Args>
+void CallOnceImpl(std::atomic<uint32_t>* control,
+ base_internal::SchedulingMode scheduling_mode, Callable&& fn,
+ Args&&... args) {
+#ifndef NDEBUG
+ {
+ uint32_t old_control = control->load(std::memory_order_acquire);
+ if (old_control != kOnceInit &&
+ old_control != kOnceRunning &&
+ old_control != kOnceWaiter &&
+ old_control != kOnceDone) {
+ ABSL_RAW_LOG(
+ FATAL,
+ "Unexpected value for control word: %lx. Either the control word "
+ "has non-static storage duration (where GoogleOnceDynamic might "
+ "be appropriate), or there's been a memory corruption.",
+ static_cast<unsigned long>(old_control)); // NOLINT
+ }
+ }
+#endif // NDEBUG
+ static const base_internal::SpinLockWaitTransition trans[] = {
+ {kOnceInit, kOnceRunning, true},
+ {kOnceRunning, kOnceWaiter, false},
+ {kOnceDone, kOnceDone, true}};
+
+ // Must do this before potentially modifying control word's state.
+ base_internal::SchedulingHelper maybe_disable_scheduling(scheduling_mode);
+ // Short circuit the simplest case to avoid procedure call overhead.
+ uint32_t old_control = kOnceInit;
+ if (control->compare_exchange_strong(old_control, kOnceRunning,
+ std::memory_order_acquire,
+ std::memory_order_relaxed) ||
+ base_internal::SpinLockWait(control, ABSL_ARRAYSIZE(trans), trans,
+ scheduling_mode) == kOnceInit) {
+ base_internal::Invoke(std::forward<Callable>(fn),
+ std::forward<Args>(args)...);
+ old_control = control->load(std::memory_order_relaxed);
+ control->store(base_internal::kOnceDone, std::memory_order_release);
+ if (old_control == base_internal::kOnceWaiter) {
+ base_internal::SpinLockWake(control, true);
+ }
+ } // else *control is already kOnceDone
+}
+
+inline std::atomic<uint32_t>* ControlWord(once_flag* flag) {
+ return &flag->control_;
+}
+
+template <typename Callable, typename... Args>
+void LowLevelCallOnce(absl::once_flag* flag, Callable&& fn, Args&&... args) {
+ std::atomic<uint32_t>* once = base_internal::ControlWord(flag);
+ uint32_t s = once->load(std::memory_order_acquire);
+ if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
+ base_internal::CallOnceImpl(once, base_internal::SCHEDULE_KERNEL_ONLY,
+ std::forward<Callable>(fn),
+ std::forward<Args>(args)...);
+ }
+}
+
+} // namespace base_internal
+
+template <typename Callable, typename... Args>
+void call_once(absl::once_flag& flag, Callable&& fn, Args&&... args) {
+ std::atomic<uint32_t>* once = base_internal::ControlWord(&flag);
+ uint32_t s = once->load(std::memory_order_acquire);
+ if (ABSL_PREDICT_FALSE(s != base_internal::kOnceDone)) {
+ base_internal::CallOnceImpl(
+ once, base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL,
+ std::forward<Callable>(fn), std::forward<Args>(args)...);
+ }
+}
+
+} // namespace absl
+
+#endif // ABSL_BASE_CALL_ONCE_H_
[07/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_test.cc
new file mode 100644
index 0000000..6408388
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_test.cc
@@ -0,0 +1,1088 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/time.h"
+
+#include <chrono> // NOLINT(build/c++11)
+#include <cstring>
+#include <ctime>
+#include <iomanip>
+#include <limits>
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/time/clock.h"
+#include "absl/time/internal/test_util.h"
+
+namespace {
+
+// A gMock matcher to match timespec values. Use this matcher like:
+// timespec ts1, ts2;
+// EXPECT_THAT(ts1, TimespecMatcher(ts2));
+MATCHER_P(TimespecMatcher, ts, "") {
+ if (ts.tv_sec == arg.tv_sec && ts.tv_nsec == arg.tv_nsec)
+ return true;
+ *result_listener << "expected: {" << ts.tv_sec << ", " << ts.tv_nsec << "} ";
+ *result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_nsec << "}";
+ return false;
+}
+
+// A gMock matcher to match timeval values. Use this matcher like:
+// timeval tv1, tv2;
+// EXPECT_THAT(tv1, TimevalMatcher(tv2));
+MATCHER_P(TimevalMatcher, tv, "") {
+ if (tv.tv_sec == arg.tv_sec && tv.tv_usec == arg.tv_usec)
+ return true;
+ *result_listener << "expected: {" << tv.tv_sec << ", " << tv.tv_usec << "} ";
+ *result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_usec << "}";
+ return false;
+}
+
+TEST(Time, ConstExpr) {
+ constexpr absl::Time t0 = absl::UnixEpoch();
+ static_assert(t0 == absl::Time(), "UnixEpoch");
+ constexpr absl::Time t1 = absl::InfiniteFuture();
+ static_assert(t1 != absl::Time(), "InfiniteFuture");
+ constexpr absl::Time t2 = absl::InfinitePast();
+ static_assert(t2 != absl::Time(), "InfinitePast");
+ constexpr absl::Time t3 = absl::FromUnixNanos(0);
+ static_assert(t3 == absl::Time(), "FromUnixNanos");
+ constexpr absl::Time t4 = absl::FromUnixMicros(0);
+ static_assert(t4 == absl::Time(), "FromUnixMicros");
+ constexpr absl::Time t5 = absl::FromUnixMillis(0);
+ static_assert(t5 == absl::Time(), "FromUnixMillis");
+ constexpr absl::Time t6 = absl::FromUnixSeconds(0);
+ static_assert(t6 == absl::Time(), "FromUnixSeconds");
+ constexpr absl::Time t7 = absl::FromTimeT(0);
+ static_assert(t7 == absl::Time(), "FromTimeT");
+}
+
+TEST(Time, ValueSemantics) {
+ absl::Time a; // Default construction
+ absl::Time b = a; // Copy construction
+ EXPECT_EQ(a, b);
+ absl::Time c(a); // Copy construction (again)
+ EXPECT_EQ(a, b);
+ EXPECT_EQ(a, c);
+ EXPECT_EQ(b, c);
+ b = c; // Assignment
+ EXPECT_EQ(a, b);
+ EXPECT_EQ(a, c);
+ EXPECT_EQ(b, c);
+}
+
+TEST(Time, UnixEpoch) {
+ absl::Time::Breakdown bd = absl::UnixEpoch().In(absl::UTCTimeZone());
+ ABSL_INTERNAL_EXPECT_TIME(bd, 1970, 1, 1, 0, 0, 0, 0, false, "UTC");
+ EXPECT_EQ(absl::ZeroDuration(), bd.subsecond);
+ EXPECT_EQ(4, bd.weekday); // Thursday
+}
+
+TEST(Time, Breakdown) {
+ absl::TimeZone tz = absl::time_internal::LoadTimeZone("America/New_York");
+ absl::Time t = absl::UnixEpoch();
+
+ // The Unix epoch as seen in NYC.
+ absl::Time::Breakdown bd = t.In(tz);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 1969, 12, 31, 19, 0, 0, -18000, false, "EST");
+ EXPECT_EQ(absl::ZeroDuration(), bd.subsecond);
+ EXPECT_EQ(3, bd.weekday); // Wednesday
+
+ // Just before the epoch.
+ t -= absl::Nanoseconds(1);
+ bd = t.In(tz);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 1969, 12, 31, 18, 59, 59, -18000, false, "EST");
+ EXPECT_EQ(absl::Nanoseconds(999999999), bd.subsecond);
+ EXPECT_EQ(3, bd.weekday); // Wednesday
+
+ // Some time later.
+ t += absl::Hours(24) * 2735;
+ t += absl::Hours(18) + absl::Minutes(30) + absl::Seconds(15) +
+ absl::Nanoseconds(9);
+ bd = t.In(tz);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 1977, 6, 28, 14, 30, 15, -14400, true, "EDT");
+ EXPECT_EQ(8, bd.subsecond / absl::Nanoseconds(1));
+ EXPECT_EQ(2, bd.weekday); // Tuesday
+}
+
+TEST(Time, AdditiveOperators) {
+ const absl::Duration d = absl::Nanoseconds(1);
+ const absl::Time t0;
+ const absl::Time t1 = t0 + d;
+
+ EXPECT_EQ(d, t1 - t0);
+ EXPECT_EQ(-d, t0 - t1);
+ EXPECT_EQ(t0, t1 - d);
+
+ absl::Time t(t0);
+ EXPECT_EQ(t0, t);
+ t += d;
+ EXPECT_EQ(t0 + d, t);
+ EXPECT_EQ(d, t - t0);
+ t -= d;
+ EXPECT_EQ(t0, t);
+
+ // Tests overflow between subseconds and seconds.
+ t = absl::UnixEpoch();
+ t += absl::Milliseconds(500);
+ EXPECT_EQ(absl::UnixEpoch() + absl::Milliseconds(500), t);
+ t += absl::Milliseconds(600);
+ EXPECT_EQ(absl::UnixEpoch() + absl::Milliseconds(1100), t);
+ t -= absl::Milliseconds(600);
+ EXPECT_EQ(absl::UnixEpoch() + absl::Milliseconds(500), t);
+ t -= absl::Milliseconds(500);
+ EXPECT_EQ(absl::UnixEpoch(), t);
+}
+
+TEST(Time, RelationalOperators) {
+ constexpr absl::Time t1 = absl::FromUnixNanos(0);
+ constexpr absl::Time t2 = absl::FromUnixNanos(1);
+ constexpr absl::Time t3 = absl::FromUnixNanos(2);
+
+ static_assert(absl::Time() == t1, "");
+ static_assert(t1 == t1, "");
+ static_assert(t2 == t2, "");
+ static_assert(t3 == t3, "");
+
+ static_assert(t1 < t2, "");
+ static_assert(t2 < t3, "");
+ static_assert(t1 < t3, "");
+
+ static_assert(t1 <= t1, "");
+ static_assert(t1 <= t2, "");
+ static_assert(t2 <= t2, "");
+ static_assert(t2 <= t3, "");
+ static_assert(t3 <= t3, "");
+ static_assert(t1 <= t3, "");
+
+ static_assert(t2 > t1, "");
+ static_assert(t3 > t2, "");
+ static_assert(t3 > t1, "");
+
+ static_assert(t2 >= t2, "");
+ static_assert(t2 >= t1, "");
+ static_assert(t3 >= t3, "");
+ static_assert(t3 >= t2, "");
+ static_assert(t1 >= t1, "");
+ static_assert(t3 >= t1, "");
+}
+
+TEST(Time, Infinity) {
+ constexpr absl::Time ifuture = absl::InfiniteFuture();
+ constexpr absl::Time ipast = absl::InfinitePast();
+
+ static_assert(ifuture == ifuture, "");
+ static_assert(ipast == ipast, "");
+ static_assert(ipast < ifuture, "");
+ static_assert(ifuture > ipast, "");
+
+ // Arithmetic saturates
+ EXPECT_EQ(ifuture, ifuture + absl::Seconds(1));
+ EXPECT_EQ(ifuture, ifuture - absl::Seconds(1));
+ EXPECT_EQ(ipast, ipast + absl::Seconds(1));
+ EXPECT_EQ(ipast, ipast - absl::Seconds(1));
+
+ EXPECT_EQ(absl::InfiniteDuration(), ifuture - ifuture);
+ EXPECT_EQ(absl::InfiniteDuration(), ifuture - ipast);
+ EXPECT_EQ(-absl::InfiniteDuration(), ipast - ifuture);
+ EXPECT_EQ(-absl::InfiniteDuration(), ipast - ipast);
+
+ constexpr absl::Time t = absl::UnixEpoch(); // Any finite time.
+ static_assert(t < ifuture, "");
+ static_assert(t > ipast, "");
+}
+
+TEST(Time, FloorConversion) {
+#define TEST_FLOOR_CONVERSION(TO, FROM) \
+ EXPECT_EQ(1, TO(FROM(1001))); \
+ EXPECT_EQ(1, TO(FROM(1000))); \
+ EXPECT_EQ(0, TO(FROM(999))); \
+ EXPECT_EQ(0, TO(FROM(1))); \
+ EXPECT_EQ(0, TO(FROM(0))); \
+ EXPECT_EQ(-1, TO(FROM(-1))); \
+ EXPECT_EQ(-1, TO(FROM(-999))); \
+ EXPECT_EQ(-1, TO(FROM(-1000))); \
+ EXPECT_EQ(-2, TO(FROM(-1001)));
+
+ TEST_FLOOR_CONVERSION(absl::ToUnixMicros, absl::FromUnixNanos);
+ TEST_FLOOR_CONVERSION(absl::ToUnixMillis, absl::FromUnixMicros);
+ TEST_FLOOR_CONVERSION(absl::ToUnixSeconds, absl::FromUnixMillis);
+ TEST_FLOOR_CONVERSION(absl::ToTimeT, absl::FromUnixMillis);
+
+#undef TEST_FLOOR_CONVERSION
+
+ // Tests ToUnixNanos.
+ EXPECT_EQ(1, absl::ToUnixNanos(absl::UnixEpoch() + absl::Nanoseconds(3) / 2));
+ EXPECT_EQ(1, absl::ToUnixNanos(absl::UnixEpoch() + absl::Nanoseconds(1)));
+ EXPECT_EQ(0, absl::ToUnixNanos(absl::UnixEpoch() + absl::Nanoseconds(1) / 2));
+ EXPECT_EQ(0, absl::ToUnixNanos(absl::UnixEpoch() + absl::Nanoseconds(0)));
+ EXPECT_EQ(-1,
+ absl::ToUnixNanos(absl::UnixEpoch() - absl::Nanoseconds(1) / 2));
+ EXPECT_EQ(-1, absl::ToUnixNanos(absl::UnixEpoch() - absl::Nanoseconds(1)));
+ EXPECT_EQ(-2,
+ absl::ToUnixNanos(absl::UnixEpoch() - absl::Nanoseconds(3) / 2));
+
+ // Tests ToUniversal, which uses a different epoch than the tests above.
+ EXPECT_EQ(1,
+ absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(101)));
+ EXPECT_EQ(1,
+ absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(100)));
+ EXPECT_EQ(0,
+ absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(99)));
+ EXPECT_EQ(0,
+ absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(1)));
+ EXPECT_EQ(0,
+ absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(0)));
+ EXPECT_EQ(-1,
+ absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(-1)));
+ EXPECT_EQ(-1,
+ absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(-99)));
+ EXPECT_EQ(
+ -1, absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(-100)));
+ EXPECT_EQ(
+ -2, absl::ToUniversal(absl::UniversalEpoch() + absl::Nanoseconds(-101)));
+
+ // Tests ToTimespec()/TimeFromTimespec()
+ const struct {
+ absl::Time t;
+ timespec ts;
+ } to_ts[] = {
+ {absl::FromUnixSeconds(1) + absl::Nanoseconds(1), {1, 1}},
+ {absl::FromUnixSeconds(1) + absl::Nanoseconds(1) / 2, {1, 0}},
+ {absl::FromUnixSeconds(1) + absl::Nanoseconds(0), {1, 0}},
+ {absl::FromUnixSeconds(0) + absl::Nanoseconds(0), {0, 0}},
+ {absl::FromUnixSeconds(0) - absl::Nanoseconds(1) / 2, {-1, 999999999}},
+ {absl::FromUnixSeconds(0) - absl::Nanoseconds(1), {-1, 999999999}},
+ {absl::FromUnixSeconds(-1) + absl::Nanoseconds(1), {-1, 1}},
+ {absl::FromUnixSeconds(-1) + absl::Nanoseconds(1) / 2, {-1, 0}},
+ {absl::FromUnixSeconds(-1) + absl::Nanoseconds(0), {-1, 0}},
+ {absl::FromUnixSeconds(-1) - absl::Nanoseconds(1) / 2, {-2, 999999999}},
+ };
+ for (const auto& test : to_ts) {
+ EXPECT_THAT(absl::ToTimespec(test.t), TimespecMatcher(test.ts));
+ }
+ const struct {
+ timespec ts;
+ absl::Time t;
+ } from_ts[] = {
+ {{1, 1}, absl::FromUnixSeconds(1) + absl::Nanoseconds(1)},
+ {{1, 0}, absl::FromUnixSeconds(1) + absl::Nanoseconds(0)},
+ {{0, 0}, absl::FromUnixSeconds(0) + absl::Nanoseconds(0)},
+ {{0, -1}, absl::FromUnixSeconds(0) - absl::Nanoseconds(1)},
+ {{-1, 999999999}, absl::FromUnixSeconds(0) - absl::Nanoseconds(1)},
+ {{-1, 1}, absl::FromUnixSeconds(-1) + absl::Nanoseconds(1)},
+ {{-1, 0}, absl::FromUnixSeconds(-1) + absl::Nanoseconds(0)},
+ {{-1, -1}, absl::FromUnixSeconds(-1) - absl::Nanoseconds(1)},
+ {{-2, 999999999}, absl::FromUnixSeconds(-1) - absl::Nanoseconds(1)},
+ };
+ for (const auto& test : from_ts) {
+ EXPECT_EQ(test.t, absl::TimeFromTimespec(test.ts));
+ }
+
+ // Tests ToTimeval()/TimeFromTimeval() (same as timespec above)
+ const struct {
+ absl::Time t;
+ timeval tv;
+ } to_tv[] = {
+ {absl::FromUnixSeconds(1) + absl::Microseconds(1), {1, 1}},
+ {absl::FromUnixSeconds(1) + absl::Microseconds(1) / 2, {1, 0}},
+ {absl::FromUnixSeconds(1) + absl::Microseconds(0), {1, 0}},
+ {absl::FromUnixSeconds(0) + absl::Microseconds(0), {0, 0}},
+ {absl::FromUnixSeconds(0) - absl::Microseconds(1) / 2, {-1, 999999}},
+ {absl::FromUnixSeconds(0) - absl::Microseconds(1), {-1, 999999}},
+ {absl::FromUnixSeconds(-1) + absl::Microseconds(1), {-1, 1}},
+ {absl::FromUnixSeconds(-1) + absl::Microseconds(1) / 2, {-1, 0}},
+ {absl::FromUnixSeconds(-1) + absl::Microseconds(0), {-1, 0}},
+ {absl::FromUnixSeconds(-1) - absl::Microseconds(1) / 2, {-2, 999999}},
+ };
+ for (const auto& test : to_tv) {
+ EXPECT_THAT(ToTimeval(test.t), TimevalMatcher(test.tv));
+ }
+ const struct {
+ timeval tv;
+ absl::Time t;
+ } from_tv[] = {
+ {{1, 1}, absl::FromUnixSeconds(1) + absl::Microseconds(1)},
+ {{1, 0}, absl::FromUnixSeconds(1) + absl::Microseconds(0)},
+ {{0, 0}, absl::FromUnixSeconds(0) + absl::Microseconds(0)},
+ {{0, -1}, absl::FromUnixSeconds(0) - absl::Microseconds(1)},
+ {{-1, 999999}, absl::FromUnixSeconds(0) - absl::Microseconds(1)},
+ {{-1, 1}, absl::FromUnixSeconds(-1) + absl::Microseconds(1)},
+ {{-1, 0}, absl::FromUnixSeconds(-1) + absl::Microseconds(0)},
+ {{-1, -1}, absl::FromUnixSeconds(-1) - absl::Microseconds(1)},
+ {{-2, 999999}, absl::FromUnixSeconds(-1) - absl::Microseconds(1)},
+ };
+ for (const auto& test : from_tv) {
+ EXPECT_EQ(test.t, absl::TimeFromTimeval(test.tv));
+ }
+
+ // Tests flooring near negative infinity.
+ const int64_t min_plus_1 = std::numeric_limits<int64_t>::min() + 1;
+ EXPECT_EQ(min_plus_1, absl::ToUnixSeconds(absl::FromUnixSeconds(min_plus_1)));
+ EXPECT_EQ(std::numeric_limits<int64_t>::min(),
+ absl::ToUnixSeconds(
+ absl::FromUnixSeconds(min_plus_1) - absl::Nanoseconds(1) / 2));
+
+ // Tests flooring near positive infinity.
+ EXPECT_EQ(std::numeric_limits<int64_t>::max(),
+ absl::ToUnixSeconds(absl::FromUnixSeconds(
+ std::numeric_limits<int64_t>::max()) + absl::Nanoseconds(1) / 2));
+ EXPECT_EQ(std::numeric_limits<int64_t>::max(),
+ absl::ToUnixSeconds(
+ absl::FromUnixSeconds(std::numeric_limits<int64_t>::max())));
+ EXPECT_EQ(std::numeric_limits<int64_t>::max() - 1,
+ absl::ToUnixSeconds(absl::FromUnixSeconds(
+ std::numeric_limits<int64_t>::max()) - absl::Nanoseconds(1) / 2));
+}
+
+TEST(Time, RoundtripConversion) {
+#define TEST_CONVERSION_ROUND_TRIP(SOURCE, FROM, TO, MATCHER) \
+ EXPECT_THAT(TO(FROM(SOURCE)), MATCHER(SOURCE))
+
+ // FromUnixNanos() and ToUnixNanos()
+ int64_t now_ns = absl::GetCurrentTimeNanos();
+ TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUnixNanos, absl::ToUnixNanos,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(0, absl::FromUnixNanos, absl::ToUnixNanos,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(1, absl::FromUnixNanos, absl::ToUnixNanos,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(now_ns, absl::FromUnixNanos, absl::ToUnixNanos,
+ testing::Eq)
+ << now_ns;
+
+ // FromUnixMicros() and ToUnixMicros()
+ int64_t now_us = absl::GetCurrentTimeNanos() / 1000;
+ TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUnixMicros, absl::ToUnixMicros,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(0, absl::FromUnixMicros, absl::ToUnixMicros,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(1, absl::FromUnixMicros, absl::ToUnixMicros,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(now_us, absl::FromUnixMicros, absl::ToUnixMicros,
+ testing::Eq)
+ << now_us;
+
+ // FromUnixMillis() and ToUnixMillis()
+ int64_t now_ms = absl::GetCurrentTimeNanos() / 1000000;
+ TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUnixMillis, absl::ToUnixMillis,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(0, absl::FromUnixMillis, absl::ToUnixMillis,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(1, absl::FromUnixMillis, absl::ToUnixMillis,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(now_ms, absl::FromUnixMillis, absl::ToUnixMillis,
+ testing::Eq)
+ << now_ms;
+
+ // FromUnixSeconds() and ToUnixSeconds()
+ int64_t now_s = std::time(nullptr);
+ TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUnixSeconds, absl::ToUnixSeconds,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(0, absl::FromUnixSeconds, absl::ToUnixSeconds,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(1, absl::FromUnixSeconds, absl::ToUnixSeconds,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(now_s, absl::FromUnixSeconds, absl::ToUnixSeconds,
+ testing::Eq)
+ << now_s;
+
+ // FromTimeT() and ToTimeT()
+ time_t now_time_t = std::time(nullptr);
+ TEST_CONVERSION_ROUND_TRIP(-1, absl::FromTimeT, absl::ToTimeT, testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(0, absl::FromTimeT, absl::ToTimeT, testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(1, absl::FromTimeT, absl::ToTimeT, testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(now_time_t, absl::FromTimeT, absl::ToTimeT,
+ testing::Eq)
+ << now_time_t;
+
+ // TimeFromTimeval() and ToTimeval()
+ timeval tv;
+ tv.tv_sec = -1;
+ tv.tv_usec = 0;
+ TEST_CONVERSION_ROUND_TRIP(tv, absl::TimeFromTimeval, absl::ToTimeval,
+ TimevalMatcher);
+ tv.tv_sec = -1;
+ tv.tv_usec = 999999;
+ TEST_CONVERSION_ROUND_TRIP(tv, absl::TimeFromTimeval, absl::ToTimeval,
+ TimevalMatcher);
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ TEST_CONVERSION_ROUND_TRIP(tv, absl::TimeFromTimeval, absl::ToTimeval,
+ TimevalMatcher);
+ tv.tv_sec = 0;
+ tv.tv_usec = 1;
+ TEST_CONVERSION_ROUND_TRIP(tv, absl::TimeFromTimeval, absl::ToTimeval,
+ TimevalMatcher);
+ tv.tv_sec = 1;
+ tv.tv_usec = 0;
+ TEST_CONVERSION_ROUND_TRIP(tv, absl::TimeFromTimeval, absl::ToTimeval,
+ TimevalMatcher);
+
+ // TimeFromTimespec() and ToTimespec()
+ timespec ts;
+ ts.tv_sec = -1;
+ ts.tv_nsec = 0;
+ TEST_CONVERSION_ROUND_TRIP(ts, absl::TimeFromTimespec, absl::ToTimespec,
+ TimespecMatcher);
+ ts.tv_sec = -1;
+ ts.tv_nsec = 999999999;
+ TEST_CONVERSION_ROUND_TRIP(ts, absl::TimeFromTimespec, absl::ToTimespec,
+ TimespecMatcher);
+ ts.tv_sec = 0;
+ ts.tv_nsec = 0;
+ TEST_CONVERSION_ROUND_TRIP(ts, absl::TimeFromTimespec, absl::ToTimespec,
+ TimespecMatcher);
+ ts.tv_sec = 0;
+ ts.tv_nsec = 1;
+ TEST_CONVERSION_ROUND_TRIP(ts, absl::TimeFromTimespec, absl::ToTimespec,
+ TimespecMatcher);
+ ts.tv_sec = 1;
+ ts.tv_nsec = 0;
+ TEST_CONVERSION_ROUND_TRIP(ts, absl::TimeFromTimespec, absl::ToTimespec,
+ TimespecMatcher);
+
+ // FromUDate() and ToUDate()
+ double now_ud = absl::GetCurrentTimeNanos() / 1000000;
+ TEST_CONVERSION_ROUND_TRIP(-1.5, absl::FromUDate, absl::ToUDate,
+ testing::DoubleEq);
+ TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUDate, absl::ToUDate,
+ testing::DoubleEq);
+ TEST_CONVERSION_ROUND_TRIP(-0.5, absl::FromUDate, absl::ToUDate,
+ testing::DoubleEq);
+ TEST_CONVERSION_ROUND_TRIP(0, absl::FromUDate, absl::ToUDate,
+ testing::DoubleEq);
+ TEST_CONVERSION_ROUND_TRIP(0.5, absl::FromUDate, absl::ToUDate,
+ testing::DoubleEq);
+ TEST_CONVERSION_ROUND_TRIP(1, absl::FromUDate, absl::ToUDate,
+ testing::DoubleEq);
+ TEST_CONVERSION_ROUND_TRIP(1.5, absl::FromUDate, absl::ToUDate,
+ testing::DoubleEq);
+ TEST_CONVERSION_ROUND_TRIP(now_ud, absl::FromUDate, absl::ToUDate,
+ testing::DoubleEq)
+ << std::fixed << std::setprecision(17) << now_ud;
+
+ // FromUniversal() and ToUniversal()
+ int64_t now_uni = ((719162LL * (24 * 60 * 60)) * (1000 * 1000 * 10)) +
+ (absl::GetCurrentTimeNanos() / 100);
+ TEST_CONVERSION_ROUND_TRIP(-1, absl::FromUniversal, absl::ToUniversal,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(0, absl::FromUniversal, absl::ToUniversal,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(1, absl::FromUniversal, absl::ToUniversal,
+ testing::Eq);
+ TEST_CONVERSION_ROUND_TRIP(now_uni, absl::FromUniversal, absl::ToUniversal,
+ testing::Eq)
+ << now_uni;
+
+#undef TEST_CONVERSION_ROUND_TRIP
+}
+
+template <typename Duration>
+std::chrono::system_clock::time_point MakeChronoUnixTime(const Duration& d) {
+ return std::chrono::system_clock::from_time_t(0) + d;
+}
+
+TEST(Time, FromChrono) {
+ EXPECT_EQ(absl::FromTimeT(-1),
+ absl::FromChrono(std::chrono::system_clock::from_time_t(-1)));
+ EXPECT_EQ(absl::FromTimeT(0),
+ absl::FromChrono(std::chrono::system_clock::from_time_t(0)));
+ EXPECT_EQ(absl::FromTimeT(1),
+ absl::FromChrono(std::chrono::system_clock::from_time_t(1)));
+
+ EXPECT_EQ(
+ absl::FromUnixMillis(-1),
+ absl::FromChrono(MakeChronoUnixTime(std::chrono::milliseconds(-1))));
+ EXPECT_EQ(absl::FromUnixMillis(0),
+ absl::FromChrono(MakeChronoUnixTime(std::chrono::milliseconds(0))));
+ EXPECT_EQ(absl::FromUnixMillis(1),
+ absl::FromChrono(MakeChronoUnixTime(std::chrono::milliseconds(1))));
+
+ // Chrono doesn't define exactly its range and precision (neither does
+ // absl::Time), so let's simply test +/- ~100 years to make sure things work.
+ const auto century_sec = 60 * 60 * 24 * 365 * int64_t{100};
+ const auto century = std::chrono::seconds(century_sec);
+ const auto chrono_future = MakeChronoUnixTime(century);
+ const auto chrono_past = MakeChronoUnixTime(-century);
+ EXPECT_EQ(absl::FromUnixSeconds(century_sec),
+ absl::FromChrono(chrono_future));
+ EXPECT_EQ(absl::FromUnixSeconds(-century_sec), absl::FromChrono(chrono_past));
+
+ // Roundtrip them both back to chrono.
+ EXPECT_EQ(chrono_future,
+ absl::ToChronoTime(absl::FromUnixSeconds(century_sec)));
+ EXPECT_EQ(chrono_past,
+ absl::ToChronoTime(absl::FromUnixSeconds(-century_sec)));
+}
+
+TEST(Time, ToChronoTime) {
+ EXPECT_EQ(std::chrono::system_clock::from_time_t(-1),
+ absl::ToChronoTime(absl::FromTimeT(-1)));
+ EXPECT_EQ(std::chrono::system_clock::from_time_t(0),
+ absl::ToChronoTime(absl::FromTimeT(0)));
+ EXPECT_EQ(std::chrono::system_clock::from_time_t(1),
+ absl::ToChronoTime(absl::FromTimeT(1)));
+
+ EXPECT_EQ(MakeChronoUnixTime(std::chrono::milliseconds(-1)),
+ absl::ToChronoTime(absl::FromUnixMillis(-1)));
+ EXPECT_EQ(MakeChronoUnixTime(std::chrono::milliseconds(0)),
+ absl::ToChronoTime(absl::FromUnixMillis(0)));
+ EXPECT_EQ(MakeChronoUnixTime(std::chrono::milliseconds(1)),
+ absl::ToChronoTime(absl::FromUnixMillis(1)));
+
+ // Time before the Unix epoch should floor, not trunc.
+ const auto tick = absl::Nanoseconds(1) / 4;
+ EXPECT_EQ(std::chrono::system_clock::from_time_t(0) -
+ std::chrono::system_clock::duration(1),
+ absl::ToChronoTime(absl::UnixEpoch() - tick));
+}
+
+TEST(Time, ConvertDateTime) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+ const absl::TimeZone goog =
+ absl::time_internal::LoadTimeZone("America/Los_Angeles");
+ const absl::TimeZone nyc =
+ absl::time_internal::LoadTimeZone("America/New_York");
+ const std::string fmt = "%a, %e %b %Y %H:%M:%S %z (%Z)";
+
+ // A simple case of normalization.
+ absl::TimeConversion oct32 = ConvertDateTime(2013, 10, 32, 8, 30, 0, goog);
+ EXPECT_TRUE(oct32.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, oct32.kind);
+ absl::TimeConversion nov01 = ConvertDateTime(2013, 11, 1, 8, 30, 0, goog);
+ EXPECT_FALSE(nov01.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, nov01.kind);
+ EXPECT_EQ(oct32.pre, nov01.pre);
+ EXPECT_EQ("Fri, 1 Nov 2013 08:30:00 -0700 (PDT)",
+ absl::FormatTime(fmt, nov01.pre, goog));
+
+ // A Spring DST transition, when there is a gap in civil time
+ // and we prefer the later of the possible interpretations of a
+ // non-existent time.
+ absl::TimeConversion mar13 = ConvertDateTime(2011, 3, 13, 2, 15, 0, nyc);
+ EXPECT_FALSE(mar13.normalized);
+ EXPECT_EQ(absl::TimeConversion::SKIPPED, mar13.kind);
+ EXPECT_EQ("Sun, 13 Mar 2011 03:15:00 -0400 (EDT)",
+ absl::FormatTime(fmt, mar13.pre, nyc));
+ EXPECT_EQ("Sun, 13 Mar 2011 03:00:00 -0400 (EDT)",
+ absl::FormatTime(fmt, mar13.trans, nyc));
+ EXPECT_EQ("Sun, 13 Mar 2011 01:15:00 -0500 (EST)",
+ absl::FormatTime(fmt, mar13.post, nyc));
+ EXPECT_EQ(mar13.pre, absl::FromDateTime(2011, 3, 13, 2, 15, 0, nyc));
+
+ // A Fall DST transition, when civil times are repeated and
+ // we prefer the earlier of the possible interpretations of an
+ // ambiguous time.
+ absl::TimeConversion nov06 = ConvertDateTime(2011, 11, 6, 1, 15, 0, nyc);
+ EXPECT_FALSE(nov06.normalized);
+ EXPECT_EQ(absl::TimeConversion::REPEATED, nov06.kind);
+ EXPECT_EQ("Sun, 6 Nov 2011 01:15:00 -0400 (EDT)",
+ absl::FormatTime(fmt, nov06.pre, nyc));
+ EXPECT_EQ("Sun, 6 Nov 2011 01:00:00 -0500 (EST)",
+ absl::FormatTime(fmt, nov06.trans, nyc));
+ EXPECT_EQ("Sun, 6 Nov 2011 01:15:00 -0500 (EST)",
+ absl::FormatTime(fmt, nov06.post, nyc));
+ EXPECT_EQ(nov06.pre, absl::FromDateTime(2011, 11, 6, 1, 15, 0, nyc));
+
+ // Check that (time_t) -1 is handled correctly.
+ absl::TimeConversion minus1 = ConvertDateTime(1969, 12, 31, 18, 59, 59, nyc);
+ EXPECT_FALSE(minus1.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, minus1.kind);
+ EXPECT_EQ(-1, absl::ToTimeT(minus1.pre));
+ EXPECT_EQ("Wed, 31 Dec 1969 18:59:59 -0500 (EST)",
+ absl::FormatTime(fmt, minus1.pre, nyc));
+ EXPECT_EQ("Wed, 31 Dec 1969 23:59:59 +0000 (UTC)",
+ absl::FormatTime(fmt, minus1.pre, utc));
+}
+
+// FromDateTime(year, mon, day, hour, min, sec, UTCTimeZone()) has
+// a specialized fastpath implementation which we exercise here.
+TEST(Time, FromDateTimeUTC) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+ const std::string fmt = "%a, %e %b %Y %H:%M:%S %z (%Z)";
+ const int kMax = std::numeric_limits<int>::max();
+ const int kMin = std::numeric_limits<int>::min();
+ absl::Time t;
+
+ // 292091940881 is the last positive year to use the fastpath.
+ t = absl::FromDateTime(292091940881, kMax, kMax, kMax, kMax, kMax, utc);
+ EXPECT_EQ("Fri, 25 Nov 292277026596 12:21:07 +0000 (UTC)",
+ absl::FormatTime(fmt, t, utc));
+ t = absl::FromDateTime(292091940882, kMax, kMax, kMax, kMax, kMax, utc);
+ EXPECT_EQ("infinite-future", absl::FormatTime(fmt, t, utc)); // no overflow
+ t = absl::FromDateTime(
+ std::numeric_limits<int64_t>::max(), kMax, kMax, kMax, kMax, kMax, utc);
+ EXPECT_EQ("infinite-future", absl::FormatTime(fmt, t, utc)); // no overflow
+
+ // -292091936940 is the last negative year to use the fastpath.
+ t = absl::FromDateTime(-292091936940, kMin, kMin, kMin, kMin, kMin, utc);
+ EXPECT_EQ("Fri, 1 Nov -292277022657 10:37:52 +0000 (UTC)",
+ absl::FormatTime(fmt, t, utc));
+ t = absl::FromDateTime(-292091936941, kMin, kMin, kMin, kMin, kMin, utc);
+ EXPECT_EQ("infinite-past", absl::FormatTime(fmt, t, utc)); // no underflow
+ t = absl::FromDateTime(
+ std::numeric_limits<int64_t>::min(), kMin, kMin, kMin, kMin, kMin, utc);
+ EXPECT_EQ("infinite-past", absl::FormatTime(fmt, t, utc)); // no overflow
+
+ // Check that we're counting leap years correctly.
+ t = absl::FromDateTime(1900, 2, 28, 23, 59, 59, utc);
+ EXPECT_EQ("Wed, 28 Feb 1900 23:59:59 +0000 (UTC)",
+ absl::FormatTime(fmt, t, utc));
+ t = absl::FromDateTime(1900, 3, 1, 0, 0, 0, utc);
+ EXPECT_EQ("Thu, 1 Mar 1900 00:00:00 +0000 (UTC)",
+ absl::FormatTime(fmt, t, utc));
+ t = absl::FromDateTime(2000, 2, 29, 23, 59, 59, utc);
+ EXPECT_EQ("Tue, 29 Feb 2000 23:59:59 +0000 (UTC)",
+ absl::FormatTime(fmt, t, utc));
+ t = absl::FromDateTime(2000, 3, 1, 0, 0, 0, utc);
+ EXPECT_EQ("Wed, 1 Mar 2000 00:00:00 +0000 (UTC)",
+ absl::FormatTime(fmt, t, utc));
+
+ // Check normalization.
+ const std::string ymdhms = "%Y-%m-%d %H:%M:%S";
+ t = absl::FromDateTime(2015, 1, 1, 0, 0, 60, utc);
+ EXPECT_EQ("2015-01-01 00:01:00", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, 1, 1, 0, 60, 0, utc);
+ EXPECT_EQ("2015-01-01 01:00:00", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, 1, 1, 24, 0, 0, utc);
+ EXPECT_EQ("2015-01-02 00:00:00", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, 1, 32, 0, 0, 0, utc);
+ EXPECT_EQ("2015-02-01 00:00:00", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, 13, 1, 0, 0, 0, utc);
+ EXPECT_EQ("2016-01-01 00:00:00", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, 13, 32, 60, 60, 60, utc);
+ EXPECT_EQ("2016-02-03 13:01:00", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, 1, 1, 0, 0, -1, utc);
+ EXPECT_EQ("2014-12-31 23:59:59", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, 1, 1, 0, -1, 0, utc);
+ EXPECT_EQ("2014-12-31 23:59:00", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, 1, 1, -1, 0, 0, utc);
+ EXPECT_EQ("2014-12-31 23:00:00", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, 1, -1, 0, 0, 0, utc);
+ EXPECT_EQ("2014-12-30 00:00:00", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, -1, 1, 0, 0, 0, utc);
+ EXPECT_EQ("2014-11-01 00:00:00", absl::FormatTime(ymdhms, t, utc));
+ t = absl::FromDateTime(2015, -1, -1, -1, -1, -1, utc);
+ EXPECT_EQ("2014-10-29 22:58:59", absl::FormatTime(ymdhms, t, utc));
+}
+
+TEST(Time, ToTM) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+
+ // Compares the results of ToTM() to gmtime_r() for lots of times over the
+ // course of a few days.
+ const absl::Time start = absl::FromDateTime(2014, 1, 2, 3, 4, 5, utc);
+ const absl::Time end = absl::FromDateTime(2014, 1, 5, 3, 4, 5, utc);
+ for (absl::Time t = start; t < end; t += absl::Seconds(30)) {
+ const struct tm tm_bt = ToTM(t, utc);
+ const time_t tt = absl::ToTimeT(t);
+ struct tm tm_lc;
+#ifdef _WIN32
+ gmtime_s(&tm_lc, &tt);
+#else
+ gmtime_r(&tt, &tm_lc);
+#endif
+ EXPECT_EQ(tm_lc.tm_year, tm_bt.tm_year);
+ EXPECT_EQ(tm_lc.tm_mon, tm_bt.tm_mon);
+ EXPECT_EQ(tm_lc.tm_mday, tm_bt.tm_mday);
+ EXPECT_EQ(tm_lc.tm_hour, tm_bt.tm_hour);
+ EXPECT_EQ(tm_lc.tm_min, tm_bt.tm_min);
+ EXPECT_EQ(tm_lc.tm_sec, tm_bt.tm_sec);
+ EXPECT_EQ(tm_lc.tm_wday, tm_bt.tm_wday);
+ EXPECT_EQ(tm_lc.tm_yday, tm_bt.tm_yday);
+ EXPECT_EQ(tm_lc.tm_isdst, tm_bt.tm_isdst);
+
+ ASSERT_FALSE(HasFailure());
+ }
+
+ // Checks that the tm_isdst field is correct when in standard time.
+ const absl::TimeZone nyc =
+ absl::time_internal::LoadTimeZone("America/New_York");
+ absl::Time t = absl::FromDateTime(2014, 3, 1, 0, 0, 0, nyc);
+ struct tm tm = ToTM(t, nyc);
+ EXPECT_FALSE(tm.tm_isdst);
+
+ // Checks that the tm_isdst field is correct when in daylight time.
+ t = absl::FromDateTime(2014, 4, 1, 0, 0, 0, nyc);
+ tm = ToTM(t, nyc);
+ EXPECT_TRUE(tm.tm_isdst);
+
+ // Checks overflow.
+ tm = ToTM(absl::InfiniteFuture(), nyc);
+ EXPECT_EQ(std::numeric_limits<int>::max() - 1900, tm.tm_year);
+ EXPECT_EQ(11, tm.tm_mon);
+ EXPECT_EQ(31, tm.tm_mday);
+ EXPECT_EQ(23, tm.tm_hour);
+ EXPECT_EQ(59, tm.tm_min);
+ EXPECT_EQ(59, tm.tm_sec);
+ EXPECT_EQ(4, tm.tm_wday);
+ EXPECT_EQ(364, tm.tm_yday);
+ EXPECT_FALSE(tm.tm_isdst);
+
+ // Checks underflow.
+ tm = ToTM(absl::InfinitePast(), nyc);
+ EXPECT_EQ(std::numeric_limits<int>::min(), tm.tm_year);
+ EXPECT_EQ(0, tm.tm_mon);
+ EXPECT_EQ(1, tm.tm_mday);
+ EXPECT_EQ(0, tm.tm_hour);
+ EXPECT_EQ(0, tm.tm_min);
+ EXPECT_EQ(0, tm.tm_sec);
+ EXPECT_EQ(0, tm.tm_wday);
+ EXPECT_EQ(0, tm.tm_yday);
+ EXPECT_FALSE(tm.tm_isdst);
+}
+
+TEST(Time, FromTM) {
+ const absl::TimeZone nyc =
+ absl::time_internal::LoadTimeZone("America/New_York");
+
+ // Verifies that tm_isdst doesn't affect anything when the time is unique.
+ struct tm tm;
+ std::memset(&tm, 0, sizeof(tm));
+ tm.tm_year = 2014 - 1900;
+ tm.tm_mon = 6 - 1;
+ tm.tm_mday = 28;
+ tm.tm_hour = 1;
+ tm.tm_min = 2;
+ tm.tm_sec = 3;
+ tm.tm_isdst = -1;
+ absl::Time t = FromTM(tm, nyc);
+ EXPECT_EQ("2014-06-28T01:02:03-04:00", absl::FormatTime(t, nyc)); // DST
+ tm.tm_isdst = 0;
+ t = FromTM(tm, nyc);
+ EXPECT_EQ("2014-06-28T01:02:03-04:00", absl::FormatTime(t, nyc)); // DST
+ tm.tm_isdst = 1;
+ t = FromTM(tm, nyc);
+ EXPECT_EQ("2014-06-28T01:02:03-04:00", absl::FormatTime(t, nyc)); // DST
+
+ // Adjusts tm to refer to an ambiguous time.
+ tm.tm_year = 2014 - 1900;
+ tm.tm_mon = 11 - 1;
+ tm.tm_mday = 2;
+ tm.tm_hour = 1;
+ tm.tm_min = 30;
+ tm.tm_sec = 42;
+ tm.tm_isdst = -1;
+ t = FromTM(tm, nyc);
+ EXPECT_EQ("2014-11-02T01:30:42-04:00", absl::FormatTime(t, nyc)); // DST
+ tm.tm_isdst = 0;
+ t = FromTM(tm, nyc);
+ EXPECT_EQ("2014-11-02T01:30:42-05:00", absl::FormatTime(t, nyc)); // STD
+ tm.tm_isdst = 1;
+ t = FromTM(tm, nyc);
+ EXPECT_EQ("2014-11-02T01:30:42-04:00", absl::FormatTime(t, nyc)); // DST
+
+ // Adjusts tm to refer to a skipped time.
+ tm.tm_year = 2014 - 1900;
+ tm.tm_mon = 3 - 1;
+ tm.tm_mday = 9;
+ tm.tm_hour = 2;
+ tm.tm_min = 30;
+ tm.tm_sec = 42;
+ tm.tm_isdst = -1;
+ t = FromTM(tm, nyc);
+ EXPECT_EQ("2014-03-09T03:30:42-04:00", absl::FormatTime(t, nyc)); // DST
+ tm.tm_isdst = 0;
+ t = FromTM(tm, nyc);
+ EXPECT_EQ("2014-03-09T01:30:42-05:00", absl::FormatTime(t, nyc)); // STD
+ tm.tm_isdst = 1;
+ t = FromTM(tm, nyc);
+ EXPECT_EQ("2014-03-09T03:30:42-04:00", absl::FormatTime(t, nyc)); // DST
+}
+
+TEST(Time, TMRoundTrip) {
+ const absl::TimeZone nyc =
+ absl::time_internal::LoadTimeZone("America/New_York");
+
+ // Test round-tripping across a skipped transition
+ absl::Time start = absl::FromDateTime(2014, 3, 9, 0, 0, 0, nyc);
+ absl::Time end = absl::FromDateTime(2014, 3, 9, 4, 0, 0, nyc);
+ for (absl::Time t = start; t < end; t += absl::Minutes(1)) {
+ struct tm tm = ToTM(t, nyc);
+ absl::Time rt = FromTM(tm, nyc);
+ EXPECT_EQ(rt, t);
+ }
+
+ // Test round-tripping across an ambiguous transition
+ start = absl::FromDateTime(2014, 11, 2, 0, 0, 0, nyc);
+ end = absl::FromDateTime(2014, 11, 2, 4, 0, 0, nyc);
+ for (absl::Time t = start; t < end; t += absl::Minutes(1)) {
+ struct tm tm = ToTM(t, nyc);
+ absl::Time rt = FromTM(tm, nyc);
+ EXPECT_EQ(rt, t);
+ }
+
+ // Test round-tripping of unique instants crossing a day boundary
+ start = absl::FromDateTime(2014, 6, 27, 22, 0, 0, nyc);
+ end = absl::FromDateTime(2014, 6, 28, 4, 0, 0, nyc);
+ for (absl::Time t = start; t < end; t += absl::Minutes(1)) {
+ struct tm tm = ToTM(t, nyc);
+ absl::Time rt = FromTM(tm, nyc);
+ EXPECT_EQ(rt, t);
+ }
+}
+
+TEST(Time, Range) {
+ // The API's documented range is +/- 100 billion years.
+ const absl::Duration range = absl::Hours(24) * 365.2425 * 100000000000;
+
+ // Arithmetic and comparison still works at +/-range around base values.
+ absl::Time bases[2] = {absl::UnixEpoch(), absl::Now()};
+ for (const auto base : bases) {
+ absl::Time bottom = base - range;
+ EXPECT_GT(bottom, bottom - absl::Nanoseconds(1));
+ EXPECT_LT(bottom, bottom + absl::Nanoseconds(1));
+ absl::Time top = base + range;
+ EXPECT_GT(top, top - absl::Nanoseconds(1));
+ EXPECT_LT(top, top + absl::Nanoseconds(1));
+ absl::Duration full_range = 2 * range;
+ EXPECT_EQ(full_range, top - bottom);
+ EXPECT_EQ(-full_range, bottom - top);
+ }
+}
+
+TEST(Time, Limits) {
+ // It is an implementation detail that Time().rep_ == ZeroDuration(),
+ // and that the resolution of a Duration is 1/4 of a nanosecond.
+ const absl::Time zero;
+ const absl::Time max =
+ zero + absl::Seconds(std::numeric_limits<int64_t>::max()) +
+ absl::Nanoseconds(999999999) + absl::Nanoseconds(3) / 4;
+ const absl::Time min =
+ zero + absl::Seconds(std::numeric_limits<int64_t>::min());
+
+ // Some simple max/min bounds checks.
+ EXPECT_LT(max, absl::InfiniteFuture());
+ EXPECT_GT(min, absl::InfinitePast());
+ EXPECT_LT(zero, max);
+ EXPECT_GT(zero, min);
+ EXPECT_GE(absl::UnixEpoch(), min);
+ EXPECT_LT(absl::UnixEpoch(), max);
+
+ // Check sign of Time differences.
+ EXPECT_LT(absl::ZeroDuration(), max - zero);
+ EXPECT_LT(absl::ZeroDuration(),
+ zero - absl::Nanoseconds(1) / 4 - min); // avoid zero - min
+
+ // Arithmetic works at max - 0.25ns and min + 0.25ns.
+ EXPECT_GT(max, max - absl::Nanoseconds(1) / 4);
+ EXPECT_LT(min, min + absl::Nanoseconds(1) / 4);
+}
+
+TEST(Time, ConversionSaturation) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+ absl::Time t;
+
+ const auto max_time_t = std::numeric_limits<time_t>::max();
+ const auto min_time_t = std::numeric_limits<time_t>::min();
+ time_t tt = max_time_t - 1;
+ t = absl::FromTimeT(tt);
+ tt = absl::ToTimeT(t);
+ EXPECT_EQ(max_time_t - 1, tt);
+ t += absl::Seconds(1);
+ tt = absl::ToTimeT(t);
+ EXPECT_EQ(max_time_t, tt);
+ t += absl::Seconds(1); // no effect
+ tt = absl::ToTimeT(t);
+ EXPECT_EQ(max_time_t, tt);
+
+ tt = min_time_t + 1;
+ t = absl::FromTimeT(tt);
+ tt = absl::ToTimeT(t);
+ EXPECT_EQ(min_time_t + 1, tt);
+ t -= absl::Seconds(1);
+ tt = absl::ToTimeT(t);
+ EXPECT_EQ(min_time_t, tt);
+ t -= absl::Seconds(1); // no effect
+ tt = absl::ToTimeT(t);
+ EXPECT_EQ(min_time_t, tt);
+
+ const auto max_timeval_sec =
+ std::numeric_limits<decltype(timeval::tv_sec)>::max();
+ const auto min_timeval_sec =
+ std::numeric_limits<decltype(timeval::tv_sec)>::min();
+ timeval tv;
+ tv.tv_sec = max_timeval_sec;
+ tv.tv_usec = 999998;
+ t = absl::TimeFromTimeval(tv);
+ tv = ToTimeval(t);
+ EXPECT_EQ(max_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(999998, tv.tv_usec);
+ t += absl::Microseconds(1);
+ tv = ToTimeval(t);
+ EXPECT_EQ(max_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(999999, tv.tv_usec);
+ t += absl::Microseconds(1); // no effect
+ tv = ToTimeval(t);
+ EXPECT_EQ(max_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(999999, tv.tv_usec);
+
+ tv.tv_sec = min_timeval_sec;
+ tv.tv_usec = 1;
+ t = absl::TimeFromTimeval(tv);
+ tv = ToTimeval(t);
+ EXPECT_EQ(min_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(1, tv.tv_usec);
+ t -= absl::Microseconds(1);
+ tv = ToTimeval(t);
+ EXPECT_EQ(min_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(0, tv.tv_usec);
+ t -= absl::Microseconds(1); // no effect
+ tv = ToTimeval(t);
+ EXPECT_EQ(min_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(0, tv.tv_usec);
+
+ const auto max_timespec_sec =
+ std::numeric_limits<decltype(timespec::tv_sec)>::max();
+ const auto min_timespec_sec =
+ std::numeric_limits<decltype(timespec::tv_sec)>::min();
+ timespec ts;
+ ts.tv_sec = max_timespec_sec;
+ ts.tv_nsec = 999999998;
+ t = absl::TimeFromTimespec(ts);
+ ts = absl::ToTimespec(t);
+ EXPECT_EQ(max_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(999999998, ts.tv_nsec);
+ t += absl::Nanoseconds(1);
+ ts = absl::ToTimespec(t);
+ EXPECT_EQ(max_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(999999999, ts.tv_nsec);
+ t += absl::Nanoseconds(1); // no effect
+ ts = absl::ToTimespec(t);
+ EXPECT_EQ(max_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(999999999, ts.tv_nsec);
+
+ ts.tv_sec = min_timespec_sec;
+ ts.tv_nsec = 1;
+ t = absl::TimeFromTimespec(ts);
+ ts = absl::ToTimespec(t);
+ EXPECT_EQ(min_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(1, ts.tv_nsec);
+ t -= absl::Nanoseconds(1);
+ ts = absl::ToTimespec(t);
+ EXPECT_EQ(min_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(0, ts.tv_nsec);
+ t -= absl::Nanoseconds(1); // no effect
+ ts = absl::ToTimespec(t);
+ EXPECT_EQ(min_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(0, ts.tv_nsec);
+
+ // Checks how Time::In() saturates on infinities.
+ absl::Time::Breakdown bd = absl::InfiniteFuture().In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, std::numeric_limits<int64_t>::max(), 12, 31, 23,
+ 59, 59, 0, false, "-0000");
+ EXPECT_EQ(absl::InfiniteDuration(), bd.subsecond);
+ EXPECT_EQ(4, bd.weekday); // Thursday
+ EXPECT_EQ(365, bd.yearday);
+ bd = absl::InfinitePast().In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, std::numeric_limits<int64_t>::min(), 1, 1, 0, 0,
+ 0, 0, false, "-0000");
+ EXPECT_EQ(-absl::InfiniteDuration(), bd.subsecond);
+ EXPECT_EQ(7, bd.weekday); // Sunday
+ EXPECT_EQ(1, bd.yearday);
+
+ // Approach the maximal Time value from below.
+ t = absl::FromDateTime(292277026596, 12, 4, 15, 30, 6, utc);
+ EXPECT_EQ("292277026596-12-04T15:30:06+00:00",
+ absl::FormatTime(absl::RFC3339_full, t, utc));
+ t = absl::FromDateTime(292277026596, 12, 4, 15, 30, 7, utc);
+ EXPECT_EQ("292277026596-12-04T15:30:07+00:00",
+ absl::FormatTime(absl::RFC3339_full, t, utc));
+ EXPECT_EQ(
+ absl::UnixEpoch() + absl::Seconds(std::numeric_limits<int64_t>::max()), t);
+
+ // Checks that we can also get the maximal Time value for a far-east zone.
+ const absl::TimeZone plus14 = absl::FixedTimeZone(14 * 60 * 60);
+ t = absl::FromDateTime(292277026596, 12, 5, 5, 30, 7, plus14);
+ EXPECT_EQ("292277026596-12-05T05:30:07+14:00",
+ absl::FormatTime(absl::RFC3339_full, t, plus14));
+ EXPECT_EQ(
+ absl::UnixEpoch() + absl::Seconds(std::numeric_limits<int64_t>::max()), t);
+
+ // One second later should push us to infinity.
+ t = absl::FromDateTime(292277026596, 12, 4, 15, 30, 8, utc);
+ EXPECT_EQ("infinite-future", absl::FormatTime(absl::RFC3339_full, t, utc));
+
+ // Approach the minimal Time value from above.
+ t = absl::FromDateTime(-292277022657, 1, 27, 8, 29, 53, utc);
+ EXPECT_EQ("-292277022657-01-27T08:29:53+00:00",
+ absl::FormatTime(absl::RFC3339_full, t, utc));
+ t = absl::FromDateTime(-292277022657, 1, 27, 8, 29, 52, utc);
+ EXPECT_EQ("-292277022657-01-27T08:29:52+00:00",
+ absl::FormatTime(absl::RFC3339_full, t, utc));
+ EXPECT_EQ(
+ absl::UnixEpoch() + absl::Seconds(std::numeric_limits<int64_t>::min()), t);
+
+ // Checks that we can also get the minimal Time value for a far-west zone.
+ const absl::TimeZone minus12 = absl::FixedTimeZone(-12 * 60 * 60);
+ t = absl::FromDateTime(-292277022657, 1, 26, 20, 29, 52, minus12);
+ EXPECT_EQ("-292277022657-01-26T20:29:52-12:00",
+ absl::FormatTime(absl::RFC3339_full, t, minus12));
+ EXPECT_EQ(
+ absl::UnixEpoch() + absl::Seconds(std::numeric_limits<int64_t>::min()), t);
+
+ // One second before should push us to -infinity.
+ t = absl::FromDateTime(-292277022657, 1, 27, 8, 29, 51, utc);
+ EXPECT_EQ("infinite-past", absl::FormatTime(absl::RFC3339_full, t, utc));
+}
+
+// In zones with POSIX-style recurring rules we use special logic to
+// handle conversions in the distant future. Here we check the limits
+// of those conversions, particularly with respect to integer overflow.
+TEST(Time, ExtendedConversionSaturation) {
+ const absl::TimeZone syd =
+ absl::time_internal::LoadTimeZone("Australia/Sydney");
+ const absl::TimeZone nyc =
+ absl::time_internal::LoadTimeZone("America/New_York");
+ const absl::Time max =
+ absl::FromUnixSeconds(std::numeric_limits<int64_t>::max());
+ absl::Time::Breakdown bd;
+ absl::Time t;
+
+ // The maximal time converted in each zone.
+ bd = max.In(syd);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 292277026596, 12, 5, 2, 30, 7, 39600, true,
+ "AEDT");
+ t = absl::FromDateTime(292277026596, 12, 5, 2, 30, 7, syd);
+ EXPECT_EQ(max, t);
+ bd = max.In(nyc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 292277026596, 12, 4, 10, 30, 7, -18000, false,
+ "EST");
+ t = absl::FromDateTime(292277026596, 12, 4, 10, 30, 7, nyc);
+ EXPECT_EQ(max, t);
+
+ // One second later should push us to infinity.
+ t = absl::FromDateTime(292277026596, 12, 5, 2, 30, 8, syd);
+ EXPECT_EQ(absl::InfiniteFuture(), t);
+ t = absl::FromDateTime(292277026596, 12, 4, 10, 30, 8, nyc);
+ EXPECT_EQ(absl::InfiniteFuture(), t);
+
+ // And we should stick there.
+ t = absl::FromDateTime(292277026596, 12, 5, 2, 30, 9, syd);
+ EXPECT_EQ(absl::InfiniteFuture(), t);
+ t = absl::FromDateTime(292277026596, 12, 4, 10, 30, 9, nyc);
+ EXPECT_EQ(absl::InfiniteFuture(), t);
+
+ // All the way up to a saturated date/time, without overflow.
+ t = absl::FromDateTime(
+ std::numeric_limits<int64_t>::max(), 12, 31, 23, 59, 59, syd);
+ EXPECT_EQ(absl::InfiniteFuture(), t);
+ t = absl::FromDateTime(
+ std::numeric_limits<int64_t>::max(), 12, 31, 23, 59, 59, nyc);
+ EXPECT_EQ(absl::InfiniteFuture(), t);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_zone_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_zone_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_zone_test.cc
new file mode 100644
index 0000000..7138560
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_zone_test.cc
@@ -0,0 +1,97 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+#include "gtest/gtest.h"
+#include "absl/time/internal/test_util.h"
+#include "absl/time/time.h"
+
+namespace cctz = absl::time_internal::cctz;
+
+namespace {
+
+TEST(TimeZone, ValueSemantics) {
+ absl::TimeZone tz;
+ absl::TimeZone tz2 = tz; // Copy-construct
+ EXPECT_EQ(tz, tz2);
+ tz2 = tz; // Copy-assign
+ EXPECT_EQ(tz, tz2);
+}
+
+TEST(TimeZone, Equality) {
+ absl::TimeZone a, b;
+ EXPECT_EQ(a, b);
+ EXPECT_EQ(a.name(), b.name());
+
+ absl::TimeZone implicit_utc;
+ absl::TimeZone explicit_utc = absl::UTCTimeZone();
+ EXPECT_EQ(implicit_utc, explicit_utc);
+ EXPECT_EQ(implicit_utc.name(), explicit_utc.name());
+
+ absl::TimeZone la = absl::time_internal::LoadTimeZone("America/Los_Angeles");
+ absl::TimeZone nyc = absl::time_internal::LoadTimeZone("America/New_York");
+ EXPECT_NE(la, nyc);
+}
+
+TEST(TimeZone, CCTZConversion) {
+ const cctz::time_zone cz = cctz::utc_time_zone();
+ const absl::TimeZone tz(cz);
+ EXPECT_EQ(cz, cctz::time_zone(tz));
+}
+
+TEST(TimeZone, DefaultTimeZones) {
+ absl::TimeZone tz;
+ EXPECT_EQ("UTC", absl::TimeZone().name());
+ EXPECT_EQ("UTC", absl::UTCTimeZone().name());
+}
+
+TEST(TimeZone, FixedTimeZone) {
+ const absl::TimeZone tz = absl::FixedTimeZone(123);
+ const cctz::time_zone cz = cctz::fixed_time_zone(cctz::sys_seconds(123));
+ EXPECT_EQ(tz, absl::TimeZone(cz));
+}
+
+TEST(TimeZone, LocalTimeZone) {
+ const absl::TimeZone local_tz = absl::LocalTimeZone();
+ absl::TimeZone tz = absl::time_internal::LoadTimeZone("localtime");
+ EXPECT_EQ(tz, local_tz);
+}
+
+TEST(TimeZone, NamedTimeZones) {
+ absl::TimeZone nyc = absl::time_internal::LoadTimeZone("America/New_York");
+ EXPECT_EQ("America/New_York", nyc.name());
+ absl::TimeZone syd = absl::time_internal::LoadTimeZone("Australia/Sydney");
+ EXPECT_EQ("Australia/Sydney", syd.name());
+ absl::TimeZone fixed = absl::FixedTimeZone((((3 * 60) + 25) * 60) + 45);
+ EXPECT_EQ("Fixed/UTC+03:25:45", fixed.name());
+}
+
+TEST(TimeZone, Failures) {
+ absl::TimeZone tz = absl::time_internal::LoadTimeZone("America/Los_Angeles");
+ EXPECT_FALSE(LoadTimeZone("Invalid/TimeZone", &tz));
+ EXPECT_EQ(absl::UTCTimeZone(), tz); // guaranteed fallback to UTC
+
+ // Ensures that the load still fails on a subsequent attempt.
+ tz = absl::time_internal::LoadTimeZone("America/Los_Angeles");
+ EXPECT_FALSE(LoadTimeZone("Invalid/TimeZone", &tz));
+ EXPECT_EQ(absl::UTCTimeZone(), tz); // guaranteed fallback to UTC
+
+ // Loading an empty std::string timezone should fail.
+ tz = absl::time_internal::LoadTimeZone("America/Los_Angeles");
+ EXPECT_FALSE(LoadTimeZone("", &tz));
+ EXPECT_EQ(absl::UTCTimeZone(), tz); // guaranteed fallback to UTC
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/types/BUILD.bazel
new file mode 100644
index 0000000..0bdb2f7
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/BUILD.bazel
@@ -0,0 +1,225 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+ "ABSL_EXCEPTIONS_FLAG",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "any",
+ hdrs = ["any.h"],
+ copts = ABSL_DEFAULT_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":bad_any_cast",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/meta:type_traits",
+ "//absl/utility",
+ ],
+)
+
+cc_library(
+ name = "bad_any_cast",
+ srcs = ["bad_any_cast.cc"],
+ hdrs = ["bad_any_cast.h"],
+ copts = ABSL_EXCEPTIONS_FLAG + ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/base",
+ "//absl/base:config",
+ ],
+)
+
+cc_test(
+ name = "any_test",
+ size = "small",
+ srcs = [
+ "any_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":any",
+ "//absl/base",
+ "//absl/base:config",
+ "//absl/base:exception_testing",
+ "//absl/container:test_instance_tracker",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "any_test_noexceptions",
+ size = "small",
+ srcs = [
+ "any_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":any",
+ "//absl/base",
+ "//absl/base:config",
+ "//absl/base:exception_testing",
+ "//absl/container:test_instance_tracker",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "any_exception_safety_test",
+ srcs = ["any_exception_safety_test.cc"],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":any",
+ "//absl/base:exception_safety_testing",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "span",
+ hdrs = ["span.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/algorithm",
+ "//absl/base:core_headers",
+ "//absl/base:throw_delegate",
+ "//absl/meta:type_traits",
+ ],
+)
+
+cc_test(
+ name = "span_test",
+ size = "small",
+ srcs = ["span_test.cc"],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":span",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/base:exception_testing",
+ "//absl/container:fixed_array",
+ "//absl/container:inlined_vector",
+ "//absl/strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "span_test_noexceptions",
+ size = "small",
+ srcs = ["span_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":span",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/base:exception_testing",
+ "//absl/container:fixed_array",
+ "//absl/container:inlined_vector",
+ "//absl/strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "optional",
+ srcs = ["optional.cc"],
+ hdrs = ["optional.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":bad_optional_access",
+ "//absl/base:config",
+ "//absl/memory",
+ "//absl/meta:type_traits",
+ "//absl/utility",
+ ],
+)
+
+cc_library(
+ name = "bad_optional_access",
+ srcs = ["bad_optional_access.cc"],
+ hdrs = ["bad_optional_access.h"],
+ copts = ABSL_DEFAULT_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ "//absl/base",
+ "//absl/base:config",
+ ],
+)
+
+cc_library(
+ name = "bad_variant_access",
+ srcs = ["bad_variant_access.cc"],
+ hdrs = ["bad_variant_access.h"],
+ copts = ABSL_EXCEPTIONS_FLAG + ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/base",
+ "//absl/base:config",
+ ],
+)
+
+cc_test(
+ name = "optional_test",
+ size = "small",
+ srcs = [
+ "optional_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":optional",
+ "//absl/base",
+ "//absl/base:config",
+ "//absl/meta:type_traits",
+ "//absl/strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "variant",
+ srcs = ["internal/variant.h"],
+ hdrs = ["variant.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":bad_variant_access",
+ "//absl/base:base_internal",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/meta:type_traits",
+ "//absl/utility",
+ ],
+)
+
+cc_test(
+ name = "variant_test",
+ size = "small",
+ srcs = ["variant_test.cc"],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ deps = [
+ ":variant",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/memory",
+ "//absl/meta:type_traits",
+ "//absl/strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/types/CMakeLists.txt
new file mode 100644
index 0000000..f51d126
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/CMakeLists.txt
@@ -0,0 +1,201 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+list(APPEND TYPES_PUBLIC_HEADERS
+ "any.h"
+ "bad_any_cast.h"
+ "bad_optional_access.h"
+ "optional.h"
+ "span.h"
+ "variant.h"
+)
+
+
+# any library
+absl_header_library(
+ TARGET
+ absl_any
+ PUBLIC_LIBRARIES
+ absl::utility
+ PRIVATE_COMPILE_FLAGS
+ ${ABSL_EXCEPTIONS_FLAG}
+ EXPORT_NAME
+ any
+)
+
+# span library
+absl_header_library(
+ TARGET
+ absl_span
+ PUBLIC_LIBRARIES
+ absl::utility
+ EXPORT_NAME
+ span
+)
+
+
+# bad_any_cast library
+list(APPEND BAD_ANY_CAST_SRC
+ "bad_any_cast.cc"
+ ${TYPES_PUBLIC_HEADERS}
+)
+
+absl_library(
+ TARGET
+ absl_bad_any_cast
+ SOURCES
+ ${BAD_ANY_CAST_SRC}
+ PUBLIC_LIBRARIES
+ absl::base absl::any
+ EXPORT_NAME
+ bad_any_cast
+)
+
+
+# optional library
+list(APPEND OPTIONAL_SRC
+ "optional.cc"
+)
+
+absl_library(
+ TARGET
+ absl_optional
+ SOURCES
+ ${OPTIONAL_SRC}
+ PUBLIC_LIBRARIES
+ absl::base
+ EXPORT_NAME
+ optional
+)
+
+
+set(BAD_OPTIONAL_ACCESS_SRC "bad_optional_access.cc")
+set(BAD_OPTIONAL_ACCESS_LIBRARIES absl::base)
+
+absl_library(
+ TARGET
+ absl_bad_optional_access
+ SOURCES
+ ${BAD_OPTIONAL_ACCESS_SRC}
+ PUBLIC_LIBRARIES
+ ${BAD_OPTIONAL_ACCESS_PUBLIC_LIBRARIES}
+ EXPORT_NAME
+ bad_optional_access
+)
+
+# variant library
+absl_library(
+ TARGET
+ absl_variant
+ SOURCES
+ "bad_variant_access.h" "bad_variant_access.cc" "variant.h" "internal/variant.h"
+ PUBLIC_LIBRARIES
+ absl::base absl::meta absl::utility
+ PRIVATE_COMPILE_FLAGS
+ ${ABSL_EXCEPTIONS_FLAG}
+ EXPORT_NAME
+ variant
+)
+
+#
+## TESTS
+#
+
+
+# test any_test
+set(ANY_TEST_SRC "any_test.cc")
+set(ANY_TEST_PUBLIC_LIBRARIES absl::base absl::throw_delegate absl::any absl::bad_any_cast test_instance_tracker_lib)
+
+absl_test(
+ TARGET
+ any_test
+ SOURCES
+ ${ANY_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${ANY_TEST_PUBLIC_LIBRARIES}
+ PRIVATE_COMPILE_FLAGS
+ ${ABSL_EXCEPTIONS_FLAG}
+)
+
+
+# test any_test_noexceptions
+absl_test(
+ TARGET
+ any_test_noexceptions
+ SOURCES
+ ${ANY_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${ANY_TEST_PUBLIC_LIBRARIES}
+)
+
+# test any_exception_safety_test
+set(ANY_EXCEPTION_SAFETY_TEST_SRC "any_exception_safety_test.cc")
+set(ANY_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES absl::any absl::base absl::base_internal_exception_safety_testing)
+
+absl_test(
+ TARGET
+ any_exception_safety_test
+ SOURCES
+ ${ANY_EXCEPTION_SAFETY_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${ANY_EXCEPTION_SAFETY_TEST_PUBLIC_LIBRARIES}
+ PRIVATE_COMPILE_FLAGS
+ ${ABSL_EXCEPTIONS_FLAG}
+)
+
+
+# test span_test
+set(SPAN_TEST_SRC "span_test.cc")
+set(SPAN_TEST_PUBLIC_LIBRARIES absl::base absl::strings absl::throw_delegate absl::span test_instance_tracker_lib)
+
+absl_test(
+ TARGET
+ span_test
+ SOURCES
+ ${SPAN_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${SPAN_TEST_PUBLIC_LIBRARIES}
+ PRIVATE_COMPILE_FLAGS
+ ${ABSL_EXCEPTIONS_FLAG}
+)
+
+
+# test span_test_noexceptions
+absl_test(
+ TARGET
+ span_test_noexceptions
+ SOURCES
+ ${SPAN_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${SPAN_TEST_PUBLIC_LIBRARIES}
+)
+
+
+
+# test optional_test
+set(OPTIONAL_TEST_SRC "optional_test.cc")
+set(OPTIONAL_TEST_PUBLIC_LIBRARIES absl::base absl::throw_delegate absl::optional absl_bad_optional_access)
+
+absl_test(
+ TARGET
+ optional_test
+ SOURCES
+ ${OPTIONAL_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${OPTIONAL_TEST_PUBLIC_LIBRARIES}
+)
+
+
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/any.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/any.h b/libraries/ostrich/backend/3rdparty/abseil/absl/types/any.h
new file mode 100644
index 0000000..a973c6d
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/any.h
@@ -0,0 +1,539 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// any.h
+// -----------------------------------------------------------------------------
+//
+// This header file define the `absl::any` type for holding a type-safe value
+// of any type. The 'absl::any` type is useful for providing a way to hold
+// something that is, as yet, unspecified. Such unspecified types
+// traditionally are passed between API boundaries until they are later cast to
+// their "destination" types. To cast to such a destination type, use
+// `absl::any_cast()`. Note that when casting an `absl::any`, you must cast it
+// to an explicit type; implicit conversions will throw.
+//
+// Example:
+//
+// auto a = absl::any(65);
+// absl::any_cast<int>(a); // 65
+// absl::any_cast<char>(a); // throws absl::bad_any_cast
+// absl::any_cast<std::string>(a); // throws absl::bad_any_cast
+//
+// `absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction
+// and is designed to be a drop-in replacement for code compliant with C++17.
+//
+// Traditionally, the behavior of casting to a temporary unspecified type has
+// been accomplished with the `void *` paradigm, where the pointer was to some
+// other unspecified type. `absl::any` provides an "owning" version of `void *`
+// that avoids issues of pointer management.
+//
+// Note: just as in the case of `void *`, use of `absl::any` (and its C++17
+// version `std::any`) is a code smell indicating that your API might not be
+// constructed correctly. We have seen that most uses of `any` are unwarranted,
+// and `absl::any`, like `std::any`, is difficult to use properly. Before using
+// this abstraction, make sure that you should not instead be rewriting your
+// code to be more specific.
+//
+// Abseil expects to release an `absl::variant` type shortly (a C++11 compatible
+// version of the C++17 `std::variant), which is generally preferred for use
+// over `absl::any`.
+#ifndef ABSL_TYPES_ANY_H_
+#define ABSL_TYPES_ANY_H_
+
+#include "absl/base/config.h"
+#include "absl/utility/utility.h"
+
+#ifdef ABSL_HAVE_STD_ANY
+
+#include <any>
+
+namespace absl {
+using std::any;
+using std::any_cast;
+using std::bad_any_cast;
+using std::make_any;
+} // namespace absl
+
+#else // ABSL_HAVE_STD_ANY
+
+#include <algorithm>
+#include <cstddef>
+#include <initializer_list>
+#include <memory>
+#include <stdexcept>
+#include <type_traits>
+#include <typeinfo>
+#include <utility>
+
+#include "absl/base/macros.h"
+#include "absl/meta/type_traits.h"
+#include "absl/types/bad_any_cast.h"
+
+// NOTE: This macro is an implementation detail that is undefined at the bottom
+// of the file. It is not intended for expansion directly from user code.
+#ifdef ABSL_ANY_DETAIL_HAS_RTTI
+#error ABSL_ANY_DETAIL_HAS_RTTI cannot be directly set
+#elif !defined(__GNUC__) || defined(__GXX_RTTI)
+#define ABSL_ANY_DETAIL_HAS_RTTI 1
+#endif // !defined(__GNUC__) || defined(__GXX_RTTI)
+
+namespace absl {
+
+namespace any_internal {
+
+template <typename Type>
+struct TypeTag {
+ constexpr static char dummy_var = 0;
+};
+
+template <typename Type>
+constexpr char TypeTag<Type>::dummy_var;
+
+// FastTypeId<Type>() evaluates at compile/link-time to a unique pointer for the
+// passed in type. These are meant to be good match for keys into maps or
+// straight up comparisons.
+template<typename Type>
+constexpr inline const void* FastTypeId() {
+ return &TypeTag<Type>::dummy_var;
+}
+
+} // namespace any_internal
+
+class any;
+
+// swap()
+//
+// Swaps two `absl::any` values. Equivalent to `x.swap(y) where `x` and `y` are
+// `absl::any` types.
+void swap(any& x, any& y) noexcept;
+
+// make_any()
+//
+// Constructs an `absl::any` of type `T` with the given arguments.
+template <typename T, typename... Args>
+any make_any(Args&&... args);
+
+// Overload of `absl::make_any()` for constructing an `absl::any` type from an
+// initializer list.
+template <typename T, typename U, typename... Args>
+any make_any(std::initializer_list<U> il, Args&&... args);
+
+// any_cast()
+//
+// Statically casts the value of a `const absl::any` type to the given type.
+// This function will throw `absl::bad_any_cast` if the stored value type of the
+// `absl::any` does not match the cast.
+//
+// `any_cast()` can also be used to get a reference to the internal storage iff
+// a reference type is passed as its `ValueType`:
+//
+// Example:
+//
+// absl::any my_any = std::vector<int>();
+// absl::any_cast<std::vector<int>&>(my_any).push_back(42);
+template <typename ValueType>
+ValueType any_cast(const any& operand);
+
+// Overload of `any_cast()` to statically cast the value of a non-const
+// `absl::any` type to the given type. This function will throw
+// `absl::bad_any_cast` if the stored value type of the `absl::any` does not
+// match the cast.
+template <typename ValueType>
+ValueType any_cast(any& operand); // NOLINT(runtime/references)
+
+// Overload of `any_cast()` to statically cast the rvalue of an `absl::any`
+// type. This function will throw `absl::bad_any_cast` if the stored value type
+// of the `absl::any` does not match the cast.
+template <typename ValueType>
+ValueType any_cast(any&& operand);
+
+// Overload of `any_cast()` to statically cast the value of a const pointer
+// `absl::any` type to the given pointer type, or `nullptr` if the stored value
+// type of the `absl::any` does not match the cast.
+template <typename ValueType>
+const ValueType* any_cast(const any* operand) noexcept;
+
+// Overload of `any_cast()` to statically cast the value of a pointer
+// `absl::any` type to the given pointer type, or `nullptr` if the stored value
+// type of the `absl::any` does not match the cast.
+template <typename ValueType>
+ValueType* any_cast(any* operand) noexcept;
+
+// -----------------------------------------------------------------------------
+// absl::any
+// -----------------------------------------------------------------------------
+//
+// An `absl::any` object provides the facility to either store an instance of a
+// type, known as the "contained object", or no value. An `absl::any` is used to
+// store values of types that are unknown at compile time. The `absl::any`
+// object, when containing a value, must contain a value type; storing a
+// reference type is neither desired nor supported.
+//
+// An `absl::any` can only store a type that is copy-constructable; move-only
+// types are not allowed within an `any` object.
+//
+// Example:
+//
+// auto a = absl::any(65); // Literal, copyable
+// auto b = absl::any(std::vector<int>()); // Default-initialized, copyable
+// std::unique_ptr<Foo> my_foo;
+// auto c = absl::any(std::move(my_foo)); // Error, not copy-constructable
+//
+// Note that `absl::any` makes use of decayed types (`absl::decay_t` in this
+// context) to remove const-volatile qualifiers (known as "cv qualifiers"),
+// decay functions to function pointers, etc. We essentially "decay" a given
+// type into its essential type.
+//
+// `absl::any` makes use of decayed types when determining the basic type `T` of
+// the value to store in the any's contained object. In the documentation below,
+// we explicitly denote this by using the phrase "a decayed type of `T`".
+//
+// Example:
+//
+// const int a = 4;
+// absl::any foo(a); // Decay ensures we store an "int", not a "const int&".
+//
+// void my_function() {}
+// absl::any bar(my_function); // Decay ensures we store a function pointer.
+//
+// `absl::any` is a C++11 compatible version of the C++17 `std::any` abstraction
+// and is designed to be a drop-in replacement for code compliant with C++17.
+class any {
+ private:
+ template <typename T>
+ struct IsInPlaceType;
+
+ public:
+ // Constructors
+
+ // Constructs an empty `absl::any` object (`any::has_value()` will return
+ // `false`).
+ constexpr any() noexcept;
+
+ // Copy constructs an `absl::any` object with a "contained object" of the
+ // passed type of `other` (or an empty `absl::any` if `other.has_value()` is
+ // `false`.
+ any(const any& other)
+ : obj_(other.has_value() ? other.obj_->Clone()
+ : std::unique_ptr<ObjInterface>()) {}
+
+ // Move constructs an `absl::any` object with a "contained object" of the
+ // passed type of `other` (or an empty `absl::any` if `other.has_value()` is
+ // `false`).
+ any(any&& other) noexcept = default;
+
+ // Constructs an `absl::any` object with a "contained object" of the decayed
+ // type of `T`, which is initialized via `std::forward<T>(value)`.
+ //
+ // This constructor will not participate in overload resolution if the
+ // decayed type of `T` is not copy-constructible.
+ template <
+ typename T, typename VT = absl::decay_t<T>,
+ absl::enable_if_t<!absl::disjunction<
+ std::is_same<any, VT>, IsInPlaceType<VT>,
+ absl::negation<std::is_copy_constructible<VT> > >::value>* = nullptr>
+ any(T&& value) : obj_(new Obj<VT>(in_place, std::forward<T>(value))) {}
+
+ // Constructs an `absl::any` object with a "contained object" of the decayed
+ // type of `T`, which is initialized via `std::forward<T>(value)`.
+ template <typename T, typename... Args, typename VT = absl::decay_t<T>,
+ absl::enable_if_t<absl::conjunction<
+ std::is_copy_constructible<VT>,
+ std::is_constructible<VT, Args...>>::value>* = nullptr>
+ explicit any(in_place_type_t<T> /*tag*/, Args&&... args)
+ : obj_(new Obj<VT>(in_place, std::forward<Args>(args)...)) {}
+
+ // Constructs an `absl::any` object with a "contained object" of the passed
+ // type `VT` as a decayed type of `T`. `VT` is initialized as if
+ // direct-non-list-initializing an object of type `VT` with the arguments
+ // `initializer_list, std::forward<Args>(args)...`.
+ template <
+ typename T, typename U, typename... Args, typename VT = absl::decay_t<T>,
+ absl::enable_if_t<
+ absl::conjunction<std::is_copy_constructible<VT>,
+ std::is_constructible<VT, std::initializer_list<U>&,
+ Args...>>::value>* = nullptr>
+ explicit any(in_place_type_t<T> /*tag*/, std::initializer_list<U> ilist,
+ Args&&... args)
+ : obj_(new Obj<VT>(in_place, ilist, std::forward<Args>(args)...)) {}
+
+ // Assignment operators
+
+ // Copy assigns an `absl::any` object with a "contained object" of the
+ // passed type.
+ any& operator=(const any& rhs) {
+ any(rhs).swap(*this);
+ return *this;
+ }
+
+ // Move assigns an `absl::any` object with a "contained object" of the
+ // passed type. `rhs` is left in a valid but otherwise unspecified state.
+ any& operator=(any&& rhs) noexcept {
+ any(std::move(rhs)).swap(*this);
+ return *this;
+ }
+
+ // Assigns an `absl::any` object with a "contained object" of the passed type.
+ template <typename T, typename VT = absl::decay_t<T>,
+ absl::enable_if_t<absl::conjunction<
+ absl::negation<std::is_same<VT, any>>,
+ std::is_copy_constructible<VT>>::value>* = nullptr>
+ any& operator=(T&& rhs) {
+ any tmp(in_place_type_t<VT>(), std::forward<T>(rhs));
+ tmp.swap(*this);
+ return *this;
+ }
+
+ // Modifiers
+
+ // any::emplace()
+ //
+ // Emplaces a value within an `absl::any` object by calling `any::reset()`,
+ // initializing the contained value as if direct-non-list-initializing an
+ // object of type `VT` with the arguments `std::forward<Args>(args)...`, and
+ // returning a reference to the new contained value.
+ //
+ // Note: If an exception is thrown during the call to `VT`'s constructor,
+ // `*this` does not contain a value, and any previously contained value has
+ // been destroyed.
+ template <
+ typename T, typename... Args, typename VT = absl::decay_t<T>,
+ absl::enable_if_t<std::is_copy_constructible<VT>::value &&
+ std::is_constructible<VT, Args...>::value>* = nullptr>
+ VT& emplace(Args&&... args) {
+ reset(); // NOTE: reset() is required here even in the world of exceptions.
+ Obj<VT>* const object_ptr =
+ new Obj<VT>(in_place, std::forward<Args>(args)...);
+ obj_ = std::unique_ptr<ObjInterface>(object_ptr);
+ return object_ptr->value;
+ }
+
+ // Overload of `any::emplace()` to emplace a value within an `absl::any`
+ // object by calling `any::reset()`, initializing the contained value as if
+ // direct-non-list-initializing an object of type `VT` with the arguments
+ // `initializer_list, std::forward<Args>(args)...`, and returning a reference
+ // to the new contained value.
+ //
+ // Note: If an exception is thrown during the call to `VT`'s constructor,
+ // `*this` does not contain a value, and any previously contained value has
+ // been destroyed. The function shall not participate in overload resolution
+ // unless `is_copy_constructible_v<VT>` is `true` and
+ // `is_constructible_v<VT, initializer_list<U>&, Args...>` is `true`.
+ template <
+ typename T, typename U, typename... Args, typename VT = absl::decay_t<T>,
+ absl::enable_if_t<std::is_copy_constructible<VT>::value &&
+ std::is_constructible<VT, std::initializer_list<U>&,
+ Args...>::value>* = nullptr>
+ VT& emplace(std::initializer_list<U> ilist, Args&&... args) {
+ reset(); // NOTE: reset() is required here even in the world of exceptions.
+ Obj<VT>* const object_ptr =
+ new Obj<VT>(in_place, ilist, std::forward<Args>(args)...);
+ obj_ = std::unique_ptr<ObjInterface>(object_ptr);
+ return object_ptr->value;
+ }
+
+ // any::reset()
+ //
+ // Resets the state of the `absl::any` object, destroying the contained object
+ // if present.
+ void reset() noexcept { obj_ = nullptr; }
+
+ // any::swap()
+ //
+ // Swaps the passed value and the value of this `absl::any` object.
+ void swap(any& other) noexcept { obj_.swap(other.obj_); }
+
+ // Observers
+
+ // any::has_value()
+ //
+ // Returns `true` if the `any` object has a contained value, otherwise
+ // returns `false`.
+ bool has_value() const noexcept { return obj_ != nullptr; }
+
+#if ABSL_ANY_DETAIL_HAS_RTTI
+ // Returns: typeid(T) if *this has a contained object of type T, otherwise
+ // typeid(void).
+ const std::type_info& type() const noexcept {
+ if (has_value()) {
+ return obj_->Type();
+ }
+
+ return typeid(void);
+ }
+#endif // ABSL_ANY_DETAIL_HAS_RTTI
+
+ private:
+ // Tagged type-erased abstraction for holding a cloneable object.
+ class ObjInterface {
+ public:
+ virtual ~ObjInterface() = default;
+ virtual std::unique_ptr<ObjInterface> Clone() const = 0;
+ virtual const void* ObjTypeId() const noexcept = 0;
+#if ABSL_ANY_DETAIL_HAS_RTTI
+ virtual const std::type_info& Type() const noexcept = 0;
+#endif // ABSL_ANY_DETAIL_HAS_RTTI
+ };
+
+ // Hold a value of some queryable type, with an ability to Clone it.
+ template <typename T>
+ class Obj : public ObjInterface {
+ public:
+ template <typename... Args>
+ explicit Obj(in_place_t /*tag*/, Args&&... args)
+ : value(std::forward<Args>(args)...) {}
+
+ std::unique_ptr<ObjInterface> Clone() const final {
+ return std::unique_ptr<ObjInterface>(new Obj(in_place, value));
+ }
+
+ const void* ObjTypeId() const noexcept final { return IdForType<T>(); }
+
+#if ABSL_ANY_DETAIL_HAS_RTTI
+ const std::type_info& Type() const noexcept final { return typeid(T); }
+#endif // ABSL_ANY_DETAIL_HAS_RTTI
+
+ T value;
+ };
+
+ std::unique_ptr<ObjInterface> CloneObj() const {
+ if (!obj_) return nullptr;
+ return obj_->Clone();
+ }
+
+ template <typename T>
+ constexpr static const void* IdForType() {
+ // Note: This type dance is to make the behavior consistent with typeid.
+ using NormalizedType =
+ typename std::remove_cv<typename std::remove_reference<T>::type>::type;
+
+ return any_internal::FastTypeId<NormalizedType>();
+ }
+
+ const void* GetObjTypeId() const {
+ return obj_ ? obj_->ObjTypeId() : any_internal::FastTypeId<void>();
+ }
+
+ // `absl::any` nonmember functions //
+
+ // Description at the declaration site (top of file).
+ template <typename ValueType>
+ friend ValueType any_cast(const any& operand);
+
+ // Description at the declaration site (top of file).
+ template <typename ValueType>
+ friend ValueType any_cast(any& operand); // NOLINT(runtime/references)
+
+ // Description at the declaration site (top of file).
+ template <typename T>
+ friend const T* any_cast(const any* operand) noexcept;
+
+ // Description at the declaration site (top of file).
+ template <typename T>
+ friend T* any_cast(any* operand) noexcept;
+
+ std::unique_ptr<ObjInterface> obj_;
+};
+
+// -----------------------------------------------------------------------------
+// Implementation Details
+// -----------------------------------------------------------------------------
+
+constexpr any::any() noexcept = default;
+
+template <typename T>
+struct any::IsInPlaceType : std::false_type {};
+
+template <typename T>
+struct any::IsInPlaceType<in_place_type_t<T>> : std::true_type {};
+
+inline void swap(any& x, any& y) noexcept { x.swap(y); }
+
+// Description at the declaration site (top of file).
+template <typename T, typename... Args>
+any make_any(Args&&... args) {
+ return any(in_place_type_t<T>(), std::forward<Args>(args)...);
+}
+
+// Description at the declaration site (top of file).
+template <typename T, typename U, typename... Args>
+any make_any(std::initializer_list<U> il, Args&&... args) {
+ return any(in_place_type_t<T>(), il, std::forward<Args>(args)...);
+}
+
+// Description at the declaration site (top of file).
+template <typename ValueType>
+ValueType any_cast(const any& operand) {
+ using U = typename std::remove_cv<
+ typename std::remove_reference<ValueType>::type>::type;
+ static_assert(std::is_constructible<ValueType, const U&>::value,
+ "Invalid ValueType");
+ auto* const result = (any_cast<U>)(&operand);
+ if (result == nullptr) {
+ any_internal::ThrowBadAnyCast();
+ }
+ return static_cast<ValueType>(*result);
+}
+
+// Description at the declaration site (top of file).
+template <typename ValueType>
+ValueType any_cast(any& operand) { // NOLINT(runtime/references)
+ using U = typename std::remove_cv<
+ typename std::remove_reference<ValueType>::type>::type;
+ static_assert(std::is_constructible<ValueType, U&>::value,
+ "Invalid ValueType");
+ auto* result = (any_cast<U>)(&operand);
+ if (result == nullptr) {
+ any_internal::ThrowBadAnyCast();
+ }
+ return static_cast<ValueType>(*result);
+}
+
+// Description at the declaration site (top of file).
+template <typename ValueType>
+ValueType any_cast(any&& operand) {
+ using U = typename std::remove_cv<
+ typename std::remove_reference<ValueType>::type>::type;
+ static_assert(std::is_constructible<ValueType, U>::value,
+ "Invalid ValueType");
+ return static_cast<ValueType>(std::move((any_cast<U&>)(operand)));
+}
+
+// Description at the declaration site (top of file).
+template <typename T>
+const T* any_cast(const any* operand) noexcept {
+ return operand && operand->GetObjTypeId() == any::IdForType<T>()
+ ? std::addressof(
+ static_cast<const any::Obj<T>*>(operand->obj_.get())->value)
+ : nullptr;
+}
+
+// Description at the declaration site (top of file).
+template <typename T>
+T* any_cast(any* operand) noexcept {
+ return operand && operand->GetObjTypeId() == any::IdForType<T>()
+ ? std::addressof(
+ static_cast<any::Obj<T>*>(operand->obj_.get())->value)
+ : nullptr;
+}
+
+} // namespace absl
+
+#undef ABSL_ANY_DETAIL_HAS_RTTI
+
+#endif // ABSL_HAVE_STD_ANY
+
+#endif // ABSL_TYPES_ANY_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/any_exception_safety_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/any_exception_safety_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/types/any_exception_safety_test.cc
new file mode 100644
index 0000000..7a72e72
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/any_exception_safety_test.cc
@@ -0,0 +1,166 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/types/any.h"
+
+#include <typeinfo>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/exception_safety_testing.h"
+
+using Thrower = absl::ThrowingValue<>;
+using NoThrowMoveThrower =
+ absl::ThrowingValue<absl::NoThrow::kMoveCtor | absl::NoThrow::kMoveAssign>;
+using ThrowerList = std::initializer_list<Thrower>;
+using ThrowerVec = std::vector<Thrower>;
+using ThrowingAlloc = absl::ThrowingAllocator<Thrower>;
+using ThrowingThrowerVec = std::vector<Thrower, ThrowingAlloc>;
+
+namespace {
+
+testing::AssertionResult AnyInvariants(absl::any* a) {
+ using testing::AssertionFailure;
+ using testing::AssertionSuccess;
+
+ if (a->has_value()) {
+ if (a->type() == typeid(void)) {
+ return AssertionFailure()
+ << "A non-empty any should not have type `void`";
+ }
+ } else {
+ if (a->type() != typeid(void)) {
+ return AssertionFailure()
+ << "An empty any should have type void, but has type "
+ << a->type().name();
+ }
+ }
+
+ // Make sure that reset() changes any to a valid state.
+ a->reset();
+ if (a->has_value()) {
+ return AssertionFailure() << "A reset `any` should be valueless";
+ }
+ if (a->type() != typeid(void)) {
+ return AssertionFailure() << "A reset `any` should have type() of `void`, "
+ "but instead has type "
+ << a->type().name();
+ }
+ try {
+ auto unused = absl::any_cast<Thrower>(*a);
+ static_cast<void>(unused);
+ return AssertionFailure()
+ << "A reset `any` should not be able to be any_cast";
+ } catch (absl::bad_any_cast) {
+ } catch (...) {
+ return AssertionFailure()
+ << "Unexpected exception thrown from absl::any_cast";
+ }
+ return AssertionSuccess();
+}
+
+testing::AssertionResult AnyIsEmpty(absl::any* a) {
+ if (!a->has_value()) {
+ return testing::AssertionSuccess();
+ }
+ return testing::AssertionFailure()
+ << "a should be empty, but instead has value "
+ << absl::any_cast<Thrower>(*a).Get();
+}
+
+TEST(AnyExceptionSafety, Ctors) {
+ Thrower val(1);
+ absl::TestThrowingCtor<absl::any>(val);
+
+ Thrower copy(val);
+ absl::TestThrowingCtor<absl::any>(copy);
+
+ absl::TestThrowingCtor<absl::any>(absl::in_place_type_t<Thrower>(), 1);
+
+ absl::TestThrowingCtor<absl::any>(absl::in_place_type_t<ThrowerVec>(),
+ ThrowerList{val});
+
+ absl::TestThrowingCtor<absl::any, absl::in_place_type_t<ThrowingThrowerVec>,
+ ThrowerList, ThrowingAlloc>(
+ absl::in_place_type_t<ThrowingThrowerVec>(), {val}, ThrowingAlloc());
+}
+
+TEST(AnyExceptionSafety, Assignment) {
+ auto original =
+ absl::any(absl::in_place_type_t<Thrower>(), 1, absl::no_throw_ctor);
+ auto any_is_strong = [original](absl::any* ap) {
+ return testing::AssertionResult(ap->has_value() &&
+ absl::any_cast<Thrower>(original) ==
+ absl::any_cast<Thrower>(*ap));
+ };
+ auto any_strong_tester = absl::MakeExceptionSafetyTester()
+ .WithInitialValue(original)
+ .WithInvariants(AnyInvariants, any_is_strong);
+
+ Thrower val(2);
+ absl::any any_val(val);
+ NoThrowMoveThrower mv_val(2);
+
+ auto assign_any = [&any_val](absl::any* ap) { *ap = any_val; };
+ auto assign_val = [&val](absl::any* ap) { *ap = val; };
+ auto move = [&val](absl::any* ap) { *ap = std::move(val); };
+ auto move_movable = [&mv_val](absl::any* ap) { *ap = std::move(mv_val); };
+
+ EXPECT_TRUE(any_strong_tester.Test(assign_any));
+ EXPECT_TRUE(any_strong_tester.Test(assign_val));
+ EXPECT_TRUE(any_strong_tester.Test(move));
+ EXPECT_TRUE(any_strong_tester.Test(move_movable));
+
+ auto empty_any_is_strong = [](absl::any* ap) {
+ return testing::AssertionResult{!ap->has_value()};
+ };
+ auto strong_empty_any_tester =
+ absl::MakeExceptionSafetyTester()
+ .WithInitialValue(absl::any{})
+ .WithInvariants(AnyInvariants, empty_any_is_strong);
+
+ EXPECT_TRUE(strong_empty_any_tester.Test(assign_any));
+ EXPECT_TRUE(strong_empty_any_tester.Test(assign_val));
+ EXPECT_TRUE(strong_empty_any_tester.Test(move));
+}
+// libstdc++ std::any fails this test
+#if !defined(ABSL_HAVE_STD_ANY)
+TEST(AnyExceptionSafety, Emplace) {
+ auto initial_val =
+ absl::any{absl::in_place_type_t<Thrower>(), 1, absl::no_throw_ctor};
+ auto one_tester = absl::MakeExceptionSafetyTester()
+ .WithInitialValue(initial_val)
+ .WithInvariants(AnyInvariants, AnyIsEmpty);
+
+ auto emp_thrower = [](absl::any* ap) { ap->emplace<Thrower>(2); };
+ auto emp_throwervec = [](absl::any* ap) {
+ std::initializer_list<Thrower> il{Thrower(2, absl::no_throw_ctor)};
+ ap->emplace<ThrowerVec>(il);
+ };
+ auto emp_movethrower = [](absl::any* ap) {
+ ap->emplace<NoThrowMoveThrower>(2);
+ };
+
+ EXPECT_TRUE(one_tester.Test(emp_thrower));
+ EXPECT_TRUE(one_tester.Test(emp_throwervec));
+ EXPECT_TRUE(one_tester.Test(emp_movethrower));
+
+ auto empty_tester = one_tester.WithInitialValue(absl::any{});
+
+ EXPECT_TRUE(empty_tester.Test(emp_thrower));
+ EXPECT_TRUE(empty_tester.Test(emp_throwervec));
+}
+#endif // ABSL_HAVE_STD_ANY
+
+} // namespace
[15/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_info.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_info.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_info.cc
new file mode 100644
index 0000000..20bba28
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_info.cc
@@ -0,0 +1,956 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file implements the TimeZoneIf interface using the "zoneinfo"
+// data provided by the IANA Time Zone Database (i.e., the only real game
+// in town).
+//
+// TimeZoneInfo represents the history of UTC-offset changes within a time
+// zone. Most changes are due to daylight-saving rules, but occasionally
+// shifts are made to the time-zone's base offset. The database only attempts
+// to be definitive for times since 1970, so be wary of local-time conversions
+// before that. Also, rule and zone-boundary changes are made at the whim
+// of governments, so the conversion of future times needs to be taken with
+// a grain of salt.
+//
+// For more information see tzfile(5), http://www.iana.org/time-zones, or
+// http://en.wikipedia.org/wiki/Zoneinfo.
+//
+// Note that we assume the proleptic Gregorian calendar and 60-second
+// minutes throughout.
+
+#include "time_zone_info.h"
+
+#include <algorithm>
+#include <cassert>
+#include <chrono>
+#include <cstdint>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+#include <functional>
+#include <iostream>
+#include <memory>
+#include <sstream>
+#include <string>
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "time_zone_fixed.h"
+#include "time_zone_posix.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+namespace {
+
+inline bool IsLeap(year_t year) {
+ return (year % 4) == 0 && ((year % 100) != 0 || (year % 400) == 0);
+}
+
+// The number of days in non-leap and leap years respectively.
+const std::int_least32_t kDaysPerYear[2] = {365, 366};
+
+// The day offsets of the beginning of each (1-based) month in non-leap and
+// leap years respectively (e.g., 335 days before December in a leap year).
+const std::int_least16_t kMonthOffsets[2][1 + 12 + 1] = {
+ {-1, 0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
+ {-1, 0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366},
+};
+
+// We reject leap-second encoded zoneinfo and so assume 60-second minutes.
+const std::int_least32_t kSecsPerDay = 24 * 60 * 60;
+
+// 400-year chunks always have 146097 days (20871 weeks).
+const std::int_least64_t kSecsPer400Years = 146097LL * kSecsPerDay;
+
+// Like kDaysPerYear[] but scaled up by a factor of kSecsPerDay.
+const std::int_least32_t kSecsPerYear[2] = {
+ 365 * kSecsPerDay,
+ 366 * kSecsPerDay,
+};
+
+// Single-byte, unsigned numeric values are encoded directly.
+inline std::uint_fast8_t Decode8(const char* cp) {
+ return static_cast<std::uint_fast8_t>(*cp) & 0xff;
+}
+
+// Multi-byte, numeric values are encoded using a MSB first,
+// twos-complement representation. These helpers decode, from
+// the given address, 4-byte and 8-byte values respectively.
+// Note: If int_fastXX_t == intXX_t and this machine is not
+// twos complement, then there will be at least one input value
+// we cannot represent.
+std::int_fast32_t Decode32(const char* cp) {
+ std::uint_fast32_t v = 0;
+ for (int i = 0; i != (32 / 8); ++i) v = (v << 8) | Decode8(cp++);
+ const std::int_fast32_t s32max = 0x7fffffff;
+ const auto s32maxU = static_cast<std::uint_fast32_t>(s32max);
+ if (v <= s32maxU) return static_cast<std::int_fast32_t>(v);
+ return static_cast<std::int_fast32_t>(v - s32maxU - 1) - s32max - 1;
+}
+
+std::int_fast64_t Decode64(const char* cp) {
+ std::uint_fast64_t v = 0;
+ for (int i = 0; i != (64 / 8); ++i) v = (v << 8) | Decode8(cp++);
+ const std::int_fast64_t s64max = 0x7fffffffffffffff;
+ const auto s64maxU = static_cast<std::uint_fast64_t>(s64max);
+ if (v <= s64maxU) return static_cast<std::int_fast64_t>(v);
+ return static_cast<std::int_fast64_t>(v - s64maxU - 1) - s64max - 1;
+}
+
+// Generate a year-relative offset for a PosixTransition.
+std::int_fast64_t TransOffset(bool leap_year, int jan1_weekday,
+ const PosixTransition& pt) {
+ std::int_fast64_t days = 0;
+ switch (pt.date.fmt) {
+ case PosixTransition::J: {
+ days = pt.date.j.day;
+ if (!leap_year || days < kMonthOffsets[1][3]) days -= 1;
+ break;
+ }
+ case PosixTransition::N: {
+ days = pt.date.n.day;
+ break;
+ }
+ case PosixTransition::M: {
+ const bool last_week = (pt.date.m.week == 5);
+ days = kMonthOffsets[leap_year][pt.date.m.month + last_week];
+ const std::int_fast64_t weekday = (jan1_weekday + days) % 7;
+ if (last_week) {
+ days -= (weekday + 7 - 1 - pt.date.m.weekday) % 7 + 1;
+ } else {
+ days += (pt.date.m.weekday + 7 - weekday) % 7;
+ days += (pt.date.m.week - 1) * 7;
+ }
+ break;
+ }
+ }
+ return (days * kSecsPerDay) + pt.time.offset;
+}
+
+inline time_zone::civil_lookup MakeUnique(const time_point<sys_seconds>& tp) {
+ time_zone::civil_lookup cl;
+ cl.kind = time_zone::civil_lookup::UNIQUE;
+ cl.pre = cl.trans = cl.post = tp;
+ return cl;
+}
+
+inline time_zone::civil_lookup MakeUnique(std::int_fast64_t unix_time) {
+ return MakeUnique(FromUnixSeconds(unix_time));
+}
+
+inline time_zone::civil_lookup MakeSkipped(const Transition& tr,
+ const civil_second& cs) {
+ time_zone::civil_lookup cl;
+ cl.kind = time_zone::civil_lookup::SKIPPED;
+ cl.pre = FromUnixSeconds(tr.unix_time - 1 + (cs - tr.prev_civil_sec));
+ cl.trans = FromUnixSeconds(tr.unix_time);
+ cl.post = FromUnixSeconds(tr.unix_time - (tr.civil_sec - cs));
+ return cl;
+}
+
+inline time_zone::civil_lookup MakeRepeated(const Transition& tr,
+ const civil_second& cs) {
+ time_zone::civil_lookup cl;
+ cl.kind = time_zone::civil_lookup::REPEATED;
+ cl.pre = FromUnixSeconds(tr.unix_time - 1 - (tr.prev_civil_sec - cs));
+ cl.trans = FromUnixSeconds(tr.unix_time);
+ cl.post = FromUnixSeconds(tr.unix_time + (cs - tr.civil_sec));
+ return cl;
+}
+
+inline civil_second YearShift(const civil_second& cs, year_t shift) {
+ return civil_second(cs.year() + shift, cs.month(), cs.day(),
+ cs.hour(), cs.minute(), cs.second());
+}
+
+} // namespace
+
+// What (no leap-seconds) UTC+seconds zoneinfo would look like.
+bool TimeZoneInfo::ResetToBuiltinUTC(const sys_seconds& offset) {
+ transition_types_.resize(1);
+ TransitionType& tt(transition_types_.back());
+ tt.utc_offset = static_cast<std::int_least32_t>(offset.count());
+ tt.is_dst = false;
+ tt.abbr_index = 0;
+
+ // We temporarily add some redundant, contemporary (2012 through 2021)
+ // transitions for performance reasons. See TimeZoneInfo::LocalTime().
+ // TODO: Fix the performance issue and remove the extra transitions.
+ transitions_.clear();
+ transitions_.reserve(12);
+ for (const std::int_fast64_t unix_time : {
+ -(1LL << 59), // BIG_BANG
+ 1325376000LL, // 2012-01-01T00:00:00+00:00
+ 1356998400LL, // 2013-01-01T00:00:00+00:00
+ 1388534400LL, // 2014-01-01T00:00:00+00:00
+ 1420070400LL, // 2015-01-01T00:00:00+00:00
+ 1451606400LL, // 2016-01-01T00:00:00+00:00
+ 1483228800LL, // 2017-01-01T00:00:00+00:00
+ 1514764800LL, // 2018-01-01T00:00:00+00:00
+ 1546300800LL, // 2019-01-01T00:00:00+00:00
+ 1577836800LL, // 2020-01-01T00:00:00+00:00
+ 1609459200LL, // 2021-01-01T00:00:00+00:00
+ 2147483647LL, // 2^31 - 1
+ }) {
+ Transition& tr(*transitions_.emplace(transitions_.end()));
+ tr.unix_time = unix_time;
+ tr.type_index = 0;
+ tr.civil_sec = LocalTime(tr.unix_time, tt).cs;
+ tr.prev_civil_sec = tr.civil_sec - 1;
+ }
+
+ default_transition_type_ = 0;
+ abbreviations_ = FixedOffsetToAbbr(offset);
+ abbreviations_.append(1, '\0'); // add NUL
+ future_spec_.clear(); // never needed for a fixed-offset zone
+ extended_ = false;
+
+ tt.civil_max = LocalTime(sys_seconds::max().count(), tt).cs;
+ tt.civil_min = LocalTime(sys_seconds::min().count(), tt).cs;
+
+ transitions_.shrink_to_fit();
+ return true;
+}
+
+// Builds the in-memory header using the raw bytes from the file.
+bool TimeZoneInfo::Header::Build(const tzhead& tzh) {
+ std::int_fast32_t v;
+ if ((v = Decode32(tzh.tzh_timecnt)) < 0) return false;
+ timecnt = static_cast<std::size_t>(v);
+ if ((v = Decode32(tzh.tzh_typecnt)) < 0) return false;
+ typecnt = static_cast<std::size_t>(v);
+ if ((v = Decode32(tzh.tzh_charcnt)) < 0) return false;
+ charcnt = static_cast<std::size_t>(v);
+ if ((v = Decode32(tzh.tzh_leapcnt)) < 0) return false;
+ leapcnt = static_cast<std::size_t>(v);
+ if ((v = Decode32(tzh.tzh_ttisstdcnt)) < 0) return false;
+ ttisstdcnt = static_cast<std::size_t>(v);
+ if ((v = Decode32(tzh.tzh_ttisgmtcnt)) < 0) return false;
+ ttisgmtcnt = static_cast<std::size_t>(v);
+ return true;
+}
+
+// How many bytes of data are associated with this header. The result
+// depends upon whether this is a section with 4-byte or 8-byte times.
+std::size_t TimeZoneInfo::Header::DataLength(std::size_t time_len) const {
+ std::size_t len = 0;
+ len += (time_len + 1) * timecnt; // unix_time + type_index
+ len += (4 + 1 + 1) * typecnt; // utc_offset + is_dst + abbr_index
+ len += 1 * charcnt; // abbreviations
+ len += (time_len + 4) * leapcnt; // leap-time + TAI-UTC
+ len += 1 * ttisstdcnt; // UTC/local indicators
+ len += 1 * ttisgmtcnt; // standard/wall indicators
+ return len;
+}
+
+// Check that the TransitionType has the expected offset/is_dst/abbreviation.
+void TimeZoneInfo::CheckTransition(const std::string& name,
+ const TransitionType& tt,
+ std::int_fast32_t offset, bool is_dst,
+ const std::string& abbr) const {
+ if (tt.utc_offset != offset || tt.is_dst != is_dst ||
+ &abbreviations_[tt.abbr_index] != abbr) {
+ std::clog << name << ": Transition"
+ << " offset=" << tt.utc_offset << "/"
+ << (tt.is_dst ? "DST" : "STD")
+ << "/abbr=" << &abbreviations_[tt.abbr_index]
+ << " does not match POSIX spec '" << future_spec_ << "'\n";
+ }
+}
+
+// zic(8) can generate no-op transitions when a zone changes rules at an
+// instant when there is actually no discontinuity. So we check whether
+// two transitions have equivalent types (same offset/is_dst/abbr).
+bool TimeZoneInfo::EquivTransitions(std::uint_fast8_t tt1_index,
+ std::uint_fast8_t tt2_index) const {
+ if (tt1_index == tt2_index) return true;
+ const TransitionType& tt1(transition_types_[tt1_index]);
+ const TransitionType& tt2(transition_types_[tt2_index]);
+ if (tt1.is_dst != tt2.is_dst) return false;
+ if (tt1.utc_offset != tt2.utc_offset) return false;
+ if (tt1.abbr_index != tt2.abbr_index) return false;
+ return true;
+}
+
+// Use the POSIX-TZ-environment-variable-style std::string to handle times
+// in years after the last transition stored in the zoneinfo data.
+void TimeZoneInfo::ExtendTransitions(const std::string& name,
+ const Header& hdr) {
+ extended_ = false;
+ bool extending = !future_spec_.empty();
+
+ PosixTimeZone posix;
+ if (extending && !ParsePosixSpec(future_spec_, &posix)) {
+ std::clog << name << ": Failed to parse '" << future_spec_ << "'\n";
+ extending = false;
+ }
+
+ if (extending && posix.dst_abbr.empty()) { // std only
+ // The future specification should match the last/default transition,
+ // and that means that handling the future will fall out naturally.
+ std::uint_fast8_t index = default_transition_type_;
+ if (hdr.timecnt != 0) index = transitions_[hdr.timecnt - 1].type_index;
+ const TransitionType& tt(transition_types_[index]);
+ CheckTransition(name, tt, posix.std_offset, false, posix.std_abbr);
+ extending = false;
+ }
+
+ if (extending && hdr.timecnt < 2) {
+ std::clog << name << ": Too few transitions for POSIX spec\n";
+ extending = false;
+ }
+
+ if (!extending) {
+ // Ensure that there is always a transition in the second half of the
+ // time line (the BIG_BANG transition is in the first half) so that the
+ // signed difference between a civil_second and the civil_second of its
+ // previous transition is always representable, without overflow.
+ const Transition& last(transitions_.back());
+ if (last.unix_time < 0) {
+ const std::uint_fast8_t type_index = last.type_index;
+ Transition& tr(*transitions_.emplace(transitions_.end()));
+ tr.unix_time = 2147483647; // 2038-01-19T03:14:07+00:00
+ tr.type_index = type_index;
+ }
+ return; // last transition wins
+ }
+
+ // Extend the transitions for an additional 400 years using the
+ // future specification. Years beyond those can be handled by
+ // mapping back to a cycle-equivalent year within that range.
+ // zic(8) should probably do this so that we don't have to.
+ // TODO: Reduce the extension by the number of compatible
+ // transitions already in place.
+ transitions_.reserve(hdr.timecnt + 400 * 2 + 1);
+ transitions_.resize(hdr.timecnt + 400 * 2);
+ extended_ = true;
+
+ // The future specification should match the last two transitions,
+ // and those transitions should have different is_dst flags. Note
+ // that nothing says the UTC offset used by the is_dst transition
+ // must be greater than that used by the !is_dst transition. (See
+ // Europe/Dublin, for example.)
+ const Transition* tr0 = &transitions_[hdr.timecnt - 1];
+ const Transition* tr1 = &transitions_[hdr.timecnt - 2];
+ const TransitionType* tt0 = &transition_types_[tr0->type_index];
+ const TransitionType* tt1 = &transition_types_[tr1->type_index];
+ const TransitionType& dst(tt0->is_dst ? *tt0 : *tt1);
+ const TransitionType& std(tt0->is_dst ? *tt1 : *tt0);
+ CheckTransition(name, dst, posix.dst_offset, true, posix.dst_abbr);
+ CheckTransition(name, std, posix.std_offset, false, posix.std_abbr);
+
+ // Add the transitions to tr1 and back to tr0 for each extra year.
+ last_year_ = LocalTime(tr0->unix_time, *tt0).cs.year();
+ bool leap_year = IsLeap(last_year_);
+ const civil_day jan1(last_year_, 1, 1);
+ std::int_fast64_t jan1_time = civil_second(jan1) - civil_second();
+ int jan1_weekday = (static_cast<int>(get_weekday(jan1)) + 1) % 7;
+ Transition* tr = &transitions_[hdr.timecnt]; // next trans to fill
+ if (LocalTime(tr1->unix_time, *tt1).cs.year() != last_year_) {
+ // Add a single extra transition to align to a calendar year.
+ transitions_.resize(transitions_.size() + 1);
+ assert(tr == &transitions_[hdr.timecnt]); // no reallocation
+ const PosixTransition& pt1(tt0->is_dst ? posix.dst_end : posix.dst_start);
+ std::int_fast64_t tr1_offset = TransOffset(leap_year, jan1_weekday, pt1);
+ tr->unix_time = jan1_time + tr1_offset - tt0->utc_offset;
+ tr++->type_index = tr1->type_index;
+ tr0 = &transitions_[hdr.timecnt];
+ tr1 = &transitions_[hdr.timecnt - 1];
+ tt0 = &transition_types_[tr0->type_index];
+ tt1 = &transition_types_[tr1->type_index];
+ }
+ const PosixTransition& pt1(tt0->is_dst ? posix.dst_end : posix.dst_start);
+ const PosixTransition& pt0(tt0->is_dst ? posix.dst_start : posix.dst_end);
+ for (const year_t limit = last_year_ + 400; last_year_ < limit;) {
+ last_year_ += 1; // an additional year of generated transitions
+ jan1_time += kSecsPerYear[leap_year];
+ jan1_weekday = (jan1_weekday + kDaysPerYear[leap_year]) % 7;
+ leap_year = !leap_year && IsLeap(last_year_);
+ std::int_fast64_t tr1_offset = TransOffset(leap_year, jan1_weekday, pt1);
+ tr->unix_time = jan1_time + tr1_offset - tt0->utc_offset;
+ tr++->type_index = tr1->type_index;
+ std::int_fast64_t tr0_offset = TransOffset(leap_year, jan1_weekday, pt0);
+ tr->unix_time = jan1_time + tr0_offset - tt1->utc_offset;
+ tr++->type_index = tr0->type_index;
+ }
+ assert(tr == &transitions_[0] + transitions_.size());
+}
+
+bool TimeZoneInfo::Load(const std::string& name, ZoneInfoSource* zip) {
+ // Read and validate the header.
+ tzhead tzh;
+ if (zip->Read(&tzh, sizeof(tzh)) != sizeof(tzh))
+ return false;
+ if (strncmp(tzh.tzh_magic, TZ_MAGIC, sizeof(tzh.tzh_magic)) != 0)
+ return false;
+ Header hdr;
+ if (!hdr.Build(tzh))
+ return false;
+ std::size_t time_len = 4;
+ if (tzh.tzh_version[0] != '\0') {
+ // Skip the 4-byte data.
+ if (zip->Skip(hdr.DataLength(time_len)) != 0)
+ return false;
+ // Read and validate the header for the 8-byte data.
+ if (zip->Read(&tzh, sizeof(tzh)) != sizeof(tzh))
+ return false;
+ if (strncmp(tzh.tzh_magic, TZ_MAGIC, sizeof(tzh.tzh_magic)) != 0)
+ return false;
+ if (tzh.tzh_version[0] == '\0')
+ return false;
+ if (!hdr.Build(tzh))
+ return false;
+ time_len = 8;
+ }
+ if (hdr.typecnt == 0)
+ return false;
+ if (hdr.leapcnt != 0) {
+ // This code assumes 60-second minutes so we do not want
+ // the leap-second encoded zoneinfo. We could reverse the
+ // compensation, but the "right" encoding is rarely used
+ // so currently we simply reject such data.
+ return false;
+ }
+ if (hdr.ttisstdcnt != 0 && hdr.ttisstdcnt != hdr.typecnt)
+ return false;
+ if (hdr.ttisgmtcnt != 0 && hdr.ttisgmtcnt != hdr.typecnt)
+ return false;
+
+ // Read the data into a local buffer.
+ std::size_t len = hdr.DataLength(time_len);
+ std::vector<char> tbuf(len);
+ if (zip->Read(tbuf.data(), len) != len)
+ return false;
+ const char* bp = tbuf.data();
+
+ // Decode and validate the transitions.
+ transitions_.reserve(hdr.timecnt + 2); // We might add a couple.
+ transitions_.resize(hdr.timecnt);
+ for (std::size_t i = 0; i != hdr.timecnt; ++i) {
+ transitions_[i].unix_time = (time_len == 4) ? Decode32(bp) : Decode64(bp);
+ bp += time_len;
+ if (i != 0) {
+ // Check that the transitions are ordered by time (as zic guarantees).
+ if (!Transition::ByUnixTime()(transitions_[i - 1], transitions_[i]))
+ return false; // out of order
+ }
+ }
+ bool seen_type_0 = false;
+ for (std::size_t i = 0; i != hdr.timecnt; ++i) {
+ transitions_[i].type_index = Decode8(bp++);
+ if (transitions_[i].type_index >= hdr.typecnt)
+ return false;
+ if (transitions_[i].type_index == 0)
+ seen_type_0 = true;
+ }
+
+ // Decode and validate the transition types.
+ transition_types_.resize(hdr.typecnt);
+ for (std::size_t i = 0; i != hdr.typecnt; ++i) {
+ transition_types_[i].utc_offset =
+ static_cast<std::int_least32_t>(Decode32(bp));
+ if (transition_types_[i].utc_offset >= kSecsPerDay ||
+ transition_types_[i].utc_offset <= -kSecsPerDay)
+ return false;
+ bp += 4;
+ transition_types_[i].is_dst = (Decode8(bp++) != 0);
+ transition_types_[i].abbr_index = Decode8(bp++);
+ if (transition_types_[i].abbr_index >= hdr.charcnt)
+ return false;
+ }
+
+ // Determine the before-first-transition type.
+ default_transition_type_ = 0;
+ if (seen_type_0 && hdr.timecnt != 0) {
+ std::uint_fast8_t index = 0;
+ if (transition_types_[0].is_dst) {
+ index = transitions_[0].type_index;
+ while (index != 0 && transition_types_[index].is_dst)
+ --index;
+ }
+ while (index != hdr.typecnt && transition_types_[index].is_dst)
+ ++index;
+ if (index != hdr.typecnt)
+ default_transition_type_ = index;
+ }
+
+ // Copy all the abbreviations.
+ abbreviations_.assign(bp, hdr.charcnt);
+ bp += hdr.charcnt;
+
+ // Skip the unused portions. We've already dispensed with leap-second
+ // encoded zoneinfo. The ttisstd/ttisgmt indicators only apply when
+ // interpreting a POSIX spec that does not include start/end rules, and
+ // that isn't the case here (see "zic -p").
+ bp += (8 + 4) * hdr.leapcnt; // leap-time + TAI-UTC
+ bp += 1 * hdr.ttisstdcnt; // UTC/local indicators
+ bp += 1 * hdr.ttisgmtcnt; // standard/wall indicators
+ assert(bp == tbuf.data() + tbuf.size());
+
+ future_spec_.clear();
+ if (tzh.tzh_version[0] != '\0') {
+ // Snarf up the NL-enclosed future POSIX spec. Note
+ // that version '3' files utilize an extended format.
+ auto get_char = [](ZoneInfoSource* zip) -> int {
+ unsigned char ch; // all non-EOF results are positive
+ return (zip->Read(&ch, 1) == 1) ? ch : EOF;
+ };
+ if (get_char(zip) != '\n')
+ return false;
+ for (int c = get_char(zip); c != '\n'; c = get_char(zip)) {
+ if (c == EOF)
+ return false;
+ future_spec_.push_back(static_cast<char>(c));
+ }
+ }
+
+ // We don't check for EOF so that we're forwards compatible.
+
+ // Trim redundant transitions. zic may have added these to work around
+ // differences between the glibc and reference implementations (see
+ // zic.c:dontmerge) and the Qt library (see zic.c:WORK_AROUND_QTBUG_53071).
+ // For us, they just get in the way when we do future_spec_ extension.
+ while (hdr.timecnt > 1) {
+ if (!EquivTransitions(transitions_[hdr.timecnt - 1].type_index,
+ transitions_[hdr.timecnt - 2].type_index)) {
+ break;
+ }
+ hdr.timecnt -= 1;
+ }
+ transitions_.resize(hdr.timecnt);
+
+ // Ensure that there is always a transition in the first half of the
+ // time line (the second half is handled in ExtendTransitions()) so that
+ // the signed difference between a civil_second and the civil_second of
+ // its previous transition is always representable, without overflow.
+ // A contemporary zic will usually have already done this for us.
+ if (transitions_.empty() || transitions_.front().unix_time >= 0) {
+ Transition& tr(*transitions_.emplace(transitions_.begin()));
+ tr.unix_time = -(1LL << 59); // see tz/zic.c "BIG_BANG"
+ tr.type_index = default_transition_type_;
+ hdr.timecnt += 1;
+ }
+
+ // Extend the transitions using the future specification.
+ ExtendTransitions(name, hdr);
+
+ // Compute the local civil time for each transition and the preceding
+ // second. These will be used for reverse conversions in MakeTime().
+ const TransitionType* ttp = &transition_types_[default_transition_type_];
+ for (std::size_t i = 0; i != transitions_.size(); ++i) {
+ Transition& tr(transitions_[i]);
+ tr.prev_civil_sec = LocalTime(tr.unix_time, *ttp).cs - 1;
+ ttp = &transition_types_[tr.type_index];
+ tr.civil_sec = LocalTime(tr.unix_time, *ttp).cs;
+ if (i != 0) {
+ // Check that the transitions are ordered by civil time. Essentially
+ // this means that an offset change cannot cross another such change.
+ // No one does this in practice, and we depend on it in MakeTime().
+ if (!Transition::ByCivilTime()(transitions_[i - 1], tr))
+ return false; // out of order
+ }
+ }
+
+ // Compute the maximum/minimum civil times that can be converted to a
+ // time_point<sys_seconds> for each of the zone's transition types.
+ for (auto& tt : transition_types_) {
+ tt.civil_max = LocalTime(sys_seconds::max().count(), tt).cs;
+ tt.civil_min = LocalTime(sys_seconds::min().count(), tt).cs;
+ }
+
+ transitions_.shrink_to_fit();
+ return true;
+}
+
+namespace {
+
+// fopen(3) adaptor.
+inline FILE* FOpen(const char* path, const char* mode) {
+#if defined(_MSC_VER)
+ FILE* fp;
+ if (fopen_s(&fp, path, mode) != 0) fp = nullptr;
+ return fp;
+#else
+ return fopen(path, mode); // TODO: Enable the close-on-exec flag.
+#endif
+}
+
+// A stdio(3)-backed implementation of ZoneInfoSource.
+class FileZoneInfoSource : public ZoneInfoSource {
+ public:
+ static std::unique_ptr<ZoneInfoSource> Open(const std::string& name);
+
+ std::size_t Read(void* ptr, std::size_t size) override {
+ size = std::min(size, len_);
+ std::size_t nread = fread(ptr, 1, size, fp_.get());
+ len_ -= nread;
+ return nread;
+ }
+ int Skip(std::size_t offset) override {
+ offset = std::min(offset, len_);
+ int rc = fseek(fp_.get(), static_cast<long>(offset), SEEK_CUR);
+ if (rc == 0) len_ -= offset;
+ return rc;
+ }
+
+ protected:
+ explicit FileZoneInfoSource(
+ FILE* fp, std::size_t len = std::numeric_limits<std::size_t>::max())
+ : fp_(fp, fclose), len_(len) {}
+
+ private:
+ std::unique_ptr<FILE, int(*)(FILE*)> fp_;
+ std::size_t len_;
+};
+
+std::unique_ptr<ZoneInfoSource> FileZoneInfoSource::Open(
+ const std::string& name) {
+ // Use of the "file:" prefix is intended for testing purposes only.
+ if (name.compare(0, 5, "file:") == 0) return Open(name.substr(5));
+
+ // Map the time-zone name to a path name.
+ std::string path;
+ if (name.empty() || name[0] != '/') {
+ const char* tzdir = "/usr/share/zoneinfo";
+ char* tzdir_env = nullptr;
+#if defined(_MSC_VER)
+ _dupenv_s(&tzdir_env, nullptr, "TZDIR");
+#else
+ tzdir_env = std::getenv("TZDIR");
+#endif
+ if (tzdir_env && *tzdir_env) tzdir = tzdir_env;
+ path += tzdir;
+ path += '/';
+#if defined(_MSC_VER)
+ free(tzdir_env);
+#endif
+ }
+ path += name;
+
+ // Open the zoneinfo file.
+ FILE* fp = FOpen(path.c_str(), "rb");
+ if (fp == nullptr) return nullptr;
+ std::size_t length = 0;
+ if (fseek(fp, 0, SEEK_END) == 0) {
+ long pos = ftell(fp);
+ if (pos >= 0) {
+ length = static_cast<std::size_t>(pos);
+ }
+ rewind(fp);
+ }
+ return std::unique_ptr<ZoneInfoSource>(new FileZoneInfoSource(fp, length));
+}
+
+#if defined(__ANDROID__)
+class AndroidZoneInfoSource : public FileZoneInfoSource {
+ public:
+ static std::unique_ptr<ZoneInfoSource> Open(const std::string& name);
+
+ private:
+ explicit AndroidZoneInfoSource(FILE* fp, std::size_t len)
+ : FileZoneInfoSource(fp, len) {}
+};
+
+std::unique_ptr<ZoneInfoSource> AndroidZoneInfoSource::Open(
+ const std::string& name) {
+ // Use of the "file:" prefix is intended for testing purposes only.
+ if (name.compare(0, 5, "file:") == 0) return Open(name.substr(5));
+
+ // See Android's libc/tzcode/bionic.cpp for additional information.
+ for (const char* tzdata : {"/data/misc/zoneinfo/current/tzdata",
+ "/system/usr/share/zoneinfo/tzdata"}) {
+ std::unique_ptr<FILE, int (*)(FILE*)> fp(FOpen(tzdata, "rb"), fclose);
+ if (fp.get() == nullptr) continue;
+
+ char hbuf[24]; // covers header.zonetab_offset too
+ if (fread(hbuf, 1, sizeof(hbuf), fp.get()) != sizeof(hbuf)) continue;
+ if (strncmp(hbuf, "tzdata", 6) != 0) continue;
+ const std::int_fast32_t index_offset = Decode32(hbuf + 12);
+ const std::int_fast32_t data_offset = Decode32(hbuf + 16);
+ if (index_offset < 0 || data_offset < index_offset) continue;
+ if (fseek(fp.get(), static_cast<long>(index_offset), SEEK_SET) != 0)
+ continue;
+
+ char ebuf[52]; // covers entry.unused too
+ const std::size_t index_size =
+ static_cast<std::size_t>(data_offset - index_offset);
+ const std::size_t zonecnt = index_size / sizeof(ebuf);
+ if (zonecnt * sizeof(ebuf) != index_size) continue;
+ for (std::size_t i = 0; i != zonecnt; ++i) {
+ if (fread(ebuf, 1, sizeof(ebuf), fp.get()) != sizeof(ebuf)) break;
+ const std::int_fast32_t start = data_offset + Decode32(ebuf + 40);
+ const std::int_fast32_t length = Decode32(ebuf + 44);
+ if (start < 0 || length < 0) break;
+ ebuf[40] = '\0'; // ensure zone name is NUL terminated
+ if (strcmp(name.c_str(), ebuf) == 0) {
+ if (fseek(fp.get(), static_cast<long>(start), SEEK_SET) != 0) break;
+ return std::unique_ptr<ZoneInfoSource>(new AndroidZoneInfoSource(
+ fp.release(), static_cast<std::size_t>(length)));
+ }
+ }
+ }
+ return nullptr;
+}
+#endif
+
+} // namespace
+
+bool TimeZoneInfo::Load(const std::string& name) {
+ // We can ensure that the loading of UTC or any other fixed-offset
+ // zone never fails because the simple, fixed-offset state can be
+ // internally generated. Note that this depends on our choice to not
+ // accept leap-second encoded ("right") zoneinfo.
+ auto offset = sys_seconds::zero();
+ if (FixedOffsetFromName(name, &offset)) {
+ return ResetToBuiltinUTC(offset);
+ }
+
+ // Find and use a ZoneInfoSource to load the named zone.
+ auto zip = cctz_extension::zone_info_source_factory(
+ name, [](const std::string& name) -> std::unique_ptr<ZoneInfoSource> {
+ if (auto zip = FileZoneInfoSource::Open(name)) return zip;
+#if defined(__ANDROID__)
+ if (auto zip = AndroidZoneInfoSource::Open(name)) return zip;
+#endif
+ return nullptr;
+ });
+ return zip != nullptr && Load(name, zip.get());
+}
+
+// BreakTime() translation for a particular transition type.
+time_zone::absolute_lookup TimeZoneInfo::LocalTime(
+ std::int_fast64_t unix_time, const TransitionType& tt) const {
+ // A civil time in "+offset" looks like (time+offset) in UTC.
+ // Note: We perform two additions in the civil_second domain to
+ // sidestep the chance of overflow in (unix_time + tt.utc_offset).
+ return {(civil_second() + unix_time) + tt.utc_offset,
+ tt.utc_offset, tt.is_dst, &abbreviations_[tt.abbr_index]};
+}
+
+// BreakTime() translation for a particular transition.
+time_zone::absolute_lookup TimeZoneInfo::LocalTime(
+ std::int_fast64_t unix_time, const Transition& tr) const {
+ const TransitionType& tt = transition_types_[tr.type_index];
+ // Note: (unix_time - tr.unix_time) will never overflow as we
+ // have ensured that there is always a "nearby" transition.
+ return {tr.civil_sec + (unix_time - tr.unix_time), // TODO: Optimize.
+ tt.utc_offset, tt.is_dst, &abbreviations_[tt.abbr_index]};
+}
+
+// MakeTime() translation with a conversion-preserving +N * 400-year shift.
+time_zone::civil_lookup TimeZoneInfo::TimeLocal(const civil_second& cs,
+ year_t c4_shift) const {
+ assert(last_year_ - 400 < cs.year() && cs.year() <= last_year_);
+ time_zone::civil_lookup cl = MakeTime(cs);
+ if (c4_shift > sys_seconds::max().count() / kSecsPer400Years) {
+ cl.pre = cl.trans = cl.post = time_point<sys_seconds>::max();
+ } else {
+ const auto offset = sys_seconds(c4_shift * kSecsPer400Years);
+ const auto limit = time_point<sys_seconds>::max() - offset;
+ for (auto* tp : {&cl.pre, &cl.trans, &cl.post}) {
+ if (*tp > limit) {
+ *tp = time_point<sys_seconds>::max();
+ } else {
+ *tp += offset;
+ }
+ }
+ }
+ return cl;
+}
+
+time_zone::absolute_lookup TimeZoneInfo::BreakTime(
+ const time_point<sys_seconds>& tp) const {
+ std::int_fast64_t unix_time = ToUnixSeconds(tp);
+ const std::size_t timecnt = transitions_.size();
+ assert(timecnt != 0); // We always add a transition.
+
+ if (unix_time < transitions_[0].unix_time) {
+ return LocalTime(unix_time, transition_types_[default_transition_type_]);
+ }
+ if (unix_time >= transitions_[timecnt - 1].unix_time) {
+ // After the last transition. If we extended the transitions using
+ // future_spec_, shift back to a supported year using the 400-year
+ // cycle of calendaric equivalence and then compensate accordingly.
+ if (extended_) {
+ const std::int_fast64_t diff =
+ unix_time - transitions_[timecnt - 1].unix_time;
+ const year_t shift = diff / kSecsPer400Years + 1;
+ const auto d = sys_seconds(shift * kSecsPer400Years);
+ time_zone::absolute_lookup al = BreakTime(tp - d);
+ al.cs = YearShift(al.cs, shift * 400);
+ return al;
+ }
+ return LocalTime(unix_time, transitions_[timecnt - 1]);
+ }
+
+ const std::size_t hint = local_time_hint_.load(std::memory_order_relaxed);
+ if (0 < hint && hint < timecnt) {
+ if (transitions_[hint - 1].unix_time <= unix_time) {
+ if (unix_time < transitions_[hint].unix_time) {
+ return LocalTime(unix_time, transitions_[hint - 1]);
+ }
+ }
+ }
+
+ const Transition target = {unix_time, 0, civil_second(), civil_second()};
+ const Transition* begin = &transitions_[0];
+ const Transition* tr = std::upper_bound(begin, begin + timecnt, target,
+ Transition::ByUnixTime());
+ local_time_hint_.store(static_cast<std::size_t>(tr - begin),
+ std::memory_order_relaxed);
+ return LocalTime(unix_time, *--tr);
+}
+
+time_zone::civil_lookup TimeZoneInfo::MakeTime(const civil_second& cs) const {
+ const std::size_t timecnt = transitions_.size();
+ assert(timecnt != 0); // We always add a transition.
+
+ // Find the first transition after our target civil time.
+ const Transition* tr = nullptr;
+ const Transition* begin = &transitions_[0];
+ const Transition* end = begin + timecnt;
+ if (cs < begin->civil_sec) {
+ tr = begin;
+ } else if (cs >= transitions_[timecnt - 1].civil_sec) {
+ tr = end;
+ } else {
+ const std::size_t hint = time_local_hint_.load(std::memory_order_relaxed);
+ if (0 < hint && hint < timecnt) {
+ if (transitions_[hint - 1].civil_sec <= cs) {
+ if (cs < transitions_[hint].civil_sec) {
+ tr = begin + hint;
+ }
+ }
+ }
+ if (tr == nullptr) {
+ const Transition target = {0, 0, cs, civil_second()};
+ tr = std::upper_bound(begin, end, target, Transition::ByCivilTime());
+ time_local_hint_.store(static_cast<std::size_t>(tr - begin),
+ std::memory_order_relaxed);
+ }
+ }
+
+ if (tr == begin) {
+ if (tr->prev_civil_sec >= cs) {
+ // Before first transition, so use the default offset.
+ const TransitionType& tt(transition_types_[default_transition_type_]);
+ if (cs < tt.civil_min) return MakeUnique(time_point<sys_seconds>::min());
+ return MakeUnique(cs - (civil_second() + tt.utc_offset));
+ }
+ // tr->prev_civil_sec < cs < tr->civil_sec
+ return MakeSkipped(*tr, cs);
+ }
+
+ if (tr == end) {
+ if (cs > (--tr)->prev_civil_sec) {
+ // After the last transition. If we extended the transitions using
+ // future_spec_, shift back to a supported year using the 400-year
+ // cycle of calendaric equivalence and then compensate accordingly.
+ if (extended_ && cs.year() > last_year_) {
+ const year_t shift = (cs.year() - last_year_ - 1) / 400 + 1;
+ return TimeLocal(YearShift(cs, shift * -400), shift);
+ }
+ const TransitionType& tt(transition_types_[tr->type_index]);
+ if (cs > tt.civil_max) return MakeUnique(time_point<sys_seconds>::max());
+ return MakeUnique(tr->unix_time + (cs - tr->civil_sec));
+ }
+ // tr->civil_sec <= cs <= tr->prev_civil_sec
+ return MakeRepeated(*tr, cs);
+ }
+
+ if (tr->prev_civil_sec < cs) {
+ // tr->prev_civil_sec < cs < tr->civil_sec
+ return MakeSkipped(*tr, cs);
+ }
+
+ if (cs <= (--tr)->prev_civil_sec) {
+ // tr->civil_sec <= cs <= tr->prev_civil_sec
+ return MakeRepeated(*tr, cs);
+ }
+
+ // In between transitions.
+ return MakeUnique(tr->unix_time + (cs - tr->civil_sec));
+}
+
+std::string TimeZoneInfo::Description() const {
+ std::ostringstream oss;
+ // TODO: It would nice if the zoneinfo data included the zone name.
+ // TODO: It would nice if the zoneinfo data included the tzdb version.
+ oss << "#trans=" << transitions_.size();
+ oss << " #types=" << transition_types_.size();
+ oss << " spec='" << future_spec_ << "'";
+ return oss.str();
+}
+
+bool TimeZoneInfo::NextTransition(time_point<sys_seconds>* tp) const {
+ if (transitions_.empty()) return false;
+ const Transition* begin = &transitions_[0];
+ const Transition* end = begin + transitions_.size();
+ if (begin->unix_time <= -(1LL << 59)) {
+ // Do not report the BIG_BANG found in recent zoneinfo data as it is
+ // really a sentinel, not a transition. See tz/zic.c.
+ ++begin;
+ }
+ std::int_fast64_t unix_time = ToUnixSeconds(*tp);
+ const Transition target = { unix_time };
+ const Transition* tr = std::upper_bound(begin, end, target,
+ Transition::ByUnixTime());
+ if (tr != begin) { // skip no-op transitions
+ for (; tr != end; ++tr) {
+ if (!EquivTransitions(tr[-1].type_index, tr[0].type_index)) break;
+ }
+ }
+ // When tr == end we return false, ignoring future_spec_.
+ if (tr == end) return false;
+ *tp = FromUnixSeconds(tr->unix_time);
+ return true;
+}
+
+bool TimeZoneInfo::PrevTransition(time_point<sys_seconds>* tp) const {
+ if (transitions_.empty()) return false;
+ const Transition* begin = &transitions_[0];
+ const Transition* end = begin + transitions_.size();
+ if (begin->unix_time <= -(1LL << 59)) {
+ // Do not report the BIG_BANG found in recent zoneinfo data as it is
+ // really a sentinel, not a transition. See tz/zic.c.
+ ++begin;
+ }
+ std::int_fast64_t unix_time = ToUnixSeconds(*tp);
+ if (FromUnixSeconds(unix_time) != *tp) {
+ if (unix_time == std::numeric_limits<std::int_fast64_t>::max()) {
+ if (end == begin) return false; // Ignore future_spec_.
+ *tp = FromUnixSeconds((--end)->unix_time);
+ return true;
+ }
+ unix_time += 1; // ceils
+ }
+ const Transition target = { unix_time };
+ const Transition* tr = std::lower_bound(begin, end, target,
+ Transition::ByUnixTime());
+ if (tr != begin) { // skip no-op transitions
+ for (; tr - 1 != begin; --tr) {
+ if (!EquivTransitions(tr[-2].type_index, tr[-1].type_index)) break;
+ }
+ }
+ // When tr == end we return the "last" transition, ignoring future_spec_.
+ if (tr == begin) return false;
+ *tp = FromUnixSeconds((--tr)->unix_time);
+ return true;
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_info.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_info.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_info.h
new file mode 100644
index 0000000..b4d1696
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_info.h
@@ -0,0 +1,132 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
+
+#include <atomic>
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+#include "absl/time/internal/cctz/include/cctz/zone_info_source.h"
+#include "time_zone_if.h"
+#include "tzfile.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// A transition to a new UTC offset.
+struct Transition {
+ std::int_least64_t unix_time; // the instant of this transition
+ std::uint_least8_t type_index; // index of the transition type
+ civil_second civil_sec; // local civil time of transition
+ civil_second prev_civil_sec; // local civil time one second earlier
+
+ struct ByUnixTime {
+ inline bool operator()(const Transition& lhs, const Transition& rhs) const {
+ return lhs.unix_time < rhs.unix_time;
+ }
+ };
+ struct ByCivilTime {
+ inline bool operator()(const Transition& lhs, const Transition& rhs) const {
+ return lhs.civil_sec < rhs.civil_sec;
+ }
+ };
+};
+
+// The characteristics of a particular transition.
+struct TransitionType {
+ std::int_least32_t utc_offset; // the new prevailing UTC offset
+ civil_second civil_max; // max convertible civil time for offset
+ civil_second civil_min; // min convertible civil time for offset
+ bool is_dst; // did we move into daylight-saving time
+ std::uint_least8_t abbr_index; // index of the new abbreviation
+};
+
+// A time zone backed by the IANA Time Zone Database (zoneinfo).
+class TimeZoneInfo : public TimeZoneIf {
+ public:
+ TimeZoneInfo() = default;
+ TimeZoneInfo(const TimeZoneInfo&) = delete;
+ TimeZoneInfo& operator=(const TimeZoneInfo&) = delete;
+
+ // Loads the zoneinfo for the given name, returning true if successful.
+ bool Load(const std::string& name);
+
+ // TimeZoneIf implementations.
+ time_zone::absolute_lookup BreakTime(
+ const time_point<sys_seconds>& tp) const override;
+ time_zone::civil_lookup MakeTime(
+ const civil_second& cs) const override;
+ std::string Description() const override;
+ bool NextTransition(time_point<sys_seconds>* tp) const override;
+ bool PrevTransition(time_point<sys_seconds>* tp) const override;
+
+ private:
+ struct Header { // counts of:
+ std::size_t timecnt; // transition times
+ std::size_t typecnt; // transition types
+ std::size_t charcnt; // zone abbreviation characters
+ std::size_t leapcnt; // leap seconds (we expect none)
+ std::size_t ttisstdcnt; // UTC/local indicators (unused)
+ std::size_t ttisgmtcnt; // standard/wall indicators (unused)
+
+ bool Build(const tzhead& tzh);
+ std::size_t DataLength(std::size_t time_len) const;
+ };
+
+ void CheckTransition(const std::string& name, const TransitionType& tt,
+ std::int_fast32_t offset, bool is_dst,
+ const std::string& abbr) const;
+ bool EquivTransitions(std::uint_fast8_t tt1_index,
+ std::uint_fast8_t tt2_index) const;
+ void ExtendTransitions(const std::string& name, const Header& hdr);
+
+ bool ResetToBuiltinUTC(const sys_seconds& offset);
+ bool Load(const std::string& name, ZoneInfoSource* zip);
+
+ // Helpers for BreakTime() and MakeTime().
+ time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time,
+ const TransitionType& tt) const;
+ time_zone::absolute_lookup LocalTime(std::int_fast64_t unix_time,
+ const Transition& tr) const;
+ time_zone::civil_lookup TimeLocal(const civil_second& cs,
+ year_t c4_shift) const;
+
+ std::vector<Transition> transitions_; // ordered by unix_time and civil_sec
+ std::vector<TransitionType> transition_types_; // distinct transition types
+ std::uint_fast8_t default_transition_type_; // for before first transition
+ std::string abbreviations_; // all the NUL-terminated abbreviations
+
+ std::string future_spec_; // for after the last zic transition
+ bool extended_; // future_spec_ was used to generate transitions
+ year_t last_year_; // the final year of the generated transitions
+
+ // We remember the transitions found during the last BreakTime() and
+ // MakeTime() calls. If the next request is for the same transition we
+ // will avoid re-searching.
+ mutable std::atomic<std::size_t> local_time_hint_ = {}; // BreakTime() hint
+ mutable std::atomic<std::size_t> time_local_hint_ = {}; // MakeTime() hint
+};
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+#endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_INFO_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_libc.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_libc.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_libc.cc
new file mode 100644
index 0000000..b0b56a5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_libc.cc
@@ -0,0 +1,156 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if defined(_WIN32) || defined(_WIN64)
+#define _CRT_SECURE_NO_WARNINGS 1
+#endif
+
+#include "time_zone_libc.h"
+
+#include <chrono>
+#include <ctime>
+#include <tuple>
+#include <utility>
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+namespace {
+
+// .first is seconds east of UTC; .second is the time-zone abbreviation.
+using OffsetAbbr = std::pair<int, const char*>;
+
+// Defines a function that can be called as follows:
+//
+// std::tm tm = ...;
+// OffsetAbbr off_abbr = get_offset_abbr(tm);
+//
+#if defined(_WIN32) || defined(_WIN64)
+// Uses the globals: '_timezone', '_dstbias' and '_tzname'.
+OffsetAbbr get_offset_abbr(const std::tm& tm) {
+ const bool is_dst = tm.tm_isdst > 0;
+ const int off = _timezone + (is_dst ? _dstbias : 0);
+ const char* abbr = _tzname[is_dst];
+ return {off, abbr};
+}
+#elif defined(__sun)
+// Uses the globals: 'timezone', 'altzone' and 'tzname'.
+OffsetAbbr get_offset_abbr(const std::tm& tm) {
+ const bool is_dst = tm.tm_isdst > 0;
+ const int off = is_dst ? altzone : timezone;
+ const char* abbr = tzname[is_dst];
+ return {off, abbr};
+}
+#elif defined(__native_client__) || defined(__myriad2__) || \
+ defined(__EMSCRIPTEN__)
+// Uses the globals: 'timezone' and 'tzname'.
+OffsetAbbr get_offset_abbr(const std::tm& tm) {
+ const bool is_dst = tm.tm_isdst > 0;
+ const int off = _timezone + (is_dst ? 60 * 60 : 0);
+ const char* abbr = tzname[is_dst];
+ return {off, abbr};
+}
+#else
+//
+// Returns an OffsetAbbr using std::tm fields with various spellings.
+//
+#if !defined(tm_gmtoff) && !defined(tm_zone)
+template <typename T>
+OffsetAbbr get_offset_abbr(const T& tm, decltype(&T::tm_gmtoff) = nullptr,
+ decltype(&T::tm_zone) = nullptr) {
+ return {tm.tm_gmtoff, tm.tm_zone};
+}
+#endif // !defined(tm_gmtoff) && !defined(tm_zone)
+#if !defined(__tm_gmtoff) && !defined(__tm_zone)
+template <typename T>
+OffsetAbbr get_offset_abbr(const T& tm, decltype(&T::__tm_gmtoff) = nullptr,
+ decltype(&T::__tm_zone) = nullptr) {
+ return {tm.__tm_gmtoff, tm.__tm_zone};
+}
+#endif // !defined(__tm_gmtoff) && !defined(__tm_zone)
+#endif
+
+} // namespace
+
+TimeZoneLibC::TimeZoneLibC(const std::string& name)
+ : local_(name == "localtime") {}
+
+time_zone::absolute_lookup TimeZoneLibC::BreakTime(
+ const time_point<sys_seconds>& tp) const {
+ time_zone::absolute_lookup al;
+ std::time_t t = ToUnixSeconds(tp);
+ std::tm tm;
+ if (local_) {
+#if defined(_WIN32) || defined(_WIN64)
+ localtime_s(&tm, &t);
+#else
+ localtime_r(&t, &tm);
+#endif
+ std::tie(al.offset, al.abbr) = get_offset_abbr(tm);
+ } else {
+#if defined(_WIN32) || defined(_WIN64)
+ gmtime_s(&tm, &t);
+#else
+ gmtime_r(&t, &tm);
+#endif
+ al.offset = 0;
+ al.abbr = "UTC";
+ }
+ al.cs = civil_second(tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+ tm.tm_hour, tm.tm_min, tm.tm_sec);
+ al.is_dst = tm.tm_isdst > 0;
+ return al;
+}
+
+time_zone::civil_lookup TimeZoneLibC::MakeTime(const civil_second& cs) const {
+ time_zone::civil_lookup cl;
+ std::time_t t;
+ if (local_) {
+ // Does not handle SKIPPED/AMBIGUOUS or huge years.
+ std::tm tm;
+ tm.tm_year = static_cast<int>(cs.year() - 1900);
+ tm.tm_mon = cs.month() - 1;
+ tm.tm_mday = cs.day();
+ tm.tm_hour = cs.hour();
+ tm.tm_min = cs.minute();
+ tm.tm_sec = cs.second();
+ tm.tm_isdst = -1;
+ t = std::mktime(&tm);
+ } else {
+ t = cs - civil_second();
+ }
+ cl.kind = time_zone::civil_lookup::UNIQUE;
+ cl.pre = cl.trans = cl.post = FromUnixSeconds(t);
+ return cl;
+}
+
+std::string TimeZoneLibC::Description() const {
+ return local_ ? "localtime" : "UTC";
+}
+
+bool TimeZoneLibC::NextTransition(time_point<sys_seconds>* tp) const {
+ return false;
+}
+
+bool TimeZoneLibC::PrevTransition(time_point<sys_seconds>* tp) const {
+ return false;
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_libc.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_libc.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_libc.h
new file mode 100644
index 0000000..41f7dde
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_libc.h
@@ -0,0 +1,50 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
+
+#include <string>
+
+#include "time_zone_if.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// A time zone backed by gmtime_r(3), localtime_r(3), and mktime(3),
+// and which therefore only supports UTC and the local time zone.
+// TODO: Add support for fixed offsets from UTC.
+class TimeZoneLibC : public TimeZoneIf {
+ public:
+ explicit TimeZoneLibC(const std::string& name);
+
+ // TimeZoneIf implementations.
+ time_zone::absolute_lookup BreakTime(
+ const time_point<sys_seconds>& tp) const override;
+ time_zone::civil_lookup MakeTime(
+ const civil_second& cs) const override;
+ std::string Description() const override;
+ bool NextTransition(time_point<sys_seconds>* tp) const override;
+ bool PrevTransition(time_point<sys_seconds>* tp) const override;
+
+ private:
+ const bool local_; // localtime or UTC
+};
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+#endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_LIBC_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_lookup.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_lookup.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_lookup.cc
new file mode 100644
index 0000000..fbd86e1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_lookup.cc
@@ -0,0 +1,142 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+#if defined(__ANDROID__)
+#include <sys/system_properties.h>
+#if __ANDROID_API__ >= 21
+#include <dlfcn.h>
+#endif
+#endif
+#include <cstdlib>
+#include <cstring>
+#include <string>
+
+#include "time_zone_fixed.h"
+#include "time_zone_impl.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+#if defined(__ANDROID__) && __ANDROID_API__ >= 21
+namespace {
+// Android 'L' removes __system_property_get() from the NDK, however
+// it is still a hidden symbol in libc so we use dlsym() to access it.
+// See Chromium's base/sys_info_android.cc for a similar example.
+
+using property_get_func = int (*)(const char*, char*);
+
+property_get_func LoadSystemPropertyGet() {
+ int flag = RTLD_LAZY | RTLD_GLOBAL;
+#if defined(RTLD_NOLOAD)
+ flag |= RTLD_NOLOAD; // libc.so should already be resident
+#endif
+ if (void* handle = dlopen("libc.so", flag)) {
+ void* sym = dlsym(handle, "__system_property_get");
+ dlclose(handle);
+ return reinterpret_cast<property_get_func>(sym);
+ }
+ return nullptr;
+}
+
+int __system_property_get(const char* name, char* value) {
+ static property_get_func system_property_get = LoadSystemPropertyGet();
+ return system_property_get ? system_property_get(name, value) : -1;
+}
+
+} // namespace
+#endif
+
+std::string time_zone::name() const {
+ return time_zone::Impl::get(*this).name();
+}
+
+time_zone::absolute_lookup time_zone::lookup(
+ const time_point<sys_seconds>& tp) const {
+ return time_zone::Impl::get(*this).BreakTime(tp);
+}
+
+time_zone::civil_lookup time_zone::lookup(const civil_second& cs) const {
+ return time_zone::Impl::get(*this).MakeTime(cs);
+}
+
+bool operator==(time_zone lhs, time_zone rhs) {
+ return &time_zone::Impl::get(lhs) == &time_zone::Impl::get(rhs);
+}
+
+bool load_time_zone(const std::string& name, time_zone* tz) {
+ return time_zone::Impl::LoadTimeZone(name, tz);
+}
+
+time_zone utc_time_zone() {
+ return time_zone::Impl::UTC(); // avoid name lookup
+}
+
+time_zone fixed_time_zone(const sys_seconds& offset) {
+ time_zone tz;
+ load_time_zone(FixedOffsetToName(offset), &tz);
+ return tz;
+}
+
+time_zone local_time_zone() {
+ const char* zone = ":localtime";
+
+ // Allow ${TZ} to override to default zone.
+ char* tz_env = nullptr;
+#if defined(_MSC_VER)
+ _dupenv_s(&tz_env, nullptr, "TZ");
+#else
+ tz_env = std::getenv("TZ");
+#endif
+#if defined(__ANDROID__)
+ char sysprop[PROP_VALUE_MAX];
+ if (tz_env == nullptr)
+ if (__system_property_get("persist.sys.timezone", sysprop) > 0)
+ tz_env = sysprop;
+#endif
+ if (tz_env) zone = tz_env;
+
+ // We only support the "[:]<zone-name>" form.
+ if (*zone == ':') ++zone;
+
+ // Map "localtime" to a system-specific name, but
+ // allow ${LOCALTIME} to override the default name.
+ char* localtime_env = nullptr;
+ if (strcmp(zone, "localtime") == 0) {
+#if defined(_MSC_VER)
+ // System-specific default is just "localtime".
+ _dupenv_s(&localtime_env, nullptr, "LOCALTIME");
+#else
+ zone = "/etc/localtime"; // System-specific default.
+ localtime_env = std::getenv("LOCALTIME");
+#endif
+ if (localtime_env) zone = localtime_env;
+ }
+
+ const std::string name = zone;
+#if defined(_MSC_VER)
+ free(localtime_env);
+ free(tz_env);
+#endif
+
+ time_zone tz;
+ load_time_zone(name, &tz); // Falls back to UTC.
+ return tz;
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
[20/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock.cc
new file mode 100644
index 0000000..772f852
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock.cc
@@ -0,0 +1,563 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/clock.h"
+
+#include "absl/base/attributes.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include <algorithm>
+#include <atomic>
+#include <cerrno>
+#include <cstdint>
+#include <ctime>
+#include <limits>
+
+#include "absl/base/internal/spinlock.h"
+#include "absl/base/internal/unscaledcycleclock.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/base/thread_annotations.h"
+
+namespace absl {
+Time Now() {
+ // TODO(bww): Get a timespec instead so we don't have to divide.
+ int64_t n = absl::GetCurrentTimeNanos();
+ if (n >= 0) {
+ return time_internal::FromUnixDuration(
+ time_internal::MakeDuration(n / 1000000000, n % 1000000000 * 4));
+ }
+ return time_internal::FromUnixDuration(absl::Nanoseconds(n));
+}
+} // namespace absl
+
+// Decide if we should use the fast GetCurrentTimeNanos() algorithm
+// based on the cyclecounter, otherwise just get the time directly
+// from the OS on every call. This can be chosen at compile-time via
+// -DABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS=[0|1]
+#ifndef ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
+#if ABSL_USE_UNSCALED_CYCLECLOCK
+#define ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS 1
+#else
+#define ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS 0
+#endif
+#endif
+
+#if defined(__APPLE__)
+#include "absl/time/internal/get_current_time_ios.inc"
+#elif defined(_WIN32)
+#include "absl/time/internal/get_current_time_windows.inc"
+#else
+#include "absl/time/internal/get_current_time_posix.inc"
+#endif
+
+// Allows override by test.
+#ifndef GET_CURRENT_TIME_NANOS_FROM_SYSTEM
+#define GET_CURRENT_TIME_NANOS_FROM_SYSTEM() \
+ ::absl::time_internal::GetCurrentTimeNanosFromSystem()
+#endif
+
+#if !ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
+namespace absl {
+int64_t GetCurrentTimeNanos() {
+ return GET_CURRENT_TIME_NANOS_FROM_SYSTEM();
+}
+} // namespace absl
+#else // Use the cyclecounter-based implementation below.
+
+// Allows override by test.
+#ifndef GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW
+#define GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW() \
+ ::absl::time_internal::UnscaledCycleClockWrapperForGetCurrentTime::Now()
+#endif
+
+// The following counters are used only by the test code.
+static int64_t stats_initializations;
+static int64_t stats_reinitializations;
+static int64_t stats_calibrations;
+static int64_t stats_slow_paths;
+static int64_t stats_fast_slow_paths;
+
+namespace absl {
+namespace time_internal {
+// This is a friend wrapper around UnscaledCycleClock::Now()
+// (needed to access UnscaledCycleClock).
+class UnscaledCycleClockWrapperForGetCurrentTime {
+ public:
+ static int64_t Now() { return base_internal::UnscaledCycleClock::Now(); }
+};
+} // namespace time_internal
+
+// uint64_t is used in this module to provide an extra bit in multiplications
+
+// Return the time in ns as told by the kernel interface. Place in *cycleclock
+// the value of the cycleclock at about the time of the syscall.
+// This call represents the time base that this module synchronizes to.
+// Ensures that *cycleclock does not step back by up to (1 << 16) from
+// last_cycleclock, to discard small backward counter steps. (Larger steps are
+// assumed to be complete resyncs, which shouldn't happen. If they do, a full
+// reinitialization of the outer algorithm should occur.)
+static int64_t GetCurrentTimeNanosFromKernel(uint64_t last_cycleclock,
+ uint64_t *cycleclock) {
+ // We try to read clock values at about the same time as the kernel clock.
+ // This value gets adjusted up or down as estimate of how long that should
+ // take, so we can reject attempts that take unusually long.
+ static std::atomic<uint64_t> approx_syscall_time_in_cycles{10 * 1000};
+
+ uint64_t local_approx_syscall_time_in_cycles = // local copy
+ approx_syscall_time_in_cycles.load(std::memory_order_relaxed);
+
+ int64_t current_time_nanos_from_system;
+ uint64_t before_cycles;
+ uint64_t after_cycles;
+ uint64_t elapsed_cycles;
+ int loops = 0;
+ do {
+ before_cycles = GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW();
+ current_time_nanos_from_system = GET_CURRENT_TIME_NANOS_FROM_SYSTEM();
+ after_cycles = GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW();
+ // elapsed_cycles is unsigned, so is large on overflow
+ elapsed_cycles = after_cycles - before_cycles;
+ if (elapsed_cycles >= local_approx_syscall_time_in_cycles &&
+ ++loops == 20) { // clock changed frequencies? Back off.
+ loops = 0;
+ if (local_approx_syscall_time_in_cycles < 1000 * 1000) {
+ local_approx_syscall_time_in_cycles =
+ (local_approx_syscall_time_in_cycles + 1) << 1;
+ }
+ approx_syscall_time_in_cycles.store(
+ local_approx_syscall_time_in_cycles,
+ std::memory_order_relaxed);
+ }
+ } while (elapsed_cycles >= local_approx_syscall_time_in_cycles ||
+ last_cycleclock - after_cycles < (static_cast<uint64_t>(1) << 16));
+
+ // Number of times in a row we've seen a kernel time call take substantially
+ // less than approx_syscall_time_in_cycles.
+ static std::atomic<uint32_t> seen_smaller{ 0 };
+
+ // Adjust approx_syscall_time_in_cycles to be within a factor of 2
+ // of the typical time to execute one iteration of the loop above.
+ if ((local_approx_syscall_time_in_cycles >> 1) < elapsed_cycles) {
+ // measured time is no smaller than half current approximation
+ seen_smaller.store(0, std::memory_order_relaxed);
+ } else if (seen_smaller.fetch_add(1, std::memory_order_relaxed) >= 3) {
+ // smaller delays several times in a row; reduce approximation by 12.5%
+ const uint64_t new_approximation =
+ local_approx_syscall_time_in_cycles -
+ (local_approx_syscall_time_in_cycles >> 3);
+ approx_syscall_time_in_cycles.store(new_approximation,
+ std::memory_order_relaxed);
+ seen_smaller.store(0, std::memory_order_relaxed);
+ }
+
+ *cycleclock = after_cycles;
+ return current_time_nanos_from_system;
+}
+
+
+// ---------------------------------------------------------------------
+// An implementation of reader-write locks that use no atomic ops in the read
+// case. This is a generalization of Lamport's method for reading a multiword
+// clock. Increment a word on each write acquisition, using the low-order bit
+// as a spinlock; the word is the high word of the "clock". Readers read the
+// high word, then all other data, then the high word again, and repeat the
+// read if the reads of the high words yields different answers, or an odd
+// value (either case suggests possible interference from a writer).
+// Here we use a spinlock to ensure only one writer at a time, rather than
+// spinning on the bottom bit of the word to benefit from SpinLock
+// spin-delay tuning.
+
+// Acquire seqlock (*seq) and return the value to be written to unlock.
+static inline uint64_t SeqAcquire(std::atomic<uint64_t> *seq) {
+ uint64_t x = seq->fetch_add(1, std::memory_order_relaxed);
+
+ // We put a release fence between update to *seq and writes to shared data.
+ // Thus all stores to shared data are effectively release operations and
+ // update to *seq above cannot be re-ordered past any of them. Note that
+ // this barrier is not for the fetch_add above. A release barrier for the
+ // fetch_add would be before it, not after.
+ std::atomic_thread_fence(std::memory_order_release);
+
+ return x + 2; // original word plus 2
+}
+
+// Release seqlock (*seq) by writing x to it---a value previously returned by
+// SeqAcquire.
+static inline void SeqRelease(std::atomic<uint64_t> *seq, uint64_t x) {
+ // The unlock store to *seq must have release ordering so that all
+ // updates to shared data must finish before this store.
+ seq->store(x, std::memory_order_release); // release lock for readers
+}
+
+// ---------------------------------------------------------------------
+
+// "nsscaled" is unit of time equal to a (2**kScale)th of a nanosecond.
+enum { kScale = 30 };
+
+// The minimum interval between samples of the time base.
+// We pick enough time to amortize the cost of the sample,
+// to get a reasonably accurate cycle counter rate reading,
+// and not so much that calculations will overflow 64-bits.
+static const uint64_t kMinNSBetweenSamples = 2000 << 20;
+
+// We require that kMinNSBetweenSamples shifted by kScale
+// have at least a bit left over for 64-bit calculations.
+static_assert(((kMinNSBetweenSamples << (kScale + 1)) >> (kScale + 1)) ==
+ kMinNSBetweenSamples,
+ "cannot represent kMaxBetweenSamplesNSScaled");
+
+// A reader-writer lock protecting the static locations below.
+// See SeqAcquire() and SeqRelease() above.
+static absl::base_internal::SpinLock lock(
+ absl::base_internal::kLinkerInitialized);
+static std::atomic<uint64_t> seq(0);
+
+// data from a sample of the kernel's time value
+struct TimeSampleAtomic {
+ std::atomic<uint64_t> raw_ns; // raw kernel time
+ std::atomic<uint64_t> base_ns; // our estimate of time
+ std::atomic<uint64_t> base_cycles; // cycle counter reading
+ std::atomic<uint64_t> nsscaled_per_cycle; // cycle period
+ // cycles before we'll sample again (a scaled reciprocal of the period,
+ // to avoid a division on the fast path).
+ std::atomic<uint64_t> min_cycles_per_sample;
+};
+// Same again, but with non-atomic types
+struct TimeSample {
+ uint64_t raw_ns; // raw kernel time
+ uint64_t base_ns; // our estimate of time
+ uint64_t base_cycles; // cycle counter reading
+ uint64_t nsscaled_per_cycle; // cycle period
+ uint64_t min_cycles_per_sample; // approx cycles before next sample
+};
+
+static struct TimeSampleAtomic last_sample; // the last sample; under seq
+
+static int64_t GetCurrentTimeNanosSlowPath() ABSL_ATTRIBUTE_COLD;
+
+// Read the contents of *atomic into *sample.
+// Each field is read atomically, but to maintain atomicity between fields,
+// the access must be done under a lock.
+static void ReadTimeSampleAtomic(const struct TimeSampleAtomic *atomic,
+ struct TimeSample *sample) {
+ sample->base_ns = atomic->base_ns.load(std::memory_order_relaxed);
+ sample->base_cycles = atomic->base_cycles.load(std::memory_order_relaxed);
+ sample->nsscaled_per_cycle =
+ atomic->nsscaled_per_cycle.load(std::memory_order_relaxed);
+ sample->min_cycles_per_sample =
+ atomic->min_cycles_per_sample.load(std::memory_order_relaxed);
+ sample->raw_ns = atomic->raw_ns.load(std::memory_order_relaxed);
+}
+
+// Public routine.
+// Algorithm: We wish to compute real time from a cycle counter. In normal
+// operation, we construct a piecewise linear approximation to the kernel time
+// source, using the cycle counter value. The start of each line segment is at
+// the same point as the end of the last, but may have a different slope (that
+// is, a different idea of the cycle counter frequency). Every couple of
+// seconds, the kernel time source is sampled and compared with the current
+// approximation. A new slope is chosen that, if followed for another couple
+// of seconds, will correct the error at the current position. The information
+// for a sample is in the "last_sample" struct. The linear approximation is
+// estimated_time = last_sample.base_ns +
+// last_sample.ns_per_cycle * (counter_reading - last_sample.base_cycles)
+// (ns_per_cycle is actually stored in different units and scaled, to avoid
+// overflow). The base_ns of the next linear approximation is the
+// estimated_time using the last approximation; the base_cycles is the cycle
+// counter value at that time; the ns_per_cycle is the number of ns per cycle
+// measured since the last sample, but adjusted so that most of the difference
+// between the estimated_time and the kernel time will be corrected by the
+// estimated time to the next sample. In normal operation, this algorithm
+// relies on:
+// - the cycle counter and kernel time rates not changing a lot in a few
+// seconds.
+// - the client calling into the code often compared to a couple of seconds, so
+// the time to the next correction can be estimated.
+// Any time ns_per_cycle is not known, a major error is detected, or the
+// assumption about frequent calls is violated, the implementation returns the
+// kernel time. It records sufficient data that a linear approximation can
+// resume a little later.
+
+int64_t GetCurrentTimeNanos() {
+ // read the data from the "last_sample" struct (but don't need raw_ns yet)
+ // The reads of "seq" and test of the values emulate a reader lock.
+ uint64_t base_ns;
+ uint64_t base_cycles;
+ uint64_t nsscaled_per_cycle;
+ uint64_t min_cycles_per_sample;
+ uint64_t seq_read0;
+ uint64_t seq_read1;
+
+ // If we have enough information to interpolate, the value returned will be
+ // derived from this cycleclock-derived time estimate. On some platforms
+ // (POWER) the function to retrieve this value has enough complexity to
+ // contribute to register pressure - reading it early before initializing
+ // the other pieces of the calculation minimizes spill/restore instructions,
+ // minimizing icache cost.
+ uint64_t now_cycles = GET_CURRENT_TIME_NANOS_CYCLECLOCK_NOW();
+
+ // Acquire pairs with the barrier in SeqRelease - if this load sees that
+ // store, the shared-data reads necessarily see that SeqRelease's updates
+ // to the same shared data.
+ seq_read0 = seq.load(std::memory_order_acquire);
+
+ base_ns = last_sample.base_ns.load(std::memory_order_relaxed);
+ base_cycles = last_sample.base_cycles.load(std::memory_order_relaxed);
+ nsscaled_per_cycle =
+ last_sample.nsscaled_per_cycle.load(std::memory_order_relaxed);
+ min_cycles_per_sample =
+ last_sample.min_cycles_per_sample.load(std::memory_order_relaxed);
+
+ // This acquire fence pairs with the release fence in SeqAcquire. Since it
+ // is sequenced between reads of shared data and seq_read1, the reads of
+ // shared data are effectively acquiring.
+ std::atomic_thread_fence(std::memory_order_acquire);
+
+ // The shared-data reads are effectively acquire ordered, and the
+ // shared-data writes are effectively release ordered. Therefore if our
+ // shared-data reads see any of a particular update's shared-data writes,
+ // seq_read1 is guaranteed to see that update's SeqAcquire.
+ seq_read1 = seq.load(std::memory_order_relaxed);
+
+ // Fast path. Return if min_cycles_per_sample has not yet elapsed since the
+ // last sample, and we read a consistent sample. The fast path activates
+ // only when min_cycles_per_sample is non-zero, which happens when we get an
+ // estimate for the cycle time. The predicate will fail if now_cycles <
+ // base_cycles, or if some other thread is in the slow path.
+ //
+ // Since we now read now_cycles before base_ns, it is possible for now_cycles
+ // to be less than base_cycles (if we were interrupted between those loads and
+ // last_sample was updated). This is harmless, because delta_cycles will wrap
+ // and report a time much much bigger than min_cycles_per_sample. In that case
+ // we will take the slow path.
+ uint64_t delta_cycles = now_cycles - base_cycles;
+ if (seq_read0 == seq_read1 && (seq_read0 & 1) == 0 &&
+ delta_cycles < min_cycles_per_sample) {
+ return base_ns + ((delta_cycles * nsscaled_per_cycle) >> kScale);
+ }
+ return GetCurrentTimeNanosSlowPath();
+}
+
+// Return (a << kScale)/b.
+// Zero is returned if b==0. Scaling is performed internally to
+// preserve precision without overflow.
+static uint64_t SafeDivideAndScale(uint64_t a, uint64_t b) {
+ // Find maximum safe_shift so that
+ // 0 <= safe_shift <= kScale and (a << safe_shift) does not overflow.
+ int safe_shift = kScale;
+ while (((a << safe_shift) >> safe_shift) != a) {
+ safe_shift--;
+ }
+ uint64_t scaled_b = b >> (kScale - safe_shift);
+ uint64_t quotient = 0;
+ if (scaled_b != 0) {
+ quotient = (a << safe_shift) / scaled_b;
+ }
+ return quotient;
+}
+
+static uint64_t UpdateLastSample(
+ uint64_t now_cycles, uint64_t now_ns, uint64_t delta_cycles,
+ const struct TimeSample *sample) ABSL_ATTRIBUTE_COLD;
+
+// The slow path of GetCurrentTimeNanos(). This is taken while gathering
+// initial samples, when enough time has elapsed since the last sample, and if
+// any other thread is writing to last_sample.
+//
+// Manually mark this 'noinline' to minimize stack frame size of the fast
+// path. Without this, sometimes a compiler may inline this big block of code
+// into the fast past. That causes lots of register spills and reloads that
+// are unnecessary unless the slow path is taken.
+//
+// TODO(absl-team): Remove this attribute when our compiler is smart enough
+// to do the right thing.
+ABSL_ATTRIBUTE_NOINLINE
+static int64_t GetCurrentTimeNanosSlowPath() LOCKS_EXCLUDED(lock) {
+ // Serialize access to slow-path. Fast-path readers are not blocked yet, and
+ // code below must not modify last_sample until the seqlock is acquired.
+ lock.Lock();
+
+ // Sample the kernel time base. This is the definition of
+ // "now" if we take the slow path.
+ static uint64_t last_now_cycles; // protected by lock
+ uint64_t now_cycles;
+ uint64_t now_ns = GetCurrentTimeNanosFromKernel(last_now_cycles, &now_cycles);
+ last_now_cycles = now_cycles;
+
+ uint64_t estimated_base_ns;
+
+ // ----------
+ // Read the "last_sample" values again; this time holding the write lock.
+ struct TimeSample sample;
+ ReadTimeSampleAtomic(&last_sample, &sample);
+
+ // ----------
+ // Try running the fast path again; another thread may have updated the
+ // sample between our run of the fast path and the sample we just read.
+ uint64_t delta_cycles = now_cycles - sample.base_cycles;
+ if (delta_cycles < sample.min_cycles_per_sample) {
+ // Another thread updated the sample. This path does not take the seqlock
+ // so that blocked readers can make progress without blocking new readers.
+ estimated_base_ns = sample.base_ns +
+ ((delta_cycles * sample.nsscaled_per_cycle) >> kScale);
+ stats_fast_slow_paths++;
+ } else {
+ estimated_base_ns =
+ UpdateLastSample(now_cycles, now_ns, delta_cycles, &sample);
+ }
+
+ lock.Unlock();
+
+ return estimated_base_ns;
+}
+
+// Main part of the algorithm. Locks out readers, updates the approximation
+// using the new sample from the kernel, and stores the result in last_sample
+// for readers. Returns the new estimated time.
+static uint64_t UpdateLastSample(uint64_t now_cycles, uint64_t now_ns,
+ uint64_t delta_cycles,
+ const struct TimeSample *sample)
+ EXCLUSIVE_LOCKS_REQUIRED(lock) {
+ uint64_t estimated_base_ns = now_ns;
+ uint64_t lock_value = SeqAcquire(&seq); // acquire seqlock to block readers
+
+ // The 5s in the next if-statement limits the time for which we will trust
+ // the cycle counter and our last sample to give a reasonable result.
+ // Errors in the rate of the source clock can be multiplied by the ratio
+ // between this limit and kMinNSBetweenSamples.
+ if (sample->raw_ns == 0 || // no recent sample, or clock went backwards
+ sample->raw_ns + static_cast<uint64_t>(5) * 1000 * 1000 * 1000 < now_ns ||
+ now_ns < sample->raw_ns || now_cycles < sample->base_cycles) {
+ // record this sample, and forget any previously known slope.
+ last_sample.raw_ns.store(now_ns, std::memory_order_relaxed);
+ last_sample.base_ns.store(estimated_base_ns, std::memory_order_relaxed);
+ last_sample.base_cycles.store(now_cycles, std::memory_order_relaxed);
+ last_sample.nsscaled_per_cycle.store(0, std::memory_order_relaxed);
+ last_sample.min_cycles_per_sample.store(0, std::memory_order_relaxed);
+ stats_initializations++;
+ } else if (sample->raw_ns + 500 * 1000 * 1000 < now_ns &&
+ sample->base_cycles + 100 < now_cycles) {
+ // Enough time has passed to compute the cycle time.
+ if (sample->nsscaled_per_cycle != 0) { // Have a cycle time estimate.
+ // Compute time from counter reading, but avoiding overflow
+ // delta_cycles may be larger than on the fast path.
+ uint64_t estimated_scaled_ns;
+ int s = -1;
+ do {
+ s++;
+ estimated_scaled_ns = (delta_cycles >> s) * sample->nsscaled_per_cycle;
+ } while (estimated_scaled_ns / sample->nsscaled_per_cycle !=
+ (delta_cycles >> s));
+ estimated_base_ns = sample->base_ns +
+ (estimated_scaled_ns >> (kScale - s));
+ }
+
+ // Compute the assumed cycle time kMinNSBetweenSamples ns into the future
+ // assuming the cycle counter rate stays the same as the last interval.
+ uint64_t ns = now_ns - sample->raw_ns;
+ uint64_t measured_nsscaled_per_cycle = SafeDivideAndScale(ns, delta_cycles);
+
+ uint64_t assumed_next_sample_delta_cycles =
+ SafeDivideAndScale(kMinNSBetweenSamples, measured_nsscaled_per_cycle);
+
+ int64_t diff_ns = now_ns - estimated_base_ns; // estimate low by this much
+
+ // We want to set nsscaled_per_cycle so that our estimate of the ns time
+ // at the assumed cycle time is the assumed ns time.
+ // That is, we want to set nsscaled_per_cycle so:
+ // kMinNSBetweenSamples + diff_ns ==
+ // (assumed_next_sample_delta_cycles * nsscaled_per_cycle) >> kScale
+ // But we wish to damp oscillations, so instead correct only most
+ // of our current error, by solving:
+ // kMinNSBetweenSamples + diff_ns - (diff_ns / 16) ==
+ // (assumed_next_sample_delta_cycles * nsscaled_per_cycle) >> kScale
+ ns = kMinNSBetweenSamples + diff_ns - (diff_ns / 16);
+ uint64_t new_nsscaled_per_cycle =
+ SafeDivideAndScale(ns, assumed_next_sample_delta_cycles);
+ if (new_nsscaled_per_cycle != 0 &&
+ diff_ns < 100 * 1000 * 1000 && -diff_ns < 100 * 1000 * 1000) {
+ // record the cycle time measurement
+ last_sample.nsscaled_per_cycle.store(
+ new_nsscaled_per_cycle, std::memory_order_relaxed);
+ uint64_t new_min_cycles_per_sample =
+ SafeDivideAndScale(kMinNSBetweenSamples, new_nsscaled_per_cycle);
+ last_sample.min_cycles_per_sample.store(
+ new_min_cycles_per_sample, std::memory_order_relaxed);
+ stats_calibrations++;
+ } else { // something went wrong; forget the slope
+ last_sample.nsscaled_per_cycle.store(0, std::memory_order_relaxed);
+ last_sample.min_cycles_per_sample.store(0, std::memory_order_relaxed);
+ estimated_base_ns = now_ns;
+ stats_reinitializations++;
+ }
+ last_sample.raw_ns.store(now_ns, std::memory_order_relaxed);
+ last_sample.base_ns.store(estimated_base_ns, std::memory_order_relaxed);
+ last_sample.base_cycles.store(now_cycles, std::memory_order_relaxed);
+ } else {
+ // have a sample, but no slope; waiting for enough time for a calibration
+ stats_slow_paths++;
+ }
+
+ SeqRelease(&seq, lock_value); // release the readers
+
+ return estimated_base_ns;
+}
+} // namespace absl
+#endif // ABSL_USE_CYCLECLOCK_FOR_GET_CURRENT_TIME_NANOS
+
+namespace absl {
+namespace {
+
+// Returns the maximum duration that SleepOnce() can sleep for.
+constexpr absl::Duration MaxSleep() {
+#ifdef _WIN32
+ // Windows Sleep() takes unsigned long argument in milliseconds.
+ return absl::Milliseconds(
+ std::numeric_limits<unsigned long>::max()); // NOLINT(runtime/int)
+#else
+ return absl::Seconds(std::numeric_limits<time_t>::max());
+#endif
+}
+
+// Sleeps for the given duration.
+// REQUIRES: to_sleep <= MaxSleep().
+void SleepOnce(absl::Duration to_sleep) {
+#ifdef _WIN32
+ Sleep(to_sleep / absl::Milliseconds(1));
+#else
+ struct timespec sleep_time = absl::ToTimespec(to_sleep);
+ while (nanosleep(&sleep_time, &sleep_time) != 0 && errno == EINTR) {
+ // Ignore signals and wait for the full interval to elapse.
+ }
+#endif
+}
+
+} // namespace
+} // namespace absl
+
+extern "C" {
+
+ABSL_ATTRIBUTE_WEAK void AbslInternalSleepFor(absl::Duration duration) {
+ while (duration > absl::ZeroDuration()) {
+ absl::Duration to_sleep = std::min(duration, absl::MaxSleep());
+ absl::SleepOnce(to_sleep);
+ duration -= to_sleep;
+ }
+}
+
+} // extern "C"
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock.h
new file mode 100644
index 0000000..3753d4e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock.h
@@ -0,0 +1,72 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: clock.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains utility functions for working with the system-wide
+// realtime clock. For descriptions of the main time abstractions used within
+// this header file, consult the time.h header file.
+#ifndef ABSL_TIME_CLOCK_H_
+#define ABSL_TIME_CLOCK_H_
+
+#include "absl/base/macros.h"
+#include "absl/time/time.h"
+
+namespace absl {
+
+// Now()
+//
+// Returns the current time, expressed as an `absl::Time` absolute time value.
+absl::Time Now();
+
+// GetCurrentTimeNanos()
+//
+// Returns the current time, expressed as a count of nanoseconds since the Unix
+// Epoch (https://en.wikipedia.org/wiki/Unix_time). Prefer `absl::Now()` instead
+// for all but the most performance-sensitive cases (i.e. when you are calling
+// this function hundreds of thousands of times per second).
+int64_t GetCurrentTimeNanos();
+
+// SleepFor()
+//
+// Sleeps for the specified duration, expressed as an `absl::Duration`.
+//
+// Notes:
+// * Signal interruptions will not reduce the sleep duration.
+// * Returns immediately when passed a nonpositive duration.
+void SleepFor(absl::Duration duration);
+
+} // namespace absl
+
+// -----------------------------------------------------------------------------
+// Implementation Details
+// -----------------------------------------------------------------------------
+
+// In some build configurations we pass --detect-odr-violations to the
+// gold linker. This causes it to flag weak symbol overrides as ODR
+// violations. Because ODR only applies to C++ and not C,
+// --detect-odr-violations ignores symbols not mangled with C++ names.
+// By changing our extension points to be extern "C", we dodge this
+// check.
+extern "C" {
+void AbslInternalSleepFor(absl::Duration duration);
+} // extern "C"
+
+inline void absl::SleepFor(absl::Duration duration) {
+ AbslInternalSleepFor(duration);
+}
+
+#endif // ABSL_TIME_CLOCK_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock_test.cc
new file mode 100644
index 0000000..f143c03
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/clock_test.cc
@@ -0,0 +1,70 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/clock.h"
+
+#include "absl/base/config.h"
+#if defined(ABSL_HAVE_ALARM)
+#include <signal.h>
+#include <unistd.h>
+#elif defined(__linux__) || defined(__APPLE__)
+#error all known Linux and Apple targets have alarm
+#endif
+
+#include "gtest/gtest.h"
+#include "absl/time/time.h"
+
+namespace {
+
+TEST(Time, Now) {
+ const absl::Time before = absl::FromUnixNanos(absl::GetCurrentTimeNanos());
+ const absl::Time now = absl::Now();
+ const absl::Time after = absl::FromUnixNanos(absl::GetCurrentTimeNanos());
+ EXPECT_GE(now, before);
+ EXPECT_GE(after, now);
+}
+
+TEST(SleepForTest, BasicSanity) {
+ absl::Duration sleep_time = absl::Milliseconds(2500);
+ absl::Time start = absl::Now();
+ absl::SleepFor(sleep_time);
+ absl::Time end = absl::Now();
+ EXPECT_LE(sleep_time - absl::Milliseconds(100), end - start);
+ EXPECT_GE(sleep_time + absl::Milliseconds(200), end - start);
+}
+
+#ifdef ABSL_HAVE_ALARM
+// Helper for test SleepFor.
+bool alarm_handler_invoked = false;
+void AlarmHandler(int signo) {
+ ASSERT_EQ(signo, SIGALRM);
+ alarm_handler_invoked = true;
+}
+
+TEST(SleepForTest, AlarmSupport) {
+ alarm_handler_invoked = false;
+ sig_t old_alarm = signal(SIGALRM, AlarmHandler);
+ alarm(2);
+ absl::Duration sleep_time = absl::Milliseconds(3500);
+ absl::Time start = absl::Now();
+ absl::SleepFor(sleep_time);
+ absl::Time end = absl::Now();
+ EXPECT_TRUE(alarm_handler_invoked);
+ EXPECT_LE(sleep_time - absl::Milliseconds(100), end - start);
+ EXPECT_GE(sleep_time + absl::Milliseconds(200), end - start);
+ signal(SIGALRM, old_alarm);
+}
+#endif // ABSL_HAVE_ALARM
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/duration.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/duration.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/duration.cc
new file mode 100644
index 0000000..82b4d98
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/duration.cc
@@ -0,0 +1,908 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The implementation of the absl::Duration class, which is declared in
+// //absl/time.h. This class behaves like a numeric type; it has no public
+// methods and is used only through the operators defined here.
+//
+// Implementation notes:
+//
+// An absl::Duration is represented as
+//
+// rep_hi_ : (int64_t) Whole seconds
+// rep_lo_ : (uint32_t) Fractions of a second
+//
+// The seconds value (rep_hi_) may be positive or negative as appropriate.
+// The fractional seconds (rep_lo_) is always a positive offset from rep_hi_.
+// The API for Duration guarantees at least nanosecond resolution, which
+// means rep_lo_ could have a max value of 1B - 1 if it stored nanoseconds.
+// However, to utilize more of the available 32 bits of space in rep_lo_,
+// we instead store quarters of a nanosecond in rep_lo_ resulting in a max
+// value of 4B - 1. This allows us to correctly handle calculations like
+// 0.5 nanos + 0.5 nanos = 1 nano. The following example shows the actual
+// Duration rep using quarters of a nanosecond.
+//
+// 2.5 sec = {rep_hi_=2, rep_lo_=2000000000} // lo = 4 * 500000000
+// -2.5 sec = {rep_hi_=-3, rep_lo_=2000000000}
+//
+// Infinite durations are represented as Durations with the rep_lo_ field set
+// to all 1s.
+//
+// +InfiniteDuration:
+// rep_hi_ : kint64max
+// rep_lo_ : ~0U
+//
+// -InfiniteDuration:
+// rep_hi_ : kint64min
+// rep_lo_ : ~0U
+//
+// Arithmetic overflows/underflows to +/- infinity and saturates.
+
+#include <algorithm>
+#include <cassert>
+#include <cctype>
+#include <cerrno>
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <cstring>
+#include <ctime>
+#include <functional>
+#include <limits>
+#include <string>
+
+#include "absl/base/casts.h"
+#include "absl/numeric/int128.h"
+#include "absl/time/time.h"
+
+namespace absl {
+
+namespace {
+
+using time_internal::kTicksPerNanosecond;
+using time_internal::kTicksPerSecond;
+
+constexpr int64_t kint64max = std::numeric_limits<int64_t>::max();
+constexpr int64_t kint64min = std::numeric_limits<int64_t>::min();
+
+// Can't use std::isinfinite() because it doesn't exist on windows.
+inline bool IsFinite(double d) {
+ return d != std::numeric_limits<double>::infinity() &&
+ d != -std::numeric_limits<double>::infinity();
+}
+
+// Can't use std::round() because it is only available in C++11.
+// Note that we ignore the possibility of floating-point over/underflow.
+template <typename Double>
+inline double Round(Double d) {
+ return d < 0 ? std::ceil(d - 0.5) : std::floor(d + 0.5);
+}
+
+// *sec may be positive or negative. *ticks must be in the range
+// -kTicksPerSecond < *ticks < kTicksPerSecond. If *ticks is negative it
+// will be normalized to a positive value by adjusting *sec accordingly.
+inline void NormalizeTicks(int64_t* sec, int64_t* ticks) {
+ if (*ticks < 0) {
+ --*sec;
+ *ticks += kTicksPerSecond;
+ }
+}
+
+// Makes a uint128 from the absolute value of the given scalar.
+inline uint128 MakeU128(int64_t a) {
+ uint128 u128 = 0;
+ if (a < 0) {
+ ++u128;
+ ++a; // Makes it safe to negate 'a'
+ a = -a;
+ }
+ u128 += static_cast<uint64_t>(a);
+ return u128;
+}
+
+// Makes a uint128 count of ticks out of the absolute value of the Duration.
+inline uint128 MakeU128Ticks(Duration d) {
+ int64_t rep_hi = time_internal::GetRepHi(d);
+ uint32_t rep_lo = time_internal::GetRepLo(d);
+ if (rep_hi < 0) {
+ ++rep_hi;
+ rep_hi = -rep_hi;
+ rep_lo = kTicksPerSecond - rep_lo;
+ }
+ uint128 u128 = static_cast<uint64_t>(rep_hi);
+ u128 *= static_cast<uint64_t>(kTicksPerSecond);
+ u128 += rep_lo;
+ return u128;
+}
+
+// Breaks a uint128 of ticks into a Duration.
+inline Duration MakeDurationFromU128(uint128 u128, bool is_neg) {
+ int64_t rep_hi;
+ uint32_t rep_lo;
+ const uint64_t h64 = Uint128High64(u128);
+ const uint64_t l64 = Uint128Low64(u128);
+ if (h64 == 0) { // fastpath
+ const uint64_t hi = l64 / kTicksPerSecond;
+ rep_hi = static_cast<int64_t>(hi);
+ rep_lo = static_cast<uint32_t>(l64 - hi * kTicksPerSecond);
+ } else {
+ // kMaxRepHi64 is the high 64 bits of (2^63 * kTicksPerSecond).
+ // Any positive tick count whose high 64 bits are >= kMaxRepHi64
+ // is not representable as a Duration. A negative tick count can
+ // have its high 64 bits == kMaxRepHi64 but only when the low 64
+ // bits are all zero, otherwise it is not representable either.
+ const uint64_t kMaxRepHi64 = 0x77359400UL;
+ if (h64 >= kMaxRepHi64) {
+ if (is_neg && h64 == kMaxRepHi64 && l64 == 0) {
+ // Avoid trying to represent -kint64min below.
+ return time_internal::MakeDuration(kint64min);
+ }
+ return is_neg ? -InfiniteDuration() : InfiniteDuration();
+ }
+ const uint128 kTicksPerSecond128 = static_cast<uint64_t>(kTicksPerSecond);
+ const uint128 hi = u128 / kTicksPerSecond128;
+ rep_hi = static_cast<int64_t>(Uint128Low64(hi));
+ rep_lo =
+ static_cast<uint32_t>(Uint128Low64(u128 - hi * kTicksPerSecond128));
+ }
+ if (is_neg) {
+ rep_hi = -rep_hi;
+ if (rep_lo != 0) {
+ --rep_hi;
+ rep_lo = kTicksPerSecond - rep_lo;
+ }
+ }
+ return time_internal::MakeDuration(rep_hi, rep_lo);
+}
+
+// Convert between int64_t and uint64_t, preserving representation. This
+// allows us to do arithmetic in the unsigned domain, where overflow has
+// well-defined behavior. See operator+=() and operator-=().
+//
+// C99 7.20.1.1.1, as referenced by C++11 18.4.1.2, says, "The typedef
+// name intN_t designates a signed integer type with width N, no padding
+// bits, and a two's complement representation." So, we can convert to
+// and from the corresponding uint64_t value using a bit cast.
+inline uint64_t EncodeTwosComp(int64_t v) {
+ return absl::bit_cast<uint64_t>(v);
+}
+inline int64_t DecodeTwosComp(uint64_t v) { return absl::bit_cast<int64_t>(v); }
+
+// Note: The overflow detection in this function is done using greater/less *or
+// equal* because kint64max/min is too large to be represented exactly in a
+// double (which only has 53 bits of precision). In order to avoid assigning to
+// rep->hi a double value that is too large for an int64_t (and therefore is
+// undefined), we must consider computations that equal kint64max/min as a
+// double as overflow cases.
+inline bool SafeAddRepHi(double a_hi, double b_hi, Duration* d) {
+ double c = a_hi + b_hi;
+ if (c >= kint64max) {
+ *d = InfiniteDuration();
+ return false;
+ }
+ if (c <= kint64min) {
+ *d = -InfiniteDuration();
+ return false;
+ }
+ *d = time_internal::MakeDuration(c, time_internal::GetRepLo(*d));
+ return true;
+}
+
+// A functor that's similar to std::multiplies<T>, except this returns the max
+// T value instead of overflowing. This is only defined for uint128.
+template <typename Ignored>
+struct SafeMultiply {
+ uint128 operator()(uint128 a, uint128 b) const {
+ // b hi is always zero because it originated as an int64_t.
+ assert(Uint128High64(b) == 0);
+ // Fastpath to avoid the expensive overflow check with division.
+ if (Uint128High64(a) == 0) {
+ return (((Uint128Low64(a) | Uint128Low64(b)) >> 32) == 0)
+ ? static_cast<uint128>(Uint128Low64(a) * Uint128Low64(b))
+ : a * b;
+ }
+ return b == 0 ? b : (a > kuint128max / b) ? kuint128max : a * b;
+ }
+};
+
+// Scales (i.e., multiplies or divides, depending on the Operation template)
+// the Duration d by the int64_t r.
+template <template <typename> class Operation>
+inline Duration ScaleFixed(Duration d, int64_t r) {
+ const uint128 a = MakeU128Ticks(d);
+ const uint128 b = MakeU128(r);
+ const uint128 q = Operation<uint128>()(a, b);
+ const bool is_neg = (time_internal::GetRepHi(d) < 0) != (r < 0);
+ return MakeDurationFromU128(q, is_neg);
+}
+
+// Scales (i.e., multiplies or divides, depending on the Operation template)
+// the Duration d by the double r.
+template <template <typename> class Operation>
+inline Duration ScaleDouble(Duration d, double r) {
+ Operation<double> op;
+ double hi_doub = op(time_internal::GetRepHi(d), r);
+ double lo_doub = op(time_internal::GetRepLo(d), r);
+
+ double hi_int = 0;
+ double hi_frac = std::modf(hi_doub, &hi_int);
+
+ // Moves hi's fractional bits to lo.
+ lo_doub /= kTicksPerSecond;
+ lo_doub += hi_frac;
+
+ double lo_int = 0;
+ double lo_frac = std::modf(lo_doub, &lo_int);
+
+ // Rolls lo into hi if necessary.
+ int64_t lo64 = Round(lo_frac * kTicksPerSecond);
+
+ Duration ans;
+ if (!SafeAddRepHi(hi_int, lo_int, &ans)) return ans;
+ int64_t hi64 = time_internal::GetRepHi(ans);
+ if (!SafeAddRepHi(hi64, lo64 / kTicksPerSecond, &ans)) return ans;
+ hi64 = time_internal::GetRepHi(ans);
+ lo64 %= kTicksPerSecond;
+ NormalizeTicks(&hi64, &lo64);
+ return time_internal::MakeDuration(hi64, lo64);
+}
+
+// Tries to divide num by den as fast as possible by looking for common, easy
+// cases. If the division was done, the quotient is in *q and the remainder is
+// in *rem and true will be returned.
+inline bool IDivFastPath(const Duration num, const Duration den, int64_t* q,
+ Duration* rem) {
+ // Bail if num or den is an infinity.
+ if (time_internal::IsInfiniteDuration(num) ||
+ time_internal::IsInfiniteDuration(den))
+ return false;
+
+ int64_t num_hi = time_internal::GetRepHi(num);
+ uint32_t num_lo = time_internal::GetRepLo(num);
+ int64_t den_hi = time_internal::GetRepHi(den);
+ uint32_t den_lo = time_internal::GetRepLo(den);
+
+ if (den_hi == 0 && den_lo == kTicksPerNanosecond) {
+ // Dividing by 1ns
+ if (num_hi >= 0 && num_hi < (kint64max - kTicksPerSecond) / 1000000000) {
+ *q = num_hi * 1000000000 + num_lo / kTicksPerNanosecond;
+ *rem = time_internal::MakeDuration(0, num_lo % den_lo);
+ return true;
+ }
+ } else if (den_hi == 0 && den_lo == 100 * kTicksPerNanosecond) {
+ // Dividing by 100ns (common when converting to Universal time)
+ if (num_hi >= 0 && num_hi < (kint64max - kTicksPerSecond) / 10000000) {
+ *q = num_hi * 10000000 + num_lo / (100 * kTicksPerNanosecond);
+ *rem = time_internal::MakeDuration(0, num_lo % den_lo);
+ return true;
+ }
+ } else if (den_hi == 0 && den_lo == 1000 * kTicksPerNanosecond) {
+ // Dividing by 1us
+ if (num_hi >= 0 && num_hi < (kint64max - kTicksPerSecond) / 1000000) {
+ *q = num_hi * 1000000 + num_lo / (1000 * kTicksPerNanosecond);
+ *rem = time_internal::MakeDuration(0, num_lo % den_lo);
+ return true;
+ }
+ } else if (den_hi == 0 && den_lo == 1000000 * kTicksPerNanosecond) {
+ // Dividing by 1ms
+ if (num_hi >= 0 && num_hi < (kint64max - kTicksPerSecond) / 1000) {
+ *q = num_hi * 1000 + num_lo / (1000000 * kTicksPerNanosecond);
+ *rem = time_internal::MakeDuration(0, num_lo % den_lo);
+ return true;
+ }
+ } else if (den_hi > 0 && den_lo == 0) {
+ // Dividing by positive multiple of 1s
+ if (num_hi >= 0) {
+ if (den_hi == 1) {
+ *q = num_hi;
+ *rem = time_internal::MakeDuration(0, num_lo);
+ return true;
+ }
+ *q = num_hi / den_hi;
+ *rem = time_internal::MakeDuration(num_hi % den_hi, num_lo);
+ return true;
+ }
+ if (num_lo != 0) {
+ num_hi += 1;
+ }
+ int64_t quotient = num_hi / den_hi;
+ int64_t rem_sec = num_hi % den_hi;
+ if (rem_sec > 0) {
+ rem_sec -= den_hi;
+ quotient += 1;
+ }
+ if (num_lo != 0) {
+ rem_sec -= 1;
+ }
+ *q = quotient;
+ *rem = time_internal::MakeDuration(rem_sec, num_lo);
+ return true;
+ }
+
+ return false;
+}
+
+} // namespace
+
+namespace time_internal {
+
+// The 'satq' argument indicates whether the quotient should saturate at the
+// bounds of int64_t. If it does saturate, the difference will spill over to
+// the remainder. If it does not saturate, the remainder remain accurate,
+// but the returned quotient will over/underflow int64_t and should not be used.
+int64_t IDivDuration(bool satq, const Duration num, const Duration den,
+ Duration* rem) {
+ int64_t q = 0;
+ if (IDivFastPath(num, den, &q, rem)) {
+ return q;
+ }
+
+ const bool num_neg = num < ZeroDuration();
+ const bool den_neg = den < ZeroDuration();
+ const bool quotient_neg = num_neg != den_neg;
+
+ if (time_internal::IsInfiniteDuration(num) || den == ZeroDuration()) {
+ *rem = num_neg ? -InfiniteDuration() : InfiniteDuration();
+ return quotient_neg ? kint64min : kint64max;
+ }
+ if (time_internal::IsInfiniteDuration(den)) {
+ *rem = num;
+ return 0;
+ }
+
+ const uint128 a = MakeU128Ticks(num);
+ const uint128 b = MakeU128Ticks(den);
+ uint128 quotient128 = a / b;
+
+ if (satq) {
+ // Limits the quotient to the range of int64_t.
+ if (quotient128 > uint128(static_cast<uint64_t>(kint64max))) {
+ quotient128 = quotient_neg ? uint128(static_cast<uint64_t>(kint64min))
+ : uint128(static_cast<uint64_t>(kint64max));
+ }
+ }
+
+ const uint128 remainder128 = a - quotient128 * b;
+ *rem = MakeDurationFromU128(remainder128, num_neg);
+
+ if (!quotient_neg || quotient128 == 0) {
+ return Uint128Low64(quotient128) & kint64max;
+ }
+ // The quotient needs to be negated, but we need to carefully handle
+ // quotient128s with the top bit on.
+ return -static_cast<int64_t>(Uint128Low64(quotient128 - 1) & kint64max) - 1;
+}
+
+} // namespace time_internal
+
+//
+// Additive operators.
+//
+
+Duration& Duration::operator+=(Duration rhs) {
+ if (time_internal::IsInfiniteDuration(*this)) return *this;
+ if (time_internal::IsInfiniteDuration(rhs)) return *this = rhs;
+ const int64_t orig_rep_hi = rep_hi_;
+ rep_hi_ =
+ DecodeTwosComp(EncodeTwosComp(rep_hi_) + EncodeTwosComp(rhs.rep_hi_));
+ if (rep_lo_ >= kTicksPerSecond - rhs.rep_lo_) {
+ rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_) + 1);
+ rep_lo_ -= kTicksPerSecond;
+ }
+ rep_lo_ += rhs.rep_lo_;
+ if (rhs.rep_hi_ < 0 ? rep_hi_ > orig_rep_hi : rep_hi_ < orig_rep_hi) {
+ return *this = rhs.rep_hi_ < 0 ? -InfiniteDuration() : InfiniteDuration();
+ }
+ return *this;
+}
+
+Duration& Duration::operator-=(Duration rhs) {
+ if (time_internal::IsInfiniteDuration(*this)) return *this;
+ if (time_internal::IsInfiniteDuration(rhs)) {
+ return *this = rhs.rep_hi_ >= 0 ? -InfiniteDuration() : InfiniteDuration();
+ }
+ const int64_t orig_rep_hi = rep_hi_;
+ rep_hi_ =
+ DecodeTwosComp(EncodeTwosComp(rep_hi_) - EncodeTwosComp(rhs.rep_hi_));
+ if (rep_lo_ < rhs.rep_lo_) {
+ rep_hi_ = DecodeTwosComp(EncodeTwosComp(rep_hi_) - 1);
+ rep_lo_ += kTicksPerSecond;
+ }
+ rep_lo_ -= rhs.rep_lo_;
+ if (rhs.rep_hi_ < 0 ? rep_hi_ < orig_rep_hi : rep_hi_ > orig_rep_hi) {
+ return *this = rhs.rep_hi_ >= 0 ? -InfiniteDuration() : InfiniteDuration();
+ }
+ return *this;
+}
+
+//
+// Multiplicative operators.
+//
+
+Duration& Duration::operator*=(int64_t r) {
+ if (time_internal::IsInfiniteDuration(*this)) {
+ const bool is_neg = (r < 0) != (rep_hi_ < 0);
+ return *this = is_neg ? -InfiniteDuration() : InfiniteDuration();
+ }
+ return *this = ScaleFixed<SafeMultiply>(*this, r);
+}
+
+Duration& Duration::operator*=(double r) {
+ if (time_internal::IsInfiniteDuration(*this) || !IsFinite(r)) {
+ const bool is_neg = (std::signbit(r) != 0) != (rep_hi_ < 0);
+ return *this = is_neg ? -InfiniteDuration() : InfiniteDuration();
+ }
+ return *this = ScaleDouble<std::multiplies>(*this, r);
+}
+
+Duration& Duration::operator/=(int64_t r) {
+ if (time_internal::IsInfiniteDuration(*this) || r == 0) {
+ const bool is_neg = (r < 0) != (rep_hi_ < 0);
+ return *this = is_neg ? -InfiniteDuration() : InfiniteDuration();
+ }
+ return *this = ScaleFixed<std::divides>(*this, r);
+}
+
+Duration& Duration::operator/=(double r) {
+ if (time_internal::IsInfiniteDuration(*this) || r == 0.0) {
+ const bool is_neg = (std::signbit(r) != 0) != (rep_hi_ < 0);
+ return *this = is_neg ? -InfiniteDuration() : InfiniteDuration();
+ }
+ return *this = ScaleDouble<std::divides>(*this, r);
+}
+
+Duration& Duration::operator%=(Duration rhs) {
+ time_internal::IDivDuration(false, *this, rhs, this);
+ return *this;
+}
+
+double FDivDuration(Duration num, Duration den) {
+ // Arithmetic with infinity is sticky.
+ if (time_internal::IsInfiniteDuration(num) || den == ZeroDuration()) {
+ return (num < ZeroDuration()) == (den < ZeroDuration())
+ ? std::numeric_limits<double>::infinity()
+ : -std::numeric_limits<double>::infinity();
+ }
+ if (time_internal::IsInfiniteDuration(den)) return 0.0;
+
+ double a =
+ static_cast<double>(time_internal::GetRepHi(num)) * kTicksPerSecond +
+ time_internal::GetRepLo(num);
+ double b =
+ static_cast<double>(time_internal::GetRepHi(den)) * kTicksPerSecond +
+ time_internal::GetRepLo(den);
+ return a / b;
+}
+
+//
+// Trunc/Floor/Ceil.
+//
+
+Duration Trunc(Duration d, Duration unit) {
+ return d - (d % unit);
+}
+
+Duration Floor(const Duration d, const Duration unit) {
+ const absl::Duration td = Trunc(d, unit);
+ return td <= d ? td : td - AbsDuration(unit);
+}
+
+Duration Ceil(const Duration d, const Duration unit) {
+ const absl::Duration td = Trunc(d, unit);
+ return td >= d ? td : td + AbsDuration(unit);
+}
+
+//
+// Factory functions.
+//
+
+Duration DurationFromTimespec(timespec ts) {
+ if (static_cast<uint64_t>(ts.tv_nsec) < 1000 * 1000 * 1000) {
+ int64_t ticks = ts.tv_nsec * kTicksPerNanosecond;
+ return time_internal::MakeDuration(ts.tv_sec, ticks);
+ }
+ return Seconds(ts.tv_sec) + Nanoseconds(ts.tv_nsec);
+}
+
+Duration DurationFromTimeval(timeval tv) {
+ if (static_cast<uint64_t>(tv.tv_usec) < 1000 * 1000) {
+ int64_t ticks = tv.tv_usec * 1000 * kTicksPerNanosecond;
+ return time_internal::MakeDuration(tv.tv_sec, ticks);
+ }
+ return Seconds(tv.tv_sec) + Microseconds(tv.tv_usec);
+}
+
+//
+// Conversion to other duration types.
+//
+
+int64_t ToInt64Nanoseconds(Duration d) {
+ if (time_internal::GetRepHi(d) >= 0 &&
+ time_internal::GetRepHi(d) >> 33 == 0) {
+ return (time_internal::GetRepHi(d) * 1000 * 1000 * 1000) +
+ (time_internal::GetRepLo(d) / kTicksPerNanosecond);
+ }
+ return d / Nanoseconds(1);
+}
+int64_t ToInt64Microseconds(Duration d) {
+ if (time_internal::GetRepHi(d) >= 0 &&
+ time_internal::GetRepHi(d) >> 43 == 0) {
+ return (time_internal::GetRepHi(d) * 1000 * 1000) +
+ (time_internal::GetRepLo(d) / (kTicksPerNanosecond * 1000));
+ }
+ return d / Microseconds(1);
+}
+int64_t ToInt64Milliseconds(Duration d) {
+ if (time_internal::GetRepHi(d) >= 0 &&
+ time_internal::GetRepHi(d) >> 53 == 0) {
+ return (time_internal::GetRepHi(d) * 1000) +
+ (time_internal::GetRepLo(d) / (kTicksPerNanosecond * 1000 * 1000));
+ }
+ return d / Milliseconds(1);
+}
+int64_t ToInt64Seconds(Duration d) {
+ int64_t hi = time_internal::GetRepHi(d);
+ if (time_internal::IsInfiniteDuration(d)) return hi;
+ if (hi < 0 && time_internal::GetRepLo(d) != 0) ++hi;
+ return hi;
+}
+int64_t ToInt64Minutes(Duration d) {
+ int64_t hi = time_internal::GetRepHi(d);
+ if (time_internal::IsInfiniteDuration(d)) return hi;
+ if (hi < 0 && time_internal::GetRepLo(d) != 0) ++hi;
+ return hi / 60;
+}
+int64_t ToInt64Hours(Duration d) {
+ int64_t hi = time_internal::GetRepHi(d);
+ if (time_internal::IsInfiniteDuration(d)) return hi;
+ if (hi < 0 && time_internal::GetRepLo(d) != 0) ++hi;
+ return hi / (60 * 60);
+}
+
+double ToDoubleNanoseconds(Duration d) {
+ return FDivDuration(d, Nanoseconds(1));
+}
+double ToDoubleMicroseconds(Duration d) {
+ return FDivDuration(d, Microseconds(1));
+}
+double ToDoubleMilliseconds(Duration d) {
+ return FDivDuration(d, Milliseconds(1));
+}
+double ToDoubleSeconds(Duration d) {
+ return FDivDuration(d, Seconds(1));
+}
+double ToDoubleMinutes(Duration d) {
+ return FDivDuration(d, Minutes(1));
+}
+double ToDoubleHours(Duration d) {
+ return FDivDuration(d, Hours(1));
+}
+
+timespec ToTimespec(Duration d) {
+ timespec ts;
+ if (!time_internal::IsInfiniteDuration(d)) {
+ int64_t rep_hi = time_internal::GetRepHi(d);
+ uint32_t rep_lo = time_internal::GetRepLo(d);
+ if (rep_hi < 0) {
+ // Tweak the fields so that unsigned division of rep_lo
+ // maps to truncation (towards zero) for the timespec.
+ rep_lo += kTicksPerNanosecond - 1;
+ if (rep_lo >= kTicksPerSecond) {
+ rep_hi += 1;
+ rep_lo -= kTicksPerSecond;
+ }
+ }
+ ts.tv_sec = rep_hi;
+ if (ts.tv_sec == rep_hi) { // no time_t narrowing
+ ts.tv_nsec = rep_lo / kTicksPerNanosecond;
+ return ts;
+ }
+ }
+ if (d >= ZeroDuration()) {
+ ts.tv_sec = std::numeric_limits<time_t>::max();
+ ts.tv_nsec = 1000 * 1000 * 1000 - 1;
+ } else {
+ ts.tv_sec = std::numeric_limits<time_t>::min();
+ ts.tv_nsec = 0;
+ }
+ return ts;
+}
+
+timeval ToTimeval(Duration d) {
+ timeval tv;
+ timespec ts = ToTimespec(d);
+ if (ts.tv_sec < 0) {
+ // Tweak the fields so that positive division of tv_nsec
+ // maps to truncation (towards zero) for the timeval.
+ ts.tv_nsec += 1000 - 1;
+ if (ts.tv_nsec >= 1000 * 1000 * 1000) {
+ ts.tv_sec += 1;
+ ts.tv_nsec -= 1000 * 1000 * 1000;
+ }
+ }
+ tv.tv_sec = ts.tv_sec;
+ if (tv.tv_sec != ts.tv_sec) { // narrowing
+ if (ts.tv_sec < 0) {
+ tv.tv_sec = std::numeric_limits<decltype(tv.tv_sec)>::min();
+ tv.tv_usec = 0;
+ } else {
+ tv.tv_sec = std::numeric_limits<decltype(tv.tv_sec)>::max();
+ tv.tv_usec = 1000 * 1000 - 1;
+ }
+ return tv;
+ }
+ tv.tv_usec = static_cast<int>(ts.tv_nsec / 1000); // suseconds_t
+ return tv;
+}
+
+std::chrono::nanoseconds ToChronoNanoseconds(Duration d) {
+ return time_internal::ToChronoDuration<std::chrono::nanoseconds>(d);
+}
+std::chrono::microseconds ToChronoMicroseconds(Duration d) {
+ return time_internal::ToChronoDuration<std::chrono::microseconds>(d);
+}
+std::chrono::milliseconds ToChronoMilliseconds(Duration d) {
+ return time_internal::ToChronoDuration<std::chrono::milliseconds>(d);
+}
+std::chrono::seconds ToChronoSeconds(Duration d) {
+ return time_internal::ToChronoDuration<std::chrono::seconds>(d);
+}
+std::chrono::minutes ToChronoMinutes(Duration d) {
+ return time_internal::ToChronoDuration<std::chrono::minutes>(d);
+}
+std::chrono::hours ToChronoHours(Duration d) {
+ return time_internal::ToChronoDuration<std::chrono::hours>(d);
+}
+
+//
+// To/From std::string formatting.
+//
+
+namespace {
+
+// Formats a positive 64-bit integer in the given field width. Note that
+// it is up to the caller of Format64() to ensure that there is sufficient
+// space before ep to hold the conversion.
+char* Format64(char* ep, int width, int64_t v) {
+ do {
+ --width;
+ *--ep = '0' + (v % 10); // contiguous digits
+ } while (v /= 10);
+ while (--width >= 0) *--ep = '0'; // zero pad
+ return ep;
+}
+
+// Helpers for FormatDuration() that format 'n' and append it to 'out'
+// followed by the given 'unit'. If 'n' formats to "0", nothing is
+// appended (not even the unit).
+
+// A type that encapsulates how to display a value of a particular unit. For
+// values that are displayed with fractional parts, the precision indicates
+// where to round the value. The precision varies with the display unit because
+// a Duration can hold only quarters of a nanosecond, so displaying information
+// beyond that is just noise.
+//
+// For example, a microsecond value of 42.00025xxxxx should not display beyond 5
+// fractional digits, because it is in the noise of what a Duration can
+// represent.
+struct DisplayUnit {
+ const char* abbr;
+ int prec;
+ double pow10;
+};
+const DisplayUnit kDisplayNano = {"ns", 2, 1e2};
+const DisplayUnit kDisplayMicro = {"us", 5, 1e5};
+const DisplayUnit kDisplayMilli = {"ms", 8, 1e8};
+const DisplayUnit kDisplaySec = {"s", 11, 1e11};
+const DisplayUnit kDisplayMin = {"m", -1, 0.0}; // prec ignored
+const DisplayUnit kDisplayHour = {"h", -1, 0.0}; // prec ignored
+
+void AppendNumberUnit(std::string* out, int64_t n, DisplayUnit unit) {
+ char buf[sizeof("2562047788015216")]; // hours in max duration
+ char* const ep = buf + sizeof(buf);
+ char* bp = Format64(ep, 0, n);
+ if (*bp != '0' || bp + 1 != ep) {
+ out->append(bp, ep - bp);
+ out->append(unit.abbr);
+ }
+}
+
+// Note: unit.prec is limited to double's digits10 value (typically 15) so it
+// always fits in buf[].
+void AppendNumberUnit(std::string* out, double n, DisplayUnit unit) {
+ const int buf_size = std::numeric_limits<double>::digits10;
+ const int prec = std::min(buf_size, unit.prec);
+ char buf[buf_size]; // also large enough to hold integer part
+ char* ep = buf + sizeof(buf);
+ double d = 0;
+ int64_t frac_part = Round(std::modf(n, &d) * unit.pow10);
+ int64_t int_part = d;
+ if (int_part != 0 || frac_part != 0) {
+ char* bp = Format64(ep, 0, int_part); // always < 1000
+ out->append(bp, ep - bp);
+ if (frac_part != 0) {
+ out->push_back('.');
+ bp = Format64(ep, prec, frac_part);
+ while (ep[-1] == '0') --ep;
+ out->append(bp, ep - bp);
+ }
+ out->append(unit.abbr);
+ }
+}
+
+} // namespace
+
+// From Go's doc at http://golang.org/pkg/time/#Duration.String
+// [FormatDuration] returns a std::string representing the duration in the
+// form "72h3m0.5s". Leading zero units are omitted. As a special
+// case, durations less than one second format use a smaller unit
+// (milli-, micro-, or nanoseconds) to ensure that the leading digit
+// is non-zero. The zero duration formats as 0, with no unit.
+std::string FormatDuration(Duration d) {
+ const Duration min_duration = Seconds(kint64min);
+ if (d == min_duration) {
+ // Avoid needing to negate kint64min by directly returning what the
+ // following code should produce in that case.
+ return "-2562047788015215h30m8s";
+ }
+ std::string s;
+ if (d < ZeroDuration()) {
+ s.append("-");
+ d = -d;
+ }
+ if (d == InfiniteDuration()) {
+ s.append("inf");
+ } else if (d < Seconds(1)) {
+ // Special case for durations with a magnitude < 1 second. The duration
+ // is printed as a fraction of a single unit, e.g., "1.2ms".
+ if (d < Microseconds(1)) {
+ AppendNumberUnit(&s, FDivDuration(d, Nanoseconds(1)), kDisplayNano);
+ } else if (d < Milliseconds(1)) {
+ AppendNumberUnit(&s, FDivDuration(d, Microseconds(1)), kDisplayMicro);
+ } else {
+ AppendNumberUnit(&s, FDivDuration(d, Milliseconds(1)), kDisplayMilli);
+ }
+ } else {
+ AppendNumberUnit(&s, IDivDuration(d, Hours(1), &d), kDisplayHour);
+ AppendNumberUnit(&s, IDivDuration(d, Minutes(1), &d), kDisplayMin);
+ AppendNumberUnit(&s, FDivDuration(d, Seconds(1)), kDisplaySec);
+ }
+ if (s.empty() || s == "-") {
+ s = "0";
+ }
+ return s;
+}
+
+namespace {
+
+// A helper for ParseDuration() that parses a leading number from the given
+// std::string and stores the result in *int_part/*frac_part/*frac_scale. The
+// given std::string pointer is modified to point to the first unconsumed char.
+bool ConsumeDurationNumber(const char** dpp, int64_t* int_part,
+ int64_t* frac_part, int64_t* frac_scale) {
+ *int_part = 0;
+ *frac_part = 0;
+ *frac_scale = 1; // invariant: *frac_part < *frac_scale
+ const char* start = *dpp;
+ for (; std::isdigit(**dpp); *dpp += 1) {
+ const int d = **dpp - '0'; // contiguous digits
+ if (*int_part > kint64max / 10) return false;
+ *int_part *= 10;
+ if (*int_part > kint64max - d) return false;
+ *int_part += d;
+ }
+ const bool int_part_empty = (*dpp == start);
+ if (**dpp != '.') return !int_part_empty;
+ for (*dpp += 1; std::isdigit(**dpp); *dpp += 1) {
+ const int d = **dpp - '0'; // contiguous digits
+ if (*frac_scale <= kint64max / 10) {
+ *frac_part *= 10;
+ *frac_part += d;
+ *frac_scale *= 10;
+ }
+ }
+ return !int_part_empty || *frac_scale != 1;
+}
+
+// A helper for ParseDuration() that parses a leading unit designator (e.g.,
+// ns, us, ms, s, m, h) from the given std::string and stores the resulting unit
+// in "*unit". The given std::string pointer is modified to point to the first
+// unconsumed char.
+bool ConsumeDurationUnit(const char** start, Duration* unit) {
+ const char *s = *start;
+ bool ok = true;
+ if (strncmp(s, "ns", 2) == 0) {
+ s += 2;
+ *unit = Nanoseconds(1);
+ } else if (strncmp(s, "us", 2) == 0) {
+ s += 2;
+ *unit = Microseconds(1);
+ } else if (strncmp(s, "ms", 2) == 0) {
+ s += 2;
+ *unit = Milliseconds(1);
+ } else if (strncmp(s, "s", 1) == 0) {
+ s += 1;
+ *unit = Seconds(1);
+ } else if (strncmp(s, "m", 1) == 0) {
+ s += 1;
+ *unit = Minutes(1);
+ } else if (strncmp(s, "h", 1) == 0) {
+ s += 1;
+ *unit = Hours(1);
+ } else {
+ ok = false;
+ }
+ *start = s;
+ return ok;
+}
+
+} // namespace
+
+// From Go's doc at http://golang.org/pkg/time/#ParseDuration
+// [ParseDuration] parses a duration std::string. A duration std::string is
+// a possibly signed sequence of decimal numbers, each with optional
+// fraction and a unit suffix, such as "300ms", "-1.5h" or "2h45m".
+// Valid time units are "ns", "us" "ms", "s", "m", "h".
+bool ParseDuration(const std::string& dur_string, Duration* d) {
+ const char* start = dur_string.c_str();
+ int sign = 1;
+
+ if (*start == '-' || *start == '+') {
+ sign = *start == '-' ? -1 : 1;
+ ++start;
+ }
+
+ // Can't parse a duration from an empty std::string.
+ if (*start == '\0') {
+ return false;
+ }
+
+ // Special case for a std::string of "0".
+ if (*start == '0' && *(start + 1) == '\0') {
+ *d = ZeroDuration();
+ return true;
+ }
+
+ if (strcmp(start, "inf") == 0) {
+ *d = sign * InfiniteDuration();
+ return true;
+ }
+
+ Duration dur;
+ while (*start != '\0') {
+ int64_t int_part;
+ int64_t frac_part;
+ int64_t frac_scale;
+ Duration unit;
+ if (!ConsumeDurationNumber(&start, &int_part, &frac_part, &frac_scale) ||
+ !ConsumeDurationUnit(&start, &unit)) {
+ return false;
+ }
+ if (int_part != 0) dur += sign * int_part * unit;
+ if (frac_part != 0) dur += sign * frac_part * unit / frac_scale;
+ }
+ *d = dur;
+ return true;
+}
+
+// TODO(absl-team): Remove once dependencies are removed.
+bool ParseFlag(const std::string& text, Duration* dst, std::string* /* err */) {
+ return ParseDuration(text, dst);
+}
+
+std::string UnparseFlag(Duration d) {
+ return FormatDuration(d);
+}
+
+} // namespace absl
[16/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_format_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_format_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_format_test.cc
new file mode 100644
index 0000000..6cea036
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_format_test.cc
@@ -0,0 +1,1408 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+#include <chrono>
+#include <iomanip>
+#include <sstream>
+#include <string>
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+using std::chrono::time_point_cast;
+using std::chrono::system_clock;
+using std::chrono::nanoseconds;
+using std::chrono::microseconds;
+using std::chrono::milliseconds;
+using std::chrono::seconds;
+using std::chrono::minutes;
+using std::chrono::hours;
+using testing::HasSubstr;
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+namespace {
+
+// This helper is a macro so that failed expectations show up with the
+// correct line numbers.
+#define ExpectTime(tp, tz, y, m, d, hh, mm, ss, off, isdst, zone) \
+ do { \
+ time_zone::absolute_lookup al = tz.lookup(tp); \
+ EXPECT_EQ(y, al.cs.year()); \
+ EXPECT_EQ(m, al.cs.month()); \
+ EXPECT_EQ(d, al.cs.day()); \
+ EXPECT_EQ(hh, al.cs.hour()); \
+ EXPECT_EQ(mm, al.cs.minute()); \
+ EXPECT_EQ(ss, al.cs.second()); \
+ EXPECT_EQ(off, al.offset); \
+ EXPECT_TRUE(isdst == al.is_dst); \
+ EXPECT_STREQ(zone, al.abbr); \
+ } while (0)
+
+const char RFC3339_full[] = "%Y-%m-%dT%H:%M:%E*S%Ez";
+const char RFC3339_sec[] = "%Y-%m-%dT%H:%M:%S%Ez";
+
+const char RFC1123_full[] = "%a, %d %b %Y %H:%M:%S %z";
+const char RFC1123_no_wday[] = "%d %b %Y %H:%M:%S %z";
+
+// A helper that tests the given format specifier by itself, and with leading
+// and trailing characters. For example: TestFormatSpecifier(tp, "%a", "Thu").
+template <typename D>
+void TestFormatSpecifier(time_point<D> tp, time_zone tz, const std::string& fmt,
+ const std::string& ans) {
+ EXPECT_EQ(ans, format(fmt, tp, tz)) << fmt;
+ EXPECT_EQ("xxx " + ans, format("xxx " + fmt, tp, tz));
+ EXPECT_EQ(ans + " yyy", format(fmt + " yyy", tp, tz));
+ EXPECT_EQ("xxx " + ans + " yyy", format("xxx " + fmt + " yyy", tp, tz));
+}
+
+} // namespace
+
+//
+// Testing format()
+//
+
+TEST(Format, TimePointResolution) {
+ const char kFmt[] = "%H:%M:%E*S";
+ const time_zone utc = utc_time_zone();
+ const time_point<nanoseconds> t0 = system_clock::from_time_t(1420167845) +
+ milliseconds(123) + microseconds(456) +
+ nanoseconds(789);
+ EXPECT_EQ("03:04:05.123456789",
+ format(kFmt, time_point_cast<nanoseconds>(t0), utc));
+ EXPECT_EQ("03:04:05.123456",
+ format(kFmt, time_point_cast<microseconds>(t0), utc));
+ EXPECT_EQ("03:04:05.123",
+ format(kFmt, time_point_cast<milliseconds>(t0), utc));
+ EXPECT_EQ("03:04:05",
+ format(kFmt, time_point_cast<seconds>(t0), utc));
+ EXPECT_EQ("03:04:05",
+ format(kFmt, time_point_cast<sys_seconds>(t0), utc));
+ EXPECT_EQ("03:04:00",
+ format(kFmt, time_point_cast<minutes>(t0), utc));
+ EXPECT_EQ("03:00:00",
+ format(kFmt, time_point_cast<hours>(t0), utc));
+}
+
+TEST(Format, TimePointExtendedResolution) {
+ const char kFmt[] = "%H:%M:%E*S";
+ const time_zone utc = utc_time_zone();
+ const time_point<sys_seconds> tp =
+ std::chrono::time_point_cast<sys_seconds>(
+ std::chrono::system_clock::from_time_t(0)) +
+ std::chrono::hours(12) + std::chrono::minutes(34) +
+ std::chrono::seconds(56);
+
+ EXPECT_EQ(
+ "12:34:56.123456789012345",
+ detail::format(kFmt, tp, detail::femtoseconds(123456789012345), utc));
+ EXPECT_EQ(
+ "12:34:56.012345678901234",
+ detail::format(kFmt, tp, detail::femtoseconds(12345678901234), utc));
+ EXPECT_EQ(
+ "12:34:56.001234567890123",
+ detail::format(kFmt, tp, detail::femtoseconds(1234567890123), utc));
+ EXPECT_EQ(
+ "12:34:56.000123456789012",
+ detail::format(kFmt, tp, detail::femtoseconds(123456789012), utc));
+
+ EXPECT_EQ("12:34:56.000000000000123",
+ detail::format(kFmt, tp, detail::femtoseconds(123), utc));
+ EXPECT_EQ("12:34:56.000000000000012",
+ detail::format(kFmt, tp, detail::femtoseconds(12), utc));
+ EXPECT_EQ("12:34:56.000000000000001",
+ detail::format(kFmt, tp, detail::femtoseconds(1), utc));
+}
+
+TEST(Format, Basics) {
+ time_zone tz = utc_time_zone();
+ time_point<nanoseconds> tp = system_clock::from_time_t(0);
+
+ // Starts with a couple basic edge cases.
+ EXPECT_EQ("", format("", tp, tz));
+ EXPECT_EQ(" ", format(" ", tp, tz));
+ EXPECT_EQ(" ", format(" ", tp, tz));
+ EXPECT_EQ("xxx", format("xxx", tp, tz));
+ std::string big(128, 'x');
+ EXPECT_EQ(big, format(big, tp, tz));
+ // Cause the 1024-byte buffer to grow.
+ std::string bigger(100000, 'x');
+ EXPECT_EQ(bigger, format(bigger, tp, tz));
+
+ tp += hours(13) + minutes(4) + seconds(5);
+ tp += milliseconds(6) + microseconds(7) + nanoseconds(8);
+ EXPECT_EQ("1970-01-01", format("%Y-%m-%d", tp, tz));
+ EXPECT_EQ("13:04:05", format("%H:%M:%S", tp, tz));
+ EXPECT_EQ("13:04:05.006", format("%H:%M:%E3S", tp, tz));
+ EXPECT_EQ("13:04:05.006007", format("%H:%M:%E6S", tp, tz));
+ EXPECT_EQ("13:04:05.006007008", format("%H:%M:%E9S", tp, tz));
+}
+
+TEST(Format, PosixConversions) {
+ const time_zone tz = utc_time_zone();
+ auto tp = system_clock::from_time_t(0);
+
+ TestFormatSpecifier(tp, tz, "%d", "01");
+ TestFormatSpecifier(tp, tz, "%e", " 1"); // extension but internal support
+ TestFormatSpecifier(tp, tz, "%H", "00");
+ TestFormatSpecifier(tp, tz, "%I", "12");
+ TestFormatSpecifier(tp, tz, "%j", "001");
+ TestFormatSpecifier(tp, tz, "%m", "01");
+ TestFormatSpecifier(tp, tz, "%M", "00");
+ TestFormatSpecifier(tp, tz, "%S", "00");
+ TestFormatSpecifier(tp, tz, "%U", "00");
+ TestFormatSpecifier(tp, tz, "%w", "4"); // 4=Thursday
+ TestFormatSpecifier(tp, tz, "%W", "00");
+ TestFormatSpecifier(tp, tz, "%y", "70");
+ TestFormatSpecifier(tp, tz, "%Y", "1970");
+ TestFormatSpecifier(tp, tz, "%z", "+0000");
+ TestFormatSpecifier(tp, tz, "%Z", "UTC");
+ TestFormatSpecifier(tp, tz, "%%", "%");
+
+#if defined(__linux__)
+ // SU/C99/TZ extensions
+ TestFormatSpecifier(tp, tz, "%C", "19");
+ TestFormatSpecifier(tp, tz, "%D", "01/01/70");
+ TestFormatSpecifier(tp, tz, "%F", "1970-01-01");
+ TestFormatSpecifier(tp, tz, "%g", "70");
+ TestFormatSpecifier(tp, tz, "%G", "1970");
+ TestFormatSpecifier(tp, tz, "%k", " 0");
+ TestFormatSpecifier(tp, tz, "%l", "12");
+ TestFormatSpecifier(tp, tz, "%n", "\n");
+ TestFormatSpecifier(tp, tz, "%R", "00:00");
+ TestFormatSpecifier(tp, tz, "%t", "\t");
+ TestFormatSpecifier(tp, tz, "%T", "00:00:00");
+ TestFormatSpecifier(tp, tz, "%u", "4"); // 4=Thursday
+ TestFormatSpecifier(tp, tz, "%V", "01");
+ TestFormatSpecifier(tp, tz, "%s", "0");
+#endif
+}
+
+TEST(Format, LocaleSpecific) {
+ const time_zone tz = utc_time_zone();
+ auto tp = system_clock::from_time_t(0);
+
+ TestFormatSpecifier(tp, tz, "%a", "Thu");
+ TestFormatSpecifier(tp, tz, "%A", "Thursday");
+ TestFormatSpecifier(tp, tz, "%b", "Jan");
+ TestFormatSpecifier(tp, tz, "%B", "January");
+
+ // %c should at least produce the numeric year and time-of-day.
+ const std::string s = format("%c", tp, utc_time_zone());
+ EXPECT_THAT(s, HasSubstr("1970"));
+ EXPECT_THAT(s, HasSubstr("00:00:00"));
+
+ TestFormatSpecifier(tp, tz, "%p", "AM");
+ TestFormatSpecifier(tp, tz, "%x", "01/01/70");
+ TestFormatSpecifier(tp, tz, "%X", "00:00:00");
+
+#if defined(__linux__)
+ // SU/C99/TZ extensions
+ TestFormatSpecifier(tp, tz, "%h", "Jan"); // Same as %b
+ TestFormatSpecifier(tp, tz, "%P", "am");
+ TestFormatSpecifier(tp, tz, "%r", "12:00:00 AM");
+
+ // Modified conversion specifiers %E_
+ TestFormatSpecifier(tp, tz, "%Ec", "Thu Jan 1 00:00:00 1970");
+ TestFormatSpecifier(tp, tz, "%EC", "19");
+ TestFormatSpecifier(tp, tz, "%Ex", "01/01/70");
+ TestFormatSpecifier(tp, tz, "%EX", "00:00:00");
+ TestFormatSpecifier(tp, tz, "%Ey", "70");
+ TestFormatSpecifier(tp, tz, "%EY", "1970");
+
+ // Modified conversion specifiers %O_
+ TestFormatSpecifier(tp, tz, "%Od", "01");
+ TestFormatSpecifier(tp, tz, "%Oe", " 1");
+ TestFormatSpecifier(tp, tz, "%OH", "00");
+ TestFormatSpecifier(tp, tz, "%OI", "12");
+ TestFormatSpecifier(tp, tz, "%Om", "01");
+ TestFormatSpecifier(tp, tz, "%OM", "00");
+ TestFormatSpecifier(tp, tz, "%OS", "00");
+ TestFormatSpecifier(tp, tz, "%Ou", "4"); // 4=Thursday
+ TestFormatSpecifier(tp, tz, "%OU", "00");
+ TestFormatSpecifier(tp, tz, "%OV", "01");
+ TestFormatSpecifier(tp, tz, "%Ow", "4"); // 4=Thursday
+ TestFormatSpecifier(tp, tz, "%OW", "00");
+ TestFormatSpecifier(tp, tz, "%Oy", "70");
+#endif
+}
+
+TEST(Format, Escaping) {
+ const time_zone tz = utc_time_zone();
+ auto tp = system_clock::from_time_t(0);
+
+ TestFormatSpecifier(tp, tz, "%%", "%");
+ TestFormatSpecifier(tp, tz, "%%a", "%a");
+ TestFormatSpecifier(tp, tz, "%%b", "%b");
+ TestFormatSpecifier(tp, tz, "%%Ea", "%Ea");
+ TestFormatSpecifier(tp, tz, "%%Es", "%Es");
+ TestFormatSpecifier(tp, tz, "%%E3S", "%E3S");
+ TestFormatSpecifier(tp, tz, "%%OS", "%OS");
+ TestFormatSpecifier(tp, tz, "%%O3S", "%O3S");
+
+ // Multiple levels of escaping.
+ TestFormatSpecifier(tp, tz, "%%%Y", "%1970");
+ TestFormatSpecifier(tp, tz, "%%%E3S", "%00.000");
+ TestFormatSpecifier(tp, tz, "%%%%E3S", "%%E3S");
+}
+
+TEST(Format, ExtendedSeconds) {
+ const time_zone tz = utc_time_zone();
+
+ // No subseconds.
+ time_point<nanoseconds> tp = system_clock::from_time_t(0);
+ tp += seconds(5);
+ EXPECT_EQ("05", format("%E*S", tp, tz));
+ EXPECT_EQ("05", format("%E0S", tp, tz));
+ EXPECT_EQ("05.0", format("%E1S", tp, tz));
+ EXPECT_EQ("05.00", format("%E2S", tp, tz));
+ EXPECT_EQ("05.000", format("%E3S", tp, tz));
+ EXPECT_EQ("05.0000", format("%E4S", tp, tz));
+ EXPECT_EQ("05.00000", format("%E5S", tp, tz));
+ EXPECT_EQ("05.000000", format("%E6S", tp, tz));
+ EXPECT_EQ("05.0000000", format("%E7S", tp, tz));
+ EXPECT_EQ("05.00000000", format("%E8S", tp, tz));
+ EXPECT_EQ("05.000000000", format("%E9S", tp, tz));
+ EXPECT_EQ("05.0000000000", format("%E10S", tp, tz));
+ EXPECT_EQ("05.00000000000", format("%E11S", tp, tz));
+ EXPECT_EQ("05.000000000000", format("%E12S", tp, tz));
+ EXPECT_EQ("05.0000000000000", format("%E13S", tp, tz));
+ EXPECT_EQ("05.00000000000000", format("%E14S", tp, tz));
+ EXPECT_EQ("05.000000000000000", format("%E15S", tp, tz));
+
+ // With subseconds.
+ tp += milliseconds(6) + microseconds(7) + nanoseconds(8);
+ EXPECT_EQ("05.006007008", format("%E*S", tp, tz));
+ EXPECT_EQ("05", format("%E0S", tp, tz));
+ EXPECT_EQ("05.0", format("%E1S", tp, tz));
+ EXPECT_EQ("05.00", format("%E2S", tp, tz));
+ EXPECT_EQ("05.006", format("%E3S", tp, tz));
+ EXPECT_EQ("05.0060", format("%E4S", tp, tz));
+ EXPECT_EQ("05.00600", format("%E5S", tp, tz));
+ EXPECT_EQ("05.006007", format("%E6S", tp, tz));
+ EXPECT_EQ("05.0060070", format("%E7S", tp, tz));
+ EXPECT_EQ("05.00600700", format("%E8S", tp, tz));
+ EXPECT_EQ("05.006007008", format("%E9S", tp, tz));
+ EXPECT_EQ("05.0060070080", format("%E10S", tp, tz));
+ EXPECT_EQ("05.00600700800", format("%E11S", tp, tz));
+ EXPECT_EQ("05.006007008000", format("%E12S", tp, tz));
+ EXPECT_EQ("05.0060070080000", format("%E13S", tp, tz));
+ EXPECT_EQ("05.00600700800000", format("%E14S", tp, tz));
+ EXPECT_EQ("05.006007008000000", format("%E15S", tp, tz));
+
+ // Times before the Unix epoch.
+ tp = system_clock::from_time_t(0) + microseconds(-1);
+ EXPECT_EQ("1969-12-31 23:59:59.999999",
+ format("%Y-%m-%d %H:%M:%E*S", tp, tz));
+
+ // Here is a "%E*S" case we got wrong for a while. While the first
+ // instant below is correctly rendered as "...:07.333304", the second
+ // one used to appear as "...:07.33330499999999999".
+ tp = system_clock::from_time_t(0) + microseconds(1395024427333304);
+ EXPECT_EQ("2014-03-17 02:47:07.333304",
+ format("%Y-%m-%d %H:%M:%E*S", tp, tz));
+ tp += microseconds(1);
+ EXPECT_EQ("2014-03-17 02:47:07.333305",
+ format("%Y-%m-%d %H:%M:%E*S", tp, tz));
+}
+
+TEST(Format, ExtendedSubeconds) {
+ const time_zone tz = utc_time_zone();
+
+ // No subseconds.
+ time_point<nanoseconds> tp = system_clock::from_time_t(0);
+ tp += seconds(5);
+ EXPECT_EQ("0", format("%E*f", tp, tz));
+ EXPECT_EQ("", format("%E0f", tp, tz));
+ EXPECT_EQ("0", format("%E1f", tp, tz));
+ EXPECT_EQ("00", format("%E2f", tp, tz));
+ EXPECT_EQ("000", format("%E3f", tp, tz));
+ EXPECT_EQ("0000", format("%E4f", tp, tz));
+ EXPECT_EQ("00000", format("%E5f", tp, tz));
+ EXPECT_EQ("000000", format("%E6f", tp, tz));
+ EXPECT_EQ("0000000", format("%E7f", tp, tz));
+ EXPECT_EQ("00000000", format("%E8f", tp, tz));
+ EXPECT_EQ("000000000", format("%E9f", tp, tz));
+ EXPECT_EQ("0000000000", format("%E10f", tp, tz));
+ EXPECT_EQ("00000000000", format("%E11f", tp, tz));
+ EXPECT_EQ("000000000000", format("%E12f", tp, tz));
+ EXPECT_EQ("0000000000000", format("%E13f", tp, tz));
+ EXPECT_EQ("00000000000000", format("%E14f", tp, tz));
+ EXPECT_EQ("000000000000000", format("%E15f", tp, tz));
+
+ // With subseconds.
+ tp += milliseconds(6) + microseconds(7) + nanoseconds(8);
+ EXPECT_EQ("006007008", format("%E*f", tp, tz));
+ EXPECT_EQ("", format("%E0f", tp, tz));
+ EXPECT_EQ("0", format("%E1f", tp, tz));
+ EXPECT_EQ("00", format("%E2f", tp, tz));
+ EXPECT_EQ("006", format("%E3f", tp, tz));
+ EXPECT_EQ("0060", format("%E4f", tp, tz));
+ EXPECT_EQ("00600", format("%E5f", tp, tz));
+ EXPECT_EQ("006007", format("%E6f", tp, tz));
+ EXPECT_EQ("0060070", format("%E7f", tp, tz));
+ EXPECT_EQ("00600700", format("%E8f", tp, tz));
+ EXPECT_EQ("006007008", format("%E9f", tp, tz));
+ EXPECT_EQ("0060070080", format("%E10f", tp, tz));
+ EXPECT_EQ("00600700800", format("%E11f", tp, tz));
+ EXPECT_EQ("006007008000", format("%E12f", tp, tz));
+ EXPECT_EQ("0060070080000", format("%E13f", tp, tz));
+ EXPECT_EQ("00600700800000", format("%E14f", tp, tz));
+ EXPECT_EQ("006007008000000", format("%E15f", tp, tz));
+
+ // Times before the Unix epoch.
+ tp = system_clock::from_time_t(0) + microseconds(-1);
+ EXPECT_EQ("1969-12-31 23:59:59.999999",
+ format("%Y-%m-%d %H:%M:%S.%E*f", tp, tz));
+
+ // Here is a "%E*S" case we got wrong for a while. While the first
+ // instant below is correctly rendered as "...:07.333304", the second
+ // one used to appear as "...:07.33330499999999999".
+ tp = system_clock::from_time_t(0) + microseconds(1395024427333304);
+ EXPECT_EQ("2014-03-17 02:47:07.333304",
+ format("%Y-%m-%d %H:%M:%S.%E*f", tp, tz));
+ tp += microseconds(1);
+ EXPECT_EQ("2014-03-17 02:47:07.333305",
+ format("%Y-%m-%d %H:%M:%S.%E*f", tp, tz));
+}
+
+TEST(Format, CompareExtendSecondsVsSubseconds) {
+ const time_zone tz = utc_time_zone();
+
+ // This test case illustrates the differences/similarities between:
+ // fmt_A: %E<prec>S
+ // fmt_B: %S.%E<prec>f
+ auto fmt_A = [](const std::string& prec) { return "%E" + prec + "S"; };
+ auto fmt_B = [](const std::string& prec) { return "%S.%E" + prec + "f"; };
+
+ // No subseconds:
+ time_point<nanoseconds> tp = system_clock::from_time_t(0);
+ tp += seconds(5);
+ // ... %E*S and %S.%E*f are different.
+ EXPECT_EQ("05", format(fmt_A("*"), tp, tz));
+ EXPECT_EQ("05.0", format(fmt_B("*"), tp, tz));
+ // ... %E0S and %S.%E0f are different.
+ EXPECT_EQ("05", format(fmt_A("0"), tp, tz));
+ EXPECT_EQ("05.", format(fmt_B("0"), tp, tz));
+ // ... %E<prec>S and %S.%E<prec>f are the same for prec in [1:15].
+ for (int prec = 1; prec <= 15; ++prec) {
+ const std::string a = format(fmt_A(std::to_string(prec)), tp, tz);
+ const std::string b = format(fmt_B(std::to_string(prec)), tp, tz);
+ EXPECT_EQ(a, b) << "prec=" << prec;
+ }
+
+ // With subseconds:
+ // ... %E*S and %S.%E*f are the same.
+ tp += milliseconds(6) + microseconds(7) + nanoseconds(8);
+ EXPECT_EQ("05.006007008", format(fmt_A("*"), tp, tz));
+ EXPECT_EQ("05.006007008", format(fmt_B("*"), tp, tz));
+ // ... %E0S and %S.%E0f are different.
+ EXPECT_EQ("05", format(fmt_A("0"), tp, tz));
+ EXPECT_EQ("05.", format(fmt_B("0"), tp, tz));
+ // ... %E<prec>S and %S.%E<prec>f are the same for prec in [1:15].
+ for (int prec = 1; prec <= 15; ++prec) {
+ const std::string a = format(fmt_A(std::to_string(prec)), tp, tz);
+ const std::string b = format(fmt_B(std::to_string(prec)), tp, tz);
+ EXPECT_EQ(a, b) << "prec=" << prec;
+ }
+}
+
+TEST(Format, ExtendedOffset) {
+ auto tp = system_clock::from_time_t(0);
+
+ time_zone tz = utc_time_zone();
+ TestFormatSpecifier(tp, tz, "%Ez", "+00:00");
+
+ EXPECT_TRUE(load_time_zone("America/New_York", &tz));
+ TestFormatSpecifier(tp, tz, "%Ez", "-05:00");
+
+ EXPECT_TRUE(load_time_zone("America/Los_Angeles", &tz));
+ TestFormatSpecifier(tp, tz, "%Ez", "-08:00");
+
+ EXPECT_TRUE(load_time_zone("Australia/Sydney", &tz));
+ TestFormatSpecifier(tp, tz, "%Ez", "+10:00");
+
+ EXPECT_TRUE(load_time_zone("Africa/Monrovia", &tz));
+ // The true offset is -00:44:30 but %z only gives (truncated) minutes.
+ TestFormatSpecifier(tp, tz, "%z", "-0044");
+ TestFormatSpecifier(tp, tz, "%Ez", "-00:44");
+}
+
+TEST(Format, ExtendedSecondOffset) {
+ const time_zone utc = utc_time_zone();
+ time_point<seconds> tp;
+ time_zone tz;
+
+ EXPECT_TRUE(load_time_zone("America/New_York", &tz));
+ tp = convert(civil_second(1883, 11, 18, 16, 59, 59), utc);
+ if (tz.lookup(tp).offset == -5 * 60 * 60) {
+ // We're likely dealing with zoneinfo that doesn't support really old
+ // timestamps, so America/New_York never looks to be on local mean time.
+ } else {
+ TestFormatSpecifier(tp, tz, "%E*z", "-04:56:02");
+ TestFormatSpecifier(tp, tz, "%Ez", "-04:56");
+ }
+ tp += seconds(1);
+ TestFormatSpecifier(tp, tz, "%E*z", "-05:00:00");
+
+ EXPECT_TRUE(load_time_zone("Europe/Moscow", &tz));
+ tp = convert(civil_second(1919, 6, 30, 23, 59, 59), utc);
+ TestFormatSpecifier(tp, tz, "%E*z", "+04:31:19");
+ TestFormatSpecifier(tp, tz, "%Ez", "+04:31");
+ tp += seconds(1);
+ TestFormatSpecifier(tp, tz, "%E*z", "+04:00:00");
+}
+
+TEST(Format, ExtendedYears) {
+ const time_zone utc = utc_time_zone();
+ const char e4y_fmt[] = "%E4Y%m%d"; // no separators
+
+ // %E4Y zero-pads the year to produce at least 4 chars, including the sign.
+ auto tp = convert(civil_second(-999, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("-9991127", format(e4y_fmt, tp, utc));
+ tp = convert(civil_second(-99, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("-0991127", format(e4y_fmt, tp, utc));
+ tp = convert(civil_second(-9, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("-0091127", format(e4y_fmt, tp, utc));
+ tp = convert(civil_second(-1, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("-0011127", format(e4y_fmt, tp, utc));
+ tp = convert(civil_second(0, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("00001127", format(e4y_fmt, tp, utc));
+ tp = convert(civil_second(1, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("00011127", format(e4y_fmt, tp, utc));
+ tp = convert(civil_second(9, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("00091127", format(e4y_fmt, tp, utc));
+ tp = convert(civil_second(99, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("00991127", format(e4y_fmt, tp, utc));
+ tp = convert(civil_second(999, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("09991127", format(e4y_fmt, tp, utc));
+ tp = convert(civil_second(9999, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("99991127", format(e4y_fmt, tp, utc));
+
+ // When the year is outside [-999:9999], more than 4 chars are produced.
+ tp = convert(civil_second(-1000, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("-10001127", format(e4y_fmt, tp, utc));
+ tp = convert(civil_second(10000, 11, 27, 0, 0, 0), utc);
+ EXPECT_EQ("100001127", format(e4y_fmt, tp, utc));
+}
+
+TEST(Format, RFC3339Format) {
+ time_zone tz;
+ EXPECT_TRUE(load_time_zone("America/Los_Angeles", &tz));
+
+ time_point<nanoseconds> tp =
+ convert(civil_second(1977, 6, 28, 9, 8, 7), tz);
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_full, tp, tz));
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_sec, tp, tz));
+
+ tp += milliseconds(100);
+ EXPECT_EQ("1977-06-28T09:08:07.1-07:00", format(RFC3339_full, tp, tz));
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_sec, tp, tz));
+
+ tp += milliseconds(20);
+ EXPECT_EQ("1977-06-28T09:08:07.12-07:00", format(RFC3339_full, tp, tz));
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_sec, tp, tz));
+
+ tp += milliseconds(3);
+ EXPECT_EQ("1977-06-28T09:08:07.123-07:00", format(RFC3339_full, tp, tz));
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_sec, tp, tz));
+
+ tp += microseconds(400);
+ EXPECT_EQ("1977-06-28T09:08:07.1234-07:00", format(RFC3339_full, tp, tz));
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_sec, tp, tz));
+
+ tp += microseconds(50);
+ EXPECT_EQ("1977-06-28T09:08:07.12345-07:00", format(RFC3339_full, tp, tz));
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_sec, tp, tz));
+
+ tp += microseconds(6);
+ EXPECT_EQ("1977-06-28T09:08:07.123456-07:00", format(RFC3339_full, tp, tz));
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_sec, tp, tz));
+
+ tp += nanoseconds(700);
+ EXPECT_EQ("1977-06-28T09:08:07.1234567-07:00", format(RFC3339_full, tp, tz));
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_sec, tp, tz));
+
+ tp += nanoseconds(80);
+ EXPECT_EQ("1977-06-28T09:08:07.12345678-07:00", format(RFC3339_full, tp, tz));
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_sec, tp, tz));
+
+ tp += nanoseconds(9);
+ EXPECT_EQ("1977-06-28T09:08:07.123456789-07:00",
+ format(RFC3339_full, tp, tz));
+ EXPECT_EQ("1977-06-28T09:08:07-07:00", format(RFC3339_sec, tp, tz));
+}
+
+TEST(Format, RFC1123Format) { // locale specific
+ time_zone tz;
+ EXPECT_TRUE(load_time_zone("America/Los_Angeles", &tz));
+
+ auto tp = convert(civil_second(1977, 6, 28, 9, 8, 7), tz);
+ EXPECT_EQ("Tue, 28 Jun 1977 09:08:07 -0700", format(RFC1123_full, tp, tz));
+ EXPECT_EQ("28 Jun 1977 09:08:07 -0700", format(RFC1123_no_wday, tp, tz));
+}
+
+//
+// Testing parse()
+//
+
+TEST(Parse, TimePointResolution) {
+ const char kFmt[] = "%H:%M:%E*S";
+ const time_zone utc = utc_time_zone();
+
+ time_point<nanoseconds> tp_ns;
+ EXPECT_TRUE(parse(kFmt, "03:04:05.123456789", utc, &tp_ns));
+ EXPECT_EQ("03:04:05.123456789", format(kFmt, tp_ns, utc));
+ EXPECT_TRUE(parse(kFmt, "03:04:05.123456", utc, &tp_ns));
+ EXPECT_EQ("03:04:05.123456", format(kFmt, tp_ns, utc));
+
+ time_point<microseconds> tp_us;
+ EXPECT_TRUE(parse(kFmt, "03:04:05.123456789", utc, &tp_us));
+ EXPECT_EQ("03:04:05.123456", format(kFmt, tp_us, utc));
+ EXPECT_TRUE(parse(kFmt, "03:04:05.123456", utc, &tp_us));
+ EXPECT_EQ("03:04:05.123456", format(kFmt, tp_us, utc));
+ EXPECT_TRUE(parse(kFmt, "03:04:05.123", utc, &tp_us));
+ EXPECT_EQ("03:04:05.123", format(kFmt, tp_us, utc));
+
+ time_point<milliseconds> tp_ms;
+ EXPECT_TRUE(parse(kFmt, "03:04:05.123456", utc, &tp_ms));
+ EXPECT_EQ("03:04:05.123", format(kFmt, tp_ms, utc));
+ EXPECT_TRUE(parse(kFmt, "03:04:05.123", utc, &tp_ms));
+ EXPECT_EQ("03:04:05.123", format(kFmt, tp_ms, utc));
+ EXPECT_TRUE(parse(kFmt, "03:04:05", utc, &tp_ms));
+ EXPECT_EQ("03:04:05", format(kFmt, tp_ms, utc));
+
+ time_point<seconds> tp_s;
+ EXPECT_TRUE(parse(kFmt, "03:04:05.123", utc, &tp_s));
+ EXPECT_EQ("03:04:05", format(kFmt, tp_s, utc));
+ EXPECT_TRUE(parse(kFmt, "03:04:05", utc, &tp_s));
+ EXPECT_EQ("03:04:05", format(kFmt, tp_s, utc));
+
+ time_point<minutes> tp_m;
+ EXPECT_TRUE(parse(kFmt, "03:04:05", utc, &tp_m));
+ EXPECT_EQ("03:04:00", format(kFmt, tp_m, utc));
+
+ time_point<hours> tp_h;
+ EXPECT_TRUE(parse(kFmt, "03:04:05", utc, &tp_h));
+ EXPECT_EQ("03:00:00", format(kFmt, tp_h, utc));
+}
+
+TEST(Parse, TimePointExtendedResolution) {
+ const char kFmt[] = "%H:%M:%E*S";
+ const time_zone utc = utc_time_zone();
+
+ time_point<sys_seconds> tp;
+ detail::femtoseconds fs;
+ EXPECT_TRUE(detail::parse(kFmt, "12:34:56.123456789012345", utc, &tp, &fs));
+ EXPECT_EQ("12:34:56.123456789012345", detail::format(kFmt, tp, fs, utc));
+ EXPECT_TRUE(detail::parse(kFmt, "12:34:56.012345678901234", utc, &tp, &fs));
+ EXPECT_EQ("12:34:56.012345678901234", detail::format(kFmt, tp, fs, utc));
+ EXPECT_TRUE(detail::parse(kFmt, "12:34:56.001234567890123", utc, &tp, &fs));
+ EXPECT_EQ("12:34:56.001234567890123", detail::format(kFmt, tp, fs, utc));
+ EXPECT_TRUE(detail::parse(kFmt, "12:34:56.000000000000123", utc, &tp, &fs));
+ EXPECT_EQ("12:34:56.000000000000123", detail::format(kFmt, tp, fs, utc));
+ EXPECT_TRUE(detail::parse(kFmt, "12:34:56.000000000000012", utc, &tp, &fs));
+ EXPECT_EQ("12:34:56.000000000000012", detail::format(kFmt, tp, fs, utc));
+ EXPECT_TRUE(detail::parse(kFmt, "12:34:56.000000000000001", utc, &tp, &fs));
+ EXPECT_EQ("12:34:56.000000000000001", detail::format(kFmt, tp, fs, utc));
+}
+
+TEST(Parse, Basics) {
+ time_zone tz = utc_time_zone();
+ time_point<nanoseconds> tp = system_clock::from_time_t(1234567890);
+
+ // Simple edge cases.
+ EXPECT_TRUE(parse("", "", tz, &tp));
+ EXPECT_EQ(system_clock::from_time_t(0), tp); // everything defaulted
+ EXPECT_TRUE(parse(" ", " ", tz, &tp));
+ EXPECT_TRUE(parse(" ", " ", tz, &tp));
+ EXPECT_TRUE(parse("x", "x", tz, &tp));
+ EXPECT_TRUE(parse("xxx", "xxx", tz, &tp));
+
+ EXPECT_TRUE(
+ parse("%Y-%m-%d %H:%M:%S %z", "2013-06-28 19:08:09 -0800", tz, &tp));
+ ExpectTime(tp, tz, 2013, 6, 29, 3, 8, 9, 0, false, "UTC");
+}
+
+TEST(Parse, WithTimeZone) {
+ time_zone tz;
+ EXPECT_TRUE(load_time_zone("America/Los_Angeles", &tz));
+ time_point<nanoseconds> tp;
+
+ // We can parse a std::string without a UTC offset if we supply a timezone.
+ EXPECT_TRUE(parse("%Y-%m-%d %H:%M:%S", "2013-06-28 19:08:09", tz, &tp));
+ ExpectTime(tp, tz, 2013, 6, 28, 19, 8, 9, -7 * 60 * 60, true, "PDT");
+
+ // But the timezone is ignored when a UTC offset is present.
+ EXPECT_TRUE(parse("%Y-%m-%d %H:%M:%S %z", "2013-06-28 19:08:09 +0800",
+ utc_time_zone(), &tp));
+ ExpectTime(tp, tz, 2013, 6, 28, 19 - 8 - 7, 8, 9, -7 * 60 * 60, true, "PDT");
+
+ // Check a skipped time (a Spring DST transition). parse() returns
+ // the preferred-offset result, as defined for ConvertDateTime().
+ EXPECT_TRUE(parse("%Y-%m-%d %H:%M:%S", "2011-03-13 02:15:00", tz, &tp));
+ ExpectTime(tp, tz, 2011, 3, 13, 3, 15, 0, -7 * 60 * 60, true, "PDT");
+
+ // Check a repeated time (a Fall DST transition). parse() returns
+ // the preferred-offset result, as defined for ConvertDateTime().
+ EXPECT_TRUE(parse("%Y-%m-%d %H:%M:%S", "2011-11-06 01:15:00", tz, &tp));
+ ExpectTime(tp, tz, 2011, 11, 6, 1, 15, 0, -7 * 60 * 60, true, "PDT");
+}
+
+TEST(Parse, LeapSecond) {
+ time_zone tz;
+ EXPECT_TRUE(load_time_zone("America/Los_Angeles", &tz));
+ time_point<nanoseconds> tp;
+
+ // ":59" -> ":59"
+ EXPECT_TRUE(parse(RFC3339_full, "2013-06-28T07:08:59-08:00", tz, &tp));
+ ExpectTime(tp, tz, 2013, 6, 28, 8, 8, 59, -7 * 60 * 60, true, "PDT");
+
+ // ":59.5" -> ":59.5"
+ EXPECT_TRUE(parse(RFC3339_full, "2013-06-28T07:08:59.5-08:00", tz, &tp));
+ ExpectTime(tp, tz, 2013, 6, 28, 8, 8, 59, -7 * 60 * 60, true, "PDT");
+
+ // ":60" -> ":00"
+ EXPECT_TRUE(parse(RFC3339_full, "2013-06-28T07:08:60-08:00", tz, &tp));
+ ExpectTime(tp, tz, 2013, 6, 28, 8, 9, 0, -7 * 60 * 60, true, "PDT");
+
+ // ":60.5" -> ":00.0"
+ EXPECT_TRUE(parse(RFC3339_full, "2013-06-28T07:08:60.5-08:00", tz, &tp));
+ ExpectTime(tp, tz, 2013, 6, 28, 8, 9, 0, -7 * 60 * 60, true, "PDT");
+
+ // ":61" -> error
+ EXPECT_FALSE(parse(RFC3339_full, "2013-06-28T07:08:61-08:00", tz, &tp));
+}
+
+TEST(Parse, ErrorCases) {
+ const time_zone tz = utc_time_zone();
+ auto tp = system_clock::from_time_t(0);
+
+ // Illegal trailing data.
+ EXPECT_FALSE(parse("%S", "123", tz, &tp));
+
+ // Can't parse an illegal format specifier.
+ EXPECT_FALSE(parse("%Q", "x", tz, &tp));
+
+ // Fails because of trailing, unparsed data "blah".
+ EXPECT_FALSE(parse("%m-%d", "2-3 blah", tz, &tp));
+
+ // Trailing whitespace is allowed.
+ EXPECT_TRUE(parse("%m-%d", "2-3 ", tz, &tp));
+ EXPECT_EQ(2, convert(tp, utc_time_zone()).month());
+ EXPECT_EQ(3, convert(tp, utc_time_zone()).day());
+
+ // Feb 31 requires normalization.
+ EXPECT_FALSE(parse("%m-%d", "2-31", tz, &tp));
+
+ // Check that we cannot have spaces in UTC offsets.
+ EXPECT_TRUE(parse("%z", "-0203", tz, &tp));
+ EXPECT_FALSE(parse("%z", "- 2 3", tz, &tp));
+ EXPECT_TRUE(parse("%Ez", "-02:03", tz, &tp));
+ EXPECT_FALSE(parse("%Ez", "- 2: 3", tz, &tp));
+
+ // Check that we reject other malformed UTC offsets.
+ EXPECT_FALSE(parse("%Ez", "+-08:00", tz, &tp));
+ EXPECT_FALSE(parse("%Ez", "-+08:00", tz, &tp));
+
+ // Check that we do not accept "-0" in fields that allow zero.
+ EXPECT_FALSE(parse("%Y", "-0", tz, &tp));
+ EXPECT_FALSE(parse("%E4Y", "-0", tz, &tp));
+ EXPECT_FALSE(parse("%H", "-0", tz, &tp));
+ EXPECT_FALSE(parse("%M", "-0", tz, &tp));
+ EXPECT_FALSE(parse("%S", "-0", tz, &tp));
+ EXPECT_FALSE(parse("%z", "+-000", tz, &tp));
+ EXPECT_FALSE(parse("%Ez", "+-0:00", tz, &tp));
+ EXPECT_FALSE(parse("%z", "-00-0", tz, &tp));
+ EXPECT_FALSE(parse("%Ez", "-00:-0", tz, &tp));
+}
+
+TEST(Parse, PosixConversions) {
+ time_zone tz = utc_time_zone();
+ auto tp = system_clock::from_time_t(0);
+ const auto reset = convert(civil_second(1977, 6, 28, 9, 8, 7), tz);
+
+ tp = reset;
+ EXPECT_TRUE(parse("%d", "15", tz, &tp));
+ EXPECT_EQ(15, convert(tp, tz).day());
+
+ // %e is an extension, but is supported internally.
+ tp = reset;
+ EXPECT_TRUE(parse("%e", "15", tz, &tp));
+ EXPECT_EQ(15, convert(tp, tz).day()); // Equivalent to %d
+
+ tp = reset;
+ EXPECT_TRUE(parse("%H", "17", tz, &tp));
+ EXPECT_EQ(17, convert(tp, tz).hour());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%I", "5", tz, &tp));
+ EXPECT_EQ(5, convert(tp, tz).hour());
+
+ // %j is parsed but ignored.
+ EXPECT_TRUE(parse("%j", "32", tz, &tp));
+
+ tp = reset;
+ EXPECT_TRUE(parse("%m", "11", tz, &tp));
+ EXPECT_EQ(11, convert(tp, tz).month());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%M", "33", tz, &tp));
+ EXPECT_EQ(33, convert(tp, tz).minute());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%S", "55", tz, &tp));
+ EXPECT_EQ(55, convert(tp, tz).second());
+
+ // %U is parsed but ignored.
+ EXPECT_TRUE(parse("%U", "15", tz, &tp));
+
+ // %w is parsed but ignored.
+ EXPECT_TRUE(parse("%w", "2", tz, &tp));
+
+ // %W is parsed but ignored.
+ EXPECT_TRUE(parse("%W", "22", tz, &tp));
+
+ tp = reset;
+ EXPECT_TRUE(parse("%y", "04", tz, &tp));
+ EXPECT_EQ(2004, convert(tp, tz).year());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%Y", "2004", tz, &tp));
+ EXPECT_EQ(2004, convert(tp, tz).year());
+
+ EXPECT_TRUE(parse("%%", "%", tz, &tp));
+
+#if defined(__linux__)
+ // SU/C99/TZ extensions
+
+ // Because we handle each (non-internal) specifier in a separate call
+ // to strptime(), there is no way to group %C and %y together. So we
+ // just skip the %C/%y case.
+#if 0
+ tp = reset;
+ EXPECT_TRUE(parse("%C %y", "20 04", tz, &tp));
+ EXPECT_EQ(2004, convert(tp, tz).year());
+#endif
+
+ tp = reset;
+ EXPECT_TRUE(parse("%D", "02/03/04", tz, &tp));
+ EXPECT_EQ(2, convert(tp, tz).month());
+ EXPECT_EQ(3, convert(tp, tz).day());
+ EXPECT_EQ(2004, convert(tp, tz).year());
+
+ EXPECT_TRUE(parse("%n", "\n", tz, &tp));
+
+ tp = reset;
+ EXPECT_TRUE(parse("%R", "03:44", tz, &tp));
+ EXPECT_EQ(3, convert(tp, tz).hour());
+ EXPECT_EQ(44, convert(tp, tz).minute());
+
+ EXPECT_TRUE(parse("%t", "\t\v\f\n\r ", tz, &tp));
+
+ tp = reset;
+ EXPECT_TRUE(parse("%T", "03:44:55", tz, &tp));
+ EXPECT_EQ(3, convert(tp, tz).hour());
+ EXPECT_EQ(44, convert(tp, tz).minute());
+ EXPECT_EQ(55, convert(tp, tz).second());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%s", "1234567890", tz, &tp));
+ EXPECT_EQ(system_clock::from_time_t(1234567890), tp);
+
+ // %s conversion, like %z/%Ez, pays no heed to the optional zone.
+ time_zone lax;
+ EXPECT_TRUE(load_time_zone("America/Los_Angeles", &lax));
+ tp = reset;
+ EXPECT_TRUE(parse("%s", "1234567890", lax, &tp));
+ EXPECT_EQ(system_clock::from_time_t(1234567890), tp);
+
+ // This is most important when the time has the same YMDhms
+ // breakdown in the zone as some other time. For example, ...
+ // 1414917000 in US/Pacific -> Sun Nov 2 01:30:00 2014 (PDT)
+ // 1414920600 in US/Pacific -> Sun Nov 2 01:30:00 2014 (PST)
+ tp = reset;
+ EXPECT_TRUE(parse("%s", "1414917000", lax, &tp));
+ EXPECT_EQ(system_clock::from_time_t(1414917000), tp);
+ tp = reset;
+ EXPECT_TRUE(parse("%s", "1414920600", lax, &tp));
+ EXPECT_EQ(system_clock::from_time_t(1414920600), tp);
+#endif
+}
+
+TEST(Parse, LocaleSpecific) {
+ time_zone tz = utc_time_zone();
+ auto tp = system_clock::from_time_t(0);
+ const auto reset = convert(civil_second(1977, 6, 28, 9, 8, 7), tz);
+
+ // %a is parsed but ignored.
+ EXPECT_TRUE(parse("%a", "Mon", tz, &tp));
+
+ // %A is parsed but ignored.
+ EXPECT_TRUE(parse("%A", "Monday", tz, &tp));
+
+ tp = reset;
+ EXPECT_TRUE(parse("%b", "Feb", tz, &tp));
+ EXPECT_EQ(2, convert(tp, tz).month());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%B", "February", tz, &tp));
+ EXPECT_EQ(2, convert(tp, tz).month());
+
+ // %p is parsed but ignored if it's alone. But it's used with %I.
+ EXPECT_TRUE(parse("%p", "AM", tz, &tp));
+ tp = reset;
+ EXPECT_TRUE(parse("%I %p", "5 PM", tz, &tp));
+ EXPECT_EQ(17, convert(tp, tz).hour());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%x", "02/03/04", tz, &tp));
+ if (convert(tp, tz).month() == 2) {
+ EXPECT_EQ(3, convert(tp, tz).day());
+ } else {
+ EXPECT_EQ(2, convert(tp, tz).day());
+ EXPECT_EQ(3, convert(tp, tz).month());
+ }
+ EXPECT_EQ(2004, convert(tp, tz).year());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%X", "15:44:55", tz, &tp));
+ EXPECT_EQ(15, convert(tp, tz).hour());
+ EXPECT_EQ(44, convert(tp, tz).minute());
+ EXPECT_EQ(55, convert(tp, tz).second());
+
+#if defined(__linux__)
+ // SU/C99/TZ extensions
+
+ tp = reset;
+ EXPECT_TRUE(parse("%h", "Feb", tz, &tp));
+ EXPECT_EQ(2, convert(tp, tz).month()); // Equivalent to %b
+
+ tp = reset;
+ EXPECT_TRUE(parse("%l %p", "5 PM", tz, &tp));
+ EXPECT_EQ(17, convert(tp, tz).hour());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%r", "03:44:55 PM", tz, &tp));
+ EXPECT_EQ(15, convert(tp, tz).hour());
+ EXPECT_EQ(44, convert(tp, tz).minute());
+ EXPECT_EQ(55, convert(tp, tz).second());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%Ec", "Tue Nov 19 05:06:07 2013", tz, &tp));
+ EXPECT_EQ(convert(civil_second(2013, 11, 19, 5, 6, 7), tz), tp);
+
+ // Modified conversion specifiers %E_
+
+ tp = reset;
+ EXPECT_TRUE(parse("%Ex", "02/03/04", tz, &tp));
+ EXPECT_EQ(2, convert(tp, tz).month());
+ EXPECT_EQ(3, convert(tp, tz).day());
+ EXPECT_EQ(2004, convert(tp, tz).year());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%EX", "15:44:55", tz, &tp));
+ EXPECT_EQ(15, convert(tp, tz).hour());
+ EXPECT_EQ(44, convert(tp, tz).minute());
+ EXPECT_EQ(55, convert(tp, tz).second());
+
+ // %Ey, the year offset from %EC, doesn't really make sense alone as there
+ // is no way to represent it in tm_year (%EC is not simply the century).
+ // Yet, because we handle each (non-internal) specifier in a separate call
+ // to strptime(), there is no way to group %EC and %Ey either. So we just
+ // skip the %EC and %Ey cases.
+
+ tp = reset;
+ EXPECT_TRUE(parse("%EY", "2004", tz, &tp));
+ EXPECT_EQ(2004, convert(tp, tz).year());
+
+ // Modified conversion specifiers %O_
+
+ tp = reset;
+ EXPECT_TRUE(parse("%Od", "15", tz, &tp));
+ EXPECT_EQ(15, convert(tp, tz).day());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%Oe", "15", tz, &tp));
+ EXPECT_EQ(15, convert(tp, tz).day()); // Equivalent to %d
+
+ tp = reset;
+ EXPECT_TRUE(parse("%OH", "17", tz, &tp));
+ EXPECT_EQ(17, convert(tp, tz).hour());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%OI", "5", tz, &tp));
+ EXPECT_EQ(5, convert(tp, tz).hour());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%Om", "11", tz, &tp));
+ EXPECT_EQ(11, convert(tp, tz).month());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%OM", "33", tz, &tp));
+ EXPECT_EQ(33, convert(tp, tz).minute());
+
+ tp = reset;
+ EXPECT_TRUE(parse("%OS", "55", tz, &tp));
+ EXPECT_EQ(55, convert(tp, tz).second());
+
+ // %OU is parsed but ignored.
+ EXPECT_TRUE(parse("%OU", "15", tz, &tp));
+
+ // %Ow is parsed but ignored.
+ EXPECT_TRUE(parse("%Ow", "2", tz, &tp));
+
+ // %OW is parsed but ignored.
+ EXPECT_TRUE(parse("%OW", "22", tz, &tp));
+
+ tp = reset;
+ EXPECT_TRUE(parse("%Oy", "04", tz, &tp));
+ EXPECT_EQ(2004, convert(tp, tz).year());
+#endif
+}
+
+TEST(Parse, ExtendedSeconds) {
+ const time_zone tz = utc_time_zone();
+ const time_point<nanoseconds> unix_epoch = system_clock::from_time_t(0);
+
+ // All %E<prec>S cases are treated the same as %E*S on input.
+ auto precisions = {"*", "0", "1", "2", "3", "4", "5", "6", "7",
+ "8", "9", "10", "11", "12", "13", "14", "15"};
+ for (const std::string& prec : precisions) {
+ const std::string fmt = "%E" + prec + "S";
+ SCOPED_TRACE(fmt);
+ time_point<nanoseconds> tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "5", tz, &tp));
+ EXPECT_EQ(unix_epoch + seconds(5), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "05", tz, &tp));
+ EXPECT_EQ(unix_epoch + seconds(5), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "05.0", tz, &tp));
+ EXPECT_EQ(unix_epoch + seconds(5), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "05.00", tz, &tp));
+ EXPECT_EQ(unix_epoch + seconds(5), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "05.6", tz, &tp));
+ EXPECT_EQ(unix_epoch + seconds(5) + milliseconds(600), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "05.60", tz, &tp));
+ EXPECT_EQ(unix_epoch + seconds(5) + milliseconds(600), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "05.600", tz, &tp));
+ EXPECT_EQ(unix_epoch + seconds(5) + milliseconds(600), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "05.67", tz, &tp));
+ EXPECT_EQ(unix_epoch + seconds(5) + milliseconds(670), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "05.670", tz, &tp));
+ EXPECT_EQ(unix_epoch + seconds(5) + milliseconds(670), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "05.678", tz, &tp));
+ EXPECT_EQ(unix_epoch + seconds(5) + milliseconds(678), tp);
+ }
+
+ // Here is a "%E*S" case we got wrong for a while. The fractional
+ // part of the first instant is less than 2^31 and was correctly
+ // parsed, while the second (and any subsecond field >=2^31) failed.
+ time_point<nanoseconds> tp = unix_epoch;
+ EXPECT_TRUE(parse("%E*S", "0.2147483647", tz, &tp));
+ EXPECT_EQ(unix_epoch + nanoseconds(214748364), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse("%E*S", "0.2147483648", tz, &tp));
+ EXPECT_EQ(unix_epoch + nanoseconds(214748364), tp);
+
+ // We should also be able to specify long strings of digits far
+ // beyond the current resolution and have them convert the same way.
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(
+ "%E*S", "0.214748364801234567890123456789012345678901234567890123456789",
+ tz, &tp));
+ EXPECT_EQ(unix_epoch + nanoseconds(214748364), tp);
+}
+
+TEST(Parse, ExtendedSecondsScan) {
+ const time_zone tz = utc_time_zone();
+ time_point<nanoseconds> tp;
+ for (int ms = 0; ms < 1000; ms += 111) {
+ for (int us = 0; us < 1000; us += 27) {
+ const int micros = ms * 1000 + us;
+ for (int ns = 0; ns < 1000; ns += 9) {
+ const auto expected =
+ system_clock::from_time_t(0) + nanoseconds(micros * 1000 + ns);
+ std::ostringstream oss;
+ oss << "0." << std::setfill('0') << std::setw(3);
+ oss << ms << std::setw(3) << us << std::setw(3) << ns;
+ const std::string input = oss.str();
+ EXPECT_TRUE(parse("%E*S", input, tz, &tp));
+ EXPECT_EQ(expected, tp) << input;
+ }
+ }
+ }
+}
+
+TEST(Parse, ExtendedSubeconds) {
+ const time_zone tz = utc_time_zone();
+ const time_point<nanoseconds> unix_epoch = system_clock::from_time_t(0);
+
+ // All %E<prec>f cases are treated the same as %E*f on input.
+ auto precisions = {"*", "0", "1", "2", "3", "4", "5", "6", "7",
+ "8", "9", "10", "11", "12", "13", "14", "15"};
+ for (const std::string& prec : precisions) {
+ const std::string fmt = "%E" + prec + "f";
+ SCOPED_TRACE(fmt);
+ time_point<nanoseconds> tp = unix_epoch - seconds(1);
+ EXPECT_TRUE(parse(fmt, "", tz, &tp));
+ EXPECT_EQ(unix_epoch, tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "6", tz, &tp));
+ EXPECT_EQ(unix_epoch + milliseconds(600), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "60", tz, &tp));
+ EXPECT_EQ(unix_epoch + milliseconds(600), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "600", tz, &tp));
+ EXPECT_EQ(unix_epoch + milliseconds(600), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "67", tz, &tp));
+ EXPECT_EQ(unix_epoch + milliseconds(670), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "670", tz, &tp));
+ EXPECT_EQ(unix_epoch + milliseconds(670), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "678", tz, &tp));
+ EXPECT_EQ(unix_epoch + milliseconds(678), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(fmt, "6789", tz, &tp));
+ EXPECT_EQ(unix_epoch + milliseconds(678) + microseconds(900), tp);
+ }
+
+ // Here is a "%E*f" case we got wrong for a while. The fractional
+ // part of the first instant is less than 2^31 and was correctly
+ // parsed, while the second (and any subsecond field >=2^31) failed.
+ time_point<nanoseconds> tp = unix_epoch;
+ EXPECT_TRUE(parse("%E*f", "2147483647", tz, &tp));
+ EXPECT_EQ(unix_epoch + nanoseconds(214748364), tp);
+ tp = unix_epoch;
+ EXPECT_TRUE(parse("%E*f", "2147483648", tz, &tp));
+ EXPECT_EQ(unix_epoch + nanoseconds(214748364), tp);
+
+ // We should also be able to specify long strings of digits far
+ // beyond the current resolution and have them convert the same way.
+ tp = unix_epoch;
+ EXPECT_TRUE(parse(
+ "%E*f", "214748364801234567890123456789012345678901234567890123456789",
+ tz, &tp));
+ EXPECT_EQ(unix_epoch + nanoseconds(214748364), tp);
+}
+
+TEST(Parse, ExtendedSubecondsScan) {
+ time_point<nanoseconds> tp;
+ const time_zone tz = utc_time_zone();
+ for (int ms = 0; ms < 1000; ms += 111) {
+ for (int us = 0; us < 1000; us += 27) {
+ const int micros = ms * 1000 + us;
+ for (int ns = 0; ns < 1000; ns += 9) {
+ std::ostringstream oss;
+ oss << std::setfill('0') << std::setw(3) << ms;
+ oss << std::setw(3) << us << std::setw(3) << ns;
+ const std::string nanos = oss.str();
+ const auto expected =
+ system_clock::from_time_t(0) + nanoseconds(micros * 1000 + ns);
+ for (int ps = 0; ps < 1000; ps += 250) {
+ std::ostringstream oss;
+ oss << std::setfill('0') << std::setw(3) << ps;
+ const std::string input = nanos + oss.str() + "999";
+ EXPECT_TRUE(parse("%E*f", input, tz, &tp));
+ EXPECT_EQ(expected + nanoseconds(ps) / 1000, tp) << input;
+ }
+ }
+ }
+ }
+}
+
+TEST(Parse, ExtendedOffset) {
+ const time_zone utc = utc_time_zone();
+ time_point<sys_seconds> tp;
+
+ // %z against +-HHMM.
+ EXPECT_TRUE(parse("%z", "+0000", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%z", "-1234", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 34, 0), utc), tp);
+ EXPECT_TRUE(parse("%z", "+1234", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 11, 26, 0), utc), tp);
+ EXPECT_FALSE(parse("%z", "-123", utc, &tp));
+
+ // %z against +-HH.
+ EXPECT_TRUE(parse("%z", "+00", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%z", "-12", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%z", "+12", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 12, 0, 0), utc), tp);
+ EXPECT_FALSE(parse("%z", "-1", utc, &tp));
+
+ // %Ez against +-HH:MM.
+ EXPECT_TRUE(parse("%Ez", "+00:00", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%Ez", "-12:34", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 34, 0), utc), tp);
+ EXPECT_TRUE(parse("%Ez", "+12:34", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 11, 26, 0), utc), tp);
+ EXPECT_FALSE(parse("%Ez", "-12:3", utc, &tp));
+
+ // %Ez against +-HHMM.
+ EXPECT_TRUE(parse("%Ez", "+0000", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%Ez", "-1234", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 34, 0), utc), tp);
+ EXPECT_TRUE(parse("%Ez", "+1234", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 11, 26, 0), utc), tp);
+ EXPECT_FALSE(parse("%Ez", "-123", utc, &tp));
+
+ // %Ez against +-HH.
+ EXPECT_TRUE(parse("%Ez", "+00", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%Ez", "-12", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%Ez", "+12", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 12, 0, 0), utc), tp);
+ EXPECT_FALSE(parse("%Ez", "-1", utc, &tp));
+}
+
+TEST(Parse, ExtendedSecondOffset) {
+ const time_zone utc = utc_time_zone();
+ time_point<sys_seconds> tp;
+
+ // %Ez against +-HH:MM:SS.
+ EXPECT_TRUE(parse("%Ez", "+00:00:00", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%Ez", "-12:34:56", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 34, 56), utc), tp);
+ EXPECT_TRUE(parse("%Ez", "+12:34:56", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 11, 25, 4), utc), tp);
+ EXPECT_FALSE(parse("%Ez", "-12:34:5", utc, &tp));
+
+ // %Ez against +-HHMMSS.
+ EXPECT_TRUE(parse("%Ez", "+000000", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%Ez", "-123456", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 34, 56), utc), tp);
+ EXPECT_TRUE(parse("%Ez", "+123456", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 11, 25, 4), utc), tp);
+ EXPECT_FALSE(parse("%Ez", "-12345", utc, &tp));
+
+ // %E*z against +-HH:MM:SS.
+ EXPECT_TRUE(parse("%E*z", "+00:00:00", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%E*z", "-12:34:56", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 34, 56), utc), tp);
+ EXPECT_TRUE(parse("%E*z", "+12:34:56", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 11, 25, 4), utc), tp);
+ EXPECT_FALSE(parse("%E*z", "-12:34:5", utc, &tp));
+
+ // %E*z against +-HHMMSS.
+ EXPECT_TRUE(parse("%E*z", "+000000", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%E*z", "-123456", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 34, 56), utc), tp);
+ EXPECT_TRUE(parse("%E*z", "+123456", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 11, 25, 4), utc), tp);
+ EXPECT_FALSE(parse("%E*z", "-12345", utc, &tp));
+
+ // %E*z against +-HH:MM.
+ EXPECT_TRUE(parse("%E*z", "+00:00", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%E*z", "-12:34", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 34, 0), utc), tp);
+ EXPECT_TRUE(parse("%E*z", "+12:34", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 11, 26, 0), utc), tp);
+ EXPECT_FALSE(parse("%E*z", "-12:3", utc, &tp));
+
+ // %E*z against +-HHMM.
+ EXPECT_TRUE(parse("%E*z", "+0000", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%E*z", "-1234", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 34, 0), utc), tp);
+ EXPECT_TRUE(parse("%E*z", "+1234", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 11, 26, 0), utc), tp);
+ EXPECT_FALSE(parse("%E*z", "-123", utc, &tp));
+
+ // %E*z against +-HH.
+ EXPECT_TRUE(parse("%E*z", "+00", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%E*z", "-12", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1970, 1, 1, 12, 0, 0), utc), tp);
+ EXPECT_TRUE(parse("%E*z", "+12", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1969, 12, 31, 12, 0, 0), utc), tp);
+ EXPECT_FALSE(parse("%E*z", "-1", utc, &tp));
+}
+
+TEST(Parse, ExtendedYears) {
+ const time_zone utc = utc_time_zone();
+ const char e4y_fmt[] = "%E4Y%m%d"; // no separators
+ time_point<sys_seconds> tp;
+
+ // %E4Y consumes exactly four chars, including any sign.
+ EXPECT_TRUE(parse(e4y_fmt, "-9991127", utc, &tp));
+ EXPECT_EQ(convert(civil_second(-999, 11, 27, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse(e4y_fmt, "-0991127", utc, &tp));
+ EXPECT_EQ(convert(civil_second(-99, 11, 27, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse(e4y_fmt, "-0091127", utc, &tp));
+ EXPECT_EQ(convert(civil_second(-9, 11, 27, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse(e4y_fmt, "-0011127", utc, &tp));
+ EXPECT_EQ(convert(civil_second(-1, 11, 27, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse(e4y_fmt, "00001127", utc, &tp));
+ EXPECT_EQ(convert(civil_second(0, 11, 27, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse(e4y_fmt, "00011127", utc, &tp));
+ EXPECT_EQ(convert(civil_second(1, 11, 27, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse(e4y_fmt, "00091127", utc, &tp));
+ EXPECT_EQ(convert(civil_second(9, 11, 27, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse(e4y_fmt, "00991127", utc, &tp));
+ EXPECT_EQ(convert(civil_second(99, 11, 27, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse(e4y_fmt, "09991127", utc, &tp));
+ EXPECT_EQ(convert(civil_second(999, 11, 27, 0, 0, 0), utc), tp);
+ EXPECT_TRUE(parse(e4y_fmt, "99991127", utc, &tp));
+ EXPECT_EQ(convert(civil_second(9999, 11, 27, 0, 0, 0), utc), tp);
+
+ // When the year is outside [-999:9999], the parse fails.
+ EXPECT_FALSE(parse(e4y_fmt, "-10001127", utc, &tp));
+ EXPECT_FALSE(parse(e4y_fmt, "100001127", utc, &tp));
+}
+
+TEST(Parse, RFC3339Format) {
+ const time_zone tz = utc_time_zone();
+ time_point<nanoseconds> tp;
+ EXPECT_TRUE(parse(RFC3339_sec, "2014-02-12T20:21:00+00:00", tz, &tp));
+ ExpectTime(tp, tz, 2014, 2, 12, 20, 21, 0, 0, false, "UTC");
+
+ // Check that %Ez also accepts "Z" as a synonym for "+00:00".
+ time_point<nanoseconds> tp2;
+ EXPECT_TRUE(parse(RFC3339_sec, "2014-02-12T20:21:00Z", tz, &tp2));
+ EXPECT_EQ(tp, tp2);
+}
+
+TEST(Parse, MaxRange) {
+ const time_zone utc = utc_time_zone();
+ time_point<sys_seconds> tp;
+
+ // tests the upper limit using +00:00 offset
+ EXPECT_TRUE(
+ parse(RFC3339_sec, "292277026596-12-04T15:30:07+00:00", utc, &tp));
+ EXPECT_EQ(tp, time_point<sys_seconds>::max());
+ EXPECT_FALSE(
+ parse(RFC3339_sec, "292277026596-12-04T15:30:08+00:00", utc, &tp));
+
+ // tests the upper limit using -01:00 offset
+ EXPECT_TRUE(
+ parse(RFC3339_sec, "292277026596-12-04T14:30:07-01:00", utc, &tp));
+ EXPECT_EQ(tp, time_point<sys_seconds>::max());
+ EXPECT_FALSE(
+ parse(RFC3339_sec, "292277026596-12-04T15:30:07-01:00", utc, &tp));
+
+ // tests the lower limit using +00:00 offset
+ EXPECT_TRUE(
+ parse(RFC3339_sec, "-292277022657-01-27T08:29:52+00:00", utc, &tp));
+ EXPECT_EQ(tp, time_point<sys_seconds>::min());
+ EXPECT_FALSE(
+ parse(RFC3339_sec, "-292277022657-01-27T08:29:51+00:00", utc, &tp));
+
+ // tests the lower limit using +01:00 offset
+ EXPECT_TRUE(
+ parse(RFC3339_sec, "-292277022657-01-27T09:29:52+01:00", utc, &tp));
+ EXPECT_EQ(tp, time_point<sys_seconds>::min());
+ EXPECT_FALSE(
+ parse(RFC3339_sec, "-292277022657-01-27T08:29:51+01:00", utc, &tp));
+
+ // tests max/min civil-second overflow
+ EXPECT_FALSE(parse(RFC3339_sec, "9223372036854775807-12-31T23:59:59-00:01",
+ utc, &tp));
+ EXPECT_FALSE(parse(RFC3339_sec, "-9223372036854775808-01-01T00:00:00+00:01",
+ utc, &tp));
+
+ // TODO: Add tests that parsing times with fractional seconds overflow
+ // appropriately. This can't be done until cctz::parse() properly detects
+ // overflow when combining the chrono seconds and femto.
+}
+
+//
+// Roundtrip test for format()/parse().
+//
+
+TEST(FormatParse, RoundTrip) {
+ time_zone lax;
+ EXPECT_TRUE(load_time_zone("America/Los_Angeles", &lax));
+ const auto in = convert(civil_second(1977, 6, 28, 9, 8, 7), lax);
+ const auto subseconds = nanoseconds(654321);
+
+ // RFC3339, which renders subseconds.
+ {
+ time_point<nanoseconds> out;
+ const std::string s = format(RFC3339_full, in + subseconds, lax);
+ EXPECT_TRUE(parse(RFC3339_full, s, lax, &out)) << s;
+ EXPECT_EQ(in + subseconds, out); // RFC3339_full includes %Ez
+ }
+
+ // RFC1123, which only does whole seconds.
+ {
+ time_point<nanoseconds> out;
+ const std::string s = format(RFC1123_full, in, lax);
+ EXPECT_TRUE(parse(RFC1123_full, s, lax, &out)) << s;
+ EXPECT_EQ(in, out); // RFC1123_full includes %z
+ }
+
+#if defined(_WIN32) || defined(_WIN64)
+ // Initial investigations indicate the %c does not roundtrip on Windows.
+ // TODO: Figure out what is going on here (perhaps a locale problem).
+#else
+ // Even though we don't know what %c will produce, it should roundtrip,
+ // but only in the 0-offset timezone.
+ {
+ time_point<nanoseconds> out;
+ time_zone utc = utc_time_zone();
+ const std::string s = format("%c", in, utc);
+ EXPECT_TRUE(parse("%c", s, utc, &out)) << s;
+ EXPECT_EQ(in, out);
+ }
+#endif
+}
+
+TEST(FormatParse, RoundTripDistantFuture) {
+ const time_zone utc = utc_time_zone();
+ const time_point<sys_seconds> in = time_point<sys_seconds>::max();
+ const std::string s = format(RFC3339_full, in, utc);
+ time_point<sys_seconds> out;
+ EXPECT_TRUE(parse(RFC3339_full, s, utc, &out)) << s;
+ EXPECT_EQ(in, out);
+}
+
+TEST(FormatParse, RoundTripDistantPast) {
+ const time_zone utc = utc_time_zone();
+ const time_point<sys_seconds> in = time_point<sys_seconds>::min();
+ const std::string s = format(RFC3339_full, in, utc);
+ time_point<sys_seconds> out;
+ EXPECT_TRUE(parse(RFC3339_full, s, utc, &out)) << s;
+ EXPECT_EQ(in, out);
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_if.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_if.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_if.cc
new file mode 100644
index 0000000..380834a
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_if.cc
@@ -0,0 +1,41 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "time_zone_if.h"
+#include "time_zone_info.h"
+#include "time_zone_libc.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+std::unique_ptr<TimeZoneIf> TimeZoneIf::Load(const std::string& name) {
+ // Support "libc:localtime" and "libc:*" to access the legacy
+ // localtime and UTC support respectively from the C library.
+ if (name.compare(0, 5, "libc:") == 0) {
+ return std::unique_ptr<TimeZoneIf>(new TimeZoneLibC(name.substr(5)));
+ }
+
+ // Otherwise use the "zoneinfo" implementation by default.
+ std::unique_ptr<TimeZoneInfo> tz(new TimeZoneInfo);
+ if (!tz->Load(name)) tz.reset();
+ return std::unique_ptr<TimeZoneIf>(tz.release());
+}
+
+// Defined out-of-line to avoid emitting a weak vtable in all TUs.
+TimeZoneIf::~TimeZoneIf() {}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_if.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_if.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_if.h
new file mode 100644
index 0000000..ce4da1b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_if.h
@@ -0,0 +1,70 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
+
+#include <chrono>
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// A simple interface used to hide time-zone complexities from time_zone::Impl.
+// Subclasses implement the functions for civil-time conversions in the zone.
+class TimeZoneIf {
+ public:
+ // A factory function for TimeZoneIf implementations.
+ static std::unique_ptr<TimeZoneIf> Load(const std::string& name);
+
+ virtual ~TimeZoneIf();
+
+ virtual time_zone::absolute_lookup BreakTime(
+ const time_point<sys_seconds>& tp) const = 0;
+ virtual time_zone::civil_lookup MakeTime(
+ const civil_second& cs) const = 0;
+
+ virtual std::string Description() const = 0;
+ virtual bool NextTransition(time_point<sys_seconds>* tp) const = 0;
+ virtual bool PrevTransition(time_point<sys_seconds>* tp) const = 0;
+
+ protected:
+ TimeZoneIf() {}
+};
+
+// Convert between time_point<sys_seconds> and a count of seconds since
+// the Unix epoch. We assume that the std::chrono::system_clock and the
+// Unix clock are second aligned, but not that they share an epoch.
+inline std::int_fast64_t ToUnixSeconds(const time_point<sys_seconds>& tp) {
+ return (tp - std::chrono::time_point_cast<sys_seconds>(
+ std::chrono::system_clock::from_time_t(0)))
+ .count();
+}
+inline time_point<sys_seconds> FromUnixSeconds(std::int_fast64_t t) {
+ return std::chrono::time_point_cast<sys_seconds>(
+ std::chrono::system_clock::from_time_t(0)) +
+ sys_seconds(t);
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+#endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IF_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_impl.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_impl.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_impl.cc
new file mode 100644
index 0000000..b3f635f
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_impl.cc
@@ -0,0 +1,117 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "time_zone_impl.h"
+
+#include <mutex>
+#include <string>
+#include <unordered_map>
+#include <utility>
+
+#include "time_zone_fixed.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+namespace {
+
+// time_zone::Impls are linked into a map to support fast lookup by name.
+using TimeZoneImplByName =
+ std::unordered_map<std::string, const time_zone::Impl*>;
+TimeZoneImplByName* time_zone_map = nullptr;
+
+// Mutual exclusion for time_zone_map.
+std::mutex time_zone_mutex;
+
+} // namespace
+
+time_zone time_zone::Impl::UTC() {
+ return time_zone(UTCImpl());
+}
+
+bool time_zone::Impl::LoadTimeZone(const std::string& name, time_zone* tz) {
+ const time_zone::Impl* const utc_impl = UTCImpl();
+
+ // First check for UTC (which is never a key in time_zone_map).
+ auto offset = sys_seconds::zero();
+ if (FixedOffsetFromName(name, &offset) && offset == sys_seconds::zero()) {
+ *tz = time_zone(utc_impl);
+ return true;
+ }
+
+ // Then check, under a shared lock, whether the time zone has already
+ // been loaded. This is the common path. TODO: Move to shared_mutex.
+ {
+ std::lock_guard<std::mutex> lock(time_zone_mutex);
+ if (time_zone_map != nullptr) {
+ TimeZoneImplByName::const_iterator itr = time_zone_map->find(name);
+ if (itr != time_zone_map->end()) {
+ *tz = time_zone(itr->second);
+ return itr->second != utc_impl;
+ }
+ }
+ }
+
+ // Now check again, under an exclusive lock.
+ std::lock_guard<std::mutex> lock(time_zone_mutex);
+ if (time_zone_map == nullptr) time_zone_map = new TimeZoneImplByName;
+ const Impl*& impl = (*time_zone_map)[name];
+ if (impl == nullptr) {
+ // The first thread in loads the new time zone.
+ Impl* new_impl = new Impl(name);
+ new_impl->zone_ = TimeZoneIf::Load(new_impl->name_);
+ if (new_impl->zone_ == nullptr) {
+ delete new_impl; // free the nascent Impl
+ impl = utc_impl; // and fallback to UTC
+ } else {
+ impl = new_impl; // install new time zone
+ }
+ }
+ *tz = time_zone(impl);
+ return impl != utc_impl;
+}
+
+const time_zone::Impl& time_zone::Impl::get(const time_zone& tz) {
+ if (tz.impl_ == nullptr) {
+ // Dereferencing an implicit-UTC time_zone is expected to be
+ // rare, so we don't mind paying a small synchronization cost.
+ return *UTCImpl();
+ }
+ return *tz.impl_;
+}
+
+void time_zone::Impl::ClearTimeZoneMapTestOnly() {
+ std::lock_guard<std::mutex> lock(time_zone_mutex);
+ if (time_zone_map != nullptr) {
+ // Existing time_zone::Impl* entries are in the wild, so we simply
+ // leak them. Future requests will result in reloading the data.
+ time_zone_map->clear();
+ }
+}
+
+time_zone::Impl::Impl(const std::string& name) : name_(name) {}
+
+const time_zone::Impl* time_zone::Impl::UTCImpl() {
+ static Impl* utc_impl = [] {
+ Impl* impl = new Impl("UTC");
+ impl->zone_ = TimeZoneIf::Load(impl->name_); // never fails
+ return impl;
+ }();
+ return utc_impl;
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_impl.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_impl.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_impl.h
new file mode 100644
index 0000000..2c1c30b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_impl.h
@@ -0,0 +1,97 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
+
+#include <memory>
+#include <string>
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+#include "time_zone_if.h"
+#include "time_zone_info.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// time_zone::Impl is the internal object referenced by a cctz::time_zone.
+class time_zone::Impl {
+ public:
+ // The UTC time zone. Also used for other time zones that fail to load.
+ static time_zone UTC();
+
+ // Load a named time zone. Returns false if the name is invalid, or if
+ // some other kind of error occurs. Note that loading "UTC" never fails.
+ static bool LoadTimeZone(const std::string& name, time_zone* tz);
+
+ // Dereferences the time_zone to obtain its Impl.
+ static const time_zone::Impl& get(const time_zone& tz);
+
+ // Clears the map of cached time zones. Primarily for use in benchmarks
+ // that gauge the performance of loading/parsing the time-zone data.
+ static void ClearTimeZoneMapTestOnly();
+
+ // The primary key is the time-zone ID (e.g., "America/New_York").
+ const std::string& name() const { return name_; }
+
+ // Breaks a time_point down to civil-time components in this time zone.
+ time_zone::absolute_lookup BreakTime(
+ const time_point<sys_seconds>& tp) const {
+ return zone_->BreakTime(tp);
+ }
+
+ // Converts the civil-time components in this time zone into a time_point.
+ // That is, the opposite of BreakTime(). The requested civil time may be
+ // ambiguous or illegal due to a change of UTC offset.
+ time_zone::civil_lookup MakeTime(const civil_second& cs) const {
+ return zone_->MakeTime(cs);
+ }
+
+ // Returns an implementation-specific description of this time zone.
+ std::string Description() const { return zone_->Description(); }
+
+ // Finds the time of the next/previous offset change in this time zone.
+ //
+ // By definition, NextTransition(&tp) returns false when tp has its
+ // maximum value, and PrevTransition(&tp) returns false when tp has its
+ // mimimum value. If the zone has no transitions, the result will also
+ // be false no matter what the argument.
+ //
+ // Otherwise, when tp has its mimimum value, NextTransition(&tp) returns
+ // true and sets tp to the first recorded transition. Chains of calls
+ // to NextTransition()/PrevTransition() will eventually return false,
+ // but it is unspecified exactly when NextTransition(&tp) jumps to false,
+ // or what time is set by PrevTransition(&tp) for a very distant tp.
+ bool NextTransition(time_point<sys_seconds>* tp) const {
+ return zone_->NextTransition(tp);
+ }
+ bool PrevTransition(time_point<sys_seconds>* tp) const {
+ return zone_->PrevTransition(tp);
+ }
+
+ private:
+ explicit Impl(const std::string& name);
+ static const Impl* UTCImpl();
+
+ const std::string name_;
+ std::unique_ptr<TimeZoneIf> zone_;
+};
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+#endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_IMPL_H_
[38/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/elf_mem_image.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/elf_mem_image.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/elf_mem_image.cc
new file mode 100644
index 0000000..d6d5192
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/elf_mem_image.cc
@@ -0,0 +1,398 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Allow dynamic symbol lookup in an in-memory Elf image.
+//
+
+#include "absl/debugging/internal/elf_mem_image.h"
+
+#ifdef ABSL_HAVE_ELF_MEM_IMAGE // defined in elf_mem_image.h
+
+#include <string.h>
+#include <cassert>
+#include <cstddef>
+#include "absl/base/internal/raw_logging.h"
+
+// From binutils/include/elf/common.h (this doesn't appear to be documented
+// anywhere else).
+//
+// /* This flag appears in a Versym structure. It means that the symbol
+// is hidden, and is only visible with an explicit version number.
+// This is a GNU extension. */
+// #define VERSYM_HIDDEN 0x8000
+//
+// /* This is the mask for the rest of the Versym information. */
+// #define VERSYM_VERSION 0x7fff
+
+#define VERSYM_VERSION 0x7fff
+
+namespace absl {
+namespace debugging_internal {
+
+namespace {
+
+#if __WORDSIZE == 32
+const int kElfClass = ELFCLASS32;
+int ElfBind(const ElfW(Sym) *symbol) { return ELF32_ST_BIND(symbol->st_info); }
+int ElfType(const ElfW(Sym) *symbol) { return ELF32_ST_TYPE(symbol->st_info); }
+#elif __WORDSIZE == 64
+const int kElfClass = ELFCLASS64;
+int ElfBind(const ElfW(Sym) *symbol) { return ELF64_ST_BIND(symbol->st_info); }
+int ElfType(const ElfW(Sym) *symbol) { return ELF64_ST_TYPE(symbol->st_info); }
+#else
+const int kElfClass = -1;
+int ElfBind(const ElfW(Sym) *) {
+ ABSL_RAW_LOG(FATAL, "Unexpected word size");
+ return 0;
+}
+int ElfType(const ElfW(Sym) *) {
+ ABSL_RAW_LOG(FATAL, "Unexpected word size");
+ return 0;
+}
+#endif
+
+// Extract an element from one of the ELF tables, cast it to desired type.
+// This is just a simple arithmetic and a glorified cast.
+// Callers are responsible for bounds checking.
+template <typename T>
+const T *GetTableElement(const ElfW(Ehdr) * ehdr, ElfW(Off) table_offset,
+ ElfW(Word) element_size, size_t index) {
+ return reinterpret_cast<const T*>(reinterpret_cast<const char *>(ehdr)
+ + table_offset
+ + index * element_size);
+}
+
+} // namespace
+
+// The value of this variable doesn't matter; it's used only for its
+// unique address.
+const int ElfMemImage::kInvalidBaseSentinel = 0;
+
+ElfMemImage::ElfMemImage(const void *base) {
+ ABSL_RAW_CHECK(base != kInvalidBase, "bad pointer");
+ Init(base);
+}
+
+int ElfMemImage::GetNumSymbols() const {
+ if (!hash_) {
+ return 0;
+ }
+ // See http://www.caldera.com/developers/gabi/latest/ch5.dynamic.html#hash
+ return hash_[1];
+}
+
+const ElfW(Sym) *ElfMemImage::GetDynsym(int index) const {
+ ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range");
+ return dynsym_ + index;
+}
+
+const ElfW(Versym) *ElfMemImage::GetVersym(int index) const {
+ ABSL_RAW_CHECK(index < GetNumSymbols(), "index out of range");
+ return versym_ + index;
+}
+
+const ElfW(Phdr) *ElfMemImage::GetPhdr(int index) const {
+ ABSL_RAW_CHECK(index < ehdr_->e_phnum, "index out of range");
+ return GetTableElement<ElfW(Phdr)>(ehdr_,
+ ehdr_->e_phoff,
+ ehdr_->e_phentsize,
+ index);
+}
+
+const char *ElfMemImage::GetDynstr(ElfW(Word) offset) const {
+ ABSL_RAW_CHECK(offset < strsize_, "offset out of range");
+ return dynstr_ + offset;
+}
+
+const void *ElfMemImage::GetSymAddr(const ElfW(Sym) *sym) const {
+ if (sym->st_shndx == SHN_UNDEF || sym->st_shndx >= SHN_LORESERVE) {
+ // Symbol corresponds to "special" (e.g. SHN_ABS) section.
+ return reinterpret_cast<const void *>(sym->st_value);
+ }
+ ABSL_RAW_CHECK(link_base_ < sym->st_value, "symbol out of range");
+ return GetTableElement<char>(ehdr_, 0, 1, sym->st_value) - link_base_;
+}
+
+const ElfW(Verdef) *ElfMemImage::GetVerdef(int index) const {
+ ABSL_RAW_CHECK(0 <= index && static_cast<size_t>(index) <= verdefnum_,
+ "index out of range");
+ const ElfW(Verdef) *version_definition = verdef_;
+ while (version_definition->vd_ndx < index && version_definition->vd_next) {
+ const char *const version_definition_as_char =
+ reinterpret_cast<const char *>(version_definition);
+ version_definition =
+ reinterpret_cast<const ElfW(Verdef) *>(version_definition_as_char +
+ version_definition->vd_next);
+ }
+ return version_definition->vd_ndx == index ? version_definition : nullptr;
+}
+
+const ElfW(Verdaux) *ElfMemImage::GetVerdefAux(
+ const ElfW(Verdef) *verdef) const {
+ return reinterpret_cast<const ElfW(Verdaux) *>(verdef+1);
+}
+
+const char *ElfMemImage::GetVerstr(ElfW(Word) offset) const {
+ ABSL_RAW_CHECK(offset < strsize_, "offset out of range");
+ return dynstr_ + offset;
+}
+
+void ElfMemImage::Init(const void *base) {
+ ehdr_ = nullptr;
+ dynsym_ = nullptr;
+ dynstr_ = nullptr;
+ versym_ = nullptr;
+ verdef_ = nullptr;
+ hash_ = nullptr;
+ strsize_ = 0;
+ verdefnum_ = 0;
+ link_base_ = ~0L; // Sentinel: PT_LOAD .p_vaddr can't possibly be this.
+ if (!base) {
+ return;
+ }
+ const intptr_t base_as_uintptr_t = reinterpret_cast<uintptr_t>(base);
+ // Fake VDSO has low bit set.
+ const bool fake_vdso = ((base_as_uintptr_t & 1) != 0);
+ base = reinterpret_cast<const void *>(base_as_uintptr_t & ~1);
+ const char *const base_as_char = reinterpret_cast<const char *>(base);
+ if (base_as_char[EI_MAG0] != ELFMAG0 || base_as_char[EI_MAG1] != ELFMAG1 ||
+ base_as_char[EI_MAG2] != ELFMAG2 || base_as_char[EI_MAG3] != ELFMAG3) {
+ assert(false);
+ return;
+ }
+ int elf_class = base_as_char[EI_CLASS];
+ if (elf_class != kElfClass) {
+ assert(false);
+ return;
+ }
+ switch (base_as_char[EI_DATA]) {
+ case ELFDATA2LSB: {
+ if (__LITTLE_ENDIAN != __BYTE_ORDER) {
+ assert(false);
+ return;
+ }
+ break;
+ }
+ case ELFDATA2MSB: {
+ if (__BIG_ENDIAN != __BYTE_ORDER) {
+ assert(false);
+ return;
+ }
+ break;
+ }
+ default: {
+ assert(false);
+ return;
+ }
+ }
+
+ ehdr_ = reinterpret_cast<const ElfW(Ehdr) *>(base);
+ const ElfW(Phdr) *dynamic_program_header = nullptr;
+ for (int i = 0; i < ehdr_->e_phnum; ++i) {
+ const ElfW(Phdr) *const program_header = GetPhdr(i);
+ switch (program_header->p_type) {
+ case PT_LOAD:
+ if (!~link_base_) {
+ link_base_ = program_header->p_vaddr;
+ }
+ break;
+ case PT_DYNAMIC:
+ dynamic_program_header = program_header;
+ break;
+ }
+ }
+ if (!~link_base_ || !dynamic_program_header) {
+ assert(false);
+ // Mark this image as not present. Can not recur infinitely.
+ Init(nullptr);
+ return;
+ }
+ ptrdiff_t relocation =
+ base_as_char - reinterpret_cast<const char *>(link_base_);
+ ElfW(Dyn) *dynamic_entry =
+ reinterpret_cast<ElfW(Dyn) *>(dynamic_program_header->p_vaddr +
+ relocation);
+ for (; dynamic_entry->d_tag != DT_NULL; ++dynamic_entry) {
+ ElfW(Xword) value = dynamic_entry->d_un.d_val;
+ if (fake_vdso) {
+ // A complication: in the real VDSO, dynamic entries are not relocated
+ // (it wasn't loaded by a dynamic loader). But when testing with a
+ // "fake" dlopen()ed vdso library, the loader relocates some (but
+ // not all!) of them before we get here.
+ if (dynamic_entry->d_tag == DT_VERDEF) {
+ // The only dynamic entry (of the ones we care about) libc-2.3.6
+ // loader doesn't relocate.
+ value += relocation;
+ }
+ } else {
+ // Real VDSO. Everything needs to be relocated.
+ value += relocation;
+ }
+ switch (dynamic_entry->d_tag) {
+ case DT_HASH:
+ hash_ = reinterpret_cast<ElfW(Word) *>(value);
+ break;
+ case DT_SYMTAB:
+ dynsym_ = reinterpret_cast<ElfW(Sym) *>(value);
+ break;
+ case DT_STRTAB:
+ dynstr_ = reinterpret_cast<const char *>(value);
+ break;
+ case DT_VERSYM:
+ versym_ = reinterpret_cast<ElfW(Versym) *>(value);
+ break;
+ case DT_VERDEF:
+ verdef_ = reinterpret_cast<ElfW(Verdef) *>(value);
+ break;
+ case DT_VERDEFNUM:
+ verdefnum_ = dynamic_entry->d_un.d_val;
+ break;
+ case DT_STRSZ:
+ strsize_ = dynamic_entry->d_un.d_val;
+ break;
+ default:
+ // Unrecognized entries explicitly ignored.
+ break;
+ }
+ }
+ if (!hash_ || !dynsym_ || !dynstr_ || !versym_ ||
+ !verdef_ || !verdefnum_ || !strsize_) {
+ assert(false); // invalid VDSO
+ // Mark this image as not present. Can not recur infinitely.
+ Init(nullptr);
+ return;
+ }
+}
+
+bool ElfMemImage::LookupSymbol(const char *name,
+ const char *version,
+ int type,
+ SymbolInfo *info_out) const {
+ for (const SymbolInfo& info : *this) {
+ if (strcmp(info.name, name) == 0 && strcmp(info.version, version) == 0 &&
+ ElfType(info.symbol) == type) {
+ if (info_out) {
+ *info_out = info;
+ }
+ return true;
+ }
+ }
+ return false;
+}
+
+bool ElfMemImage::LookupSymbolByAddress(const void *address,
+ SymbolInfo *info_out) const {
+ for (const SymbolInfo& info : *this) {
+ const char *const symbol_start =
+ reinterpret_cast<const char *>(info.address);
+ const char *const symbol_end = symbol_start + info.symbol->st_size;
+ if (symbol_start <= address && address < symbol_end) {
+ if (info_out) {
+ // Client wants to know details for that symbol (the usual case).
+ if (ElfBind(info.symbol) == STB_GLOBAL) {
+ // Strong symbol; just return it.
+ *info_out = info;
+ return true;
+ } else {
+ // Weak or local. Record it, but keep looking for a strong one.
+ *info_out = info;
+ }
+ } else {
+ // Client only cares if there is an overlapping symbol.
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+ElfMemImage::SymbolIterator::SymbolIterator(const void *const image, int index)
+ : index_(index), image_(image) {
+}
+
+const ElfMemImage::SymbolInfo *ElfMemImage::SymbolIterator::operator->() const {
+ return &info_;
+}
+
+const ElfMemImage::SymbolInfo& ElfMemImage::SymbolIterator::operator*() const {
+ return info_;
+}
+
+bool ElfMemImage::SymbolIterator::operator==(const SymbolIterator &rhs) const {
+ return this->image_ == rhs.image_ && this->index_ == rhs.index_;
+}
+
+bool ElfMemImage::SymbolIterator::operator!=(const SymbolIterator &rhs) const {
+ return !(*this == rhs);
+}
+
+ElfMemImage::SymbolIterator &ElfMemImage::SymbolIterator::operator++() {
+ this->Update(1);
+ return *this;
+}
+
+ElfMemImage::SymbolIterator ElfMemImage::begin() const {
+ SymbolIterator it(this, 0);
+ it.Update(0);
+ return it;
+}
+
+ElfMemImage::SymbolIterator ElfMemImage::end() const {
+ return SymbolIterator(this, GetNumSymbols());
+}
+
+void ElfMemImage::SymbolIterator::Update(int increment) {
+ const ElfMemImage *image = reinterpret_cast<const ElfMemImage *>(image_);
+ ABSL_RAW_CHECK(image->IsPresent() || increment == 0, "");
+ if (!image->IsPresent()) {
+ return;
+ }
+ index_ += increment;
+ if (index_ >= image->GetNumSymbols()) {
+ index_ = image->GetNumSymbols();
+ return;
+ }
+ const ElfW(Sym) *symbol = image->GetDynsym(index_);
+ const ElfW(Versym) *version_symbol = image->GetVersym(index_);
+ ABSL_RAW_CHECK(symbol && version_symbol, "");
+ const char *const symbol_name = image->GetDynstr(symbol->st_name);
+ const ElfW(Versym) version_index = version_symbol[0] & VERSYM_VERSION;
+ const ElfW(Verdef) *version_definition = nullptr;
+ const char *version_name = "";
+ if (symbol->st_shndx == SHN_UNDEF) {
+ // Undefined symbols reference DT_VERNEED, not DT_VERDEF, and
+ // version_index could well be greater than verdefnum_, so calling
+ // GetVerdef(version_index) may trigger assertion.
+ } else {
+ version_definition = image->GetVerdef(version_index);
+ }
+ if (version_definition) {
+ // I am expecting 1 or 2 auxiliary entries: 1 for the version itself,
+ // optional 2nd if the version has a parent.
+ ABSL_RAW_CHECK(
+ version_definition->vd_cnt == 1 || version_definition->vd_cnt == 2,
+ "wrong number of entries");
+ const ElfW(Verdaux) *version_aux = image->GetVerdefAux(version_definition);
+ version_name = image->GetVerstr(version_aux->vda_name);
+ }
+ info_.name = symbol_name;
+ info_.version = version_name;
+ info_.address = image->GetSymAddr(symbol);
+ info_.symbol = symbol;
+}
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_HAVE_ELF_MEM_IMAGE
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/elf_mem_image.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/elf_mem_image.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/elf_mem_image.h
new file mode 100644
index 0000000..3b57726
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/elf_mem_image.h
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2017 The Abseil Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Allow dynamic symbol lookup for in-memory Elf images.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
+#define ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
+
+// Including this will define the __GLIBC__ macro if glibc is being
+// used.
+#include <climits>
+
+// Maybe one day we can rewrite this file not to require the elf
+// symbol extensions in glibc, but for right now we need them.
+#ifdef ABSL_HAVE_ELF_MEM_IMAGE
+#error ABSL_HAVE_ELF_MEM_IMAGE cannot be directly set
+#endif
+
+#if defined(__ELF__) && defined(__GLIBC__) && !defined(__native_client__) && \
+ !defined(__asmjs__) && !defined(__wasm__)
+#define ABSL_HAVE_ELF_MEM_IMAGE 1
+#endif
+
+#if ABSL_HAVE_ELF_MEM_IMAGE
+
+#include <link.h> // for ElfW
+
+namespace absl {
+namespace debugging_internal {
+
+// An in-memory ELF image (may not exist on disk).
+class ElfMemImage {
+ private:
+ // Sentinel: there could never be an elf image at &kInvalidBaseSentinel.
+ static const int kInvalidBaseSentinel;
+
+ public:
+ // Sentinel: there could never be an elf image at this address.
+ static constexpr const void *const kInvalidBase =
+ static_cast<const void*>(&kInvalidBaseSentinel);
+
+ // Information about a single vdso symbol.
+ // All pointers are into .dynsym, .dynstr, or .text of the VDSO.
+ // Do not free() them or modify through them.
+ struct SymbolInfo {
+ const char *name; // E.g. "__vdso_getcpu"
+ const char *version; // E.g. "LINUX_2.6", could be ""
+ // for unversioned symbol.
+ const void *address; // Relocated symbol address.
+ const ElfW(Sym) *symbol; // Symbol in the dynamic symbol table.
+ };
+
+ // Supports iteration over all dynamic symbols.
+ class SymbolIterator {
+ public:
+ friend class ElfMemImage;
+ const SymbolInfo *operator->() const;
+ const SymbolInfo &operator*() const;
+ SymbolIterator& operator++();
+ bool operator!=(const SymbolIterator &rhs) const;
+ bool operator==(const SymbolIterator &rhs) const;
+ private:
+ SymbolIterator(const void *const image, int index);
+ void Update(int incr);
+ SymbolInfo info_;
+ int index_;
+ const void *const image_;
+ };
+
+
+ explicit ElfMemImage(const void *base);
+ void Init(const void *base);
+ bool IsPresent() const { return ehdr_ != nullptr; }
+ const ElfW(Phdr)* GetPhdr(int index) const;
+ const ElfW(Sym)* GetDynsym(int index) const;
+ const ElfW(Versym)* GetVersym(int index) const;
+ const ElfW(Verdef)* GetVerdef(int index) const;
+ const ElfW(Verdaux)* GetVerdefAux(const ElfW(Verdef) *verdef) const;
+ const char* GetDynstr(ElfW(Word) offset) const;
+ const void* GetSymAddr(const ElfW(Sym) *sym) const;
+ const char* GetVerstr(ElfW(Word) offset) const;
+ int GetNumSymbols() const;
+
+ SymbolIterator begin() const;
+ SymbolIterator end() const;
+
+ // Look up versioned dynamic symbol in the image.
+ // Returns false if image is not present, or doesn't contain given
+ // symbol/version/type combination.
+ // If info_out is non-null, additional details are filled in.
+ bool LookupSymbol(const char *name, const char *version,
+ int symbol_type, SymbolInfo *info_out) const;
+
+ // Find info about symbol (if any) which overlaps given address.
+ // Returns true if symbol was found; false if image isn't present
+ // or doesn't have a symbol overlapping given address.
+ // If info_out is non-null, additional details are filled in.
+ bool LookupSymbolByAddress(const void *address, SymbolInfo *info_out) const;
+
+ private:
+ const ElfW(Ehdr) *ehdr_;
+ const ElfW(Sym) *dynsym_;
+ const ElfW(Versym) *versym_;
+ const ElfW(Verdef) *verdef_;
+ const ElfW(Word) *hash_;
+ const char *dynstr_;
+ size_t strsize_;
+ size_t verdefnum_;
+ ElfW(Addr) link_base_; // Link-time base (p_vaddr of first PT_LOAD).
+};
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_HAVE_ELF_MEM_IMAGE
+
+#endif // ABSL_DEBUGGING_INTERNAL_ELF_MEM_IMAGE_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/examine_stack.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/examine_stack.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/examine_stack.cc
new file mode 100644
index 0000000..261daae
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/examine_stack.cc
@@ -0,0 +1,147 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#include "absl/debugging/internal/examine_stack.h"
+
+#ifndef _WIN32
+#include <unistd.h>
+#endif
+
+#include <csignal>
+#include <cstdio>
+
+#include "absl/base/attributes.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/macros.h"
+#include "absl/debugging/stacktrace.h"
+#include "absl/debugging/symbolize.h"
+
+namespace absl {
+namespace debugging_internal {
+
+// Returns the program counter from signal context, nullptr if
+// unknown. vuc is a ucontext_t*. We use void* to avoid the use of
+// ucontext_t on non-POSIX systems.
+void* GetProgramCounter(void* vuc) {
+#ifdef __linux__
+ if (vuc != nullptr) {
+ ucontext_t* context = reinterpret_cast<ucontext_t*>(vuc);
+#if defined(__aarch64__)
+ return reinterpret_cast<void*>(context->uc_mcontext.pc);
+#elif defined(__arm__)
+ return reinterpret_cast<void*>(context->uc_mcontext.arm_pc);
+#elif defined(__i386__)
+ if (14 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
+ return reinterpret_cast<void*>(context->uc_mcontext.gregs[14]);
+#elif defined(__powerpc64__)
+ return reinterpret_cast<void*>(context->uc_mcontext.gp_regs[32]);
+#elif defined(__powerpc__)
+ return reinterpret_cast<void*>(context->uc_mcontext.regs->nip);
+#elif defined(__x86_64__)
+ if (16 < ABSL_ARRAYSIZE(context->uc_mcontext.gregs))
+ return reinterpret_cast<void*>(context->uc_mcontext.gregs[16]);
+#else
+#error "Undefined Architecture."
+#endif
+ }
+#elif defined(__akaros__)
+ auto* ctx = reinterpret_cast<struct user_context*>(vuc);
+ return reinterpret_cast<void*>(get_user_ctx_pc(ctx));
+#endif
+ static_cast<void>(vuc);
+ return nullptr;
+}
+
+// The %p field width for printf() functions is two characters per byte,
+// and two extra for the leading "0x".
+static constexpr int kPrintfPointerFieldWidth = 2 + 2 * sizeof(void*);
+
+// Print a program counter, its stack frame size, and its symbol name.
+// Note that there is a separate symbolize_pc argument. Return addresses may be
+// at the end of the function, and this allows the caller to back up from pc if
+// appropriate.
+static void DumpPCAndFrameSizeAndSymbol(void (*writerfn)(const char*, void*),
+ void* writerfn_arg, void* pc,
+ void* symbolize_pc, int framesize,
+ const char* const prefix) {
+ char tmp[1024];
+ const char* symbol = "(unknown)";
+ if (absl::Symbolize(symbolize_pc, tmp, sizeof(tmp))) {
+ symbol = tmp;
+ }
+ char buf[1024];
+ if (framesize <= 0) {
+ snprintf(buf, sizeof(buf), "%s@ %*p (unknown) %s\n", prefix,
+ kPrintfPointerFieldWidth, pc, symbol);
+ } else {
+ snprintf(buf, sizeof(buf), "%s@ %*p %9d %s\n", prefix,
+ kPrintfPointerFieldWidth, pc, framesize, symbol);
+ }
+ writerfn(buf, writerfn_arg);
+}
+
+// Print a program counter and the corresponding stack frame size.
+static void DumpPCAndFrameSize(void (*writerfn)(const char*, void*),
+ void* writerfn_arg, void* pc, int framesize,
+ const char* const prefix) {
+ char buf[100];
+ if (framesize <= 0) {
+ snprintf(buf, sizeof(buf), "%s@ %*p (unknown)\n", prefix,
+ kPrintfPointerFieldWidth, pc);
+ } else {
+ snprintf(buf, sizeof(buf), "%s@ %*p %9d\n", prefix,
+ kPrintfPointerFieldWidth, pc, framesize);
+ }
+ writerfn(buf, writerfn_arg);
+}
+
+void DumpPCAndFrameSizesAndStackTrace(
+ void* pc, void* const stack[], int frame_sizes[], int depth,
+ int min_dropped_frames, bool symbolize_stacktrace,
+ void (*writerfn)(const char*, void*), void* writerfn_arg) {
+ if (pc != nullptr) {
+ // We don't know the stack frame size for PC, use 0.
+ if (symbolize_stacktrace) {
+ DumpPCAndFrameSizeAndSymbol(writerfn, writerfn_arg, pc, pc, 0, "PC: ");
+ } else {
+ DumpPCAndFrameSize(writerfn, writerfn_arg, pc, 0, "PC: ");
+ }
+ }
+ for (int i = 0; i < depth; i++) {
+ if (symbolize_stacktrace) {
+ // Pass the previous address of pc as the symbol address because pc is a
+ // return address, and an overrun may occur when the function ends with a
+ // call to a function annotated noreturn (e.g. CHECK). Note that we don't
+ // do this for pc above, as the adjustment is only correct for return
+ // addresses.
+ DumpPCAndFrameSizeAndSymbol(writerfn, writerfn_arg, stack[i],
+ reinterpret_cast<char*>(stack[i]) - 1,
+ frame_sizes[i], " ");
+ } else {
+ DumpPCAndFrameSize(writerfn, writerfn_arg, stack[i], frame_sizes[i],
+ " ");
+ }
+ }
+ if (min_dropped_frames > 0) {
+ char buf[100];
+ snprintf(buf, sizeof(buf), " @ ... and at least %d more frames\n",
+ min_dropped_frames);
+ writerfn(buf, writerfn_arg);
+ }
+}
+
+} // namespace debugging_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/examine_stack.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/examine_stack.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/examine_stack.h
new file mode 100644
index 0000000..a16c03b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/examine_stack.h
@@ -0,0 +1,38 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
+#define ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
+
+namespace absl {
+namespace debugging_internal {
+
+// Returns the program counter from signal context, or nullptr if
+// unknown. `vuc` is a ucontext_t*. We use void* to avoid the use of
+// ucontext_t on non-POSIX systems.
+void* GetProgramCounter(void* vuc);
+
+// Uses `writerfn` to dump the program counter, stack trace, and stack
+// frame sizes.
+void DumpPCAndFrameSizesAndStackTrace(
+ void* pc, void* const stack[], int frame_sizes[], int depth,
+ int min_dropped_frames, bool symbolize_stacktrace,
+ void (*writerfn)(const char*, void*), void* writerfn_arg);
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_EXAMINE_STACK_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption.cc
new file mode 100644
index 0000000..2b3b972
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption.cc
@@ -0,0 +1,172 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/debugging/internal/stack_consumption.h"
+
+#ifdef ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
+
+#include <signal.h>
+#include <sys/mman.h>
+#include <unistd.h>
+
+#include <string.h>
+
+#include "absl/base/attributes.h"
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+namespace debugging_internal {
+namespace {
+
+// This code requires that we know the direction in which the stack
+// grows. It is commonly believed that this can be detected by putting
+// a variable on the stack and then passing its address to a function
+// that compares the address of this variable to the address of a
+// variable on the function's own stack. However, this is unspecified
+// behavior in C++: If two pointers p and q of the same type point to
+// different objects that are not members of the same object or
+// elements of the same array or to different functions, or if only
+// one of them is null, the results of p<q, p>q, p<=q, and p>=q are
+// unspecified. Therefore, instead we hardcode the direction of the
+// stack on platforms we know about.
+#if defined(__i386__) || defined(__x86_64__) || defined(__ppc__)
+constexpr bool kStackGrowsDown = true;
+#else
+#error Need to define kStackGrowsDown
+#endif
+
+// To measure the stack footprint of some code, we create a signal handler
+// (for SIGUSR2 say) that exercises this code on an alternate stack. This
+// alternate stack is initialized to some known pattern (0x55, 0x55, 0x55,
+// ...). We then self-send this signal, and after the signal handler returns,
+// look at the alternate stack buffer to see what portion has been touched.
+//
+// This trick gives us the the stack footprint of the signal handler. But the
+// signal handler, even before the code for it is exercised, consumes some
+// stack already. We however only want the stack usage of the code inside the
+// signal handler. To measure this accurately, we install two signal handlers:
+// one that does nothing and just returns, and the user-provided signal
+// handler. The difference between the stack consumption of these two signals
+// handlers should give us the stack foorprint of interest.
+
+void EmptySignalHandler(int) {}
+
+// This is arbitrary value, and could be increase further, at the cost of
+// memset()ting it all to known sentinel value.
+constexpr int kAlternateStackSize = 64 << 10; // 64KiB
+
+constexpr int kSafetyMargin = 32;
+constexpr char kAlternateStackFillValue = 0x55;
+
+// These helper functions look at the alternate stack buffer, and figure
+// out what portion of this buffer has been touched - this is the stack
+// consumption of the signal handler running on this alternate stack.
+// This function will return -1 if the alternate stack buffer has not been
+// touched. It will abort the program if the buffer has overflowed or is about
+// to overflow.
+int GetStackConsumption(const void* const altstack) {
+ const char* begin;
+ int increment;
+ if (kStackGrowsDown) {
+ begin = reinterpret_cast<const char*>(altstack);
+ increment = 1;
+ } else {
+ begin = reinterpret_cast<const char*>(altstack) + kAlternateStackSize - 1;
+ increment = -1;
+ }
+
+ for (int usage_count = kAlternateStackSize; usage_count > 0; --usage_count) {
+ if (*begin != kAlternateStackFillValue) {
+ ABSL_RAW_CHECK(usage_count <= kAlternateStackSize - kSafetyMargin,
+ "Buffer has overflowed or is about to overflow");
+ return usage_count;
+ }
+ begin += increment;
+ }
+
+ ABSL_RAW_LOG(FATAL, "Unreachable code");
+ return -1;
+}
+
+} // namespace
+
+int GetSignalHandlerStackConsumption(void (*signal_handler)(int)) {
+ // The alt-signal-stack cannot be heap allocated because there is a
+ // bug in glibc-2.2 where some signal handler setup code looks at the
+ // current stack pointer to figure out what thread is currently running.
+ // Therefore, the alternate stack must be allocated from the main stack
+ // itself.
+ void* altstack = mmap(nullptr, kAlternateStackSize, PROT_READ | PROT_WRITE,
+ MAP_PRIVATE | MAP_ANONYMOUS, -1, 0);
+ ABSL_RAW_CHECK(altstack != MAP_FAILED, "mmap() failed");
+
+ // Set up the alt-signal-stack (and save the older one).
+ stack_t sigstk;
+ memset(&sigstk, 0, sizeof(sigstk));
+ stack_t old_sigstk;
+ sigstk.ss_sp = altstack;
+ sigstk.ss_size = kAlternateStackSize;
+ sigstk.ss_flags = 0;
+ ABSL_RAW_CHECK(sigaltstack(&sigstk, &old_sigstk) == 0,
+ "sigaltstack() failed");
+
+ // Set up SIGUSR1 and SIGUSR2 signal handlers (and save the older ones).
+ struct sigaction sa;
+ memset(&sa, 0, sizeof(sa));
+ struct sigaction old_sa1, old_sa2;
+ sigemptyset(&sa.sa_mask);
+ sa.sa_flags = SA_ONSTACK;
+
+ // SIGUSR1 maps to EmptySignalHandler.
+ sa.sa_handler = EmptySignalHandler;
+ ABSL_RAW_CHECK(sigaction(SIGUSR1, &sa, &old_sa1) == 0, "sigaction() failed");
+
+ // SIGUSR2 maps to signal_handler.
+ sa.sa_handler = signal_handler;
+ ABSL_RAW_CHECK(sigaction(SIGUSR2, &sa, &old_sa2) == 0, "sigaction() failed");
+
+ // Send SIGUSR1 signal and measure the stack consumption of the empty
+ // signal handler.
+ // The first signal might use more stack space. Run once and ignore the
+ // results to get that out of the way.
+ ABSL_RAW_CHECK(kill(getpid(), SIGUSR1) == 0, "kill() failed");
+
+ memset(altstack, kAlternateStackFillValue, kAlternateStackSize);
+ ABSL_RAW_CHECK(kill(getpid(), SIGUSR1) == 0, "kill() failed");
+ int base_stack_consumption = GetStackConsumption(altstack);
+
+ // Send SIGUSR2 signal and measure the stack consumption of signal_handler.
+ ABSL_RAW_CHECK(kill(getpid(), SIGUSR2) == 0, "kill() failed");
+ int signal_handler_stack_consumption = GetStackConsumption(altstack);
+
+ // Now restore the old alt-signal-stack and signal handlers.
+ ABSL_RAW_CHECK(sigaltstack(&old_sigstk, nullptr) == 0,
+ "sigaltstack() failed");
+ ABSL_RAW_CHECK(sigaction(SIGUSR1, &old_sa1, nullptr) == 0,
+ "sigaction() failed");
+ ABSL_RAW_CHECK(sigaction(SIGUSR2, &old_sa2, nullptr) == 0,
+ "sigaction() failed");
+
+ ABSL_RAW_CHECK(munmap(altstack, kAlternateStackSize) == 0, "munmap() failed");
+ if (signal_handler_stack_consumption != -1 && base_stack_consumption != -1) {
+ return signal_handler_stack_consumption - base_stack_consumption;
+ }
+ return -1;
+}
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption.h
new file mode 100644
index 0000000..4c5fa0f
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption.h
@@ -0,0 +1,45 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Helper function for measuring stack consumption of signal handlers.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
+#define ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
+
+// The code in this module is not portable.
+// Use this feature test macro to detect its availability.
+#ifdef ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
+#error ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION cannot be set directly
+#elif !defined(__APPLE__) && !defined(_WIN32) && \
+ (defined(__i386__) || defined(__x86_64__) || defined(__ppc__))
+#define ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION 1
+
+namespace absl {
+namespace debugging_internal {
+
+// Returns the stack consumption in bytes for the code exercised by
+// signal_handler. To measure stack consumption, signal_handler is registered
+// as a signal handler, so the code that it exercises must be async-signal
+// safe. The argument of signal_handler is an implementation detail of signal
+// handlers and should ignored by the code for signal_handler. Use global
+// variables to pass information between your test code and signal_handler.
+int GetSignalHandlerStackConsumption(void (*signal_handler)(int));
+
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
+
+#endif // ABSL_DEBUGGING_INTERNAL_STACK_CONSUMPTION_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption_test.cc
new file mode 100644
index 0000000..5ce3846
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stack_consumption_test.cc
@@ -0,0 +1,48 @@
+//
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/debugging/internal/stack_consumption.h"
+
+#ifdef ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
+
+#include <string.h>
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+namespace debugging_internal {
+namespace {
+
+static void SimpleSignalHandler(int signo) {
+ char buf[100];
+ memset(buf, 'a', sizeof(buf));
+
+ // Never true, but prevents compiler from optimizing buf out.
+ if (signo == 0) {
+ ABSL_RAW_LOG(INFO, "%p", static_cast<void*>(buf));
+ }
+}
+
+TEST(SignalHandlerStackConsumptionTest, MeasuresStackConsumption) {
+ // Our handler should consume reasonable number of bytes.
+ EXPECT_GE(GetSignalHandlerStackConsumption(SimpleSignalHandler), 100);
+}
+
+} // namespace
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_INTERNAL_HAVE_DEBUGGING_STACK_CONSUMPTION
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_aarch64-inl.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_aarch64-inl.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_aarch64-inl.inc
new file mode 100644
index 0000000..a861c0a
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_aarch64-inl.inc
@@ -0,0 +1,189 @@
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
+
+// Generate stack tracer for aarch64
+
+#if defined(__linux__)
+#include <sys/mman.h>
+#include <ucontext.h>
+#include <unistd.h>
+#endif
+
+#include <atomic>
+#include <cassert>
+#include <cstdint>
+#include <iostream>
+
+#include "absl/debugging/internal/address_is_readable.h"
+#include "absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems
+#include "absl/debugging/stacktrace.h"
+
+static const uintptr_t kUnknownFrameSize = 0;
+
+#if defined(__linux__)
+// Returns the address of the VDSO __kernel_rt_sigreturn function, if present.
+static const unsigned char* GetKernelRtSigreturnAddress() {
+ constexpr uintptr_t kImpossibleAddress = 1;
+ static std::atomic<uintptr_t> memoized{kImpossibleAddress};
+ uintptr_t address = memoized.load(std::memory_order_relaxed);
+ if (address != kImpossibleAddress) {
+ return reinterpret_cast<const unsigned char*>(address);
+ }
+
+ address = reinterpret_cast<uintptr_t>(nullptr);
+
+#ifdef ABSL_HAVE_VDSO_SUPPORT
+ absl::debugging_internal::VDSOSupport vdso;
+ if (vdso.IsPresent()) {
+ absl::debugging_internal::VDSOSupport::SymbolInfo symbol_info;
+ if (!vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_2.6.39", STT_FUNC,
+ &symbol_info) ||
+ symbol_info.address == nullptr) {
+ // Unexpected: VDSO is present, yet the expected symbol is missing
+ // or null.
+ assert(false && "VDSO is present, but doesn't have expected symbol");
+ } else {
+ if (reinterpret_cast<uintptr_t>(symbol_info.address) !=
+ kImpossibleAddress) {
+ address = reinterpret_cast<uintptr_t>(symbol_info.address);
+ } else {
+ assert(false && "VDSO returned invalid address");
+ }
+ }
+ }
+#endif
+
+ memoized.store(address, std::memory_order_relaxed);
+ return reinterpret_cast<const unsigned char*>(address);
+}
+#endif // __linux__
+
+// Compute the size of a stack frame in [low..high). We assume that
+// low < high. Return size of kUnknownFrameSize.
+template<typename T>
+static inline uintptr_t ComputeStackFrameSize(const T* low,
+ const T* high) {
+ const char* low_char_ptr = reinterpret_cast<const char *>(low);
+ const char* high_char_ptr = reinterpret_cast<const char *>(high);
+ return low < high ? high_char_ptr - low_char_ptr : kUnknownFrameSize;
+}
+
+// Given a pointer to a stack frame, locate and return the calling
+// stackframe, or return null if no stackframe can be found. Perform sanity
+// checks (the strictness of which is controlled by the boolean parameter
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
+template<bool STRICT_UNWINDING, bool WITH_CONTEXT>
+static void **NextStackFrame(void **old_frame_pointer, const void *uc) {
+ void **new_frame_pointer = reinterpret_cast<void**>(*old_frame_pointer);
+ bool check_frame_size = true;
+
+#if defined(__linux__)
+ if (WITH_CONTEXT && uc != nullptr) {
+ // Check to see if next frame's return address is __kernel_rt_sigreturn.
+ if (old_frame_pointer[1] == GetKernelRtSigreturnAddress()) {
+ const ucontext_t *ucv = static_cast<const ucontext_t *>(uc);
+ // old_frame_pointer[0] is not suitable for unwinding, look at
+ // ucontext to discover frame pointer before signal.
+ void **const pre_signal_frame_pointer =
+ reinterpret_cast<void **>(ucv->uc_mcontext.regs[29]);
+
+ // Check that alleged frame pointer is actually readable. This is to
+ // prevent "double fault" in case we hit the first fault due to e.g.
+ // stack corruption.
+ if (!absl::debugging_internal::AddressIsReadable(
+ pre_signal_frame_pointer))
+ return nullptr;
+
+ // Alleged frame pointer is readable, use it for further unwinding.
+ new_frame_pointer = pre_signal_frame_pointer;
+
+ // Skip frame size check if we return from a signal. We may be using a
+ // an alternate stack for signals.
+ check_frame_size = false;
+ }
+ }
+#endif
+
+ // aarch64 ABI requires stack pointer to be 16-byte-aligned.
+ if ((reinterpret_cast<uintptr_t>(new_frame_pointer) & 15) != 0)
+ return nullptr;
+
+ // Check frame size. In strict mode, we assume frames to be under
+ // 100,000 bytes. In non-strict mode, we relax the limit to 1MB.
+ if (check_frame_size) {
+ const uintptr_t max_size = STRICT_UNWINDING ? 100000 : 1000000;
+ const uintptr_t frame_size =
+ ComputeStackFrameSize(old_frame_pointer, new_frame_pointer);
+ if (frame_size == kUnknownFrameSize || frame_size > max_size)
+ return nullptr;
+ }
+
+ return new_frame_pointer;
+}
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
+ const void *ucp, int *min_dropped_frames) {
+#ifdef __GNUC__
+ void **frame_pointer = reinterpret_cast<void**>(__builtin_frame_address(0));
+#else
+# error reading stack point not yet supported on this platform.
+#endif
+
+ skip_count++; // Skip the frame for this function.
+ int n = 0;
+
+ // The frame pointer points to low address of a frame. The first 64-bit
+ // word of a frame points to the next frame up the call chain, which normally
+ // is just after the high address of the current frame. The second word of
+ // a frame contains return adress of to the caller. To find a pc value
+ // associated with the current frame, we need to go down a level in the call
+ // chain. So we remember return the address of the last frame seen. This
+ // does not work for the first stack frame, which belongs to UnwindImp() but
+ // we skip the frame for UnwindImp() anyway.
+ void* prev_return_address = nullptr;
+
+ while (frame_pointer && n < max_depth) {
+ // The absl::GetStackFrames routine is called when we are in some
+ // informational context (the failure signal handler for example).
+ // Use the non-strict unwinding rules to produce a stack trace
+ // that is as complete as possible (even if it contains a few bogus
+ // entries in some rare cases).
+ void **next_frame_pointer =
+ NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
+
+ if (skip_count > 0) {
+ skip_count--;
+ } else {
+ result[n] = prev_return_address;
+ if (IS_STACK_FRAMES) {
+ sizes[n] = ComputeStackFrameSize(frame_pointer, next_frame_pointer);
+ }
+ n++;
+ }
+ prev_return_address = frame_pointer[1];
+ frame_pointer = next_frame_pointer;
+ }
+ if (min_dropped_frames != nullptr) {
+ // Implementation detail: we clamp the max of frames we are willing to
+ // count, so as not to spend too much time in the loop below.
+ const int kMaxUnwind = 200;
+ int j = 0;
+ for (; frame_pointer != nullptr && j < kMaxUnwind; j++) {
+ frame_pointer =
+ NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(frame_pointer, ucp);
+ }
+ *min_dropped_frames = j;
+ }
+ return n;
+}
+
+namespace absl {
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+ return true;
+}
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_AARCH64_INL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_arm-inl.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_arm-inl.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_arm-inl.inc
new file mode 100644
index 0000000..c840833
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_arm-inl.inc
@@ -0,0 +1,123 @@
+// Copyright 2011 and onwards Google Inc.
+// All rights reserved.
+//
+// Author: Doug Kwan
+// This is inspired by Craig Silverstein's PowerPC stacktrace code.
+//
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
+
+#include <cstdint>
+
+#include "absl/debugging/stacktrace.h"
+
+// WARNING:
+// This only works if all your code is in either ARM or THUMB mode. With
+// interworking, the frame pointer of the caller can either be in r11 (ARM
+// mode) or r7 (THUMB mode). A callee only saves the frame pointer of its
+// mode in a fixed location on its stack frame. If the caller is a different
+// mode, there is no easy way to find the frame pointer. It can either be
+// still in the designated register or saved on stack along with other callee
+// saved registers.
+
+// Given a pointer to a stack frame, locate and return the calling
+// stackframe, or return nullptr if no stackframe can be found. Perform sanity
+// checks (the strictness of which is controlled by the boolean parameter
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
+template<bool STRICT_UNWINDING>
+static void **NextStackFrame(void **old_sp) {
+ void **new_sp = (void**) old_sp[-1];
+
+ // Check that the transition from frame pointer old_sp to frame
+ // pointer new_sp isn't clearly bogus
+ if (STRICT_UNWINDING) {
+ // With the stack growing downwards, older stack frame must be
+ // at a greater address that the current one.
+ if (new_sp <= old_sp) return nullptr;
+ // Assume stack frames larger than 100,000 bytes are bogus.
+ if ((uintptr_t)new_sp - (uintptr_t)old_sp > 100000) return nullptr;
+ } else {
+ // In the non-strict mode, allow discontiguous stack frames.
+ // (alternate-signal-stacks for example).
+ if (new_sp == old_sp) return nullptr;
+ // And allow frames upto about 1MB.
+ if ((new_sp > old_sp)
+ && ((uintptr_t)new_sp - (uintptr_t)old_sp > 1000000)) return nullptr;
+ }
+ if ((uintptr_t)new_sp & (sizeof(void *) - 1)) return nullptr;
+ return new_sp;
+}
+
+// This ensures that absl::GetStackTrace sets up the Link Register properly.
+#ifdef __GNUC__
+void StacktraceArmDummyFunction() __attribute__((noinline));
+void StacktraceArmDummyFunction() { __asm__ volatile(""); }
+#else
+# error StacktraceArmDummyFunction() needs to be ported to this platform.
+#endif
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
+ const void * /* ucp */, int *min_dropped_frames) {
+#ifdef __GNUC__
+ void **sp = reinterpret_cast<void**>(__builtin_frame_address(0));
+#else
+# error reading stack point not yet supported on this platform.
+#endif
+
+ // On ARM, the return address is stored in the link register (r14).
+ // This is not saved on the stack frame of a leaf function. To
+ // simplify code that reads return addresses, we call a dummy
+ // function so that the return address of this function is also
+ // stored in the stack frame. This works at least for gcc.
+ StacktraceArmDummyFunction();
+
+ int n = 0;
+ while (sp && n < max_depth) {
+ // The absl::GetStackFrames routine is called when we are in some
+ // informational context (the failure signal handler for example).
+ // Use the non-strict unwinding rules to produce a stack trace
+ // that is as complete as possible (even if it contains a few bogus
+ // entries in some rare cases).
+ void **next_sp = NextStackFrame<!IS_STACK_FRAMES>(sp);
+
+ if (skip_count > 0) {
+ skip_count--;
+ } else {
+ result[n] = *sp;
+
+ if (IS_STACK_FRAMES) {
+ if (next_sp > sp) {
+ sizes[n] = (uintptr_t)next_sp - (uintptr_t)sp;
+ } else {
+ // A frame-size of 0 is used to indicate unknown frame size.
+ sizes[n] = 0;
+ }
+ }
+ n++;
+ }
+ sp = next_sp;
+ }
+ if (min_dropped_frames != nullptr) {
+ // Implementation detail: we clamp the max of frames we are willing to
+ // count, so as not to spend too much time in the loop below.
+ const int kMaxUnwind = 200;
+ int j = 0;
+ for (; sp != nullptr && j < kMaxUnwind; j++) {
+ sp = NextStackFrame<!IS_STACK_FRAMES>(sp);
+ }
+ *min_dropped_frames = j;
+ }
+ return n;
+}
+
+namespace absl {
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+ return false;
+}
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_ARM_INL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_config.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_config.h b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_config.h
new file mode 100644
index 0000000..48adfcc
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_config.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright 2017 The Abseil Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+
+ * Defines ABSL_STACKTRACE_INL_HEADER to the *-inl.h containing
+ * actual unwinder implementation.
+ * This header is "private" to stacktrace.cc.
+ * DO NOT include it into any other files.
+*/
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
+
+// First, test platforms which only support a stub.
+#if ABSL_STACKTRACE_INL_HEADER
+#error ABSL_STACKTRACE_INL_HEADER cannot be directly set
+#elif defined(__native_client__) || defined(__APPLE__) || \
+ defined(__FreeBSD__) || defined(__ANDROID__) || defined(__myriad2__) || \
+ defined(__asmjs__) || defined(__wasm__) || defined(__Fuchsia__)
+#define ABSL_STACKTRACE_INL_HEADER \
+ "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
+
+// Next, test for Mips and Windows.
+// TODO(marmstrong): Mips case, remove the check for ABSL_STACKTRACE_INL_HEADER
+#elif defined(__mips__) && !defined(ABSL_STACKTRACE_INL_HEADER)
+#define ABSL_STACKTRACE_INL_HEADER \
+ "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
+#elif defined(_WIN32) // windows
+#define ABSL_STACKTRACE_INL_HEADER \
+ "absl/debugging/internal/stacktrace_win32-inl.inc"
+
+// Finally, test NO_FRAME_POINTER.
+#elif !defined(NO_FRAME_POINTER)
+# if defined(__i386__) || defined(__x86_64__)
+#define ABSL_STACKTRACE_INL_HEADER \
+ "absl/debugging/internal/stacktrace_x86-inl.inc"
+# elif defined(__ppc__) || defined(__PPC__)
+#define ABSL_STACKTRACE_INL_HEADER \
+ "absl/debugging/internal/stacktrace_powerpc-inl.inc"
+# elif defined(__aarch64__)
+#define ABSL_STACKTRACE_INL_HEADER \
+ "absl/debugging/internal/stacktrace_aarch64-inl.inc"
+# elif defined(__arm__)
+#define ABSL_STACKTRACE_INL_HEADER \
+ "absl/debugging/internal/stacktrace_arm-inl.inc"
+# endif
+#else // defined(NO_FRAME_POINTER)
+# if defined(__i386__) || defined(__x86_64__) || defined(__aarch64__)
+#define ABSL_STACKTRACE_INL_HEADER \
+ "absl/debugging/internal/stacktrace_unimplemented-inl.inc"
+# elif defined(__ppc__) || defined(__PPC__)
+// Use glibc's backtrace.
+#define ABSL_STACKTRACE_INL_HEADER \
+ "absl/debugging/internal/stacktrace_generic-inl.inc"
+# elif defined(__arm__)
+# error stacktrace without frame pointer is not supported on ARM
+# endif
+#endif // NO_FRAME_POINTER
+
+#if !defined(ABSL_STACKTRACE_INL_HEADER)
+#error Not supported yet
+#endif
+
+#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_CONFIG_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_generic-inl.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_generic-inl.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_generic-inl.inc
new file mode 100644
index 0000000..2c9ca41
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_generic-inl.inc
@@ -0,0 +1,59 @@
+// Copyright 2000 - 2007 Google Inc.
+// All rights reserved.
+//
+// Author: Sanjay Ghemawat
+//
+// Portable implementation - just use glibc
+//
+// Note: The glibc implementation may cause a call to malloc.
+// This can cause a deadlock in HeapProfiler.
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
+
+#include <execinfo.h>
+#include <cstring>
+
+#include "absl/debugging/stacktrace.h"
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
+ const void *ucp, int *min_dropped_frames) {
+ static const int kStackLength = 64;
+ void * stack[kStackLength];
+ int size;
+
+ size = backtrace(stack, kStackLength);
+ skip_count++; // we want to skip the current frame as well
+ int result_count = size - skip_count;
+ if (result_count < 0)
+ result_count = 0;
+ if (result_count > max_depth)
+ result_count = max_depth;
+ for (int i = 0; i < result_count; i++)
+ result[i] = stack[i + skip_count];
+
+ if (IS_STACK_FRAMES) {
+ // No implementation for finding out the stack frame sizes yet.
+ memset(sizes, 0, sizeof(*sizes) * result_count);
+ }
+ if (min_dropped_frames != nullptr) {
+ if (size - skip_count - max_depth > 0) {
+ *min_dropped_frames = size - skip_count - max_depth;
+ } else {
+ *min_dropped_frames = 0;
+ }
+ }
+
+ return result_count;
+}
+
+namespace absl {
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+ return true;
+}
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_GENERIC_INL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_powerpc-inl.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_powerpc-inl.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_powerpc-inl.inc
new file mode 100644
index 0000000..297bdad
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_powerpc-inl.inc
@@ -0,0 +1,243 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Produce stack trace. I'm guessing (hoping!) the code is much like
+// for x86. For apple machines, at least, it seems to be; see
+// http://developer.apple.com/documentation/mac/runtimehtml/RTArch-59.html
+// http://www.linux-foundation.org/spec/ELF/ppc64/PPC-elf64abi-1.9.html#STACK
+// Linux has similar code: http://patchwork.ozlabs.org/linuxppc/patch?id=8882
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
+
+#if defined(__linux__)
+#include <asm/ptrace.h> // for PT_NIP.
+#include <ucontext.h> // for ucontext_t
+#endif
+
+#include <unistd.h>
+#include <cassert>
+#include <cstdint>
+#include <cstdio>
+
+#include "absl/base/port.h"
+#include "absl/debugging/stacktrace.h"
+#include "absl/debugging/internal/address_is_readable.h"
+#include "absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems
+
+// Given a stack pointer, return the saved link register value.
+// Note that this is the link register for a callee.
+static inline void *StacktracePowerPCGetLR(void **sp) {
+ // PowerPC has 3 main ABIs, which say where in the stack the
+ // Link Register is. For DARWIN and AIX (used by apple and
+ // linux ppc64), it's in sp[2]. For SYSV (used by linux ppc),
+ // it's in sp[1].
+#if defined(_CALL_AIX) || defined(_CALL_DARWIN)
+ return *(sp+2);
+#elif defined(_CALL_SYSV)
+ return *(sp+1);
+#elif defined(__APPLE__) || defined(__FreeBSD__) || \
+ (defined(__linux__) && defined(__PPC64__))
+ // This check is in case the compiler doesn't define _CALL_AIX/etc.
+ return *(sp+2);
+#elif defined(__linux)
+ // This check is in case the compiler doesn't define _CALL_SYSV.
+ return *(sp+1);
+#else
+#error Need to specify the PPC ABI for your archiecture.
+#endif
+}
+
+// Given a pointer to a stack frame, locate and return the calling
+// stackframe, or return null if no stackframe can be found. Perform sanity
+// checks (the strictness of which is controlled by the boolean parameter
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
+template<bool STRICT_UNWINDING, bool IS_WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack.
+static void **NextStackFrame(void **old_sp, const void *uc) {
+ void **new_sp = (void **) *old_sp;
+ enum { kStackAlignment = 16 };
+
+ // Check that the transition from frame pointer old_sp to frame
+ // pointer new_sp isn't clearly bogus
+ if (STRICT_UNWINDING) {
+ // With the stack growing downwards, older stack frame must be
+ // at a greater address that the current one.
+ if (new_sp <= old_sp) return nullptr;
+ // Assume stack frames larger than 100,000 bytes are bogus.
+ if ((uintptr_t)new_sp - (uintptr_t)old_sp > 100000) return nullptr;
+ } else {
+ // In the non-strict mode, allow discontiguous stack frames.
+ // (alternate-signal-stacks for example).
+ if (new_sp == old_sp) return nullptr;
+ // And allow frames upto about 1MB.
+ if ((new_sp > old_sp)
+ && ((uintptr_t)new_sp - (uintptr_t)old_sp > 1000000)) return nullptr;
+ }
+ if ((uintptr_t)new_sp % kStackAlignment != 0) return nullptr;
+
+#if defined(__linux__)
+ enum StackTraceKernelSymbolStatus {
+ kNotInitialized = 0, kAddressValid, kAddressInvalid };
+
+ if (IS_WITH_CONTEXT && uc != nullptr) {
+ static StackTraceKernelSymbolStatus kernel_symbol_status =
+ kNotInitialized; // Sentinel: not computed yet.
+ // Initialize with sentinel value: __kernel_rt_sigtramp_rt64 can not
+ // possibly be there.
+ static const unsigned char *kernel_sigtramp_rt64_address = nullptr;
+ if (kernel_symbol_status == kNotInitialized) {
+ absl::debugging_internal::VDSOSupport vdso;
+ if (vdso.IsPresent()) {
+ absl::debugging_internal::VDSOSupport::SymbolInfo
+ sigtramp_rt64_symbol_info;
+ if (!vdso.LookupSymbol(
+ "__kernel_sigtramp_rt64", "LINUX_2.6.15",
+ absl::debugging_internal::VDSOSupport::kVDSOSymbolType,
+ &sigtramp_rt64_symbol_info) ||
+ sigtramp_rt64_symbol_info.address == nullptr) {
+ // Unexpected: VDSO is present, yet the expected symbol is missing
+ // or null.
+ assert(false && "VDSO is present, but doesn't have expected symbol");
+ kernel_symbol_status = kAddressInvalid;
+ } else {
+ kernel_sigtramp_rt64_address =
+ reinterpret_cast<const unsigned char *>(
+ sigtramp_rt64_symbol_info.address);
+ kernel_symbol_status = kAddressValid;
+ }
+ } else {
+ kernel_symbol_status = kAddressInvalid;
+ }
+ }
+
+ if (new_sp != nullptr &&
+ kernel_symbol_status == kAddressValid &&
+ StacktracePowerPCGetLR(new_sp) == kernel_sigtramp_rt64_address) {
+ const ucontext_t* signal_context =
+ reinterpret_cast<const ucontext_t*>(uc);
+ void **const sp_before_signal =
+ reinterpret_cast<void**>(signal_context->uc_mcontext.gp_regs[PT_R1]);
+ // Check that alleged sp before signal is nonnull and is reasonably
+ // aligned.
+ if (sp_before_signal != nullptr &&
+ ((uintptr_t)sp_before_signal % kStackAlignment) == 0) {
+ // Check that alleged stack pointer is actually readable. This is to
+ // prevent a "double fault" in case we hit the first fault due to e.g.
+ // a stack corruption.
+ if (absl::debugging_internal::AddressIsReadable(sp_before_signal)) {
+ // Alleged stack pointer is readable, use it for further unwinding.
+ new_sp = sp_before_signal;
+ }
+ }
+ }
+ }
+#endif
+
+ return new_sp;
+}
+
+// This ensures that absl::GetStackTrace sets up the Link Register properly.
+void StacktracePowerPCDummyFunction() __attribute__((noinline));
+void StacktracePowerPCDummyFunction() { __asm__ volatile(""); }
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack.
+static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
+ const void *ucp, int *min_dropped_frames) {
+ void **sp;
+ // Apple OS X uses an old version of gnu as -- both Darwin 7.9.0 (Panther)
+ // and Darwin 8.8.1 (Tiger) use as 1.38. This means we have to use a
+ // different asm syntax. I don't know quite the best way to discriminate
+ // systems using the old as from the new one; I've gone with __APPLE__.
+#ifdef __APPLE__
+ __asm__ volatile ("mr %0,r1" : "=r" (sp));
+#else
+ __asm__ volatile ("mr %0,1" : "=r" (sp));
+#endif
+
+ // On PowerPC, the "Link Register" or "Link Record" (LR), is a stack
+ // entry that holds the return address of the subroutine call (what
+ // instruction we run after our function finishes). This is the
+ // same as the stack-pointer of our parent routine, which is what we
+ // want here. While the compiler will always(?) set up LR for
+ // subroutine calls, it may not for leaf functions (such as this one).
+ // This routine forces the compiler (at least gcc) to push it anyway.
+ StacktracePowerPCDummyFunction();
+
+ // The LR save area is used by the callee, so the top entry is bogus.
+ skip_count++;
+
+ int n = 0;
+
+ // Unlike ABIs of X86 and ARM, PowerPC ABIs say that return address (in
+ // the link register) of a function call is stored in the caller's stack
+ // frame instead of the callee's. When we look for the return address
+ // associated with a stack frame, we need to make sure that there is a
+ // caller frame before it. So we call NextStackFrame before entering the
+ // loop below and check next_sp instead of sp for loop termination.
+ // The outermost frame is set up by runtimes and it does not have a
+ // caller frame, so it is skipped.
+
+ // The absl::GetStackFrames routine is called when we are in some
+ // informational context (the failure signal handler for example).
+ // Use the non-strict unwinding rules to produce a stack trace
+ // that is as complete as possible (even if it contains a few
+ // bogus entries in some rare cases).
+ void **next_sp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(sp, ucp);
+
+ while (next_sp && n < max_depth) {
+ if (skip_count > 0) {
+ skip_count--;
+ } else {
+ result[n] = StacktracePowerPCGetLR(sp);
+ if (IS_STACK_FRAMES) {
+ if (next_sp > sp) {
+ sizes[n] = (uintptr_t)next_sp - (uintptr_t)sp;
+ } else {
+ // A frame-size of 0 is used to indicate unknown frame size.
+ sizes[n] = 0;
+ }
+ }
+ n++;
+ }
+
+ sp = next_sp;
+ next_sp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(sp, ucp);
+ }
+
+ if (min_dropped_frames != nullptr) {
+ // Implementation detail: we clamp the max of frames we are willing to
+ // count, so as not to spend too much time in the loop below.
+ const int kMaxUnwind = 1000;
+ int j = 0;
+ for (; next_sp != nullptr && j < kMaxUnwind; j++) {
+ next_sp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(next_sp, ucp);
+ }
+ *min_dropped_frames = j;
+ }
+ return n;
+}
+
+namespace absl {
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+ return true;
+}
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_POWERPC_INL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_unimplemented-inl.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_unimplemented-inl.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_unimplemented-inl.inc
new file mode 100644
index 0000000..e256fdd
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_unimplemented-inl.inc
@@ -0,0 +1,22 @@
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+static int UnwindImpl(void** /* result */, int* /* sizes */,
+ int /* max_depth */, int /* skip_count */,
+ const void* /* ucp */, int *min_dropped_frames) {
+ if (min_dropped_frames != nullptr) {
+ *min_dropped_frames = 0;
+ }
+ return 0;
+}
+
+namespace absl {
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+ return false;
+}
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_UNIMPLEMENTED_INL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_win32-inl.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_win32-inl.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_win32-inl.inc
new file mode 100644
index 0000000..a8f8a56
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_win32-inl.inc
@@ -0,0 +1,83 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Produces a stack trace for Windows. Normally, one could use
+// stacktrace_x86-inl.h or stacktrace_x86_64-inl.h -- and indeed, that
+// should work for binaries compiled using MSVC in "debug" mode.
+// However, in "release" mode, Windows uses frame-pointer
+// optimization, which makes getting a stack trace very difficult.
+//
+// There are several approaches one can take. One is to use Windows
+// intrinsics like StackWalk64. These can work, but have restrictions
+// on how successful they can be. Another attempt is to write a
+// version of stacktrace_x86-inl.h that has heuristic support for
+// dealing with FPO, similar to what WinDbg does (see
+// http://www.nynaeve.net/?p=97). There are (non-working) examples of
+// these approaches, complete with TODOs, in stacktrace_win32-inl.h#1
+//
+// The solution we've ended up doing is to call the undocumented
+// windows function RtlCaptureStackBackTrace, which probably doesn't
+// work with FPO but at least is fast, and doesn't require a symbol
+// server.
+//
+// This code is inspired by a patch from David Vitek:
+// http://code.google.com/p/google-perftools/issues/detail?id=83
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
+
+#include <windows.h> // for GetProcAddress and GetModuleHandle
+#include <cassert>
+
+typedef USHORT NTAPI RtlCaptureStackBackTrace_Function(
+ IN ULONG frames_to_skip,
+ IN ULONG frames_to_capture,
+ OUT PVOID *backtrace,
+ OUT PULONG backtrace_hash);
+
+// Load the function we need at static init time, where we don't have
+// to worry about someone else holding the loader's lock.
+static RtlCaptureStackBackTrace_Function* const RtlCaptureStackBackTrace_fn =
+ (RtlCaptureStackBackTrace_Function*)
+ GetProcAddress(GetModuleHandleA("ntdll.dll"), "RtlCaptureStackBackTrace");
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+static int UnwindImpl(void** result, int* sizes, int max_depth, int skip_count,
+ const void *ucp, int *min_dropped_frames) {
+ int n = 0;
+ if (!RtlCaptureStackBackTrace_fn) {
+ // can't find a stacktrace with no function to call
+ } else {
+ n = (int)RtlCaptureStackBackTrace_fn(skip_count + 2, max_depth, result, 0);
+ }
+ if (IS_STACK_FRAMES) {
+ // No implementation for finding out the stack frame sizes yet.
+ memset(sizes, 0, sizeof(*sizes) * n);
+ }
+ if (min_dropped_frames != nullptr) {
+ // Not implemented.
+ *min_dropped_frames = 0;
+ }
+ return n;
+}
+
+namespace absl {
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+ return false;
+}
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_WIN32_INL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_x86-inl.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_x86-inl.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_x86-inl.inc
new file mode 100644
index 0000000..ac85b92
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/debugging/internal/stacktrace_x86-inl.inc
@@ -0,0 +1,337 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Produce stack trace
+
+#ifndef ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
+#define ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
+
+#if defined(__linux__) && (defined(__i386__) || defined(__x86_64__))
+#include <ucontext.h> // for ucontext_t
+#endif
+
+#if !defined(_WIN32)
+#include <unistd.h>
+#endif
+
+#include <cassert>
+#include <cstdint>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/debugging/internal/address_is_readable.h"
+#include "absl/debugging/internal/vdso_support.h" // a no-op on non-elf or non-glibc systems
+#include "absl/debugging/stacktrace.h"
+#include "absl/base/internal/raw_logging.h"
+
+#if defined(__linux__) && defined(__i386__)
+// Count "push %reg" instructions in VDSO __kernel_vsyscall(),
+// preceeding "syscall" or "sysenter".
+// If __kernel_vsyscall uses frame pointer, answer 0.
+//
+// kMaxBytes tells how many instruction bytes of __kernel_vsyscall
+// to analyze before giving up. Up to kMaxBytes+1 bytes of
+// instructions could be accessed.
+//
+// Here are known __kernel_vsyscall instruction sequences:
+//
+// SYSENTER (linux-2.6.26/arch/x86/vdso/vdso32/sysenter.S).
+// Used on Intel.
+// 0xffffe400 <__kernel_vsyscall+0>: push %ecx
+// 0xffffe401 <__kernel_vsyscall+1>: push %edx
+// 0xffffe402 <__kernel_vsyscall+2>: push %ebp
+// 0xffffe403 <__kernel_vsyscall+3>: mov %esp,%ebp
+// 0xffffe405 <__kernel_vsyscall+5>: sysenter
+//
+// SYSCALL (see linux-2.6.26/arch/x86/vdso/vdso32/syscall.S).
+// Used on AMD.
+// 0xffffe400 <__kernel_vsyscall+0>: push %ebp
+// 0xffffe401 <__kernel_vsyscall+1>: mov %ecx,%ebp
+// 0xffffe403 <__kernel_vsyscall+3>: syscall
+//
+
+// The sequence below isn't actually expected in Google fleet,
+// here only for completeness. Remove this comment from OSS release.
+
+// i386 (see linux-2.6.26/arch/x86/vdso/vdso32/int80.S)
+// 0xffffe400 <__kernel_vsyscall+0>: int $0x80
+// 0xffffe401 <__kernel_vsyscall+1>: ret
+//
+static const int kMaxBytes = 10;
+
+// We use assert()s instead of DCHECK()s -- this is too low level
+// for DCHECK().
+
+static int CountPushInstructions(const unsigned char *const addr) {
+ int result = 0;
+ for (int i = 0; i < kMaxBytes; ++i) {
+ if (addr[i] == 0x89) {
+ // "mov reg,reg"
+ if (addr[i + 1] == 0xE5) {
+ // Found "mov %esp,%ebp".
+ return 0;
+ }
+ ++i; // Skip register encoding byte.
+ } else if (addr[i] == 0x0F &&
+ (addr[i + 1] == 0x34 || addr[i + 1] == 0x05)) {
+ // Found "sysenter" or "syscall".
+ return result;
+ } else if ((addr[i] & 0xF0) == 0x50) {
+ // Found "push %reg".
+ ++result;
+ } else if (addr[i] == 0xCD && addr[i + 1] == 0x80) {
+ // Found "int $0x80"
+ assert(result == 0);
+ return 0;
+ } else {
+ // Unexpected instruction.
+ assert(false && "unexpected instruction in __kernel_vsyscall");
+ return 0;
+ }
+ }
+ // Unexpected: didn't find SYSENTER or SYSCALL in
+ // [__kernel_vsyscall, __kernel_vsyscall + kMaxBytes) interval.
+ assert(false && "did not find SYSENTER or SYSCALL in __kernel_vsyscall");
+ return 0;
+}
+#endif
+
+// Assume stack frames larger than 100,000 bytes are bogus.
+static const int kMaxFrameBytes = 100000;
+
+// Returns the stack frame pointer from signal context, 0 if unknown.
+// vuc is a ucontext_t *. We use void* to avoid the use
+// of ucontext_t on non-POSIX systems.
+static uintptr_t GetFP(const void *vuc) {
+#if !defined(__linux__)
+ static_cast<void>(vuc); // Avoid an unused argument compiler warning.
+#else
+ if (vuc != nullptr) {
+ auto *uc = reinterpret_cast<const ucontext_t *>(vuc);
+#if defined(__i386__)
+ const auto bp = uc->uc_mcontext.gregs[REG_EBP];
+ const auto sp = uc->uc_mcontext.gregs[REG_ESP];
+#elif defined(__x86_64__)
+ const auto bp = uc->uc_mcontext.gregs[REG_RBP];
+ const auto sp = uc->uc_mcontext.gregs[REG_RSP];
+#else
+ const uintptr_t bp = 0;
+ const uintptr_t sp = 0;
+#endif
+ // Sanity-check that the base pointer is valid. It should be as long as
+ // SHRINK_WRAP_FRAME_POINTER is not set, but it's possible that some code in
+ // the process is compiled with --copt=-fomit-frame-pointer or
+ // --copt=-momit-leaf-frame-pointer.
+ //
+ // TODO(bcmills): -momit-leaf-frame-pointer is currently the default
+ // behavior when building with clang. Talk to the C++ toolchain team about
+ // fixing that.
+ if (bp >= sp && bp - sp <= kMaxFrameBytes) return bp;
+
+ // If bp isn't a plausible frame pointer, return the stack pointer instead.
+ // If we're lucky, it points to the start of a stack frame; otherwise, we'll
+ // get one frame of garbage in the stack trace and fail the sanity check on
+ // the next iteration.
+ return sp;
+ }
+#endif
+ return 0;
+}
+
+// Given a pointer to a stack frame, locate and return the calling
+// stackframe, or return null if no stackframe can be found. Perform sanity
+// checks (the strictness of which is controlled by the boolean parameter
+// "STRICT_UNWINDING") to reduce the chance that a bad pointer is returned.
+template <bool STRICT_UNWINDING, bool WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack.
+static void **NextStackFrame(void **old_fp, const void *uc) {
+ void **new_fp = (void **)*old_fp;
+
+#if defined(__linux__) && defined(__i386__)
+ if (WITH_CONTEXT && uc != nullptr) {
+ // How many "push %reg" instructions are there at __kernel_vsyscall?
+ // This is constant for a given kernel and processor, so compute
+ // it only once.
+ static int num_push_instructions = -1; // Sentinel: not computed yet.
+ // Initialize with sentinel value: __kernel_rt_sigreturn can not possibly
+ // be there.
+ static const unsigned char *kernel_rt_sigreturn_address = nullptr;
+ static const unsigned char *kernel_vsyscall_address = nullptr;
+ if (num_push_instructions == -1) {
+ absl::debugging_internal::VDSOSupport vdso;
+ if (vdso.IsPresent()) {
+ absl::debugging_internal::VDSOSupport::SymbolInfo
+ rt_sigreturn_symbol_info;
+ absl::debugging_internal::VDSOSupport::SymbolInfo vsyscall_symbol_info;
+ if (!vdso.LookupSymbol("__kernel_rt_sigreturn", "LINUX_2.5", STT_FUNC,
+ &rt_sigreturn_symbol_info) ||
+ !vdso.LookupSymbol("__kernel_vsyscall", "LINUX_2.5", STT_FUNC,
+ &vsyscall_symbol_info) ||
+ rt_sigreturn_symbol_info.address == nullptr ||
+ vsyscall_symbol_info.address == nullptr) {
+ // Unexpected: 32-bit VDSO is present, yet one of the expected
+ // symbols is missing or null.
+ assert(false && "VDSO is present, but doesn't have expected symbols");
+ num_push_instructions = 0;
+ } else {
+ kernel_rt_sigreturn_address =
+ reinterpret_cast<const unsigned char *>(
+ rt_sigreturn_symbol_info.address);
+ kernel_vsyscall_address =
+ reinterpret_cast<const unsigned char *>(
+ vsyscall_symbol_info.address);
+ num_push_instructions =
+ CountPushInstructions(kernel_vsyscall_address);
+ }
+ } else {
+ num_push_instructions = 0;
+ }
+ }
+ if (num_push_instructions != 0 && kernel_rt_sigreturn_address != nullptr &&
+ old_fp[1] == kernel_rt_sigreturn_address) {
+ const ucontext_t *ucv = static_cast<const ucontext_t *>(uc);
+ // This kernel does not use frame pointer in its VDSO code,
+ // and so %ebp is not suitable for unwinding.
+ void **const reg_ebp =
+ reinterpret_cast<void **>(ucv->uc_mcontext.gregs[REG_EBP]);
+ const unsigned char *const reg_eip =
+ reinterpret_cast<unsigned char *>(ucv->uc_mcontext.gregs[REG_EIP]);
+ if (new_fp == reg_ebp && kernel_vsyscall_address <= reg_eip &&
+ reg_eip - kernel_vsyscall_address < kMaxBytes) {
+ // We "stepped up" to __kernel_vsyscall, but %ebp is not usable.
+ // Restore from 'ucv' instead.
+ void **const reg_esp =
+ reinterpret_cast<void **>(ucv->uc_mcontext.gregs[REG_ESP]);
+ // Check that alleged %esp is not null and is reasonably aligned.
+ if (reg_esp &&
+ ((uintptr_t)reg_esp & (sizeof(reg_esp) - 1)) == 0) {
+ // Check that alleged %esp is actually readable. This is to prevent
+ // "double fault" in case we hit the first fault due to e.g. stack
+ // corruption.
+ void *const reg_esp2 = reg_esp[num_push_instructions - 1];
+ if (absl::debugging_internal::AddressIsReadable(reg_esp2)) {
+ // Alleged %esp is readable, use it for further unwinding.
+ new_fp = reinterpret_cast<void **>(reg_esp2);
+ }
+ }
+ }
+ }
+ }
+#endif
+
+ const uintptr_t old_fp_u = reinterpret_cast<uintptr_t>(old_fp);
+ const uintptr_t new_fp_u = reinterpret_cast<uintptr_t>(new_fp);
+
+ // Check that the transition from frame pointer old_fp to frame
+ // pointer new_fp isn't clearly bogus. Skip the checks if new_fp
+ // matches the signal context, so that we don't skip out early when
+ // using an alternate signal stack.
+ //
+ // TODO(bcmills): The GetFP call should be completely unnecessary when
+ // SHRINK_WRAP_FRAME_POINTER is set (because we should be back in the thread's
+ // stack by this point), but it is empirically still needed (e.g. when the
+ // stack includes a call to abort). unw_get_reg returns UNW_EBADREG for some
+ // frames. Figure out why GetValidFrameAddr and/or libunwind isn't doing what
+ // it's supposed to.
+ if (STRICT_UNWINDING &&
+ (!WITH_CONTEXT || uc == nullptr || new_fp_u != GetFP(uc))) {
+ // With the stack growing downwards, older stack frame must be
+ // at a greater address that the current one.
+ if (new_fp_u <= old_fp_u) return nullptr;
+ if (new_fp_u - old_fp_u > kMaxFrameBytes) return nullptr;
+ } else {
+ if (new_fp == nullptr) return nullptr; // skip AddressIsReadable() below
+ // In the non-strict mode, allow discontiguous stack frames.
+ // (alternate-signal-stacks for example).
+ if (new_fp == old_fp) return nullptr;
+ }
+
+ if (new_fp_u & (sizeof(void *) - 1)) return nullptr;
+#ifdef __i386__
+ // On 32-bit machines, the stack pointer can be very close to
+ // 0xffffffff, so we explicitly check for a pointer into the
+ // last two pages in the address space
+ if (new_fp_u >= 0xffffe000) return nullptr;
+#endif
+#if !defined(_WIN32)
+ if (!STRICT_UNWINDING) {
+ // Lax sanity checks cause a crash in 32-bit tcmalloc/crash_reason_test
+ // on AMD-based machines with VDSO-enabled kernels.
+ // Make an extra sanity check to insure new_fp is readable.
+ // Note: NextStackFrame<false>() is only called while the program
+ // is already on its last leg, so it's ok to be slow here.
+
+ if (!absl::debugging_internal::AddressIsReadable(new_fp)) {
+ return nullptr;
+ }
+ }
+#endif
+ return new_fp;
+}
+
+template <bool IS_STACK_FRAMES, bool IS_WITH_CONTEXT>
+ABSL_ATTRIBUTE_NO_SANITIZE_ADDRESS // May read random elements from stack.
+ABSL_ATTRIBUTE_NO_SANITIZE_MEMORY // May read random elements from stack.
+ABSL_ATTRIBUTE_NOINLINE
+static int UnwindImpl(void **result, int *sizes, int max_depth, int skip_count,
+ const void *ucp, int *min_dropped_frames) {
+ int n = 0;
+ void **fp = reinterpret_cast<void **>(__builtin_frame_address(0));
+
+ while (fp && n < max_depth) {
+ if (*(fp + 1) == reinterpret_cast<void *>(0)) {
+ // In 64-bit code, we often see a frame that
+ // points to itself and has a return address of 0.
+ break;
+ }
+ void **next_fp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(fp, ucp);
+ if (skip_count > 0) {
+ skip_count--;
+ } else {
+ result[n] = *(fp + 1);
+ if (IS_STACK_FRAMES) {
+ if (next_fp > fp) {
+ sizes[n] = (uintptr_t)next_fp - (uintptr_t)fp;
+ } else {
+ // A frame-size of 0 is used to indicate unknown frame size.
+ sizes[n] = 0;
+ }
+ }
+ n++;
+ }
+ fp = next_fp;
+ }
+ if (min_dropped_frames != nullptr) {
+ // Implementation detail: we clamp the max of frames we are willing to
+ // count, so as not to spend too much time in the loop below.
+ const int kMaxUnwind = 1000;
+ int j = 0;
+ for (; fp != nullptr && j < kMaxUnwind; j++) {
+ fp = NextStackFrame<!IS_STACK_FRAMES, IS_WITH_CONTEXT>(fp, ucp);
+ }
+ *min_dropped_frames = j;
+ }
+ return n;
+}
+
+namespace absl {
+namespace debugging_internal {
+bool StackTraceWorksForTest() {
+ return true;
+}
+} // namespace debugging_internal
+} // namespace absl
+
+#endif // ABSL_DEBUGGING_INTERNAL_STACKTRACE_X86_INL_INC_
[54/62] [abbrv] marmotta git commit: Merge branch 'develop' of
https://git-wip-us.apache.org/repos/asf/marmotta into develop
Posted by ja...@apache.org.
Merge branch 'develop' of https://git-wip-us.apache.org/repos/asf/marmotta into develop
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/a0f54523
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/a0f54523
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/a0f54523
Branch: refs/heads/master
Commit: a0f54523e2145124562e9778f47c7541254ba789
Parents: 3270df0 310ce40
Author: Jakob Frank <ja...@apache.org>
Authored: Mon Apr 30 09:01:26 2018 +0200
Committer: Jakob Frank <ja...@apache.org>
Committed: Mon Apr 30 09:01:26 2018 +0200
----------------------------------------------------------------------
.../backend/3rdparty/abseil/.clang-format | 4 +
.../ostrich/backend/3rdparty/abseil/.gitignore | 2 +
.../3rdparty/abseil/ABSEIL_ISSUE_TEMPLATE.md | 22 +
.../ostrich/backend/3rdparty/abseil/AUTHORS | 6 +
.../3rdparty/abseil/CMake/AbseilHelpers.cmake | 157 +
.../backend/3rdparty/abseil/CMake/README.md | 79 +
.../backend/3rdparty/abseil/CMakeLists.txt | 86 +
.../backend/3rdparty/abseil/CONTRIBUTING.md | 91 +
.../ostrich/backend/3rdparty/abseil/LICENSE | 204 +
.../ostrich/backend/3rdparty/abseil/README.md | 108 +
.../ostrich/backend/3rdparty/abseil/WORKSPACE | 25 +
.../backend/3rdparty/abseil/absl/BUILD.bazel | 52 +
.../backend/3rdparty/abseil/absl/CMakeLists.txt | 30 +
.../3rdparty/abseil/absl/algorithm/BUILD.bazel | 69 +
.../abseil/absl/algorithm/CMakeLists.txt | 63 +
.../3rdparty/abseil/absl/algorithm/algorithm.h | 150 +
.../abseil/absl/algorithm/algorithm_test.cc | 182 +
.../3rdparty/abseil/absl/algorithm/container.h | 1642 ++
.../abseil/absl/algorithm/container_test.cc | 997 +
.../3rdparty/abseil/absl/base/BUILD.bazel | 395 +
.../3rdparty/abseil/absl/base/CMakeLists.txt | 358 +
.../3rdparty/abseil/absl/base/attributes.h | 567 +
.../3rdparty/abseil/absl/base/bit_cast_test.cc | 107 +
.../3rdparty/abseil/absl/base/call_once.h | 216 +
.../3rdparty/abseil/absl/base/call_once_test.cc | 102 +
.../backend/3rdparty/abseil/absl/base/casts.h | 140 +
.../backend/3rdparty/abseil/absl/base/config.h | 427 +
.../3rdparty/abseil/absl/base/config_test.cc | 60 +
.../abseil/absl/base/dynamic_annotations.cc | 129 +
.../abseil/absl/base/dynamic_annotations.h | 409 +
.../absl/base/exception_safety_testing_test.cc | 842 +
.../abseil/absl/base/inline_variable_test.cc | 62 +
.../abseil/absl/base/inline_variable_test_a.cc | 25 +
.../abseil/absl/base/inline_variable_test_b.cc | 25 +
.../abseil/absl/base/internal/atomic_hook.h | 150 +
.../abseil/absl/base/internal/cycleclock.cc | 81 +
.../abseil/absl/base/internal/cycleclock.h | 77 +
.../abseil/absl/base/internal/direct_mmap.h | 151 +
.../3rdparty/abseil/absl/base/internal/endian.h | 269 +
.../abseil/absl/base/internal/endian_test.cc | 279 +
.../base/internal/exception_safety_testing.cc | 41 +
.../base/internal/exception_safety_testing.h | 997 +
.../absl/base/internal/exception_testing.h | 38 +
.../abseil/absl/base/internal/identity.h | 33 +
.../abseil/absl/base/internal/inline_variable.h | 107 +
.../base/internal/inline_variable_testing.h | 44 +
.../3rdparty/abseil/absl/base/internal/invoke.h | 188 +
.../absl/base/internal/low_level_alloc.cc | 604 +
.../abseil/absl/base/internal/low_level_alloc.h | 119 +
.../absl/base/internal/low_level_alloc_test.cc | 157 +
.../absl/base/internal/low_level_scheduling.h | 104 +
.../abseil/absl/base/internal/per_thread_tls.h | 48 +
.../abseil/absl/base/internal/pretty_function.h | 33 +
.../abseil/absl/base/internal/raw_logging.cc | 218 +
.../abseil/absl/base/internal/raw_logging.h | 137 +
.../abseil/absl/base/internal/scheduling_mode.h | 54 +
.../abseil/absl/base/internal/spinlock.cc | 238 +
.../abseil/absl/base/internal/spinlock.h | 239 +
.../absl/base/internal/spinlock_akaros.inc | 35 +
.../absl/base/internal/spinlock_posix.inc | 46 +
.../abseil/absl/base/internal/spinlock_wait.cc | 79 +
.../abseil/absl/base/internal/spinlock_wait.h | 91 +
.../absl/base/internal/spinlock_win32.inc | 37 +
.../abseil/absl/base/internal/sysinfo.cc | 404 +
.../abseil/absl/base/internal/sysinfo.h | 63 +
.../abseil/absl/base/internal/sysinfo_test.cc | 98 +
.../absl/base/internal/thread_identity.cc | 123 +
.../abseil/absl/base/internal/thread_identity.h | 240 +
.../absl/base/internal/thread_identity_test.cc | 126 +
.../abseil/absl/base/internal/throw_delegate.cc | 106 +
.../abseil/absl/base/internal/throw_delegate.h | 71 +
.../absl/base/internal/tsan_mutex_interface.h | 66 +
.../absl/base/internal/unaligned_access.h | 256 +
.../absl/base/internal/unscaledcycleclock.cc | 101 +
.../absl/base/internal/unscaledcycleclock.h | 119 +
.../3rdparty/abseil/absl/base/invoke_test.cc | 200 +
.../3rdparty/abseil/absl/base/log_severity.h | 67 +
.../backend/3rdparty/abseil/absl/base/macros.h | 202 +
.../3rdparty/abseil/absl/base/optimization.h | 165 +
.../3rdparty/abseil/absl/base/policy_checks.h | 121 +
.../backend/3rdparty/abseil/absl/base/port.h | 26 +
.../abseil/absl/base/raw_logging_test.cc | 50 +
.../abseil/absl/base/spinlock_test_common.cc | 266 +
.../abseil/absl/base/thread_annotations.h | 258 +
.../abseil/absl/base/throw_delegate_test.cc | 94 +
.../3rdparty/abseil/absl/container/BUILD.bazel | 128 +
.../abseil/absl/container/CMakeLists.txt | 126 +
.../abseil/absl/container/fixed_array.h | 498 +
.../abseil/absl/container/fixed_array_test.cc | 659 +
.../abseil/absl/container/inlined_vector.h | 1384 ++
.../absl/container/inlined_vector_test.cc | 1766 ++
.../container/internal/test_instance_tracker.cc | 26 +
.../container/internal/test_instance_tracker.h | 220 +
.../internal/test_instance_tracker_test.cc | 160 +
.../backend/3rdparty/abseil/absl/copts.bzl | 155 +
.../3rdparty/abseil/absl/debugging/BUILD.bazel | 305 +
.../abseil/absl/debugging/CMakeLists.txt | 193 +
.../absl/debugging/failure_signal_handler.cc | 351 +
.../absl/debugging/failure_signal_handler.h | 103 +
.../debugging/failure_signal_handler_test.cc | 146 +
.../debugging/internal/address_is_readable.cc | 133 +
.../debugging/internal/address_is_readable.h | 29 +
.../abseil/absl/debugging/internal/demangle.cc | 1862 ++
.../abseil/absl/debugging/internal/demangle.h | 67 +
.../absl/debugging/internal/demangle_test.cc | 191 +
.../absl/debugging/internal/elf_mem_image.cc | 398 +
.../absl/debugging/internal/elf_mem_image.h | 130 +
.../absl/debugging/internal/examine_stack.cc | 147 +
.../absl/debugging/internal/examine_stack.h | 38 +
.../debugging/internal/stack_consumption.cc | 172 +
.../absl/debugging/internal/stack_consumption.h | 45 +
.../internal/stack_consumption_test.cc | 48 +
.../internal/stacktrace_aarch64-inl.inc | 189 +
.../debugging/internal/stacktrace_arm-inl.inc | 123 +
.../absl/debugging/internal/stacktrace_config.h | 74 +
.../internal/stacktrace_generic-inl.inc | 59 +
.../internal/stacktrace_powerpc-inl.inc | 243 +
.../internal/stacktrace_unimplemented-inl.inc | 22 +
.../debugging/internal/stacktrace_win32-inl.inc | 83 +
.../debugging/internal/stacktrace_x86-inl.inc | 337 +
.../abseil/absl/debugging/internal/symbolize.h | 122 +
.../absl/debugging/internal/vdso_support.cc | 192 +
.../absl/debugging/internal/vdso_support.h | 155 +
.../abseil/absl/debugging/leak_check.cc | 48 +
.../3rdparty/abseil/absl/debugging/leak_check.h | 111 +
.../abseil/absl/debugging/leak_check_disable.cc | 20 +
.../absl/debugging/leak_check_fail_test.cc | 41 +
.../abseil/absl/debugging/leak_check_test.cc | 42 +
.../abseil/absl/debugging/stacktrace.cc | 133 +
.../3rdparty/abseil/absl/debugging/stacktrace.h | 167 +
.../3rdparty/abseil/absl/debugging/symbolize.cc | 28 +
.../3rdparty/abseil/absl/debugging/symbolize.h | 35 +
.../abseil/absl/debugging/symbolize_elf.inc | 1473 ++
.../abseil/absl/debugging/symbolize_test.cc | 517 +
.../absl/debugging/symbolize_unimplemented.inc | 35 +
.../abseil/absl/debugging/symbolize_win32.inc | 74 +
.../3rdparty/abseil/absl/memory/BUILD.bazel | 47 +
.../3rdparty/abseil/absl/memory/CMakeLists.txt | 52 +
.../3rdparty/abseil/absl/memory/memory.h | 640 +
.../3rdparty/abseil/absl/memory/memory_test.cc | 614 +
.../3rdparty/abseil/absl/meta/BUILD.bazel | 29 +
.../3rdparty/abseil/absl/meta/CMakeLists.txt | 49 +
.../3rdparty/abseil/absl/meta/type_traits.h | 372 +
.../abseil/absl/meta/type_traits_test.cc | 799 +
.../3rdparty/abseil/absl/numeric/BUILD.bazel | 41 +
.../3rdparty/abseil/absl/numeric/CMakeLists.txt | 62 +
.../3rdparty/abseil/absl/numeric/int128.cc | 225 +
.../3rdparty/abseil/absl/numeric/int128.h | 656 +
.../absl/numeric/int128_have_intrinsic.inc | 18 +
.../abseil/absl/numeric/int128_no_intrinsic.inc | 18 +
.../abseil/absl/numeric/int128_stream_test.cc | 666 +
.../3rdparty/abseil/absl/numeric/int128_test.cc | 431 +
.../3rdparty/abseil/absl/strings/BUILD.bazel | 322 +
.../3rdparty/abseil/absl/strings/CMakeLists.txt | 304 +
.../3rdparty/abseil/absl/strings/ascii.cc | 198 +
.../3rdparty/abseil/absl/strings/ascii.h | 239 +
.../3rdparty/abseil/absl/strings/ascii_test.cc | 354 +
.../3rdparty/abseil/absl/strings/escaping.cc | 1109 +
.../3rdparty/abseil/absl/strings/escaping.h | 161 +
.../abseil/absl/strings/escaping_test.cc | 641 +
.../abseil/absl/strings/internal/char_map.h | 154 +
.../absl/strings/internal/char_map_test.cc | 172 +
.../strings/internal/escaping_test_common.inc | 113 +
.../abseil/absl/strings/internal/memutil.cc | 110 +
.../abseil/absl/strings/internal/memutil.h | 146 +
.../absl/strings/internal/memutil_test.cc | 179 +
.../strings/internal/numbers_test_common.inc | 156 +
.../absl/strings/internal/ostringstream.cc | 34 +
.../absl/strings/internal/ostringstream.h | 87 +
.../absl/strings/internal/ostringstream_test.cc | 102 +
.../strings/internal/resize_uninitialized.h | 69 +
.../internal/resize_uninitialized_test.cc | 68 +
.../absl/strings/internal/stl_type_traits.h | 246 +
.../absl/strings/internal/str_join_internal.h | 309 +
.../absl/strings/internal/str_split_internal.h | 435 +
.../abseil/absl/strings/internal/utf8.cc | 51 +
.../abseil/absl/strings/internal/utf8.h | 47 +
.../abseil/absl/strings/internal/utf8_test.cc | 57 +
.../3rdparty/abseil/absl/strings/match.cc | 40 +
.../3rdparty/abseil/absl/strings/match.h | 84 +
.../3rdparty/abseil/absl/strings/match_test.cc | 99 +
.../3rdparty/abseil/absl/strings/numbers.cc | 919 +
.../3rdparty/abseil/absl/strings/numbers.h | 172 +
.../abseil/absl/strings/numbers_test.cc | 1186 +
.../3rdparty/abseil/absl/strings/str_cat.cc | 239 +
.../3rdparty/abseil/absl/strings/str_cat.h | 385 +
.../abseil/absl/strings/str_cat_test.cc | 539 +
.../3rdparty/abseil/absl/strings/str_join.h | 288 +
.../abseil/absl/strings/str_join_test.cc | 473 +
.../3rdparty/abseil/absl/strings/str_replace.cc | 79 +
.../3rdparty/abseil/absl/strings/str_replace.h | 213 +
.../abseil/absl/strings/str_replace_test.cc | 341 +
.../3rdparty/abseil/absl/strings/str_split.cc | 136 +
.../3rdparty/abseil/absl/strings/str_split.h | 511 +
.../abseil/absl/strings/str_split_test.cc | 907 +
.../3rdparty/abseil/absl/strings/string_view.cc | 247 +
.../3rdparty/abseil/absl/strings/string_view.h | 570 +
.../abseil/absl/strings/string_view_test.cc | 1136 +
.../3rdparty/abseil/absl/strings/strip.h | 89 +
.../3rdparty/abseil/absl/strings/strip_test.cc | 201 +
.../3rdparty/abseil/absl/strings/substitute.cc | 170 +
.../3rdparty/abseil/absl/strings/substitute.h | 668 +
.../abseil/absl/strings/substitute_test.cc | 192 +
.../abseil/absl/strings/testdata/getline-1.txt | 3 +
.../abseil/absl/strings/testdata/getline-2.txt | 1 +
.../abseil/absl/synchronization/BUILD.bazel | 206 +
.../abseil/absl/synchronization/CMakeLists.txt | 154 +
.../abseil/absl/synchronization/barrier.cc | 50 +
.../abseil/absl/synchronization/barrier.h | 77 +
.../abseil/absl/synchronization/barrier_test.cc | 75 +
.../absl/synchronization/blocking_counter.cc | 55 +
.../absl/synchronization/blocking_counter.h | 97 +
.../synchronization/blocking_counter_test.cc | 66 +
.../internal/create_thread_identity.cc | 112 +
.../internal/create_thread_identity.h | 53 +
.../synchronization/internal/graphcycles.cc | 709 +
.../absl/synchronization/internal/graphcycles.h | 136 +
.../internal/graphcycles_test.cc | 462 +
.../synchronization/internal/kernel_timeout.h | 149 +
.../synchronization/internal/mutex_nonprod.cc | 318 +
.../synchronization/internal/mutex_nonprod.inc | 256 +
.../synchronization/internal/per_thread_sem.cc | 99 +
.../synchronization/internal/per_thread_sem.h | 107 +
.../internal/per_thread_sem_test.cc | 172 +
.../absl/synchronization/internal/thread_pool.h | 90 +
.../absl/synchronization/internal/waiter.cc | 412 +
.../absl/synchronization/internal/waiter.h | 139 +
.../absl/synchronization/lifetime_test.cc | 132 +
.../abseil/absl/synchronization/mutex.cc | 2688 +++
.../abseil/absl/synchronization/mutex.h | 1022 +
.../abseil/absl/synchronization/mutex_test.cc | 1539 ++
.../abseil/absl/synchronization/notification.cc | 84 +
.../abseil/absl/synchronization/notification.h | 112 +
.../absl/synchronization/notification_test.cc | 124 +
.../3rdparty/abseil/absl/time/BUILD.bazel | 97 +
.../3rdparty/abseil/absl/time/CMakeLists.txt | 96 +
.../backend/3rdparty/abseil/absl/time/clock.cc | 563 +
.../backend/3rdparty/abseil/absl/time/clock.h | 72 +
.../3rdparty/abseil/absl/time/clock_test.cc | 70 +
.../3rdparty/abseil/absl/time/duration.cc | 908 +
.../3rdparty/abseil/absl/time/duration_test.cc | 1688 ++
.../backend/3rdparty/abseil/absl/time/format.cc | 142 +
.../3rdparty/abseil/absl/time/format_test.cc | 437 +
.../abseil/absl/time/internal/cctz/BUILD.bazel | 105 +
.../internal/cctz/include/cctz/civil_time.h | 329 +
.../cctz/include/cctz/civil_time_detail.h | 564 +
.../time/internal/cctz/include/cctz/time_zone.h | 316 +
.../cctz/include/cctz/zone_info_source.h | 91 +
.../time/internal/cctz/src/civil_time_detail.cc | 90 +
.../time/internal/cctz/src/civil_time_test.cc | 1049 +
.../time/internal/cctz/src/time_zone_fixed.cc | 133 +
.../time/internal/cctz/src/time_zone_fixed.h | 49 +
.../time/internal/cctz/src/time_zone_format.cc | 848 +
.../internal/cctz/src/time_zone_format_test.cc | 1408 ++
.../absl/time/internal/cctz/src/time_zone_if.cc | 41 +
.../absl/time/internal/cctz/src/time_zone_if.h | 70 +
.../time/internal/cctz/src/time_zone_impl.cc | 117 +
.../time/internal/cctz/src/time_zone_impl.h | 97 +
.../time/internal/cctz/src/time_zone_info.cc | 956 +
.../time/internal/cctz/src/time_zone_info.h | 132 +
.../time/internal/cctz/src/time_zone_libc.cc | 156 +
.../time/internal/cctz/src/time_zone_libc.h | 50 +
.../time/internal/cctz/src/time_zone_lookup.cc | 142 +
.../internal/cctz/src/time_zone_lookup_test.cc | 1259 +
.../time/internal/cctz/src/time_zone_posix.cc | 155 +
.../time/internal/cctz/src/time_zone_posix.h | 118 +
.../abseil/absl/time/internal/cctz/src/tzfile.h | 117 +
.../time/internal/cctz/src/zone_info_source.cc | 70 +
.../time/internal/cctz/testdata/README.zoneinfo | 37 +
.../absl/time/internal/cctz/testdata/version | 1 +
.../cctz/testdata/zoneinfo/Africa/Abidjan | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Accra | Bin 0 -> 842 bytes
.../cctz/testdata/zoneinfo/Africa/Addis_Ababa | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Algiers | Bin 0 -> 760 bytes
.../cctz/testdata/zoneinfo/Africa/Asmara | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Asmera | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Bamako | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Bangui | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Banjul | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Bissau | Bin 0 -> 208 bytes
.../cctz/testdata/zoneinfo/Africa/Blantyre | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Brazzaville | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Bujumbura | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Cairo | Bin 0 -> 1972 bytes
.../cctz/testdata/zoneinfo/Africa/Casablanca | Bin 0 -> 1643 bytes
.../cctz/testdata/zoneinfo/Africa/Ceuta | Bin 0 -> 2059 bytes
.../cctz/testdata/zoneinfo/Africa/Conakry | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Dakar | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Dar_es_Salaam | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Djibouti | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Douala | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/El_Aaiun | Bin 0 -> 1473 bytes
.../cctz/testdata/zoneinfo/Africa/Freetown | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Gaborone | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Harare | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Johannesburg | Bin 0 -> 271 bytes
.../internal/cctz/testdata/zoneinfo/Africa/Juba | Bin 0 -> 683 bytes
.../cctz/testdata/zoneinfo/Africa/Kampala | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Khartoum | Bin 0 -> 713 bytes
.../cctz/testdata/zoneinfo/Africa/Kigali | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Kinshasa | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lagos | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Libreville | Bin 0 -> 171 bytes
.../internal/cctz/testdata/zoneinfo/Africa/Lome | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Luanda | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lubumbashi | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lusaka | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Malabo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Maputo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Maseru | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/Africa/Mbabane | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/Africa/Mogadishu | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Monrovia | Bin 0 -> 233 bytes
.../cctz/testdata/zoneinfo/Africa/Nairobi | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Ndjamena | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Africa/Niamey | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Nouakchott | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Ouagadougou | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Porto-Novo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Sao_Tome | Bin 0 -> 234 bytes
.../cctz/testdata/zoneinfo/Africa/Timbuktu | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Tripoli | Bin 0 -> 655 bytes
.../cctz/testdata/zoneinfo/Africa/Tunis | Bin 0 -> 710 bytes
.../cctz/testdata/zoneinfo/Africa/Windhoek | Bin 0 -> 1030 bytes
.../cctz/testdata/zoneinfo/America/Adak | Bin 0 -> 2365 bytes
.../cctz/testdata/zoneinfo/America/Anchorage | Bin 0 -> 2380 bytes
.../cctz/testdata/zoneinfo/America/Anguilla | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Antigua | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Araguaina | Bin 0 -> 910 bytes
.../zoneinfo/America/Argentina/Buenos_Aires | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/Catamarca | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/ComodRivadavia | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Cordoba | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Jujuy | Bin 0 -> 1081 bytes
.../zoneinfo/America/Argentina/La_Rioja | Bin 0 -> 1123 bytes
.../testdata/zoneinfo/America/Argentina/Mendoza | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/Rio_Gallegos | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Salta | Bin 0 -> 1081 bytes
.../zoneinfo/America/Argentina/San_Juan | Bin 0 -> 1123 bytes
.../zoneinfo/America/Argentina/San_Luis | Bin 0 -> 1139 bytes
.../testdata/zoneinfo/America/Argentina/Tucuman | Bin 0 -> 1137 bytes
.../testdata/zoneinfo/America/Argentina/Ushuaia | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Aruba | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Asuncion | Bin 0 -> 2077 bytes
.../cctz/testdata/zoneinfo/America/Atikokan | Bin 0 -> 345 bytes
.../cctz/testdata/zoneinfo/America/Atka | Bin 0 -> 2365 bytes
.../cctz/testdata/zoneinfo/America/Bahia | Bin 0 -> 1050 bytes
.../testdata/zoneinfo/America/Bahia_Banderas | Bin 0 -> 1588 bytes
.../cctz/testdata/zoneinfo/America/Barbados | Bin 0 -> 344 bytes
.../cctz/testdata/zoneinfo/America/Belem | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/America/Belize | Bin 0 -> 978 bytes
.../cctz/testdata/zoneinfo/America/Blanc-Sablon | Bin 0 -> 307 bytes
.../cctz/testdata/zoneinfo/America/Boa_Vista | Bin 0 -> 658 bytes
.../cctz/testdata/zoneinfo/America/Bogota | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/America/Boise | Bin 0 -> 2403 bytes
.../cctz/testdata/zoneinfo/America/Buenos_Aires | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Cambridge_Bay | Bin 0 -> 2098 bytes
.../cctz/testdata/zoneinfo/America/Campo_Grande | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/America/Cancun | Bin 0 -> 816 bytes
.../cctz/testdata/zoneinfo/America/Caracas | Bin 0 -> 289 bytes
.../cctz/testdata/zoneinfo/America/Catamarca | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Cayenne | Bin 0 -> 224 bytes
.../cctz/testdata/zoneinfo/America/Cayman | Bin 0 -> 203 bytes
.../cctz/testdata/zoneinfo/America/Chicago | Bin 0 -> 3585 bytes
.../cctz/testdata/zoneinfo/America/Chihuahua | Bin 0 -> 1522 bytes
.../testdata/zoneinfo/America/Coral_Harbour | Bin 0 -> 345 bytes
.../cctz/testdata/zoneinfo/America/Cordoba | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Costa_Rica | Bin 0 -> 341 bytes
.../cctz/testdata/zoneinfo/America/Creston | Bin 0 -> 233 bytes
.../cctz/testdata/zoneinfo/America/Cuiaba | Bin 0 -> 1988 bytes
.../cctz/testdata/zoneinfo/America/Curacao | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Danmarkshavn | Bin 0 -> 712 bytes
.../cctz/testdata/zoneinfo/America/Dawson | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/America/Dawson_Creek | Bin 0 -> 1059 bytes
.../cctz/testdata/zoneinfo/America/Denver | Bin 0 -> 2453 bytes
.../cctz/testdata/zoneinfo/America/Detroit | Bin 0 -> 2188 bytes
.../cctz/testdata/zoneinfo/America/Dominica | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Edmonton | Bin 0 -> 2402 bytes
.../cctz/testdata/zoneinfo/America/Eirunepe | Bin 0 -> 690 bytes
.../cctz/testdata/zoneinfo/America/El_Salvador | Bin 0 -> 250 bytes
.../cctz/testdata/zoneinfo/America/Ensenada | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Fort_Nelson | Bin 0 -> 2249 bytes
.../cctz/testdata/zoneinfo/America/Fort_Wayne | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Fortaleza | Bin 0 -> 742 bytes
.../cctz/testdata/zoneinfo/America/Glace_Bay | Bin 0 -> 2206 bytes
.../cctz/testdata/zoneinfo/America/Godthab | Bin 0 -> 1892 bytes
.../cctz/testdata/zoneinfo/America/Goose_Bay | Bin 0 -> 3219 bytes
.../cctz/testdata/zoneinfo/America/Grand_Turk | Bin 0 -> 1881 bytes
.../cctz/testdata/zoneinfo/America/Grenada | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Guadeloupe | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Guatemala | Bin 0 -> 306 bytes
.../cctz/testdata/zoneinfo/America/Guayaquil | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/America/Guyana | Bin 0 -> 266 bytes
.../cctz/testdata/zoneinfo/America/Halifax | Bin 0 -> 3438 bytes
.../cctz/testdata/zoneinfo/America/Havana | Bin 0 -> 2437 bytes
.../cctz/testdata/zoneinfo/America/Hermosillo | Bin 0 -> 454 bytes
.../zoneinfo/America/Indiana/Indianapolis | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Indiana/Knox | Bin 0 -> 2437 bytes
.../testdata/zoneinfo/America/Indiana/Marengo | Bin 0 -> 1731 bytes
.../zoneinfo/America/Indiana/Petersburg | Bin 0 -> 1913 bytes
.../testdata/zoneinfo/America/Indiana/Tell_City | Bin 0 -> 1735 bytes
.../testdata/zoneinfo/America/Indiana/Vevay | Bin 0 -> 1423 bytes
.../testdata/zoneinfo/America/Indiana/Vincennes | Bin 0 -> 1703 bytes
.../testdata/zoneinfo/America/Indiana/Winamac | Bin 0 -> 1787 bytes
.../cctz/testdata/zoneinfo/America/Indianapolis | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Inuvik | Bin 0 -> 1928 bytes
.../cctz/testdata/zoneinfo/America/Iqaluit | Bin 0 -> 2046 bytes
.../cctz/testdata/zoneinfo/America/Jamaica | Bin 0 -> 507 bytes
.../cctz/testdata/zoneinfo/America/Jujuy | Bin 0 -> 1081 bytes
.../cctz/testdata/zoneinfo/America/Juneau | Bin 0 -> 2362 bytes
.../zoneinfo/America/Kentucky/Louisville | Bin 0 -> 2781 bytes
.../zoneinfo/America/Kentucky/Monticello | Bin 0 -> 2361 bytes
.../cctz/testdata/zoneinfo/America/Knox_IN | Bin 0 -> 2437 bytes
.../cctz/testdata/zoneinfo/America/Kralendijk | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/La_Paz | Bin 0 -> 257 bytes
.../cctz/testdata/zoneinfo/America/Lima | Bin 0 -> 431 bytes
.../cctz/testdata/zoneinfo/America/Los_Angeles | Bin 0 -> 2845 bytes
.../cctz/testdata/zoneinfo/America/Louisville | Bin 0 -> 2781 bytes
.../testdata/zoneinfo/America/Lower_Princes | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Maceio | Bin 0 -> 770 bytes
.../cctz/testdata/zoneinfo/America/Managua | Bin 0 -> 463 bytes
.../cctz/testdata/zoneinfo/America/Manaus | Bin 0 -> 630 bytes
.../cctz/testdata/zoneinfo/America/Marigot | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Martinique | Bin 0 -> 257 bytes
.../cctz/testdata/zoneinfo/America/Matamoros | Bin 0 -> 1416 bytes
.../cctz/testdata/zoneinfo/America/Mazatlan | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/America/Mendoza | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Menominee | Bin 0 -> 2283 bytes
.../cctz/testdata/zoneinfo/America/Merida | Bin 0 -> 1456 bytes
.../cctz/testdata/zoneinfo/America/Metlakatla | Bin 0 -> 1418 bytes
.../cctz/testdata/zoneinfo/America/Mexico_City | Bin 0 -> 1618 bytes
.../cctz/testdata/zoneinfo/America/Miquelon | Bin 0 -> 1696 bytes
.../cctz/testdata/zoneinfo/America/Moncton | Bin 0 -> 3163 bytes
.../cctz/testdata/zoneinfo/America/Monterrey | Bin 0 -> 1416 bytes
.../cctz/testdata/zoneinfo/America/Montevideo | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/America/Montreal | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/America/Montserrat | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Nassau | Bin 0 -> 2284 bytes
.../cctz/testdata/zoneinfo/America/New_York | Bin 0 -> 3545 bytes
.../cctz/testdata/zoneinfo/America/Nipigon | Bin 0 -> 2131 bytes
.../cctz/testdata/zoneinfo/America/Nome | Bin 0 -> 2376 bytes
.../cctz/testdata/zoneinfo/America/Noronha | Bin 0 -> 742 bytes
.../zoneinfo/America/North_Dakota/Beulah | Bin 0 -> 2389 bytes
.../zoneinfo/America/North_Dakota/Center | Bin 0 -> 2389 bytes
.../zoneinfo/America/North_Dakota/New_Salem | Bin 0 -> 2389 bytes
.../cctz/testdata/zoneinfo/America/Ojinaga | Bin 0 -> 1522 bytes
.../cctz/testdata/zoneinfo/America/Panama | Bin 0 -> 203 bytes
.../cctz/testdata/zoneinfo/America/Pangnirtung | Bin 0 -> 2108 bytes
.../cctz/testdata/zoneinfo/America/Paramaribo | Bin 0 -> 296 bytes
.../cctz/testdata/zoneinfo/America/Phoenix | Bin 0 -> 353 bytes
.../testdata/zoneinfo/America/Port-au-Prince | Bin 0 -> 1455 bytes
.../testdata/zoneinfo/America/Port_of_Spain | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Porto_Acre | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/America/Porto_Velho | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/America/Puerto_Rico | Bin 0 -> 255 bytes
.../cctz/testdata/zoneinfo/America/Punta_Arenas | Bin 0 -> 1911 bytes
.../cctz/testdata/zoneinfo/America/Rainy_River | Bin 0 -> 2131 bytes
.../cctz/testdata/zoneinfo/America/Rankin_Inlet | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Recife | Bin 0 -> 742 bytes
.../cctz/testdata/zoneinfo/America/Regina | Bin 0 -> 994 bytes
.../cctz/testdata/zoneinfo/America/Resolute | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Rio_Branco | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/America/Rosario | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Santa_Isabel | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Santarem | Bin 0 -> 632 bytes
.../cctz/testdata/zoneinfo/America/Santiago | Bin 0 -> 2538 bytes
.../testdata/zoneinfo/America/Santo_Domingo | Bin 0 -> 491 bytes
.../cctz/testdata/zoneinfo/America/Sao_Paulo | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/America/Scoresbysund | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Shiprock | Bin 0 -> 2453 bytes
.../cctz/testdata/zoneinfo/America/Sitka | Bin 0 -> 2350 bytes
.../testdata/zoneinfo/America/St_Barthelemy | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Johns | Bin 0 -> 3664 bytes
.../cctz/testdata/zoneinfo/America/St_Kitts | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Lucia | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Thomas | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Vincent | Bin 0 -> 170 bytes
.../testdata/zoneinfo/America/Swift_Current | Bin 0 -> 574 bytes
.../cctz/testdata/zoneinfo/America/Tegucigalpa | Bin 0 -> 278 bytes
.../cctz/testdata/zoneinfo/America/Thule | Bin 0 -> 1528 bytes
.../cctz/testdata/zoneinfo/America/Thunder_Bay | Bin 0 -> 2211 bytes
.../cctz/testdata/zoneinfo/America/Tijuana | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Toronto | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/America/Tortola | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Vancouver | Bin 0 -> 2901 bytes
.../cctz/testdata/zoneinfo/America/Virgin | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Whitehorse | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/America/Winnipeg | Bin 0 -> 2891 bytes
.../cctz/testdata/zoneinfo/America/Yakutat | Bin 0 -> 2314 bytes
.../cctz/testdata/zoneinfo/America/Yellowknife | Bin 0 -> 1980 bytes
.../cctz/testdata/zoneinfo/Antarctica/Casey | Bin 0 -> 311 bytes
.../cctz/testdata/zoneinfo/Antarctica/Davis | Bin 0 -> 311 bytes
.../testdata/zoneinfo/Antarctica/DumontDUrville | Bin 0 -> 216 bytes
.../cctz/testdata/zoneinfo/Antarctica/Macquarie | Bin 0 -> 1543 bytes
.../cctz/testdata/zoneinfo/Antarctica/Mawson | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Antarctica/McMurdo | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Antarctica/Palmer | Bin 0 -> 1432 bytes
.../cctz/testdata/zoneinfo/Antarctica/Rothera | Bin 0 -> 186 bytes
.../testdata/zoneinfo/Antarctica/South_Pole | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Antarctica/Syowa | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Antarctica/Troll | Bin 0 -> 1176 bytes
.../cctz/testdata/zoneinfo/Antarctica/Vostok | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Arctic/Longyearbyen | Bin 0 -> 2251 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aden | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Almaty | Bin 0 -> 1031 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Amman | Bin 0 -> 1877 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Anadyr | Bin 0 -> 1222 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aqtau | Bin 0 -> 1017 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aqtobe | Bin 0 -> 1047 bytes
.../cctz/testdata/zoneinfo/Asia/Ashgabat | Bin 0 -> 651 bytes
.../cctz/testdata/zoneinfo/Asia/Ashkhabad | Bin 0 -> 651 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Atyrau | Bin 0 -> 1025 bytes
.../cctz/testdata/zoneinfo/Asia/Baghdad | Bin 0 -> 1004 bytes
.../cctz/testdata/zoneinfo/Asia/Bahrain | Bin 0 -> 225 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Baku | Bin 0 -> 1269 bytes
.../cctz/testdata/zoneinfo/Asia/Bangkok | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Barnaul | Bin 0 -> 1255 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Beirut | Bin 0 -> 2175 bytes
.../cctz/testdata/zoneinfo/Asia/Bishkek | Bin 0 -> 1045 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Brunei | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Calcutta | Bin 0 -> 312 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Chita | Bin 0 -> 1257 bytes
.../cctz/testdata/zoneinfo/Asia/Choibalsan | Bin 0 -> 991 bytes
.../cctz/testdata/zoneinfo/Asia/Chongqing | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Chungking | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Colombo | Bin 0 -> 413 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dacca | Bin 0 -> 370 bytes
.../cctz/testdata/zoneinfo/Asia/Damascus | Bin 0 -> 2320 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dhaka | Bin 0 -> 370 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dili | Bin 0 -> 253 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dubai | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Dushanbe | Bin 0 -> 621 bytes
.../cctz/testdata/zoneinfo/Asia/Famagusta | Bin 0 -> 2042 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Gaza | Bin 0 -> 2295 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Harbin | Bin 0 -> 414 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Hebron | Bin 0 -> 2323 bytes
.../cctz/testdata/zoneinfo/Asia/Ho_Chi_Minh | Bin 0 -> 389 bytes
.../cctz/testdata/zoneinfo/Asia/Hong_Kong | Bin 0 -> 1189 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Hovd | Bin 0 -> 921 bytes
.../cctz/testdata/zoneinfo/Asia/Irkutsk | Bin 0 -> 1276 bytes
.../cctz/testdata/zoneinfo/Asia/Istanbul | Bin 0 -> 2166 bytes
.../cctz/testdata/zoneinfo/Asia/Jakarta | Bin 0 -> 392 bytes
.../cctz/testdata/zoneinfo/Asia/Jayapura | Bin 0 -> 251 bytes
.../cctz/testdata/zoneinfo/Asia/Jerusalem | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Kabul | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Kamchatka | Bin 0 -> 1198 bytes
.../cctz/testdata/zoneinfo/Asia/Karachi | Bin 0 -> 417 bytes
.../cctz/testdata/zoneinfo/Asia/Kashgar | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Kathmandu | Bin 0 -> 238 bytes
.../cctz/testdata/zoneinfo/Asia/Katmandu | Bin 0 -> 238 bytes
.../cctz/testdata/zoneinfo/Asia/Khandyga | Bin 0 -> 1311 bytes
.../cctz/testdata/zoneinfo/Asia/Kolkata | Bin 0 -> 312 bytes
.../cctz/testdata/zoneinfo/Asia/Krasnoyarsk | Bin 0 -> 1243 bytes
.../cctz/testdata/zoneinfo/Asia/Kuala_Lumpur | Bin 0 -> 424 bytes
.../cctz/testdata/zoneinfo/Asia/Kuching | Bin 0 -> 521 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Kuwait | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Macao | Bin 0 -> 771 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Macau | Bin 0 -> 771 bytes
.../cctz/testdata/zoneinfo/Asia/Magadan | Bin 0 -> 1258 bytes
.../cctz/testdata/zoneinfo/Asia/Makassar | Bin 0 -> 288 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Manila | Bin 0 -> 367 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Muscat | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Nicosia | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/Asia/Novokuznetsk | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Asia/Novosibirsk | Bin 0 -> 1255 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Omsk | Bin 0 -> 1243 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Oral | Bin 0 -> 1039 bytes
.../cctz/testdata/zoneinfo/Asia/Phnom_Penh | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Pontianak | Bin 0 -> 395 bytes
.../cctz/testdata/zoneinfo/Asia/Pyongyang | Bin 0 -> 272 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Qatar | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Asia/Qyzylorda | Bin 0 -> 1047 bytes
.../cctz/testdata/zoneinfo/Asia/Rangoon | Bin 0 -> 297 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Riyadh | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Saigon | Bin 0 -> 389 bytes
.../cctz/testdata/zoneinfo/Asia/Sakhalin | Bin 0 -> 1234 bytes
.../cctz/testdata/zoneinfo/Asia/Samarkand | Bin 0 -> 619 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Seoul | Bin 0 -> 531 bytes
.../cctz/testdata/zoneinfo/Asia/Shanghai | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Singapore | Bin 0 -> 424 bytes
.../cctz/testdata/zoneinfo/Asia/Srednekolymsk | Bin 0 -> 1244 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Taipei | Bin 0 -> 790 bytes
.../cctz/testdata/zoneinfo/Asia/Tashkent | Bin 0 -> 635 bytes
.../cctz/testdata/zoneinfo/Asia/Tbilisi | Bin 0 -> 1080 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tehran | Bin 0 -> 1718 bytes
.../cctz/testdata/zoneinfo/Asia/Tel_Aviv | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Thimbu | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Thimphu | Bin 0 -> 229 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tokyo | Bin 0 -> 318 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tomsk | Bin 0 -> 1255 bytes
.../cctz/testdata/zoneinfo/Asia/Ujung_Pandang | Bin 0 -> 288 bytes
.../cctz/testdata/zoneinfo/Asia/Ulaanbaatar | Bin 0 -> 921 bytes
.../cctz/testdata/zoneinfo/Asia/Ulan_Bator | Bin 0 -> 921 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Urumqi | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Ust-Nera | Bin 0 -> 1290 bytes
.../cctz/testdata/zoneinfo/Asia/Vientiane | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Vladivostok | Bin 0 -> 1244 bytes
.../cctz/testdata/zoneinfo/Asia/Yakutsk | Bin 0 -> 1243 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Yangon | Bin 0 -> 297 bytes
.../cctz/testdata/zoneinfo/Asia/Yekaterinburg | Bin 0 -> 1281 bytes
.../cctz/testdata/zoneinfo/Asia/Yerevan | Bin 0 -> 1213 bytes
.../cctz/testdata/zoneinfo/Atlantic/Azores | Bin 0 -> 3493 bytes
.../cctz/testdata/zoneinfo/Atlantic/Bermuda | Bin 0 -> 2004 bytes
.../cctz/testdata/zoneinfo/Atlantic/Canary | Bin 0 -> 1911 bytes
.../cctz/testdata/zoneinfo/Atlantic/Cape_Verde | Bin 0 -> 284 bytes
.../cctz/testdata/zoneinfo/Atlantic/Faeroe | Bin 0 -> 1829 bytes
.../cctz/testdata/zoneinfo/Atlantic/Faroe | Bin 0 -> 1829 bytes
.../cctz/testdata/zoneinfo/Atlantic/Jan_Mayen | Bin 0 -> 2251 bytes
.../cctz/testdata/zoneinfo/Atlantic/Madeira | Bin 0 -> 3484 bytes
.../cctz/testdata/zoneinfo/Atlantic/Reykjavik | Bin 0 -> 1188 bytes
.../testdata/zoneinfo/Atlantic/South_Georgia | Bin 0 -> 181 bytes
.../cctz/testdata/zoneinfo/Atlantic/St_Helena | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Atlantic/Stanley | Bin 0 -> 1251 bytes
.../cctz/testdata/zoneinfo/Australia/ACT | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Adelaide | Bin 0 -> 2238 bytes
.../cctz/testdata/zoneinfo/Australia/Brisbane | Bin 0 -> 452 bytes
.../testdata/zoneinfo/Australia/Broken_Hill | Bin 0 -> 2274 bytes
.../cctz/testdata/zoneinfo/Australia/Canberra | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Currie | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Darwin | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Australia/Eucla | Bin 0 -> 503 bytes
.../cctz/testdata/zoneinfo/Australia/Hobart | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Australia/LHI | Bin 0 -> 1889 bytes
.../cctz/testdata/zoneinfo/Australia/Lindeman | Bin 0 -> 522 bytes
.../cctz/testdata/zoneinfo/Australia/Lord_Howe | Bin 0 -> 1889 bytes
.../cctz/testdata/zoneinfo/Australia/Melbourne | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/NSW | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/North | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Australia/Perth | Bin 0 -> 479 bytes
.../cctz/testdata/zoneinfo/Australia/Queensland | Bin 0 -> 452 bytes
.../cctz/testdata/zoneinfo/Australia/South | Bin 0 -> 2238 bytes
.../cctz/testdata/zoneinfo/Australia/Sydney | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Tasmania | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Australia/Victoria | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/West | Bin 0 -> 479 bytes
.../cctz/testdata/zoneinfo/Australia/Yancowinna | Bin 0 -> 2274 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/Acre | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/Brazil/DeNoronha | Bin 0 -> 742 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/East | Bin 0 -> 2016 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/West | Bin 0 -> 630 bytes
.../time/internal/cctz/testdata/zoneinfo/CET | Bin 0 -> 2102 bytes
.../internal/cctz/testdata/zoneinfo/CST6CDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Canada/Atlantic | Bin 0 -> 3438 bytes
.../cctz/testdata/zoneinfo/Canada/Central | Bin 0 -> 2891 bytes
.../cctz/testdata/zoneinfo/Canada/Eastern | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/Canada/Mountain | Bin 0 -> 2402 bytes
.../cctz/testdata/zoneinfo/Canada/Newfoundland | Bin 0 -> 3664 bytes
.../cctz/testdata/zoneinfo/Canada/Pacific | Bin 0 -> 2901 bytes
.../cctz/testdata/zoneinfo/Canada/Saskatchewan | Bin 0 -> 994 bytes
.../cctz/testdata/zoneinfo/Canada/Yukon | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/Chile/Continental | Bin 0 -> 2538 bytes
.../cctz/testdata/zoneinfo/Chile/EasterIsland | Bin 0 -> 2242 bytes
.../time/internal/cctz/testdata/zoneinfo/Cuba | Bin 0 -> 2437 bytes
.../time/internal/cctz/testdata/zoneinfo/EET | Bin 0 -> 1876 bytes
.../time/internal/cctz/testdata/zoneinfo/EST | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/EST5EDT | Bin 0 -> 2294 bytes
.../time/internal/cctz/testdata/zoneinfo/Egypt | Bin 0 -> 1972 bytes
.../time/internal/cctz/testdata/zoneinfo/Eire | Bin 0 -> 3531 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+1 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+10 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+11 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+12 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+2 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+3 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+4 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+5 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+6 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+7 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+8 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+9 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-1 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-10 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-11 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-12 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-13 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-14 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-2 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-3 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-4 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-5 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-6 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-7 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-8 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-9 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT0 | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Etc/Greenwich | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/UCT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/UTC | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Etc/Universal | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/Zulu | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Europe/Amsterdam | Bin 0 -> 2949 bytes
.../cctz/testdata/zoneinfo/Europe/Andorra | Bin 0 -> 1751 bytes
.../cctz/testdata/zoneinfo/Europe/Astrakhan | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Europe/Athens | Bin 0 -> 2271 bytes
.../cctz/testdata/zoneinfo/Europe/Belfast | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Belgrade | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Berlin | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Europe/Bratislava | Bin 0 -> 2272 bytes
.../cctz/testdata/zoneinfo/Europe/Brussels | Bin 0 -> 2970 bytes
.../cctz/testdata/zoneinfo/Europe/Bucharest | Bin 0 -> 2221 bytes
.../cctz/testdata/zoneinfo/Europe/Budapest | Bin 0 -> 2405 bytes
.../cctz/testdata/zoneinfo/Europe/Busingen | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Chisinau | Bin 0 -> 2445 bytes
.../cctz/testdata/zoneinfo/Europe/Copenhagen | Bin 0 -> 2160 bytes
.../cctz/testdata/zoneinfo/Europe/Dublin | Bin 0 -> 3531 bytes
.../cctz/testdata/zoneinfo/Europe/Gibraltar | Bin 0 -> 3061 bytes
.../cctz/testdata/zoneinfo/Europe/Guernsey | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Helsinki | Bin 0 -> 1909 bytes
.../cctz/testdata/zoneinfo/Europe/Isle_of_Man | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Istanbul | Bin 0 -> 2166 bytes
.../cctz/testdata/zoneinfo/Europe/Jersey | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Kaliningrad | Bin 0 -> 1518 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Kiev | Bin 0 -> 2097 bytes
.../cctz/testdata/zoneinfo/Europe/Kirov | Bin 0 -> 1167 bytes
.../cctz/testdata/zoneinfo/Europe/Lisbon | Bin 0 -> 3469 bytes
.../cctz/testdata/zoneinfo/Europe/Ljubljana | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/London | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Luxembourg | Bin 0 -> 2974 bytes
.../cctz/testdata/zoneinfo/Europe/Madrid | Bin 0 -> 2637 bytes
.../cctz/testdata/zoneinfo/Europe/Malta | Bin 0 -> 2629 bytes
.../cctz/testdata/zoneinfo/Europe/Mariehamn | Bin 0 -> 1909 bytes
.../cctz/testdata/zoneinfo/Europe/Minsk | Bin 0 -> 1370 bytes
.../cctz/testdata/zoneinfo/Europe/Monaco | Bin 0 -> 2953 bytes
.../cctz/testdata/zoneinfo/Europe/Moscow | Bin 0 -> 1544 bytes
.../cctz/testdata/zoneinfo/Europe/Nicosia | Bin 0 -> 2016 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Oslo | Bin 0 -> 2251 bytes
.../cctz/testdata/zoneinfo/Europe/Paris | Bin 0 -> 2971 bytes
.../cctz/testdata/zoneinfo/Europe/Podgorica | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Prague | Bin 0 -> 2272 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Riga | Bin 0 -> 2235 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Rome | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Samara | Bin 0 -> 1253 bytes
.../cctz/testdata/zoneinfo/Europe/San_Marino | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Sarajevo | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Saratov | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Europe/Simferopol | Bin 0 -> 1490 bytes
.../cctz/testdata/zoneinfo/Europe/Skopje | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Sofia | Bin 0 -> 2130 bytes
.../cctz/testdata/zoneinfo/Europe/Stockholm | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Tallinn | Bin 0 -> 2187 bytes
.../cctz/testdata/zoneinfo/Europe/Tirane | Bin 0 -> 2098 bytes
.../cctz/testdata/zoneinfo/Europe/Tiraspol | Bin 0 -> 2445 bytes
.../cctz/testdata/zoneinfo/Europe/Ulyanovsk | Bin 0 -> 1281 bytes
.../cctz/testdata/zoneinfo/Europe/Uzhgorod | Bin 0 -> 2103 bytes
.../cctz/testdata/zoneinfo/Europe/Vaduz | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Vatican | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Vienna | Bin 0 -> 2237 bytes
.../cctz/testdata/zoneinfo/Europe/Vilnius | Bin 0 -> 2199 bytes
.../cctz/testdata/zoneinfo/Europe/Volgograd | Bin 0 -> 1167 bytes
.../cctz/testdata/zoneinfo/Europe/Warsaw | Bin 0 -> 2705 bytes
.../cctz/testdata/zoneinfo/Europe/Zagreb | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Zaporozhye | Bin 0 -> 2115 bytes
.../cctz/testdata/zoneinfo/Europe/Zurich | Bin 0 -> 1918 bytes
.../internal/cctz/testdata/zoneinfo/Factory | Bin 0 -> 148 bytes
.../time/internal/cctz/testdata/zoneinfo/GB | Bin 0 -> 3687 bytes
.../internal/cctz/testdata/zoneinfo/GB-Eire | Bin 0 -> 3687 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT+0 | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT-0 | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Greenwich | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/HST | Bin 0 -> 128 bytes
.../internal/cctz/testdata/zoneinfo/Hongkong | Bin 0 -> 1189 bytes
.../internal/cctz/testdata/zoneinfo/Iceland | Bin 0 -> 1188 bytes
.../cctz/testdata/zoneinfo/Indian/Antananarivo | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Chagos | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Indian/Christmas | Bin 0 -> 182 bytes
.../cctz/testdata/zoneinfo/Indian/Cocos | Bin 0 -> 191 bytes
.../cctz/testdata/zoneinfo/Indian/Comoro | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Kerguelen | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Indian/Mahe | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Indian/Maldives | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Indian/Mauritius | Bin 0 -> 267 bytes
.../cctz/testdata/zoneinfo/Indian/Mayotte | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Reunion | Bin 0 -> 187 bytes
.../time/internal/cctz/testdata/zoneinfo/Iran | Bin 0 -> 1718 bytes
.../time/internal/cctz/testdata/zoneinfo/Israel | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Jamaica | Bin 0 -> 507 bytes
.../time/internal/cctz/testdata/zoneinfo/Japan | Bin 0 -> 318 bytes
.../internal/cctz/testdata/zoneinfo/Kwajalein | Bin 0 -> 259 bytes
.../time/internal/cctz/testdata/zoneinfo/Libya | Bin 0 -> 655 bytes
.../time/internal/cctz/testdata/zoneinfo/MET | Bin 0 -> 2102 bytes
.../time/internal/cctz/testdata/zoneinfo/MST | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/MST7MDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Mexico/BajaNorte | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/Mexico/BajaSur | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/Mexico/General | Bin 0 -> 1618 bytes
.../time/internal/cctz/testdata/zoneinfo/NZ | Bin 0 -> 2460 bytes
.../internal/cctz/testdata/zoneinfo/NZ-CHAT | Bin 0 -> 2087 bytes
.../time/internal/cctz/testdata/zoneinfo/Navajo | Bin 0 -> 2453 bytes
.../time/internal/cctz/testdata/zoneinfo/PRC | Bin 0 -> 414 bytes
.../internal/cctz/testdata/zoneinfo/PST8PDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Pacific/Apia | Bin 0 -> 1134 bytes
.../cctz/testdata/zoneinfo/Pacific/Auckland | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Pacific/Bougainville | Bin 0 -> 296 bytes
.../cctz/testdata/zoneinfo/Pacific/Chatham | Bin 0 -> 2087 bytes
.../cctz/testdata/zoneinfo/Pacific/Chuuk | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Easter | Bin 0 -> 2242 bytes
.../cctz/testdata/zoneinfo/Pacific/Efate | Bin 0 -> 492 bytes
.../cctz/testdata/zoneinfo/Pacific/Enderbury | Bin 0 -> 259 bytes
.../cctz/testdata/zoneinfo/Pacific/Fakaofo | Bin 0 -> 221 bytes
.../cctz/testdata/zoneinfo/Pacific/Fiji | Bin 0 -> 1104 bytes
.../cctz/testdata/zoneinfo/Pacific/Funafuti | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Galapagos | Bin 0 -> 268 bytes
.../cctz/testdata/zoneinfo/Pacific/Gambier | Bin 0 -> 186 bytes
.../cctz/testdata/zoneinfo/Pacific/Guadalcanal | Bin 0 -> 188 bytes
.../cctz/testdata/zoneinfo/Pacific/Guam | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Pacific/Honolulu | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/Pacific/Johnston | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/Pacific/Kiritimati | Bin 0 -> 263 bytes
.../cctz/testdata/zoneinfo/Pacific/Kosrae | Bin 0 -> 251 bytes
.../cctz/testdata/zoneinfo/Pacific/Kwajalein | Bin 0 -> 259 bytes
.../cctz/testdata/zoneinfo/Pacific/Majuro | Bin 0 -> 221 bytes
.../cctz/testdata/zoneinfo/Pacific/Marquesas | Bin 0 -> 195 bytes
.../cctz/testdata/zoneinfo/Pacific/Midway | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Nauru | Bin 0 -> 282 bytes
.../cctz/testdata/zoneinfo/Pacific/Niue | Bin 0 -> 266 bytes
.../cctz/testdata/zoneinfo/Pacific/Norfolk | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Pacific/Noumea | Bin 0 -> 328 bytes
.../cctz/testdata/zoneinfo/Pacific/Pago_Pago | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Palau | Bin 0 -> 182 bytes
.../cctz/testdata/zoneinfo/Pacific/Pitcairn | Bin 0 -> 223 bytes
.../cctz/testdata/zoneinfo/Pacific/Pohnpei | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Ponape | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Port_Moresby | Bin 0 -> 206 bytes
.../cctz/testdata/zoneinfo/Pacific/Rarotonga | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/Pacific/Saipan | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Pacific/Samoa | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Tahiti | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Pacific/Tarawa | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Tongatapu | Bin 0 -> 393 bytes
.../cctz/testdata/zoneinfo/Pacific/Truk | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Wake | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Wallis | Bin 0 -> 183 bytes
.../internal/cctz/testdata/zoneinfo/Pacific/Yap | Bin 0 -> 183 bytes
.../time/internal/cctz/testdata/zoneinfo/Poland | Bin 0 -> 2705 bytes
.../internal/cctz/testdata/zoneinfo/Portugal | Bin 0 -> 3469 bytes
.../time/internal/cctz/testdata/zoneinfo/ROC | Bin 0 -> 790 bytes
.../time/internal/cctz/testdata/zoneinfo/ROK | Bin 0 -> 531 bytes
.../internal/cctz/testdata/zoneinfo/Singapore | Bin 0 -> 424 bytes
.../time/internal/cctz/testdata/zoneinfo/Turkey | Bin 0 -> 2166 bytes
.../time/internal/cctz/testdata/zoneinfo/UCT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/US/Alaska | Bin 0 -> 2380 bytes
.../internal/cctz/testdata/zoneinfo/US/Aleutian | Bin 0 -> 2365 bytes
.../internal/cctz/testdata/zoneinfo/US/Arizona | Bin 0 -> 353 bytes
.../internal/cctz/testdata/zoneinfo/US/Central | Bin 0 -> 3585 bytes
.../cctz/testdata/zoneinfo/US/East-Indiana | Bin 0 -> 1675 bytes
.../internal/cctz/testdata/zoneinfo/US/Eastern | Bin 0 -> 3545 bytes
.../internal/cctz/testdata/zoneinfo/US/Hawaii | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/US/Indiana-Starke | Bin 0 -> 2437 bytes
.../internal/cctz/testdata/zoneinfo/US/Michigan | Bin 0 -> 2188 bytes
.../internal/cctz/testdata/zoneinfo/US/Mountain | Bin 0 -> 2453 bytes
.../internal/cctz/testdata/zoneinfo/US/Pacific | Bin 0 -> 2845 bytes
.../internal/cctz/testdata/zoneinfo/US/Samoa | Bin 0 -> 196 bytes
.../time/internal/cctz/testdata/zoneinfo/UTC | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Universal | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/W-SU | Bin 0 -> 1544 bytes
.../time/internal/cctz/testdata/zoneinfo/WET | Bin 0 -> 1873 bytes
.../time/internal/cctz/testdata/zoneinfo/Zulu | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/iso3166.tab | 274 +
.../internal/cctz/testdata/zoneinfo/localtime | Bin 0 -> 148 bytes
.../cctz/testdata/zoneinfo/zone1970.tab | 382 +
.../absl/time/internal/get_current_time_ios.inc | 80 +
.../time/internal/get_current_time_posix.inc | 22 +
.../time/internal/get_current_time_windows.inc | 17 +
.../abseil/absl/time/internal/test_util.cc | 123 +
.../abseil/absl/time/internal/test_util.h | 49 +
.../abseil/absl/time/internal/zoneinfo.inc | 729 +
.../backend/3rdparty/abseil/absl/time/time.cc | 385 +
.../backend/3rdparty/abseil/absl/time/time.h | 1342 ++
.../3rdparty/abseil/absl/time/time_norm_test.cc | 306 +
.../3rdparty/abseil/absl/time/time_test.cc | 1088 +
.../3rdparty/abseil/absl/time/time_zone_test.cc | 97 +
.../3rdparty/abseil/absl/types/BUILD.bazel | 225 +
.../3rdparty/abseil/absl/types/CMakeLists.txt | 201 +
.../backend/3rdparty/abseil/absl/types/any.h | 539 +
.../absl/types/any_exception_safety_test.cc | 166 +
.../3rdparty/abseil/absl/types/any_test.cc | 724 +
.../3rdparty/abseil/absl/types/bad_any_cast.cc | 40 +
.../3rdparty/abseil/absl/types/bad_any_cast.h | 57 +
.../abseil/absl/types/bad_optional_access.cc | 42 +
.../abseil/absl/types/bad_optional_access.h | 60 +
.../abseil/absl/types/bad_variant_access.cc | 58 +
.../abseil/absl/types/bad_variant_access.h | 64 +
.../abseil/absl/types/internal/variant.h | 1387 ++
.../3rdparty/abseil/absl/types/optional.cc | 24 +
.../3rdparty/abseil/absl/types/optional.h | 1131 +
.../3rdparty/abseil/absl/types/optional_test.cc | 1625 ++
.../backend/3rdparty/abseil/absl/types/span.h | 748 +
.../3rdparty/abseil/absl/types/span_test.cc | 781 +
.../3rdparty/abseil/absl/types/variant.h | 838 +
.../3rdparty/abseil/absl/types/variant_test.cc | 2612 ++
.../3rdparty/abseil/absl/utility/BUILD.bazel | 33 +
.../3rdparty/abseil/absl/utility/CMakeLists.txt | 45 +
.../3rdparty/abseil/absl/utility/utility.h | 291 +
.../abseil/absl/utility/utility_test.cc | 345 +
.../ostrich/backend/3rdparty/gtest/.gitignore | 40 +
.../ostrich/backend/3rdparty/gtest/.travis.yml | 78 +
.../ostrich/backend/3rdparty/gtest/BUILD.bazel | 175 +
.../backend/3rdparty/gtest/CMakeLists.txt | 33 +
.../backend/3rdparty/gtest/CONTRIBUTING.md | 160 +
.../ostrich/backend/3rdparty/gtest/LICENSE | 28 +
.../ostrich/backend/3rdparty/gtest/Makefile.am | 14 +
.../ostrich/backend/3rdparty/gtest/README.md | 122 +
.../ostrich/backend/3rdparty/gtest/WORKSPACE | 8 +
.../ostrich/backend/3rdparty/gtest/appveyor.yml | 99 +
.../3rdparty/gtest/ci/build-linux-autotools.sh | 44 +
.../3rdparty/gtest/ci/build-linux-bazel.sh | 36 +
.../backend/3rdparty/gtest/ci/env-linux.sh | 41 +
.../backend/3rdparty/gtest/ci/env-osx.sh | 40 +
.../3rdparty/gtest/ci/get-nprocessors.sh | 48 +
.../backend/3rdparty/gtest/ci/install-linux.sh | 49 +
.../backend/3rdparty/gtest/ci/install-osx.sh | 39 +
.../backend/3rdparty/gtest/ci/log-config.sh | 51 +
.../ostrich/backend/3rdparty/gtest/ci/travis.sh | 36 +
.../ostrich/backend/3rdparty/gtest/configure.ac | 16 +
.../backend/3rdparty/gtest/googlemock/CHANGES | 126 +
.../3rdparty/gtest/googlemock/CMakeLists.txt | 242 +
.../3rdparty/gtest/googlemock/CONTRIBUTORS | 40 +
.../backend/3rdparty/gtest/googlemock/LICENSE | 28 +
.../3rdparty/gtest/googlemock/Makefile.am | 224 +
.../backend/3rdparty/gtest/googlemock/README.md | 344 +
.../3rdparty/gtest/googlemock/cmake/gmock.pc.in | 9 +
.../gtest/googlemock/cmake/gmock_main.pc.in | 9 +
.../3rdparty/gtest/googlemock/configure.ac | 146 +
.../gtest/googlemock/docs/CheatSheet.md | 564 +
.../3rdparty/gtest/googlemock/docs/CookBook.md | 3660 +++
.../3rdparty/gtest/googlemock/docs/DesignDoc.md | 280 +
.../gtest/googlemock/docs/Documentation.md | 15 +
.../gtest/googlemock/docs/ForDummies.md | 447 +
.../googlemock/docs/FrequentlyAskedQuestions.md | 628 +
.../gtest/googlemock/docs/KnownIssues.md | 19 +
.../googlemock/include/gmock/gmock-actions.h | 1262 +
.../include/gmock/gmock-cardinalities.h | 147 +
.../include/gmock/gmock-generated-actions.h | 2571 ++
.../gmock/gmock-generated-actions.h.pump | 833 +
.../gmock/gmock-generated-function-mockers.h | 1379 ++
.../gmock-generated-function-mockers.h.pump | 347 +
.../include/gmock/gmock-generated-matchers.h | 2258 ++
.../gmock/gmock-generated-matchers.h.pump | 675 +
.../include/gmock/gmock-generated-nice-strict.h | 458 +
.../gmock/gmock-generated-nice-strict.h.pump | 178 +
.../googlemock/include/gmock/gmock-matchers.h | 5255 ++++
.../include/gmock/gmock-more-actions.h | 246 +
.../include/gmock/gmock-more-matchers.h | 91 +
.../include/gmock/gmock-spec-builders.h | 1918 ++
.../gtest/googlemock/include/gmock/gmock.h | 95 +
.../internal/custom/gmock-generated-actions.h | 8 +
.../custom/gmock-generated-actions.h.pump | 10 +
.../gmock/internal/custom/gmock-matchers.h | 38 +
.../include/gmock/internal/custom/gmock-port.h | 46 +
.../internal/gmock-generated-internal-utils.h | 286 +
.../gmock-generated-internal-utils.h.pump | 136 +
.../gmock/internal/gmock-internal-utils.h | 574 +
.../include/gmock/internal/gmock-port.h | 87 +
.../3rdparty/gtest/googlemock/make/Makefile | 101 +
.../gtest/googlemock/msvc/2005/gmock.sln | 32 +
.../gtest/googlemock/msvc/2005/gmock.vcproj | 191 +
.../googlemock/msvc/2005/gmock_config.vsprops | 15 +
.../googlemock/msvc/2005/gmock_main.vcproj | 187 +
.../googlemock/msvc/2005/gmock_test.vcproj | 201 +
.../gtest/googlemock/msvc/2010/gmock.sln | 46 +
.../gtest/googlemock/msvc/2010/gmock.vcxproj | 145 +
.../googlemock/msvc/2010/gmock_config.props | 19 +
.../googlemock/msvc/2010/gmock_main.vcxproj | 151 +
.../googlemock/msvc/2010/gmock_test.vcxproj | 176 +
.../gtest/googlemock/msvc/2015/gmock.sln | 46 +
.../gtest/googlemock/msvc/2015/gmock.vcxproj | 145 +
.../googlemock/msvc/2015/gmock_config.props | 19 +
.../googlemock/msvc/2015/gmock_main.vcxproj | 151 +
.../googlemock/msvc/2015/gmock_test.vcxproj | 176 +
.../googlemock/scripts/fuse_gmock_files.py | 240 +
.../gtest/googlemock/scripts/generator/LICENSE | 203 +
.../gtest/googlemock/scripts/generator/README | 35 +
.../scripts/generator/README.cppclean | 115 +
.../scripts/generator/cpp/__init__.py | 0
.../googlemock/scripts/generator/cpp/ast.py | 1733 ++
.../scripts/generator/cpp/gmock_class.py | 227 +
.../scripts/generator/cpp/gmock_class_test.py | 448 +
.../scripts/generator/cpp/keywords.py | 59 +
.../scripts/generator/cpp/tokenize.py | 287 +
.../googlemock/scripts/generator/cpp/utils.py | 41 +
.../googlemock/scripts/generator/gmock_gen.py | 31 +
.../gtest/googlemock/scripts/gmock-config.in | 303 +
.../gtest/googlemock/scripts/gmock_doctor.py | 640 +
.../3rdparty/gtest/googlemock/scripts/upload.py | 1387 ++
.../gtest/googlemock/scripts/upload_gmock.py | 78 +
.../3rdparty/gtest/googlemock/src/gmock-all.cc | 47 +
.../gtest/googlemock/src/gmock-cardinalities.cc | 156 +
.../googlemock/src/gmock-internal-utils.cc | 204 +
.../gtest/googlemock/src/gmock-matchers.cc | 573 +
.../gtest/googlemock/src/gmock-spec-builders.cc | 883 +
.../3rdparty/gtest/googlemock/src/gmock.cc | 205 +
.../3rdparty/gtest/googlemock/src/gmock_main.cc | 54 +
.../3rdparty/gtest/googlemock/test/BUILD.bazel | 123 +
.../gtest/googlemock/test/gmock-actions_test.cc | 1575 ++
.../googlemock/test/gmock-cardinalities_test.cc | 428 +
.../test/gmock-generated-actions_test.cc | 1230 +
.../gmock-generated-function-mockers_test.cc | 647 +
.../test/gmock-generated-internal-utils_test.cc | 129 +
.../test/gmock-generated-matchers_test.cc | 1341 ++
.../test/gmock-internal-utils_test.cc | 718 +
.../googlemock/test/gmock-matchers_test.cc | 6769 ++++++
.../googlemock/test/gmock-more-actions_test.cc | 710 +
.../googlemock/test/gmock-nice-strict_test.cc | 511 +
.../gtest/googlemock/test/gmock-port_test.cc | 43 +
.../googlemock/test/gmock-spec-builders_test.cc | 2771 +++
.../gtest/googlemock/test/gmock_all_test.cc | 51 +
.../gtest/googlemock/test/gmock_ex_test.cc | 81 +
.../gtest/googlemock/test/gmock_leak_test.py | 108 +
.../gtest/googlemock/test/gmock_leak_test_.cc | 100 +
.../gtest/googlemock/test/gmock_link2_test.cc | 40 +
.../gtest/googlemock/test/gmock_link_test.cc | 40 +
.../gtest/googlemock/test/gmock_link_test.h | 691 +
.../gtest/googlemock/test/gmock_output_test.py | 183 +
.../gtest/googlemock/test/gmock_output_test_.cc | 310 +
.../test/gmock_output_test_golden.txt | 317 +
.../gtest/googlemock/test/gmock_stress_test.cc | 323 +
.../gtest/googlemock/test/gmock_test.cc | 262 +
.../gtest/googlemock/test/gmock_test_utils.py | 110 +
.../backend/3rdparty/gtest/googletest/CHANGES | 157 +
.../3rdparty/gtest/googletest/CMakeLists.txt | 312 +
.../3rdparty/gtest/googletest/CONTRIBUTORS | 37 +
.../backend/3rdparty/gtest/googletest/LICENSE | 28 +
.../3rdparty/gtest/googletest/Makefile.am | 339 +
.../backend/3rdparty/gtest/googletest/README.md | 360 +
.../3rdparty/gtest/googletest/cmake/gtest.pc.in | 9 +
.../gtest/googletest/cmake/gtest_main.pc.in | 10 +
.../gtest/googletest/cmake/internal_utils.cmake | 280 +
.../gtest/googletest/codegear/gtest.cbproj | 138 +
.../gtest/googletest/codegear/gtest.groupproj | 54 +
.../gtest/googletest/codegear/gtest_all.cc | 38 +
.../gtest/googletest/codegear/gtest_link.cc | 40 +
.../gtest/googletest/codegear/gtest_main.cbproj | 82 +
.../googletest/codegear/gtest_unittest.cbproj | 88 +
.../3rdparty/gtest/googletest/configure.ac | 68 +
.../gtest/googletest/docs/AdvancedGuide.md | 2416 ++
.../gtest/googletest/docs/Documentation.md | 16 +
.../3rdparty/gtest/googletest/docs/FAQ.md | 1092 +
.../3rdparty/gtest/googletest/docs/Pkgconfig.md | 146 +
.../3rdparty/gtest/googletest/docs/Primer.md | 536 +
.../gtest/googletest/docs/PumpManual.md | 177 +
.../3rdparty/gtest/googletest/docs/Samples.md | 14 +
.../gtest/googletest/docs/XcodeGuide.md | 93 +
.../googletest/include/gtest/gtest-death-test.h | 342 +
.../googletest/include/gtest/gtest-message.h | 249 +
.../googletest/include/gtest/gtest-param-test.h | 1438 ++
.../include/gtest/gtest-param-test.h.pump | 501 +
.../googletest/include/gtest/gtest-printers.h | 1078 +
.../gtest/googletest/include/gtest/gtest-spi.h | 231 +
.../googletest/include/gtest/gtest-test-part.h | 179 +
.../googletest/include/gtest/gtest-typed-test.h | 264 +
.../gtest/googletest/include/gtest/gtest.h | 2330 ++
.../googletest/include/gtest/gtest_pred_impl.h | 357 +
.../gtest/googletest/include/gtest/gtest_prod.h | 61 +
.../include/gtest/internal/custom/gtest-port.h | 75 +
.../gtest/internal/custom/gtest-printers.h | 42 +
.../include/gtest/internal/custom/gtest.h | 45 +
.../gtest/internal/gtest-death-test-internal.h | 275 +
.../include/gtest/internal/gtest-filepath.h | 205 +
.../include/gtest/internal/gtest-internal.h | 1277 +
.../include/gtest/internal/gtest-linked_ptr.h | 243 +
.../gtest/internal/gtest-param-util-generated.h | 5139 ++++
.../internal/gtest-param-util-generated.h.pump | 279 +
.../include/gtest/internal/gtest-param-util.h | 723 +
.../include/gtest/internal/gtest-port-arch.h | 100 +
.../include/gtest/internal/gtest-port.h | 2686 +++
.../include/gtest/internal/gtest-string.h | 167 +
.../include/gtest/internal/gtest-tuple.h | 1020 +
.../include/gtest/internal/gtest-tuple.h.pump | 347 +
.../include/gtest/internal/gtest-type-util.h | 3331 +++
.../gtest/internal/gtest-type-util.h.pump | 297 +
.../3rdparty/gtest/googletest/m4/acx_pthread.m4 | 363 +
.../3rdparty/gtest/googletest/m4/gtest.m4 | 74 +
.../3rdparty/gtest/googletest/make/Makefile | 82 +
.../gtest/googletest/msvc/2010/gtest-md.sln | 55 +
.../gtest/googletest/msvc/2010/gtest-md.vcxproj | 149 +
.../msvc/2010/gtest-md.vcxproj.filters | 18 +
.../gtest/googletest/msvc/2010/gtest.sln | 55 +
.../gtest/googletest/msvc/2010/gtest.vcxproj | 149 +
.../googletest/msvc/2010/gtest.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_main-md.vcxproj | 154 +
.../msvc/2010/gtest_main-md.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_main.vcxproj | 162 +
.../msvc/2010/gtest_main.vcxproj.filters | 18 +
.../msvc/2010/gtest_prod_test-md.vcxproj | 199 +
.../2010/gtest_prod_test-md.vcxproj.filters | 26 +
.../msvc/2010/gtest_prod_test.vcxproj | 191 +
.../msvc/2010/gtest_prod_test.vcxproj.filters | 26 +
.../msvc/2010/gtest_unittest-md.vcxproj | 188 +
.../msvc/2010/gtest_unittest-md.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_unittest.vcxproj | 180 +
.../msvc/2010/gtest_unittest.vcxproj.filters | 18 +
.../gtest/googletest/samples/prime_tables.h | 127 +
.../gtest/googletest/samples/sample1.cc | 68 +
.../3rdparty/gtest/googletest/samples/sample1.h | 43 +
.../googletest/samples/sample10_unittest.cc | 140 +
.../googletest/samples/sample1_unittest.cc | 154 +
.../gtest/googletest/samples/sample2.cc | 56 +
.../3rdparty/gtest/googletest/samples/sample2.h | 85 +
.../googletest/samples/sample2_unittest.cc | 110 +
.../gtest/googletest/samples/sample3-inl.h | 172 +
.../googletest/samples/sample3_unittest.cc | 152 +
.../gtest/googletest/samples/sample4.cc | 46 +
.../3rdparty/gtest/googletest/samples/sample4.h | 53 +
.../googletest/samples/sample4_unittest.cc | 49 +
.../googletest/samples/sample5_unittest.cc | 199 +
.../googletest/samples/sample6_unittest.cc | 225 +
.../googletest/samples/sample7_unittest.cc | 118 +
.../googletest/samples/sample8_unittest.cc | 174 +
.../googletest/samples/sample9_unittest.cc | 157 +
.../3rdparty/gtest/googletest/scripts/common.py | 83 +
.../googletest/scripts/fuse_gtest_files.py | 253 +
.../googletest/scripts/gen_gtest_pred_impl.py | 730 +
.../gtest/googletest/scripts/gtest-config.in | 274 +
.../3rdparty/gtest/googletest/scripts/pump.py | 855 +
.../gtest/googletest/scripts/release_docs.py | 158 +
.../gtest/googletest/scripts/test/Makefile | 59 +
.../3rdparty/gtest/googletest/scripts/upload.py | 1387 ++
.../gtest/googletest/scripts/upload_gtest.py | 78 +
.../3rdparty/gtest/googletest/src/gtest-all.cc | 48 +
.../gtest/googletest/src/gtest-death-test.cc | 1346 ++
.../gtest/googletest/src/gtest-filepath.cc | 385 +
.../gtest/googletest/src/gtest-internal-inl.h | 1175 +
.../3rdparty/gtest/googletest/src/gtest-port.cc | 1253 +
.../gtest/googletest/src/gtest-printers.cc | 458 +
.../gtest/googletest/src/gtest-test-part.cc | 102 +
.../gtest/googletest/src/gtest-typed-test.cc | 119 +
.../3rdparty/gtest/googletest/src/gtest.cc | 5841 +++++
.../3rdparty/gtest/googletest/src/gtest_main.cc | 38 +
.../3rdparty/gtest/googletest/test/BUILD.bazel | 380 +
.../googletest/test/gtest-death-test_ex_test.cc | 93 +
.../googletest/test/gtest-death-test_test.cc | 1423 ++
.../googletest/test/gtest-filepath_test.cc | 652 +
.../googletest/test/gtest-linked_ptr_test.cc | 154 +
.../googletest/test/gtest-listener_test.cc | 311 +
.../gtest/googletest/test/gtest-message_test.cc | 159 +
.../gtest/googletest/test/gtest-options_test.cc | 207 +
.../googletest/test/gtest-param-test2_test.cc | 61 +
.../googletest/test/gtest-param-test_test.cc | 1110 +
.../googletest/test/gtest-param-test_test.h | 53 +
.../gtest/googletest/test/gtest-port_test.cc | 1303 +
.../googletest/test/gtest-printers_test.cc | 1731 ++
.../googletest/test/gtest-test-part_test.cc | 208 +
.../gtest/googletest/test/gtest-tuple_test.cc | 320 +
.../googletest/test/gtest-typed-test2_test.cc | 45 +
.../googletest/test/gtest-typed-test_test.cc | 380 +
.../googletest/test/gtest-typed-test_test.h | 66 +
.../googletest/test/gtest-unittest-api_test.cc | 341 +
.../gtest/googletest/test/gtest_all_test.cc | 47 +
.../test/gtest_assert_by_exception_test.cc | 119 +
.../test/gtest_break_on_failure_unittest.py | 210 +
.../test/gtest_break_on_failure_unittest_.cc | 87 +
.../test/gtest_catch_exceptions_test.py | 235 +
.../test/gtest_catch_exceptions_test_.cc | 311 +
.../gtest/googletest/test/gtest_color_test.py | 129 +
.../gtest/googletest/test/gtest_color_test_.cc | 63 +
.../gtest/googletest/test/gtest_env_var_test.py | 119 +
.../googletest/test/gtest_env_var_test_.cc | 124 +
.../googletest/test/gtest_environment_test.cc | 189 +
.../googletest/test/gtest_filter_unittest.py | 638 +
.../googletest/test/gtest_filter_unittest_.cc | 138 +
.../gtest/googletest/test/gtest_help_test.py | 172 +
.../gtest/googletest/test/gtest_help_test_.cc | 46 +
.../googletest/test/gtest_json_outfiles_test.py | 162 +
.../test/gtest_json_output_unittest.py | 611 +
.../googletest/test/gtest_json_test_utils.py | 60 +
.../test/gtest_list_tests_unittest.py | 207 +
.../test/gtest_list_tests_unittest_.cc | 157 +
.../googletest/test/gtest_main_unittest.cc | 45 +
.../googletest/test/gtest_no_test_unittest.cc | 56 +
.../gtest/googletest/test/gtest_output_test.py | 344 +
.../gtest/googletest/test/gtest_output_test_.cc | 1067 +
.../test/gtest_output_test_golden_lin.txt | 781 +
.../googletest/test/gtest_pred_impl_unittest.cc | 2427 ++
.../test/gtest_premature_exit_test.cc | 127 +
.../gtest/googletest/test/gtest_prod_test.cc | 57 +
.../gtest/googletest/test/gtest_repeat_test.cc | 236 +
.../gtest/googletest/test/gtest_shuffle_test.py | 325 +
.../googletest/test/gtest_shuffle_test_.cc | 103 +
.../googletest/test/gtest_sole_header_test.cc | 57 +
.../gtest/googletest/test/gtest_stress_test.cc | 250 +
.../gtest/googletest/test/gtest_test_utils.py | 318 +
.../test/gtest_throw_on_failure_ex_test.cc | 92 +
.../test/gtest_throw_on_failure_test.py | 171 +
.../test/gtest_throw_on_failure_test_.cc | 72 +
.../googletest/test/gtest_uninitialized_test.py | 69 +
.../test/gtest_uninitialized_test_.cc | 43 +
.../gtest/googletest/test/gtest_unittest.cc | 7750 ++++++
.../googletest/test/gtest_xml_outfile1_test_.cc | 48 +
.../googletest/test/gtest_xml_outfile2_test_.cc | 48 +
.../googletest/test/gtest_xml_outfiles_test.py | 140 +
.../test/gtest_xml_output_unittest.py | 378 +
.../test/gtest_xml_output_unittest_.cc | 179 +
.../googletest/test/gtest_xml_test_utils.py | 196 +
.../gtest/googletest/test/production.cc | 36 +
.../3rdparty/gtest/googletest/test/production.h | 55 +
.../xcode/Config/DebugProject.xcconfig | 30 +
.../xcode/Config/FrameworkTarget.xcconfig | 17 +
.../googletest/xcode/Config/General.xcconfig | 41 +
.../xcode/Config/ReleaseProject.xcconfig | 32 +
.../xcode/Config/StaticLibraryTarget.xcconfig | 18 +
.../googletest/xcode/Config/TestTarget.xcconfig | 8 +
.../gtest/googletest/xcode/Resources/Info.plist | 30 +
.../xcode/Samples/FrameworkSample/Info.plist | 28 +
.../WidgetFramework.xcodeproj/project.pbxproj | 457 +
.../xcode/Samples/FrameworkSample/runtests.sh | 62 +
.../xcode/Samples/FrameworkSample/widget.cc | 63 +
.../xcode/Samples/FrameworkSample/widget.h | 59 +
.../Samples/FrameworkSample/widget_test.cc | 68 +
.../gtest/googletest/xcode/Scripts/runtests.sh | 65 +
.../googletest/xcode/Scripts/versiongenerate.py | 100 +
.../xcode/gtest.xcodeproj/project.pbxproj | 1182 +
libraries/ostrich/backend/CMakeLists.txt | 9 +-
libraries/ostrich/backend/ldpath/CMakeLists.txt | 6 -
.../ostrich/backend/ldpath/ldpath_model.cc | 26 -
libraries/ostrich/backend/ldpath/ldpath_model.h | 46 -
libraries/ostrich/backend/ldpath/parser_base.cc | 5 -
libraries/ostrich/backend/ldpath/parser_base.h | 304 -
libraries/ostrich/backend/model/CMakeLists.txt | 2 +-
libraries/ostrich/backend/model/rdf_model.cc | 25 +-
.../ostrich/backend/model/rdf_namespaces.cc | 11 +-
.../ostrich/backend/model/rdf_namespaces.h | 76 +-
libraries/ostrich/backend/parser/CMakeLists.txt | 2 +-
libraries/ostrich/backend/parser/rdf_parser.cc | 7 +-
libraries/ostrich/backend/parser/rdf_parser.h | 4 +-
.../backend/persistence/base_persistence.cc | 19 +-
.../backend/persistence/leveldb_server.cc | 1 +
.../ostrich/backend/sharding/CMakeLists.txt | 2 +-
libraries/ostrich/backend/sharding/server.cc | 6 +-
.../ostrich/backend/sparql/rasqal_model.cc | 2 +-
libraries/ostrich/backend/test/CMakeLists.txt | 31 +-
libraries/ostrich/backend/test/LevelDBTest.cc | 20 +-
libraries/ostrich/backend/test/NamespaceTest.cc | 21 +-
.../ostrich/backend/test/PersistenceTest.cc | 20 +-
libraries/ostrich/backend/test/SparqlTest.cc | 20 +-
libraries/ostrich/backend/test/StatementTest.cc | 21 +-
.../ostrich/backend/test/gmock-gtest-all.cc | 12243 ----------
libraries/ostrich/backend/test/gmock/gmock.h | 14978 ------------
libraries/ostrich/backend/test/gtest/gtest.h | 21197 -----------------
libraries/ostrich/backend/test/main.cc | 11 -
libraries/ostrich/backend/util/CMakeLists.txt | 2 +-
libraries/ostrich/backend/util/raptor_util.cc | 2 +-
libraries/ostrich/backend/util/split.cc | 40 -
libraries/ostrich/backend/util/split.h | 38 -
libraries/ostrich/backend/util/time_logger.cc | 21 +-
libraries/ostrich/backend/util/time_logger.h | 21 +-
1250 files changed, 224941 insertions(+), 49008 deletions(-)
----------------------------------------------------------------------
[50/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/CMake/AbseilHelpers.cmake
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/CMake/AbseilHelpers.cmake b/libraries/ostrich/backend/3rdparty/abseil/CMake/AbseilHelpers.cmake
new file mode 100644
index 0000000..0520fba
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/CMake/AbseilHelpers.cmake
@@ -0,0 +1,157 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+include(CMakeParseArguments)
+
+
+#
+# create a library in the absl namespace
+#
+# parameters
+# SOURCES : sources files for the library
+# PUBLIC_LIBRARIES: targets and flags for linking phase
+# PRIVATE_COMPILE_FLAGS: compile flags for the library. Will not be exported.
+# EXPORT_NAME: export name for the absl:: target export
+# TARGET: target name
+#
+# create a target associated to <NAME>
+# libraries are installed under CMAKE_INSTALL_FULL_LIBDIR by default
+#
+function(absl_library)
+ cmake_parse_arguments(ABSL_LIB
+ "DISABLE_INSTALL" # keep that in case we want to support installation one day
+ "TARGET;EXPORT_NAME"
+ "SOURCES;PUBLIC_LIBRARIES;PRIVATE_COMPILE_FLAGS"
+ ${ARGN}
+ )
+
+ set(_NAME ${ABSL_LIB_TARGET})
+ string(TOUPPER ${_NAME} _UPPER_NAME)
+
+ add_library(${_NAME} STATIC ${ABSL_LIB_SOURCES})
+
+ target_compile_options(${_NAME} PRIVATE ${ABSL_COMPILE_CXXFLAGS} ${ABSL_LIB_PRIVATE_COMPILE_FLAGS})
+ target_link_libraries(${_NAME} PUBLIC ${ABSL_LIB_PUBLIC_LIBRARIES})
+ target_include_directories(${_NAME}
+ PUBLIC ${ABSL_COMMON_INCLUDE_DIRS} ${ABSL_LIB_PUBLIC_INCLUDE_DIRS}
+ PRIVATE ${ABSL_LIB_PRIVATE_INCLUDE_DIRS}
+ )
+
+ if(ABSL_LIB_EXPORT_NAME)
+ add_library(absl::${ABSL_LIB_EXPORT_NAME} ALIAS ${_NAME})
+ endif()
+endfunction()
+
+
+
+#
+# header only virtual target creation
+#
+function(absl_header_library)
+ cmake_parse_arguments(ABSL_HO_LIB
+ "DISABLE_INSTALL"
+ "EXPORT_NAME;TARGET"
+ "PUBLIC_LIBRARIES;PRIVATE_COMPILE_FLAGS;PUBLIC_INCLUDE_DIRS;PRIVATE_INCLUDE_DIRS"
+ ${ARGN}
+ )
+
+ set(_NAME ${ABSL_HO_LIB_TARGET})
+
+ set(__dummy_header_only_lib_file "${CMAKE_CURRENT_BINARY_DIR}/${_NAME}_header_only_dummy.cc")
+
+ if(NOT EXISTS ${__dummy_header_only_lib_file})
+ file(WRITE ${__dummy_header_only_lib_file}
+ "/* generated file for header-only cmake target */
+
+ namespace absl {
+
+ // single meaningless symbol
+ void ${_NAME}__header_fakesym() {}
+ } // namespace absl
+ "
+ )
+ endif()
+
+
+ add_library(${_NAME} ${__dummy_header_only_lib_file})
+ target_link_libraries(${_NAME} PUBLIC ${ABSL_HO_LIB_PUBLIC_LIBRARIES})
+ target_include_directories(${_NAME}
+ PUBLIC ${ABSL_COMMON_INCLUDE_DIRS} ${ABSL_HO_LIB_PUBLIC_INCLUDE_DIRS}
+ PRIVATE ${ABSL_HO_LIB_PRIVATE_INCLUDE_DIRS}
+ )
+
+ if(ABSL_HO_LIB_EXPORT_NAME)
+ add_library(absl::${ABSL_HO_LIB_EXPORT_NAME} ALIAS ${_NAME})
+ endif()
+
+endfunction()
+
+
+#
+# create an abseil unit_test and add it to the executed test list
+#
+# parameters
+# TARGET: target name prefix
+# SOURCES: sources files for the tests
+# PUBLIC_LIBRARIES: targets and flags for linking phase.
+# PRIVATE_COMPILE_FLAGS: compile flags for the test. Will not be exported.
+#
+# create a target associated to <NAME>_bin
+#
+# all tests will be register for execution with add_test()
+#
+# test compilation and execution is disable when BUILD_TESTING=OFF
+#
+function(absl_test)
+
+ cmake_parse_arguments(ABSL_TEST
+ ""
+ "TARGET"
+ "SOURCES;PUBLIC_LIBRARIES;PRIVATE_COMPILE_FLAGS;PUBLIC_INCLUDE_DIRS"
+ ${ARGN}
+ )
+
+
+ if(BUILD_TESTING)
+
+ set(_NAME ${ABSL_TEST_TARGET})
+ string(TOUPPER ${_NAME} _UPPER_NAME)
+
+ add_executable(${_NAME}_bin ${ABSL_TEST_SOURCES})
+
+ target_compile_options(${_NAME}_bin PRIVATE ${ABSL_COMPILE_CXXFLAGS} ${ABSL_TEST_PRIVATE_COMPILE_FLAGS})
+ target_link_libraries(${_NAME}_bin PUBLIC ${ABSL_TEST_PUBLIC_LIBRARIES} ${ABSL_TEST_COMMON_LIBRARIES})
+ target_include_directories(${_NAME}_bin
+ PUBLIC ${ABSL_COMMON_INCLUDE_DIRS} ${ABSL_TEST_PUBLIC_INCLUDE_DIRS}
+ PRIVATE ${GMOCK_INCLUDE_DIRS} ${GTEST_INCLUDE_DIRS}
+ )
+
+ add_test(${_NAME}_test ${_NAME}_bin)
+ endif(BUILD_TESTING)
+
+endfunction()
+
+
+
+
+function(check_target my_target)
+
+ if(NOT TARGET ${my_target})
+ message(FATAL_ERROR " ABSL: compiling absl requires a ${my_target} CMake target in your project,
+ see CMake/README.md for more details")
+ endif(NOT TARGET ${my_target})
+
+endfunction()
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/CMake/README.md
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/CMake/README.md b/libraries/ostrich/backend/3rdparty/abseil/CMake/README.md
new file mode 100644
index 0000000..e99340c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/CMake/README.md
@@ -0,0 +1,79 @@
+# Abseil CMake Build Instructions
+
+Abseil comes with a CMake build script ([CMakeLists.txt](../CMakeLists.txt))
+that can be used on a wide range of platforms ("C" stands for cross-platform.).
+If you don't have CMake installed already, you can download it for free from
+<http://www.cmake.org/>.
+
+CMake works by generating native makefiles or build projects that can
+be used in the compiler environment of your choice.
+
+For API/ABI compatibility reasons, we strongly recommend building Abseil in a
+subdirectory of your project or as an embedded dependency.
+
+## Incorporating Abseil Into a CMake Project
+
+The recommendations below are similar to those for using CMake within the
+googletest framework
+(<https://github.com/google/googletest/blob/master/googletest/README.md#incorporating-into-an-existing-cmake-project>)
+
+### Step-by-Step Instructions
+
+1. If you want to build the Abseil tests, integrate the Abseil dependency
+[Google Test](https://github.com/google/googletest) into your CMake project. To disable Abseil tests, you have to pass
+`-DBUILD_TESTING=OFF` when configuring your project with CMake.
+
+2. Download Abseil and copy it into a subdirectory in your CMake project or add
+Abseil as a [git submodule](https://git-scm.com/docs/git-submodule) in your
+CMake project.
+
+3. You can then use the CMake command
+[`add_subdirectory()`](https://cmake.org/cmake/help/latest/command/add_subdirectory.html)
+to include Abseil directly in your CMake project.
+
+4. Add the **absl::** target you wish to use to the
+[`target_link_libraries()`](https://cmake.org/cmake/help/latest/command/target_link_libraries.html)
+section of your executable or of your library.<br>
+Here is a short CMakeLists.txt example of a project file using Abseil.
+
+```cmake
+cmake_minimum_required(VERSION 2.8.12)
+project(my_project)
+
+set(CMAKE_CXX_FLAGS "-std=c++11 -stdlib=libc++ ${CMAKE_CXX_FLAGS}")
+
+if(MSVC)
+ # /wd4005 macro-redefinition
+ # /wd4068 unknown pragma
+ # /wd4244 conversion from 'type1' to 'type2'
+ # /wd4267 conversion from 'size_t' to 'type2'
+ # /wd4800 force value to bool 'true' or 'false' (performance warning)
+ add_compile_options(/wd4005 /wd4068 /wd4244 /wd4267 /wd4800)
+ add_definitions(/DNOMINMAX /DWIN32_LEAN_AND_MEAN=1 /D_CRT_SECURE_NO_WARNINGS)
+endif()
+
+add_subdirectory(googletest)
+add_subdirectory(cctz)
+add_subdirectory(abseil-cpp)
+
+add_executable(my_exe source.cpp)
+target_link_libraries(my_exe absl::base absl::synchronization absl::strings)
+```
+
+### Available Abseil CMake Public Targets
+
+Here's a non-exhaustive list of Abseil CMake public targets:
+
+```cmake
+absl::base
+absl::algorithm
+absl::container
+absl::debugging
+absl::memory
+absl::meta
+absl::numeric
+absl::strings
+absl::synchronization
+absl::time
+absl::utility
+```
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/CMakeLists.txt
new file mode 100644
index 0000000..e46bdf4
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/CMakeLists.txt
@@ -0,0 +1,86 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+cmake_minimum_required(VERSION 2.8.12)
+project(absl)
+
+# enable ctest
+include(CTest)
+
+list(APPEND CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/CMake)
+
+include(GNUInstallDirs)
+include(AbseilHelpers)
+
+
+# config options
+if (MSVC)
+ # /wd4005 macro-redefinition
+ # /wd4068 unknown pragma
+ # /wd4244 conversion from 'type1' to 'type2'
+ # /wd4267 conversion from 'size_t' to 'type2'
+ # /wd4800 force value to bool 'true' or 'false' (performance warning)
+ add_compile_options(/W3 /WX /wd4005 /wd4068 /wd4244 /wd4267 /wd4800)
+ add_definitions(/DNOMINMAX /DWIN32_LEAN_AND_MEAN=1 /D_CRT_SECURE_NO_WARNINGS /D_SCL_SECURE_NO_WARNINGS)
+else()
+ set(ABSL_STD_CXX_FLAG "-std=c++11" CACHE STRING "c++ std flag (default: c++11)")
+endif()
+
+
+
+##
+## Using absl targets
+##
+## all public absl targets are
+## exported with the absl:: prefix
+##
+## e.g absl::base absl::synchronization absl::strings ....
+##
+## DO NOT rely on the internal targets outside of the prefix
+
+
+# include current path
+list(APPEND ABSL_COMMON_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR})
+
+# -std=X
+set(CMAKE_CXX_FLAGS "${ABSL_STD_CXX_FLAG} ${CMAKE_CXX_FLAGS}")
+set(CMAKE_CXX_FLAGS "${CMAKE_CXX_WARNING_VLA} ${CMAKE_CXX_FLAGS} ")
+
+# -fexceptions
+set(ABSL_EXCEPTIONS_FLAG "${CMAKE_CXX_EXCEPTIONS}")
+
+# find dependencies
+## pthread
+find_package(Threads REQUIRED)
+
+# commented: used only for standalone test
+# Don't remove these or else CMake CI will break
+#add_subdirectory(googletest)
+
+## check targets
+if(BUILD_TESTING)
+ check_target(gtest)
+ check_target(gtest_main)
+ check_target(gmock)
+
+ list(APPEND ABSL_TEST_COMMON_LIBRARIES
+ gtest_main
+ gtest
+ gmock
+ ${CMAKE_THREAD_LIBS_INIT}
+ )
+endif()
+
+add_subdirectory(absl)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/CONTRIBUTING.md
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/CONTRIBUTING.md b/libraries/ostrich/backend/3rdparty/abseil/CONTRIBUTING.md
new file mode 100644
index 0000000..40351dd
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/CONTRIBUTING.md
@@ -0,0 +1,91 @@
+# How to Contribute to Abseil
+
+We'd love to accept your patches and contributions to this project. There are
+just a few small guidelines you need to follow.
+
+NOTE: If you are new to GitHub, please start by reading [Pull Request
+howto](https://help.github.com/articles/about-pull-requests/)
+
+## Contributor License Agreement
+
+Contributions to this project must be accompanied by a Contributor License
+Agreement. You (or your employer) retain the copyright to your contribution,
+this simply gives us permission to use and redistribute your contributions as
+part of the project. Head over to <https://cla.developers.google.com/> to see
+your current agreements on file or to sign a new one.
+
+You generally only need to submit a CLA once, so if you've already submitted one
+(even if it was for a different project), you probably don't need to do it
+again.
+
+## Coding Style
+
+To keep the source consistent, readable, diffable and easy to merge, we use a
+fairly rigid coding style, as defined by the
+[google-styleguide](https://github.com/google/styleguide) project. All patches
+will be expected to conform to the style outlined
+[here](https://google.github.io/styleguide/cppguide.html).
+
+## Guidelines for Pull Requests
+
+* If you are a Googler, it is preferable to first create an internal CL and
+ have it reviewed and submitted. The code propagation process will deliver
+ the change to GitHub.
+
+* Create **small PRs** that are narrowly focused on **addressing a single
+ concern**. We often receive PRs that are trying to fix several things at a
+ time, but if only one fix is considered acceptable, nothing gets merged and
+ both author's & review's time is wasted. Create more PRs to address
+ different concerns and everyone will be happy.
+
+* For speculative changes, consider opening an [Abseil
+ issue](https://github.com/abseil/abseil-cpp/issues) and discussing it first.
+ If you are suggesting a behavioral or API change, consider starting with an
+ [Abseil proposal template](ABSEIL_ISSUE_TEMPLATE.md).
+
+* Provide a good **PR description** as a record of **what** change is being
+ made and **why** it was made. Link to a GitHub issue if it exists.
+
+* Don't fix code style and formatting unless you are already changing that
+ line to address an issue. Formatting of modified lines may be done using
+ `git clang-format`. PRs with irrelevant changes won't be merged. If
+ you do want to fix formatting or style, do that in a separate PR.
+
+* Unless your PR is trivial, you should expect there will be reviewer comments
+ that you'll need to address before merging. We expect you to be reasonably
+ responsive to those comments, otherwise the PR will be closed after 2-3
+ weeks of inactivity.
+
+* Maintain **clean commit history** and use **meaningful commit messages**.
+ PRs with messy commit history are difficult to review and won't be merged.
+ Use `rebase -i upstream/master` to curate your commit history and/or to
+ bring in latest changes from master (but avoid rebasing in the middle of a
+ code review).
+
+* Keep your PR up to date with upstream/master (if there are merge conflicts,
+ we can't really merge your change).
+
+* **All tests need to be passing** before your change can be merged. We
+ recommend you **run tests locally** (see below)
+
+* Exceptions to the rules can be made if there's a compelling reason for doing
+ so. That is - the rules are here to serve us, not the other way around, and
+ the rules need to be serving their intended purpose to be valuable.
+
+* All submissions, including submissions by project members, require review.
+
+## Running Tests
+
+Use "bazel test <>" functionality to run the unit tests.
+
+Prerequisites for building and running tests are listed in
+[README.md](README.md)
+
+## Abseil Committers
+
+The current members of the Abseil engineering team are the only committers at
+present.
+
+## Release Process
+
+Abseil lives at head, where latest-and-greatest code can be found.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/LICENSE
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/LICENSE b/libraries/ostrich/backend/3rdparty/abseil/LICENSE
new file mode 100644
index 0000000..fef7d96
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/LICENSE
@@ -0,0 +1,204 @@
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
+ APPENDIX: How to apply the Apache License to your work.
+
+ To apply the Apache License to your work, attach the following
+ boilerplate notice, with the fields enclosed by brackets "[]"
+ replaced with your own identifying information. (Don't include
+ the brackets!) The text should be enclosed in the appropriate
+ comment syntax for the file format. We also recommend that a
+ file or class name and description of purpose be included on the
+ same "printed page" as the copyright notice for easier
+ identification within third-party archives.
+
+ Copyright [yyyy] [name of copyright owner]
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+
+
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/README.md
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/README.md b/libraries/ostrich/backend/3rdparty/abseil/README.md
new file mode 100644
index 0000000..8eed575
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/README.md
@@ -0,0 +1,108 @@
+# Abseil - C++ Common Libraries
+
+The repository contains the Abseil C++ library code. Abseil is an open-source
+collection of C++ code (compliant to C++11) designed to augment the C++
+standard library.
+
+## Table of Contents
+
+- [About Abseil](#about)
+- [Quickstart](#quickstart)
+- [Building Abseil](#build)
+- [Codemap](#codemap)
+- [License](#license)
+- [Links](#links)
+
+<a name="about"></a>
+## About Abseil
+
+Abseil is an open-source collection of C++ library code designed to augment
+the C++ standard library. The Abseil library code is collected from Google's
+own C++ code base, has been extensively tested and used in production, and
+is the same code we depend on in our daily coding lives.
+
+In some cases, Abseil provides pieces missing from the C++ standard; in
+others, Abseil provides alternatives to the standard for special needs
+we've found through usage in the Google code base. We denote those cases
+clearly within the library code we provide you.
+
+Abseil is not meant to be a competitor to the standard library; we've
+just found that many of these utilities serve a purpose within our code
+base, and we now want to provide those resources to the C++ community as
+a whole.
+
+<a name="quickstart"></a>
+## Quickstart
+
+If you want to just get started, make sure you at least run through the
+[Abseil Quickstart](https://abseil.io/docs/cpp/quickstart). The Quickstart
+contains information about setting up your development environment, downloading
+the Abseil code, running tests, and getting a simple binary working.
+
+<a name="build"></a>
+## Building Abseil
+
+[Bazel](http://bazel.build) is the official build system for Abseil,
+which is supported on most major platforms (Linux, Windows, MacOS, for example)
+and compilers. See the [quickstart](https://abseil.io/docs/cpp/quickstart) for
+more information on building Abseil using the Bazel build system.
+
+<a name="cmake"></a>
+If you require CMake support, please check the
+[CMake build instructions](CMake/README.md).
+
+## Codemap
+
+Abseil contains the following C++ library components:
+
+* [`base`](absl/base/) Abseil Fundamentals
+ <br /> The `base` library contains initialization code and other code which
+ all other Abseil code depends on. Code within `base` may not depend on any
+ other code (other than the C++ standard library).
+* [`algorithm`](absl/algorithm/)
+ <br /> The `algorithm` library contains additions to the C++ `<algorithm>`
+ library and container-based versions of such algorithms.
+* [`container`](absl/container/)
+ <br /> The `container` library contains additional STL-style containers.
+* [`debugging`](absl/debugging/)
+ <br /> The `debugging` library contains code useful for enabling leak
+ checks. Future updates will add stacktrace and symbolization utilities.
+* [`memory`](absl/memory/)
+ <br /> The `memory` library contains C++11-compatible versions of
+ `std::make_unique()` and related memory management facilities.
+* [`meta`](absl/meta/)
+ <br /> The `meta` library contains C++11-compatible versions of type checks
+ available within C++14 and C++17 versions of the C++ `<type_traits>` library.
+* [`numeric`](absl/numeric/)
+ <br /> The `numeric` library contains C++11-compatible 128-bit integers.
+* [`strings`](absl/strings/)
+ <br /> The `strings` library contains a variety of strings routines and
+ utilities, including a C++11-compatible version of the C++17
+ `std::string_view` type.
+* [`synchronization`](absl/synchronization/)
+ <br /> The `synchronization` library contains concurrency primitives (Abseil's
+ `absl::Mutex` class, an alternative to `std::mutex`) and a variety of
+ synchronization abstractions.
+* [`time`](absl/time/)
+ <br /> The `time` library contains abstractions for computing with absolute
+ points in time, durations of time, and formatting and parsing time within
+ time zones.
+* [`types`](absl/types/)
+ <br /> The `types` library contains non-container utility types, like a
+ C++11-compatible version of the C++17 `std::optional` type.
+
+## License
+
+The Abseil C++ library is licensed under the terms of the Apache
+license. See [LICENSE](LICENSE) for more information.
+
+## Links
+
+For more information about Abseil:
+
+* Consult our [Abseil Introduction](http://abseil.io/about/intro)
+* Read [Why Adopt Abseil](http://abseil.io/about/philosophy) to understand our
+ design philosophy.
+* Peruse our
+ [Abseil Compatibility Guarantees](http://abseil.io/about/compatibility) to
+ understand both what we promise to you, and what we expect of you in return.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/WORKSPACE
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/WORKSPACE b/libraries/ostrich/backend/3rdparty/abseil/WORKSPACE
new file mode 100644
index 0000000..0546573
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/WORKSPACE
@@ -0,0 +1,25 @@
+workspace(name = "com_google_absl")
+# Bazel toolchains
+http_archive(
+ name = "bazel_toolchains",
+ urls = [
+ "https://mirror.bazel.build/github.com/bazelbuild/bazel-toolchains/archive/r324073.tar.gz",
+ "https://github.com/bazelbuild/bazel-toolchains/archive/r324073.tar.gz",
+ ],
+ strip_prefix = "bazel-toolchains-r324073",
+ sha256 = "71548c0d6cd53eddebbde4fa9962f5395e82645fb9992719e0890505b177f245",
+)
+
+# GoogleTest/GoogleMock framework. Used by most unit-tests.
+http_archive(
+ name = "com_google_googletest",
+ urls = ["https://github.com/google/googletest/archive/master.zip"],
+ strip_prefix = "googletest-master",
+)
+
+# RE2 regular-expression framework. Used by some unit-tests.
+http_archive(
+ name = "com_googlesource_code_re2",
+ urls = ["https://github.com/google/re2/archive/master.zip"],
+ strip_prefix = "re2-master",
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/BUILD.bazel
new file mode 100644
index 0000000..439addb
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/BUILD.bazel
@@ -0,0 +1,52 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+config_setting(
+ name = "llvm_compiler",
+ values = {
+ "compiler": "llvm",
+ },
+ visibility = [":__subpackages__"],
+)
+
+# following configs are based on mapping defined in: https://git.io/v5Ijz
+config_setting(
+ name = "ios",
+ values = {
+ "cpu": "darwin",
+ },
+ visibility = [":__subpackages__"],
+)
+
+config_setting(
+ name = "windows",
+ values = {
+ "cpu": "x64_windows",
+ },
+ visibility = [":__subpackages__"],
+)
+
+config_setting(
+ name = "ppc",
+ values = {
+ "cpu": "ppc",
+ },
+ visibility = [":__subpackages__"],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/CMakeLists.txt
new file mode 100644
index 0000000..689f64e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/CMakeLists.txt
@@ -0,0 +1,30 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+
+add_subdirectory(base)
+add_subdirectory(algorithm)
+add_subdirectory(container)
+add_subdirectory(debugging)
+add_subdirectory(memory)
+add_subdirectory(meta)
+add_subdirectory(numeric)
+add_subdirectory(strings)
+add_subdirectory(synchronization)
+add_subdirectory(time)
+add_subdirectory(types)
+add_subdirectory(utility)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/BUILD.bazel
new file mode 100644
index 0000000..255b986
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/BUILD.bazel
@@ -0,0 +1,69 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "algorithm",
+ hdrs = ["algorithm.h"],
+ copts = ABSL_DEFAULT_COPTS,
+)
+
+cc_test(
+ name = "algorithm_test",
+ size = "small",
+ srcs = ["algorithm_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":algorithm",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "container",
+ hdrs = [
+ "container.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":algorithm",
+ "//absl/base:core_headers",
+ "//absl/meta:type_traits",
+ ],
+)
+
+cc_test(
+ name = "container_test",
+ srcs = ["container_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":container",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "//absl/memory",
+ "//absl/types:span",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/CMakeLists.txt
new file mode 100644
index 0000000..fdf45c5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/CMakeLists.txt
@@ -0,0 +1,63 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+list(APPEND ALGORITHM_PUBLIC_HEADERS
+ "algorithm.h"
+ "container.h"
+)
+
+
+#
+## TESTS
+#
+
+# test algorithm_test
+list(APPEND ALGORITHM_TEST_SRC
+ "algorithm_test.cc"
+ ${ALGORITHM_PUBLIC_HEADERS}
+ ${ALGORITHM_INTERNAL_HEADERS}
+)
+
+absl_header_library(
+ TARGET
+ absl_algorithm
+ EXPORT_NAME
+ algorithm
+)
+
+absl_test(
+ TARGET
+ algorithm_test
+ SOURCES
+ ${ALGORITHM_TEST_SRC}
+ PUBLIC_LIBRARIES
+ absl::algorithm
+)
+
+
+
+
+# test container_test
+set(CONTAINER_TEST_SRC "container_test.cc")
+
+absl_test(
+ TARGET
+ container_test
+ SOURCES
+ ${CONTAINER_TEST_SRC}
+ PUBLIC_LIBRARIES
+ absl::algorithm
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/algorithm.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/algorithm.h b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/algorithm.h
new file mode 100644
index 0000000..3d65864
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/algorithm.h
@@ -0,0 +1,150 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: algorithm.h
+// -----------------------------------------------------------------------------
+//
+// This header file contains Google extensions to the standard <algorithm> C++
+// header.
+
+#ifndef ABSL_ALGORITHM_ALGORITHM_H_
+#define ABSL_ALGORITHM_ALGORITHM_H_
+
+#include <algorithm>
+#include <iterator>
+#include <type_traits>
+
+namespace absl {
+
+namespace algorithm_internal {
+
+// Performs comparisons with operator==, similar to C++14's `std::equal_to<>`.
+struct EqualTo {
+ template <typename T, typename U>
+ bool operator()(const T& a, const U& b) const {
+ return a == b;
+ }
+};
+
+template <typename InputIter1, typename InputIter2, typename Pred>
+bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+ InputIter2 last2, Pred pred, std::input_iterator_tag,
+ std::input_iterator_tag) {
+ while (true) {
+ if (first1 == last1) return first2 == last2;
+ if (first2 == last2) return false;
+ if (!pred(*first1, *first2)) return false;
+ ++first1;
+ ++first2;
+ }
+}
+
+template <typename InputIter1, typename InputIter2, typename Pred>
+bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+ InputIter2 last2, Pred&& pred, std::random_access_iterator_tag,
+ std::random_access_iterator_tag) {
+ return (last1 - first1 == last2 - first2) &&
+ std::equal(first1, last1, first2, std::forward<Pred>(pred));
+}
+
+// When we are using our own internal predicate that just applies operator==, we
+// forward to the non-predicate form of std::equal. This enables an optimization
+// in libstdc++ that can result in std::memcmp being used for integer types.
+template <typename InputIter1, typename InputIter2>
+bool EqualImpl(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+ InputIter2 last2, algorithm_internal::EqualTo /* unused */,
+ std::random_access_iterator_tag,
+ std::random_access_iterator_tag) {
+ return (last1 - first1 == last2 - first2) &&
+ std::equal(first1, last1, first2);
+}
+
+template <typename It>
+It RotateImpl(It first, It middle, It last, std::true_type) {
+ return std::rotate(first, middle, last);
+}
+
+template <typename It>
+It RotateImpl(It first, It middle, It last, std::false_type) {
+ std::rotate(first, middle, last);
+ return std::next(first, std::distance(middle, last));
+}
+
+} // namespace algorithm_internal
+
+// Compares the equality of two ranges specified by pairs of iterators, using
+// the given predicate, returning true iff for each corresponding iterator i1
+// and i2 in the first and second range respectively, pred(*i1, *i2) == true
+//
+// This comparison takes at most min(`last1` - `first1`, `last2` - `first2`)
+// invocations of the predicate. Additionally, if InputIter1 and InputIter2 are
+// both random-access iterators, and `last1` - `first1` != `last2` - `first2`,
+// then the predicate is never invoked and the function returns false.
+//
+// This is a C++11-compatible implementation of C++14 `std::equal`. See
+// http://en.cppreference.com/w/cpp/algorithm/equal for more information.
+template <typename InputIter1, typename InputIter2, typename Pred>
+bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+ InputIter2 last2, Pred&& pred) {
+ return algorithm_internal::EqualImpl(
+ first1, last1, first2, last2, std::forward<Pred>(pred),
+ typename std::iterator_traits<InputIter1>::iterator_category{},
+ typename std::iterator_traits<InputIter2>::iterator_category{});
+}
+
+// Performs comparison of two ranges specified by pairs of iterators using
+// operator==.
+template <typename InputIter1, typename InputIter2>
+bool equal(InputIter1 first1, InputIter1 last1, InputIter2 first2,
+ InputIter2 last2) {
+ return absl::equal(first1, last1, first2, last2,
+ algorithm_internal::EqualTo{});
+}
+
+// Performs a linear search for `value` using the iterator `first` up to
+// but not including `last`, returning true if [`first`, `last`) contains an
+// element equal to `value`.
+//
+// A linear search is of O(n) complexity which is guaranteed to make at most
+// n = (`last` - `first`) comparisons. A linear search over short containers
+// may be faster than a binary search, even when the container is sorted.
+template <typename InputIterator, typename EqualityComparable>
+bool linear_search(InputIterator first, InputIterator last,
+ const EqualityComparable& value) {
+ return std::find(first, last, value) != last;
+}
+
+// Performs a left rotation on a range of elements (`first`, `last`) such that
+// `middle` is now the first element. `rotate()` returns an iterator pointing to
+// the first element before rotation. This function is exactly the same as
+// `std::rotate`, but fixes a bug in gcc
+// <= 4.9 where `std::rotate` returns `void` instead of an iterator.
+//
+// The complexity of this algorithm is the same as that of `std::rotate`, but if
+// `ForwardIterator` is not a random-access iterator, then `absl::rotate`
+// performs an additional pass over the range to construct the return value.
+
+template <typename ForwardIterator>
+ForwardIterator rotate(ForwardIterator first, ForwardIterator middle,
+ ForwardIterator last) {
+ return algorithm_internal::RotateImpl(
+ first, middle, last,
+ std::is_same<decltype(std::rotate(first, middle, last)),
+ ForwardIterator>());
+}
+
+} // namespace absl
+
+#endif // ABSL_ALGORITHM_ALGORITHM_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/algorithm_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/algorithm_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/algorithm_test.cc
new file mode 100644
index 0000000..e4322bc
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/algorithm/algorithm_test.cc
@@ -0,0 +1,182 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/algorithm/algorithm.h"
+
+#include <algorithm>
+#include <list>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+
+namespace {
+
+TEST(EqualTest, DefaultComparisonRandomAccess) {
+ std::vector<int> v1{1, 2, 3};
+ std::vector<int> v2 = v1;
+ std::vector<int> v3 = {1, 2};
+ std::vector<int> v4 = {1, 2, 4};
+
+ EXPECT_TRUE(absl::equal(v1.begin(), v1.end(), v2.begin(), v2.end()));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), v3.begin(), v3.end()));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), v4.begin(), v4.end()));
+}
+
+TEST(EqualTest, DefaultComparison) {
+ std::list<int> lst1{1, 2, 3};
+ std::list<int> lst2 = lst1;
+ std::list<int> lst3{1, 2};
+ std::list<int> lst4{1, 2, 4};
+
+ EXPECT_TRUE(absl::equal(lst1.begin(), lst1.end(), lst2.begin(), lst2.end()));
+ EXPECT_FALSE(absl::equal(lst1.begin(), lst1.end(), lst3.begin(), lst3.end()));
+ EXPECT_FALSE(absl::equal(lst1.begin(), lst1.end(), lst4.begin(), lst4.end()));
+}
+
+TEST(EqualTest, EmptyRange) {
+ std::vector<int> v1{1, 2, 3};
+ std::vector<int> empty1;
+ std::vector<int> empty2;
+
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), empty1.begin(), empty1.end()));
+ EXPECT_FALSE(absl::equal(empty1.begin(), empty1.end(), v1.begin(), v1.end()));
+ EXPECT_TRUE(
+ absl::equal(empty1.begin(), empty1.end(), empty2.begin(), empty2.end()));
+}
+
+TEST(EqualTest, MixedIterTypes) {
+ std::vector<int> v1{1, 2, 3};
+ std::list<int> lst1{v1.begin(), v1.end()};
+ std::list<int> lst2{1, 2, 4};
+ std::list<int> lst3{1, 2};
+
+ EXPECT_TRUE(absl::equal(v1.begin(), v1.end(), lst1.begin(), lst1.end()));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), lst2.begin(), lst2.end()));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), lst3.begin(), lst3.end()));
+}
+
+TEST(EqualTest, MixedValueTypes) {
+ std::vector<int> v1{1, 2, 3};
+ std::vector<char> v2{1, 2, 3};
+ std::vector<char> v3{1, 2};
+ std::vector<char> v4{1, 2, 4};
+
+ EXPECT_TRUE(absl::equal(v1.begin(), v1.end(), v2.begin(), v2.end()));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), v3.begin(), v3.end()));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), v4.begin(), v4.end()));
+}
+
+TEST(EqualTest, WeirdIterators) {
+ std::vector<bool> v1{true, false};
+ std::vector<bool> v2 = v1;
+ std::vector<bool> v3{true};
+ std::vector<bool> v4{true, true, true};
+
+ EXPECT_TRUE(absl::equal(v1.begin(), v1.end(), v2.begin(), v2.end()));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), v3.begin(), v3.end()));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), v4.begin(), v4.end()));
+}
+
+TEST(EqualTest, CustomComparison) {
+ int n[] = {1, 2, 3, 4};
+ std::vector<int*> v1{&n[0], &n[1], &n[2]};
+ std::vector<int*> v2 = v1;
+ std::vector<int*> v3{&n[0], &n[1], &n[3]};
+ std::vector<int*> v4{&n[0], &n[1]};
+
+ auto eq = [](int* a, int* b) { return *a == *b; };
+
+ EXPECT_TRUE(absl::equal(v1.begin(), v1.end(), v2.begin(), v2.end(), eq));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), v3.begin(), v3.end(), eq));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), v4.begin(), v4.end(), eq));
+}
+
+TEST(EqualTest, MoveOnlyPredicate) {
+ std::vector<int> v1{1, 2, 3};
+ std::vector<int> v2{4, 5, 6};
+
+ // move-only equality predicate
+ struct Eq {
+ Eq() = default;
+ Eq(Eq &&) = default;
+ Eq(const Eq &) = delete;
+ Eq &operator=(const Eq &) = delete;
+ bool operator()(const int a, const int b) const { return a == b; }
+ };
+
+ EXPECT_TRUE(absl::equal(v1.begin(), v1.end(), v1.begin(), v1.end(), Eq()));
+ EXPECT_FALSE(absl::equal(v1.begin(), v1.end(), v2.begin(), v2.end(), Eq()));
+}
+
+struct CountingTrivialPred {
+ int* count;
+ bool operator()(int, int) const {
+ ++*count;
+ return true;
+ }
+};
+
+TEST(EqualTest, RandomAccessComplexity) {
+ std::vector<int> v1{1, 1, 3};
+ std::vector<int> v2 = v1;
+ std::vector<int> v3{1, 2};
+
+ do {
+ int count = 0;
+ absl::equal(v1.begin(), v1.end(), v2.begin(), v2.end(),
+ CountingTrivialPred{&count});
+ EXPECT_LE(count, 3);
+ } while (std::next_permutation(v2.begin(), v2.end()));
+
+ int count = 0;
+ absl::equal(v1.begin(), v1.end(), v3.begin(), v3.end(),
+ CountingTrivialPred{&count});
+ EXPECT_EQ(count, 0);
+}
+
+class LinearSearchTest : public testing::Test {
+ protected:
+ LinearSearchTest() : container_{1, 2, 3} {}
+
+ static bool Is3(int n) { return n == 3; }
+ static bool Is4(int n) { return n == 4; }
+
+ std::vector<int> container_;
+};
+
+TEST_F(LinearSearchTest, linear_search) {
+ EXPECT_TRUE(absl::linear_search(container_.begin(), container_.end(), 3));
+ EXPECT_FALSE(absl::linear_search(container_.begin(), container_.end(), 4));
+}
+
+TEST_F(LinearSearchTest, linear_searchConst) {
+ const std::vector<int> *const const_container = &container_;
+ EXPECT_TRUE(
+ absl::linear_search(const_container->begin(), const_container->end(), 3));
+ EXPECT_FALSE(
+ absl::linear_search(const_container->begin(), const_container->end(), 4));
+}
+
+TEST(RotateTest, Rotate) {
+ std::vector<int> v{0, 1, 2, 3, 4};
+ EXPECT_EQ(*absl::rotate(v.begin(), v.begin() + 2, v.end()), 0);
+ EXPECT_THAT(v, testing::ElementsAreArray({2, 3, 4, 0, 1}));
+
+ std::list<int> l{0, 1, 2, 3, 4};
+ EXPECT_EQ(*absl::rotate(l.begin(), std::next(l.begin(), 3), l.end()), 0);
+ EXPECT_THAT(l, testing::ElementsAreArray({3, 4, 0, 1, 2}));
+}
+
+} // namespace
[03/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/span_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/span_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/types/span_test.cc
new file mode 100644
index 0000000..5a4f001
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/span_test.cc
@@ -0,0 +1,781 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/types/span.h"
+
+#include <array>
+#include <initializer_list>
+#include <numeric>
+#include <stdexcept>
+#include <string>
+#include <type_traits>
+#include <vector>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/exception_testing.h"
+#include "absl/container/fixed_array.h"
+#include "absl/container/inlined_vector.h"
+#include "absl/strings/str_cat.h"
+
+namespace {
+
+MATCHER_P(DataIs, data,
+ absl::StrCat("data() is ", negation ? "is " : "isn't ",
+ testing::PrintToString(data))) {
+ return arg.data() == data;
+}
+
+template <typename T>
+auto SpanIs(T data, size_t size)
+ -> decltype(testing::AllOf(DataIs(data), testing::SizeIs(size))) {
+ return testing::AllOf(DataIs(data), testing::SizeIs(size));
+}
+
+template <typename Container>
+auto SpanIs(const Container& c) -> decltype(SpanIs(c.data(), c.size())) {
+ return SpanIs(c.data(), c.size());
+}
+
+std::vector<int> MakeRamp(int len, int offset = 0) {
+ std::vector<int> v(len);
+ std::iota(v.begin(), v.end(), offset);
+ return v;
+}
+
+TEST(IntSpan, EmptyCtors) {
+ absl::Span<int> s;
+ EXPECT_THAT(s, SpanIs(nullptr, 0));
+}
+
+TEST(IntSpan, PtrLenCtor) {
+ int a[] = {1, 2, 3};
+ absl::Span<int> s(&a[0], 2);
+ EXPECT_THAT(s, SpanIs(a, 2));
+}
+
+TEST(IntSpan, ArrayCtor) {
+ int a[] = {1, 2, 3};
+ absl::Span<int> s(a);
+ EXPECT_THAT(s, SpanIs(a, 3));
+
+ EXPECT_TRUE((std::is_constructible<absl::Span<const int>, int[3]>::value));
+ EXPECT_TRUE(
+ (std::is_constructible<absl::Span<const int>, const int[3]>::value));
+ EXPECT_FALSE((std::is_constructible<absl::Span<int>, const int[3]>::value));
+ EXPECT_TRUE((std::is_convertible<int[3], absl::Span<const int>>::value));
+ EXPECT_TRUE(
+ (std::is_convertible<const int[3], absl::Span<const int>>::value));
+}
+
+template <typename T>
+void TakesGenericSpan(absl::Span<T>) {}
+
+TEST(IntSpan, ContainerCtor) {
+ std::vector<int> empty;
+ absl::Span<int> s_empty(empty);
+ EXPECT_THAT(s_empty, SpanIs(empty));
+
+ std::vector<int> filled{1, 2, 3};
+ absl::Span<int> s_filled(filled);
+ EXPECT_THAT(s_filled, SpanIs(filled));
+
+ absl::Span<int> s_from_span(filled);
+ EXPECT_THAT(s_from_span, SpanIs(s_filled));
+
+ absl::Span<const int> const_filled = filled;
+ EXPECT_THAT(const_filled, SpanIs(filled));
+
+ absl::Span<const int> const_from_span = s_filled;
+ EXPECT_THAT(const_from_span, SpanIs(s_filled));
+
+ EXPECT_TRUE(
+ (std::is_convertible<std::vector<int>&, absl::Span<const int>>::value));
+ EXPECT_TRUE(
+ (std::is_convertible<absl::Span<int>&, absl::Span<const int>>::value));
+
+ TakesGenericSpan(absl::Span<int>(filled));
+}
+
+// A struct supplying shallow data() const.
+struct ContainerWithShallowConstData {
+ std::vector<int> storage;
+ int* data() const { return const_cast<int*>(storage.data()); }
+ int size() const { return storage.size(); }
+};
+
+TEST(IntSpan, ShallowConstness) {
+ const ContainerWithShallowConstData c{MakeRamp(20)};
+ absl::Span<int> s(
+ c); // We should be able to do this even though data() is const.
+ s[0] = -1;
+ EXPECT_EQ(c.storage[0], -1);
+}
+
+TEST(CharSpan, StringCtor) {
+ std::string empty = "";
+ absl::Span<char> s_empty(empty);
+ EXPECT_THAT(s_empty, SpanIs(empty));
+
+ std::string abc = "abc";
+ absl::Span<char> s_abc(abc);
+ EXPECT_THAT(s_abc, SpanIs(abc));
+
+ absl::Span<const char> s_const_abc = abc;
+ EXPECT_THAT(s_const_abc, SpanIs(abc));
+
+ EXPECT_FALSE((std::is_constructible<absl::Span<int>, std::string>::value));
+ EXPECT_FALSE((std::is_constructible<absl::Span<const int>, std::string>::value));
+ EXPECT_TRUE((std::is_convertible<std::string, absl::Span<const char>>::value));
+}
+
+TEST(IntSpan, FromConstPointer) {
+ EXPECT_TRUE((std::is_constructible<absl::Span<const int* const>,
+ std::vector<int*>>::value));
+ EXPECT_TRUE((std::is_constructible<absl::Span<const int* const>,
+ std::vector<const int*>>::value));
+ EXPECT_FALSE((
+ std::is_constructible<absl::Span<const int*>, std::vector<int*>>::value));
+ EXPECT_FALSE((
+ std::is_constructible<absl::Span<int*>, std::vector<const int*>>::value));
+}
+
+struct TypeWithMisleadingData {
+ int& data() { return i; }
+ int size() { return 1; }
+ int i;
+};
+
+struct TypeWithMisleadingSize {
+ int* data() { return &i; }
+ const char* size() { return "1"; }
+ int i;
+};
+
+TEST(IntSpan, EvilTypes) {
+ EXPECT_FALSE(
+ (std::is_constructible<absl::Span<int>, TypeWithMisleadingData&>::value));
+ EXPECT_FALSE(
+ (std::is_constructible<absl::Span<int>, TypeWithMisleadingSize&>::value));
+}
+
+struct Base {
+ int* data() { return &i; }
+ int size() { return 1; }
+ int i;
+};
+struct Derived : Base {};
+
+TEST(IntSpan, SpanOfDerived) {
+ EXPECT_TRUE((std::is_constructible<absl::Span<int>, Base&>::value));
+ EXPECT_TRUE((std::is_constructible<absl::Span<int>, Derived&>::value));
+ EXPECT_FALSE(
+ (std::is_constructible<absl::Span<Base>, std::vector<Derived>>::value));
+}
+
+void TestInitializerList(absl::Span<const int> s, const std::vector<int>& v) {
+ EXPECT_TRUE(absl::equal(s.begin(), s.end(), v.begin(), v.end()));
+}
+
+TEST(ConstIntSpan, InitializerListConversion) {
+ TestInitializerList({}, {});
+ TestInitializerList({1}, {1});
+ TestInitializerList({1, 2, 3}, {1, 2, 3});
+
+ EXPECT_FALSE((std::is_constructible<absl::Span<int>,
+ std::initializer_list<int>>::value));
+ EXPECT_FALSE((
+ std::is_convertible<absl::Span<int>, std::initializer_list<int>>::value));
+}
+
+TEST(IntSpan, Data) {
+ int i;
+ absl::Span<int> s(&i, 1);
+ EXPECT_EQ(&i, s.data());
+}
+
+TEST(IntSpan, SizeLengthEmpty) {
+ absl::Span<int> empty;
+ EXPECT_EQ(empty.size(), 0);
+ EXPECT_TRUE(empty.empty());
+ EXPECT_EQ(empty.size(), empty.length());
+
+ auto v = MakeRamp(10);
+ absl::Span<int> s(v);
+ EXPECT_EQ(s.size(), 10);
+ EXPECT_FALSE(s.empty());
+ EXPECT_EQ(s.size(), s.length());
+}
+
+TEST(IntSpan, ElementAccess) {
+ auto v = MakeRamp(10);
+ absl::Span<int> s(v);
+ for (int i = 0; i < s.size(); ++i) {
+ EXPECT_EQ(s[i], s.at(i));
+ }
+
+ EXPECT_EQ(s.front(), s[0]);
+ EXPECT_EQ(s.back(), s[9]);
+}
+
+TEST(IntSpan, AtThrows) {
+ auto v = MakeRamp(10);
+ absl::Span<int> s(v);
+
+ EXPECT_EQ(s.at(9), 9);
+ ABSL_BASE_INTERNAL_EXPECT_FAIL(s.at(10), std::out_of_range,
+ "failed bounds check");
+}
+
+TEST(IntSpan, RemovePrefixAndSuffix) {
+ auto v = MakeRamp(20, 1);
+ absl::Span<int> s(v);
+ EXPECT_EQ(s.size(), 20);
+
+ s.remove_suffix(0);
+ s.remove_prefix(0);
+ EXPECT_EQ(s.size(), 20);
+
+ s.remove_prefix(1);
+ EXPECT_EQ(s.size(), 19);
+ EXPECT_EQ(s[0], 2);
+
+ s.remove_suffix(1);
+ EXPECT_EQ(s.size(), 18);
+ EXPECT_EQ(s.back(), 19);
+
+ s.remove_prefix(7);
+ EXPECT_EQ(s.size(), 11);
+ EXPECT_EQ(s[0], 9);
+
+ s.remove_suffix(11);
+ EXPECT_EQ(s.size(), 0);
+
+ EXPECT_EQ(v, MakeRamp(20, 1));
+}
+
+TEST(IntSpan, Subspan) {
+ std::vector<int> empty;
+ EXPECT_EQ(absl::MakeSpan(empty).subspan(), empty);
+ EXPECT_THAT(absl::MakeSpan(empty).subspan(0, 0), SpanIs(empty));
+ EXPECT_THAT(absl::MakeSpan(empty).subspan(0, absl::Span<const int>::npos),
+ SpanIs(empty));
+
+ auto ramp = MakeRamp(10);
+ EXPECT_THAT(absl::MakeSpan(ramp).subspan(), SpanIs(ramp));
+ EXPECT_THAT(absl::MakeSpan(ramp).subspan(0, 10), SpanIs(ramp));
+ EXPECT_THAT(absl::MakeSpan(ramp).subspan(0, absl::Span<const int>::npos),
+ SpanIs(ramp));
+ EXPECT_THAT(absl::MakeSpan(ramp).subspan(0, 3), SpanIs(ramp.data(), 3));
+ EXPECT_THAT(absl::MakeSpan(ramp).subspan(5, absl::Span<const int>::npos),
+ SpanIs(ramp.data() + 5, 5));
+ EXPECT_THAT(absl::MakeSpan(ramp).subspan(3, 3), SpanIs(ramp.data() + 3, 3));
+ EXPECT_THAT(absl::MakeSpan(ramp).subspan(10, 5), SpanIs(ramp.data() + 10, 0));
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+ EXPECT_THROW(absl::MakeSpan(ramp).subspan(11, 5), std::out_of_range);
+#else
+ EXPECT_DEATH(absl::MakeSpan(ramp).subspan(11, 5), "");
+#endif
+}
+
+TEST(IntSpan, MakeSpanPtrLength) {
+ std::vector<int> empty;
+ auto s_empty = absl::MakeSpan(empty.data(), empty.size());
+ EXPECT_THAT(s_empty, SpanIs(empty));
+
+ std::array<int, 3> a{{1, 2, 3}};
+ auto s = absl::MakeSpan(a.data(), a.size());
+ EXPECT_THAT(s, SpanIs(a));
+
+ EXPECT_THAT(absl::MakeConstSpan(empty.data(), empty.size()), SpanIs(s_empty));
+ EXPECT_THAT(absl::MakeConstSpan(a.data(), a.size()), SpanIs(s));
+}
+
+TEST(IntSpan, MakeSpanTwoPtrs) {
+ std::vector<int> empty;
+ auto s_empty = absl::MakeSpan(empty.data(), empty.data());
+ EXPECT_THAT(s_empty, SpanIs(empty));
+
+ std::vector<int> v{1, 2, 3};
+ auto s = absl::MakeSpan(v.data(), v.data() + 1);
+ EXPECT_THAT(s, SpanIs(v.data(), 1));
+
+ EXPECT_THAT(absl::MakeConstSpan(empty.data(), empty.data()), SpanIs(s_empty));
+ EXPECT_THAT(absl::MakeConstSpan(v.data(), v.data() + 1), SpanIs(s));
+}
+
+TEST(IntSpan, MakeSpanContainer) {
+ std::vector<int> empty;
+ auto s_empty = absl::MakeSpan(empty);
+ EXPECT_THAT(s_empty, SpanIs(empty));
+
+ std::vector<int> v{1, 2, 3};
+ auto s = absl::MakeSpan(v);
+ EXPECT_THAT(s, SpanIs(v));
+
+ EXPECT_THAT(absl::MakeConstSpan(empty), SpanIs(s_empty));
+ EXPECT_THAT(absl::MakeConstSpan(v), SpanIs(s));
+
+ EXPECT_THAT(absl::MakeSpan(s), SpanIs(s));
+ EXPECT_THAT(absl::MakeConstSpan(s), SpanIs(s));
+}
+
+TEST(CharSpan, MakeSpanString) {
+ std::string empty = "";
+ auto s_empty = absl::MakeSpan(empty);
+ EXPECT_THAT(s_empty, SpanIs(empty));
+
+ std::string str = "abc";
+ auto s_str = absl::MakeSpan(str);
+ EXPECT_THAT(s_str, SpanIs(str));
+
+ EXPECT_THAT(absl::MakeConstSpan(empty), SpanIs(s_empty));
+ EXPECT_THAT(absl::MakeConstSpan(str), SpanIs(s_str));
+}
+
+TEST(IntSpan, MakeSpanArray) {
+ int a[] = {1, 2, 3};
+ auto s = absl::MakeSpan(a);
+ EXPECT_THAT(s, SpanIs(a, 3));
+
+ const int ca[] = {1, 2, 3};
+ auto s_ca = absl::MakeSpan(ca);
+ EXPECT_THAT(s_ca, SpanIs(ca, 3));
+
+ EXPECT_THAT(absl::MakeConstSpan(a), SpanIs(s));
+ EXPECT_THAT(absl::MakeConstSpan(ca), SpanIs(s_ca));
+}
+
+// Compile-asserts that the argument has the expected decayed type.
+template <typename Expected, typename T>
+void CheckType(const T& /* value */) {
+ testing::StaticAssertTypeEq<Expected, T>();
+}
+
+TEST(IntSpan, MakeSpanTypes) {
+ std::vector<int> vec;
+ const std::vector<int> cvec;
+ int a[1];
+ const int ca[] = {1};
+ int* ip = a;
+ const int* cip = ca;
+ std::string s = "";
+ const std::string cs = "";
+ CheckType<absl::Span<int>>(absl::MakeSpan(vec));
+ CheckType<absl::Span<const int>>(absl::MakeSpan(cvec));
+ CheckType<absl::Span<int>>(absl::MakeSpan(ip, ip + 1));
+ CheckType<absl::Span<int>>(absl::MakeSpan(ip, 1));
+ CheckType<absl::Span<const int>>(absl::MakeSpan(cip, cip + 1));
+ CheckType<absl::Span<const int>>(absl::MakeSpan(cip, 1));
+ CheckType<absl::Span<int>>(absl::MakeSpan(a));
+ CheckType<absl::Span<int>>(absl::MakeSpan(a, a + 1));
+ CheckType<absl::Span<int>>(absl::MakeSpan(a, 1));
+ CheckType<absl::Span<const int>>(absl::MakeSpan(ca));
+ CheckType<absl::Span<const int>>(absl::MakeSpan(ca, ca + 1));
+ CheckType<absl::Span<const int>>(absl::MakeSpan(ca, 1));
+ CheckType<absl::Span<char>>(absl::MakeSpan(s));
+ CheckType<absl::Span<const char>>(absl::MakeSpan(cs));
+}
+
+TEST(ConstIntSpan, MakeConstSpanTypes) {
+ std::vector<int> vec;
+ const std::vector<int> cvec;
+ int array[1];
+ const int carray[] = {0};
+ int* ptr = array;
+ const int* cptr = carray;
+ std::string s = "";
+ std::string cs = "";
+ CheckType<absl::Span<const int>>(absl::MakeConstSpan(vec));
+ CheckType<absl::Span<const int>>(absl::MakeConstSpan(cvec));
+ CheckType<absl::Span<const int>>(absl::MakeConstSpan(ptr, ptr + 1));
+ CheckType<absl::Span<const int>>(absl::MakeConstSpan(ptr, 1));
+ CheckType<absl::Span<const int>>(absl::MakeConstSpan(cptr, cptr + 1));
+ CheckType<absl::Span<const int>>(absl::MakeConstSpan(cptr, 1));
+ CheckType<absl::Span<const int>>(absl::MakeConstSpan(array));
+ CheckType<absl::Span<const int>>(absl::MakeConstSpan(carray));
+ CheckType<absl::Span<const char>>(absl::MakeConstSpan(s));
+ CheckType<absl::Span<const char>>(absl::MakeConstSpan(cs));
+}
+
+TEST(IntSpan, Equality) {
+ const int arr1[] = {1, 2, 3, 4, 5};
+ int arr2[] = {1, 2, 3, 4, 5};
+ std::vector<int> vec1(std::begin(arr1), std::end(arr1));
+ std::vector<int> vec2 = vec1;
+ std::vector<int> other_vec = {2, 4, 6, 8, 10};
+ // These two slices are from different vectors, but have the same size and
+ // have the same elements (right now). They should compare equal. Test both
+ // == and !=.
+ const absl::Span<const int> from1 = vec1;
+ const absl::Span<const int> from2 = vec2;
+ EXPECT_EQ(from1, from1);
+ EXPECT_FALSE(from1 != from1);
+ EXPECT_EQ(from1, from2);
+ EXPECT_FALSE(from1 != from2);
+
+ // These two slices have different underlying vector values. They should be
+ // considered not equal. Test both == and !=.
+ const absl::Span<const int> from_other = other_vec;
+ EXPECT_NE(from1, from_other);
+ EXPECT_FALSE(from1 == from_other);
+
+ // Comparison between a vector and its slice should be equal. And vice-versa.
+ // This ensures implicit conversion to Span works on both sides of ==.
+ EXPECT_EQ(vec1, from1);
+ EXPECT_FALSE(vec1 != from1);
+ EXPECT_EQ(from1, vec1);
+ EXPECT_FALSE(from1 != vec1);
+
+ // This verifies that absl::Span<T> can be compared freely with
+ // absl::Span<const T>.
+ const absl::Span<int> mutable_from1(vec1);
+ const absl::Span<int> mutable_from2(vec2);
+ EXPECT_EQ(from1, mutable_from1);
+ EXPECT_EQ(mutable_from1, from1);
+ EXPECT_EQ(mutable_from1, mutable_from2);
+ EXPECT_EQ(mutable_from2, mutable_from1);
+
+ // Comparison between a vector and its slice should be equal for mutable
+ // Spans as well.
+ EXPECT_EQ(vec1, mutable_from1);
+ EXPECT_FALSE(vec1 != mutable_from1);
+ EXPECT_EQ(mutable_from1, vec1);
+ EXPECT_FALSE(mutable_from1 != vec1);
+
+ // Comparison between convertible-to-Span-of-const and Span-of-mutable. Arrays
+ // are used because they're the only value type which converts to a
+ // Span-of-mutable. EXPECT_TRUE is used instead of EXPECT_EQ to avoid
+ // array-to-pointer decay.
+ EXPECT_TRUE(arr1 == mutable_from1);
+ EXPECT_FALSE(arr1 != mutable_from1);
+ EXPECT_TRUE(mutable_from1 == arr1);
+ EXPECT_FALSE(mutable_from1 != arr1);
+
+ // Comparison between convertible-to-Span-of-mutable and Span-of-const
+ EXPECT_TRUE(arr2 == from1);
+ EXPECT_FALSE(arr2 != from1);
+ EXPECT_TRUE(from1 == arr2);
+ EXPECT_FALSE(from1 != arr2);
+
+ // With a different size, the array slices should not be equal.
+ EXPECT_NE(from1, absl::Span<const int>(from1).subspan(0, from1.size() - 1));
+
+ // With different contents, the array slices should not be equal.
+ ++vec2.back();
+ EXPECT_NE(from1, from2);
+}
+
+class IntSpanOrderComparisonTest : public testing::Test {
+ public:
+ IntSpanOrderComparisonTest()
+ : arr_before_{1, 2, 3},
+ arr_after_{1, 2, 4},
+ carr_after_{1, 2, 4},
+ vec_before_(std::begin(arr_before_), std::end(arr_before_)),
+ vec_after_(std::begin(arr_after_), std::end(arr_after_)),
+ before_(vec_before_),
+ after_(vec_after_),
+ cbefore_(vec_before_),
+ cafter_(vec_after_) {}
+
+ protected:
+ int arr_before_[3], arr_after_[3];
+ const int carr_after_[3];
+ std::vector<int> vec_before_, vec_after_;
+ absl::Span<int> before_, after_;
+ absl::Span<const int> cbefore_, cafter_;
+};
+
+TEST_F(IntSpanOrderComparisonTest, CompareSpans) {
+ EXPECT_TRUE(cbefore_ < cafter_);
+ EXPECT_TRUE(cbefore_ <= cafter_);
+ EXPECT_TRUE(cafter_ > cbefore_);
+ EXPECT_TRUE(cafter_ >= cbefore_);
+
+ EXPECT_FALSE(cbefore_ > cafter_);
+ EXPECT_FALSE(cafter_ < cbefore_);
+
+ EXPECT_TRUE(before_ < after_);
+ EXPECT_TRUE(before_ <= after_);
+ EXPECT_TRUE(after_ > before_);
+ EXPECT_TRUE(after_ >= before_);
+
+ EXPECT_FALSE(before_ > after_);
+ EXPECT_FALSE(after_ < before_);
+
+ EXPECT_TRUE(cbefore_ < after_);
+ EXPECT_TRUE(cbefore_ <= after_);
+ EXPECT_TRUE(after_ > cbefore_);
+ EXPECT_TRUE(after_ >= cbefore_);
+
+ EXPECT_FALSE(cbefore_ > after_);
+ EXPECT_FALSE(after_ < cbefore_);
+}
+
+TEST_F(IntSpanOrderComparisonTest, SpanOfConstAndContainer) {
+ EXPECT_TRUE(cbefore_ < vec_after_);
+ EXPECT_TRUE(cbefore_ <= vec_after_);
+ EXPECT_TRUE(vec_after_ > cbefore_);
+ EXPECT_TRUE(vec_after_ >= cbefore_);
+
+ EXPECT_FALSE(cbefore_ > vec_after_);
+ EXPECT_FALSE(vec_after_ < cbefore_);
+
+ EXPECT_TRUE(arr_before_ < cafter_);
+ EXPECT_TRUE(arr_before_ <= cafter_);
+ EXPECT_TRUE(cafter_ > arr_before_);
+ EXPECT_TRUE(cafter_ >= arr_before_);
+
+ EXPECT_FALSE(arr_before_ > cafter_);
+ EXPECT_FALSE(cafter_ < arr_before_);
+}
+
+TEST_F(IntSpanOrderComparisonTest, SpanOfMutableAndContainer) {
+ EXPECT_TRUE(vec_before_ < after_);
+ EXPECT_TRUE(vec_before_ <= after_);
+ EXPECT_TRUE(after_ > vec_before_);
+ EXPECT_TRUE(after_ >= vec_before_);
+
+ EXPECT_FALSE(vec_before_ > after_);
+ EXPECT_FALSE(after_ < vec_before_);
+
+ EXPECT_TRUE(before_ < carr_after_);
+ EXPECT_TRUE(before_ <= carr_after_);
+ EXPECT_TRUE(carr_after_ > before_);
+ EXPECT_TRUE(carr_after_ >= before_);
+
+ EXPECT_FALSE(before_ > carr_after_);
+ EXPECT_FALSE(carr_after_ < before_);
+}
+
+TEST_F(IntSpanOrderComparisonTest, EqualSpans) {
+ EXPECT_FALSE(before_ < before_);
+ EXPECT_TRUE(before_ <= before_);
+ EXPECT_FALSE(before_ > before_);
+ EXPECT_TRUE(before_ >= before_);
+}
+
+TEST_F(IntSpanOrderComparisonTest, Subspans) {
+ auto subspan = before_.subspan(0, 1);
+ EXPECT_TRUE(subspan < before_);
+ EXPECT_TRUE(subspan <= before_);
+ EXPECT_TRUE(before_ > subspan);
+ EXPECT_TRUE(before_ >= subspan);
+
+ EXPECT_FALSE(subspan > before_);
+ EXPECT_FALSE(before_ < subspan);
+}
+
+TEST_F(IntSpanOrderComparisonTest, EmptySpans) {
+ absl::Span<int> empty;
+ EXPECT_FALSE(empty < empty);
+ EXPECT_TRUE(empty <= empty);
+ EXPECT_FALSE(empty > empty);
+ EXPECT_TRUE(empty >= empty);
+
+ EXPECT_TRUE(empty < before_);
+ EXPECT_TRUE(empty <= before_);
+ EXPECT_TRUE(before_ > empty);
+ EXPECT_TRUE(before_ >= empty);
+
+ EXPECT_FALSE(empty > before_);
+ EXPECT_FALSE(before_ < empty);
+}
+
+TEST(IntSpan, ExposesContainerTypesAndConsts) {
+ absl::Span<int> slice;
+ CheckType<absl::Span<int>::iterator>(slice.begin());
+ EXPECT_TRUE((std::is_convertible<decltype(slice.begin()),
+ absl::Span<int>::const_iterator>::value));
+ CheckType<absl::Span<int>::const_iterator>(slice.cbegin());
+ EXPECT_TRUE((std::is_convertible<decltype(slice.end()),
+ absl::Span<int>::const_iterator>::value));
+ CheckType<absl::Span<int>::const_iterator>(slice.cend());
+ CheckType<absl::Span<int>::reverse_iterator>(slice.rend());
+ EXPECT_TRUE(
+ (std::is_convertible<decltype(slice.rend()),
+ absl::Span<int>::const_reverse_iterator>::value));
+ CheckType<absl::Span<int>::const_reverse_iterator>(slice.crend());
+ testing::StaticAssertTypeEq<int, absl::Span<int>::value_type>();
+ testing::StaticAssertTypeEq<int, absl::Span<const int>::value_type>();
+ testing::StaticAssertTypeEq<int*, absl::Span<int>::pointer>();
+ testing::StaticAssertTypeEq<const int*, absl::Span<const int>::pointer>();
+ testing::StaticAssertTypeEq<int&, absl::Span<int>::reference>();
+ testing::StaticAssertTypeEq<const int&, absl::Span<const int>::reference>();
+ testing::StaticAssertTypeEq<const int&, absl::Span<int>::const_reference>();
+ testing::StaticAssertTypeEq<const int&,
+ absl::Span<const int>::const_reference>();
+ EXPECT_EQ(static_cast<absl::Span<int>::size_type>(-1), absl::Span<int>::npos);
+}
+
+TEST(IntSpan, IteratorsAndReferences) {
+ auto accept_pointer = [](int*) {};
+ auto accept_reference = [](int&) {};
+ auto accept_iterator = [](absl::Span<int>::iterator) {};
+ auto accept_const_iterator = [](absl::Span<int>::const_iterator) {};
+ auto accept_reverse_iterator = [](absl::Span<int>::reverse_iterator) {};
+ auto accept_const_reverse_iterator =
+ [](absl::Span<int>::const_reverse_iterator) {};
+
+ int a[1];
+ absl::Span<int> s = a;
+
+ accept_pointer(s.data());
+ accept_iterator(s.begin());
+ accept_const_iterator(s.begin());
+ accept_const_iterator(s.cbegin());
+ accept_iterator(s.end());
+ accept_const_iterator(s.end());
+ accept_const_iterator(s.cend());
+ accept_reverse_iterator(s.rbegin());
+ accept_const_reverse_iterator(s.rbegin());
+ accept_const_reverse_iterator(s.crbegin());
+ accept_reverse_iterator(s.rend());
+ accept_const_reverse_iterator(s.rend());
+ accept_const_reverse_iterator(s.crend());
+
+ accept_reference(s[0]);
+ accept_reference(s.at(0));
+ accept_reference(s.front());
+ accept_reference(s.back());
+}
+
+TEST(IntSpan, IteratorsAndReferences_Const) {
+ auto accept_pointer = [](int*) {};
+ auto accept_reference = [](int&) {};
+ auto accept_iterator = [](absl::Span<int>::iterator) {};
+ auto accept_const_iterator = [](absl::Span<int>::const_iterator) {};
+ auto accept_reverse_iterator = [](absl::Span<int>::reverse_iterator) {};
+ auto accept_const_reverse_iterator =
+ [](absl::Span<int>::const_reverse_iterator) {};
+
+ int a[1];
+ const absl::Span<int> s = a;
+
+ accept_pointer(s.data());
+ accept_iterator(s.begin());
+ accept_const_iterator(s.begin());
+ accept_const_iterator(s.cbegin());
+ accept_iterator(s.end());
+ accept_const_iterator(s.end());
+ accept_const_iterator(s.cend());
+ accept_reverse_iterator(s.rbegin());
+ accept_const_reverse_iterator(s.rbegin());
+ accept_const_reverse_iterator(s.crbegin());
+ accept_reverse_iterator(s.rend());
+ accept_const_reverse_iterator(s.rend());
+ accept_const_reverse_iterator(s.crend());
+
+ accept_reference(s[0]);
+ accept_reference(s.at(0));
+ accept_reference(s.front());
+ accept_reference(s.back());
+}
+
+TEST(IntSpan, NoexceptTest) {
+ int a[] = {1, 2, 3};
+ std::vector<int> v;
+ EXPECT_TRUE(noexcept(absl::Span<const int>()));
+ EXPECT_TRUE(noexcept(absl::Span<const int>(a, 2)));
+ EXPECT_TRUE(noexcept(absl::Span<const int>(a)));
+ EXPECT_TRUE(noexcept(absl::Span<const int>(v)));
+ EXPECT_TRUE(noexcept(absl::Span<int>(v)));
+ EXPECT_TRUE(noexcept(absl::Span<const int>({1, 2, 3})));
+ EXPECT_TRUE(noexcept(absl::MakeSpan(v)));
+ EXPECT_TRUE(noexcept(absl::MakeSpan(a)));
+ EXPECT_TRUE(noexcept(absl::MakeSpan(a, 2)));
+ EXPECT_TRUE(noexcept(absl::MakeSpan(a, a + 1)));
+ EXPECT_TRUE(noexcept(absl::MakeConstSpan(v)));
+ EXPECT_TRUE(noexcept(absl::MakeConstSpan(a)));
+ EXPECT_TRUE(noexcept(absl::MakeConstSpan(a, 2)));
+ EXPECT_TRUE(noexcept(absl::MakeConstSpan(a, a + 1)));
+
+ absl::Span<int> s(v);
+ EXPECT_TRUE(noexcept(s.data()));
+ EXPECT_TRUE(noexcept(s.size()));
+ EXPECT_TRUE(noexcept(s.length()));
+ EXPECT_TRUE(noexcept(s.empty()));
+ EXPECT_TRUE(noexcept(s[0]));
+ EXPECT_TRUE(noexcept(s.front()));
+ EXPECT_TRUE(noexcept(s.back()));
+ EXPECT_TRUE(noexcept(s.begin()));
+ EXPECT_TRUE(noexcept(s.cbegin()));
+ EXPECT_TRUE(noexcept(s.end()));
+ EXPECT_TRUE(noexcept(s.cend()));
+ EXPECT_TRUE(noexcept(s.rbegin()));
+ EXPECT_TRUE(noexcept(s.crbegin()));
+ EXPECT_TRUE(noexcept(s.rend()));
+ EXPECT_TRUE(noexcept(s.crend()));
+ EXPECT_TRUE(noexcept(s.remove_prefix(0)));
+ EXPECT_TRUE(noexcept(s.remove_suffix(0)));
+}
+
+// ConstexprTester exercises expressions in a constexpr context. Simply placing
+// the expression in a constexpr function is not enough, as some compilers will
+// simply compile the constexpr function as runtime code. Using template
+// parameters forces compile-time execution.
+template <int i>
+struct ConstexprTester {};
+
+#define ABSL_TEST_CONSTEXPR(expr) \
+ do { \
+ ABSL_ATTRIBUTE_UNUSED ConstexprTester<(expr, 1)> t; \
+ } while (0)
+
+struct ContainerWithConstexprMethods {
+ constexpr int size() const { return 1; }
+ constexpr const int* data() const { return &i; }
+ const int i;
+};
+
+TEST(ConstIntSpan, ConstexprTest) {
+ static constexpr int a[] = {1, 2, 3};
+ static constexpr int sized_arr[2] = {1, 2};
+ static constexpr ContainerWithConstexprMethods c{1};
+ ABSL_TEST_CONSTEXPR(absl::Span<const int>());
+ ABSL_TEST_CONSTEXPR(absl::Span<const int>(a, 2));
+ ABSL_TEST_CONSTEXPR(absl::Span<const int>(sized_arr));
+ ABSL_TEST_CONSTEXPR(absl::Span<const int>(c));
+ ABSL_TEST_CONSTEXPR(absl::MakeSpan(&a[0], 1));
+ ABSL_TEST_CONSTEXPR(absl::MakeSpan(c));
+ ABSL_TEST_CONSTEXPR(absl::MakeSpan(a));
+ ABSL_TEST_CONSTEXPR(absl::MakeConstSpan(&a[0], 1));
+ ABSL_TEST_CONSTEXPR(absl::MakeConstSpan(c));
+ ABSL_TEST_CONSTEXPR(absl::MakeConstSpan(a));
+
+ constexpr absl::Span<const int> span = c;
+ ABSL_TEST_CONSTEXPR(span.data());
+ ABSL_TEST_CONSTEXPR(span.size());
+ ABSL_TEST_CONSTEXPR(span.length());
+ ABSL_TEST_CONSTEXPR(span.empty());
+ ABSL_TEST_CONSTEXPR(span.begin());
+ ABSL_TEST_CONSTEXPR(span.cbegin());
+ ABSL_TEST_CONSTEXPR(span.subspan(0, 0));
+ ABSL_TEST_CONSTEXPR(span[0]);
+}
+
+struct BigStruct {
+ char bytes[10000];
+};
+
+TEST(Span, SpanSize) {
+ EXPECT_LE(sizeof(absl::Span<int>), 2 * sizeof(void*));
+ EXPECT_LE(sizeof(absl::Span<BigStruct>), 2 * sizeof(void*));
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/variant.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/variant.h b/libraries/ostrich/backend/3rdparty/abseil/absl/types/variant.h
new file mode 100644
index 0000000..52a311e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/variant.h
@@ -0,0 +1,838 @@
+// Copyright 2018 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// variant.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines an `absl::variant` type for holding a type-safe
+// value of some prescribed set of types (noted as alternative types), and
+// associated functions for managing variants.
+//
+// The `absl::variant` type is a form of type-safe union. An `absl::variant`
+// should always hold a value of one of its alternative types (except in the
+// "valueless by exception state" -- see below). A default-constructed
+// `absl::variant` will hold the value of its first alternative type, provided
+// it is default-constructable.
+//
+// In exceptional cases due to error, an `absl::variant` can hold no
+// value (known as a "valueless by exception" state), though this is not the
+// norm.
+//
+// As with `absl::optional`, an `absl::variant` -- when it holds a value --
+// allocates a value of that type directly within the `variant` itself; it
+// cannot hold a reference, array, or the type `void`; it can, however, hold a
+// pointer to externally managed memory.
+//
+// `absl::variant` is a C++11 compatible version of the C++17 `std::variant`
+// abstraction and is designed to be a drop-in replacement for code compliant
+// with C++17.
+
+#ifndef ABSL_TYPES_VARIANT_H_
+#define ABSL_TYPES_VARIANT_H_
+
+#include "absl/base/config.h"
+#include "absl/utility/utility.h"
+
+#ifdef ABSL_HAVE_STD_VARIANT
+
+#include <variant>
+
+namespace absl {
+using std::bad_variant_access;
+using std::get;
+using std::get_if;
+using std::holds_alternative;
+using std::monostate;
+using std::variant;
+using std::variant_alternative;
+using std::variant_alternative_t;
+using std::variant_npos;
+using std::variant_size;
+using std::variant_size_v;
+using std::visit;
+} // namespace absl
+
+#else // ABSL_HAVE_STD_VARIANT
+
+#include <functional>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/meta/type_traits.h"
+#include "absl/types/internal/variant.h"
+
+namespace absl {
+
+// -----------------------------------------------------------------------------
+// absl::variant
+// -----------------------------------------------------------------------------
+//
+// An 'absl::variant` type is a form of type-safe union. An `absl::variant` --
+// except in exceptional cases -- always holds a value of one of its alternative
+// types.
+//
+// Example:
+//
+// // Construct a variant that holds either an integer or a std::string and
+// // assign it to a std::string.
+// absl::variant<int, std::string> v = std::string("abc");
+//
+// // A default-contructed variant will hold a value-initialized value of
+// // the first alternative type.
+// auto a = absl::variant<int, std::string>(); // Holds an int of value '0'.
+//
+// // variants are assignable.
+//
+// // copy assignment
+// auto v1 = absl::variant<int, std::string>("abc");
+// auto v2 = absl::variant<int, std::string>(10);
+// v2 = v1; // copy assign
+//
+// // move assignment
+// auto v1 = absl::variant<int, std::string>("abc");
+// v1 = absl::variant<int, std::string>(10);
+//
+// // assignment through type conversion
+// a = 128; // variant contains int
+// a = "128"; // variant contains std::string
+//
+// An `absl::variant` holding a value of one of its alternative types `T` holds
+// an allocation of `T` directly within the variant itself. An `absl::variant`
+// is not allowed to allocate additional storage, such as dynamic memory, to
+// allocate the contained value. The contained value shall be allocated in a
+// region of the variant storage suitably aligned for all alternative types.
+template <typename... Ts>
+class variant;
+
+// swap()
+//
+// Swaps two `absl::variant` values. This function is equivalent to `v.swap(w)`
+// where `v` and `w` are `absl::variant` types.
+//
+// Note that this function requires all alternative types to be both swappable
+// and move-constructible, because any two variants may refer to either the same
+// type (in which case, they will be swapped) or to two different types (in
+// which case the values will need to be moved).
+//
+template <typename... Ts>
+void swap(variant<Ts...>& v, variant<Ts...>& w) noexcept(noexcept(v.swap(w))) {
+ v.swap(w);
+}
+
+// variant_size
+//
+// Returns the number of alterative types available for a given `absl::variant`
+// type as a compile-time constant expression. As this is a class template, it
+// is not generally useful for accessing the number of alternative types of
+// any given `absl::variant` instance.
+//
+// Example:
+//
+// auto a = absl::variant<int, std::string>;
+// constexpr int num_types =
+// absl::variant_size<absl::variant<int, std::string>>();
+//
+// // You can also use the member constant `value`.
+// constexpr int num_types =
+// absl::variant_size<absl::variant<int, std::string>>::value;
+//
+// // `absl::variant_size` is more valuable for use in generic code:
+// template <typename Variant>
+// constexpr bool IsVariantMultivalue() {
+// return absl::variant_size<Variant>() > 1;
+// }
+//
+// Note that the set of cv-qualified specializations of `variant_size` are
+// provided to ensure that those specializations compile (especially when passed
+// within template logic).
+template <class T>
+struct variant_size;
+
+template <class... Ts>
+struct variant_size<variant<Ts...>>
+ : std::integral_constant<std::size_t, sizeof...(Ts)> {};
+
+// Specialization of `variant_size` for const qualified variants.
+template <class T>
+struct variant_size<const T> : variant_size<T>::type {};
+
+// Specialization of `variant_size` for volatile qualified variants.
+template <class T>
+struct variant_size<volatile T> : variant_size<T>::type {};
+
+// Specialization of `variant_size` for const volatile qualified variants.
+template <class T>
+struct variant_size<const volatile T> : variant_size<T>::type {};
+
+// variant_alternative
+//
+// Returns the alternative type for a given `absl::variant` at the passed
+// index value as a compile-time constant expression. As this is a class
+// template resulting in a type, it is not useful for access of the run-time
+// value of any given `absl::variant` variable.
+//
+// Example:
+//
+// // The type of the 0th alternative is "int".
+// using alternative_type_0
+// = absl::variant_alternative<0, absl::variant<int, std::string>>::type;
+//
+// static_assert(std::is_same<alternative_type_0, int>::value, "");
+//
+// // `absl::variant_alternative` is more valuable for use in generic code:
+// template <typename Variant>
+// constexpr bool IsFirstElementTrivial() {
+// return std::is_trivial_v<variant_alternative<0, Variant>::type>;
+// }
+//
+// Note that the set of cv-qualified specializations of `variant_alternative`
+// are provided to ensure that those specializations compile (especially when
+// passed within template logic).
+template <std::size_t I, class T>
+struct variant_alternative;
+
+template <std::size_t I, class... Types>
+struct variant_alternative<I, variant<Types...>> {
+ using type =
+ variant_internal::VariantAlternativeSfinaeT<I, variant<Types...>>;
+};
+
+// Specialization of `variant_alternative` for const qualified variants.
+template <std::size_t I, class T>
+struct variant_alternative<I, const T> {
+ using type = const typename variant_alternative<I, T>::type;
+};
+
+// Specialization of `variant_alternative` for volatile qualified variants.
+template <std::size_t I, class T>
+struct variant_alternative<I, volatile T> {
+ using type = volatile typename variant_alternative<I, T>::type;
+};
+
+// Specialization of `variant_alternative` for const volatile qualified
+// variants.
+template <std::size_t I, class T>
+struct variant_alternative<I, const volatile T> {
+ using type = const volatile typename variant_alternative<I, T>::type;
+};
+
+// Template type alias for variant_alternative<I, T>::type.
+//
+// Example:
+//
+// using alternative_type_0
+// = absl::variant_alternative_t<0, absl::variant<int, std::string>>;
+// static_assert(std::is_same<alternative_type_0, int>::value, "");
+template <std::size_t I, class T>
+using variant_alternative_t = typename variant_alternative<I, T>::type;
+
+// holds_alternative()
+//
+// Checks whether the given variant currently holds a given alternative type,
+// returning `true` if so.
+//
+// Example:
+//
+// absl::variant<int, std::string> bar = 42;
+// if (absl::holds_alternative<int>(foo)) {
+// std::cout << "The variant holds an integer";
+// }
+template <class T, class... Types>
+constexpr bool holds_alternative(const variant<Types...>& v) noexcept {
+ static_assert(
+ variant_internal::UnambiguousIndexOfImpl<variant<Types...>, T,
+ 0>::value != sizeof...(Types),
+ "The type T must occur exactly once in Types...");
+ return v.index() ==
+ variant_internal::UnambiguousIndexOf<variant<Types...>, T>::value;
+}
+
+// get()
+//
+// Returns a reference to the value currently within a given variant, using
+// either a unique alternative type amongst the variant's set of alternative
+// types, or the variant's index value. Attempting to get a variant's value
+// using a type that is not unique within the variant's set of alternative types
+// is a compile-time error. If the index of the alternative being specified is
+// different from the index of the alternative that is currently stored, throws
+// `absl::bad_variant_access`.
+//
+// Example:
+//
+// auto a = absl::variant<int, std::string>;
+//
+// // Get the value by type (if unique).
+// int i = absl::get<int>(a);
+//
+// auto b = absl::variant<int, int>;
+//
+// // Getting the value by a type that is not unique is ill-formed.
+// int j = absl::get<int>(b); // Compile Error!
+//
+// // Getting value by index not ambiguous and allowed.
+// int k = absl::get<1>(b);
+
+// Overload for getting a variant's lvalue by type.
+template <class T, class... Types>
+constexpr T& get(variant<Types...>& v) { // NOLINT
+ return variant_internal::VariantCoreAccess::Access<
+ variant_internal::IndexOf<T, Types...>::value>(v);
+}
+
+// Overload for getting a variant's rvalue by type.
+// Note: `absl::move()` is required to allow use of constexpr in C++11.
+template <class T, class... Types>
+constexpr T&& get(variant<Types...>&& v) {
+ return variant_internal::VariantCoreAccess::Access<
+ variant_internal::IndexOf<T, Types...>::value>(absl::move(v));
+}
+
+// Overload for getting a variant's const lvalue by type.
+template <class T, class... Types>
+constexpr const T& get(const variant<Types...>& v) {
+ return variant_internal::VariantCoreAccess::Access<
+ variant_internal::IndexOf<T, Types...>::value>(v);
+}
+
+// Overload for getting a variant's const rvalue by type.
+// Note: `absl::move()` is required to allow use of constexpr in C++11.
+template <class T, class... Types>
+constexpr const T&& get(const variant<Types...>&& v) {
+ return variant_internal::VariantCoreAccess::Access<
+ variant_internal::IndexOf<T, Types...>::value>(absl::move(v));
+}
+
+// Overload for getting a variant's lvalue by index.
+template <std::size_t I, class... Types>
+constexpr variant_alternative_t<I, variant<Types...>>& get(
+ variant<Types...>& v) { // NOLINT
+ return variant_internal::VariantCoreAccess::Access<I>(v);
+}
+
+// Overload for getting a variant's rvalue by index.
+// Note: `absl::move()` is required to allow use of constexpr in C++11.
+template <std::size_t I, class... Types>
+constexpr variant_alternative_t<I, variant<Types...>>&& get(
+ variant<Types...>&& v) {
+ return variant_internal::VariantCoreAccess::Access<I>(absl::move(v));
+}
+
+// Overload for getting a variant's const lvalue by index.
+template <std::size_t I, class... Types>
+constexpr const variant_alternative_t<I, variant<Types...>>& get(
+ const variant<Types...>& v) {
+ return variant_internal::VariantCoreAccess::Access<I>(v);
+}
+
+// Overload for getting a variant's const rvalue by index.
+// Note: `absl::move()` is required to allow use of constexpr in C++11.
+template <std::size_t I, class... Types>
+constexpr const variant_alternative_t<I, variant<Types...>>&& get(
+ const variant<Types...>&& v) {
+ return variant_internal::VariantCoreAccess::Access<I>(absl::move(v));
+}
+
+// get_if()
+//
+// Returns a pointer to the value currently stored within a given variant, if
+// present, using either a unique alternative type amonst the variant's set of
+// alternative types, or the variant's index value. If such a value does not
+// exist, returns `nullptr`.
+//
+// As with `get`, attempting to get a variant's value using a type that is not
+// unique within the variant's set of alternative types is a compile-time error.
+
+// Overload for getting a pointer to the value stored in the given variant by
+// index.
+template <std::size_t I, class... Types>
+constexpr absl::add_pointer_t<variant_alternative_t<I, variant<Types...>>>
+get_if(variant<Types...>* v) noexcept {
+ return (v != nullptr && v->index() == I) ? std::addressof(absl::get<I>(*v))
+ : nullptr;
+}
+
+// Overload for getting a pointer to the const value stored in the given
+// variant by index.
+template <std::size_t I, class... Types>
+constexpr absl::add_pointer_t<const variant_alternative_t<I, variant<Types...>>>
+get_if(const variant<Types...>* v) noexcept {
+ return (v != nullptr && v->index() == I) ? std::addressof(absl::get<I>(*v))
+ : nullptr;
+}
+
+// Overload for getting a pointer to the value stored in the given variant by
+// type.
+template <class T, class... Types>
+constexpr absl::add_pointer_t<T> get_if(variant<Types...>* v) noexcept {
+ return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
+}
+
+// Overload for getting a pointer to the const value stored in the given variant
+// by type.
+template <class T, class... Types>
+constexpr absl::add_pointer_t<const T> get_if(
+ const variant<Types...>* v) noexcept {
+ return absl::get_if<variant_internal::IndexOf<T, Types...>::value>(v);
+}
+
+// visit()
+//
+// Calls a provided functor on a given set of variants. `absl::visit()` is
+// commonly used to conditionally inspect the state of a given variant (or set
+// of variants).
+// Requires: The expression in the Effects: element shall be a valid expression
+// of the same type and value category, for all combinations of alternative
+// types of all variants. Otherwise, the program is ill-formed.
+//
+// Example:
+//
+// // Define a visitor functor
+// struct GetVariant {
+// template<typename T>
+// void operator()(const T& i) const {
+// std::cout << "The variant's value is: " << i;
+// }
+// };
+//
+// // Declare our variant, and call `absl::visit()` on it.
+// std::variant<int, std::string> foo = std::string("foo");
+// GetVariant visitor;
+// std::visit(visitor, foo); // Prints `The variant's value is: foo'
+template <typename Visitor, typename... Variants>
+variant_internal::VisitResult<Visitor, Variants...> visit(Visitor&& vis,
+ Variants&&... vars) {
+ return variant_internal::visit_indices<
+ variant_size<absl::decay_t<Variants>>::value...>(
+ variant_internal::PerformVisitation<Visitor, Variants...>{
+ std::forward_as_tuple(absl::forward<Variants>(vars)...),
+ absl::forward<Visitor>(vis)},
+ vars.index()...);
+}
+
+// monostate
+//
+// The monostate class serves as a first alternative type for a variant for
+// which the first variant type is otherwise not default-constructible.
+struct monostate {};
+
+// `absl::monostate` Relational Operators
+
+constexpr bool operator<(monostate, monostate) noexcept { return false; }
+constexpr bool operator>(monostate, monostate) noexcept { return false; }
+constexpr bool operator<=(monostate, monostate) noexcept { return true; }
+constexpr bool operator>=(monostate, monostate) noexcept { return true; }
+constexpr bool operator==(monostate, monostate) noexcept { return true; }
+constexpr bool operator!=(monostate, monostate) noexcept { return false; }
+
+
+//------------------------------------------------------------------------------
+// `absl::variant` Template Definition
+//------------------------------------------------------------------------------
+template <typename T0, typename... Tn>
+class variant<T0, Tn...> : private variant_internal::VariantBase<T0, Tn...> {
+ static_assert(absl::conjunction<std::is_object<T0>, std::is_object<Tn>...,
+ absl::negation<std::is_array<T0>>,
+ absl::negation<std::is_array<Tn>>...,
+ std::is_nothrow_destructible<T0>,
+ std::is_nothrow_destructible<Tn>...>::value,
+ "Attempted to instantiate a variant with an unsupported type.");
+
+ friend struct variant_internal::VariantCoreAccess;
+
+ private:
+ using Base = variant_internal::VariantBase<T0, Tn...>;
+
+ public:
+ // Constructors
+
+ // Constructs a variant holding a default-initialized value of the first
+ // alternative type.
+ constexpr variant() /*noexcept(see 111above)*/ = default;
+
+ // Copy constructor, standard semantics
+ variant(const variant& other) = default;
+
+ // Move constructor, standard semantics
+ variant(variant&& other) /*noexcept(see above)*/ = default;
+
+ // Constructs a variant of an alternative type specified by overload
+ // resolution of the provided forwarding arguments through
+ // direct-initialization.
+ //
+ // Note: If the selected constructor is a constexpr constructor, this
+ // constructor shall be a constexpr constructor.
+ //
+ // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
+ // has been voted passed the design phase in the C++ standard meeting in Mar
+ // 2018. It will be implemented and integrated into `absl::variant`.
+ template <
+ class T,
+ std::size_t I = std::enable_if<
+ variant_internal::IsNeitherSelfNorInPlace<variant,
+ absl::decay_t<T>>::value,
+ variant_internal::IndexOfConstructedType<variant, T>>::type::value,
+ class Tj = absl::variant_alternative_t<I, variant>,
+ absl::enable_if_t<std::is_constructible<Tj, T>::value>* =
+ nullptr>
+ constexpr variant(T&& t) noexcept(std::is_nothrow_constructible<Tj, T>::value)
+ : Base(variant_internal::EmplaceTag<I>(), absl::forward<T>(t)) {}
+
+ // Constructs a variant of an alternative type from the arguments through
+ // direct-initialization.
+ //
+ // Note: If the selected constructor is a constexpr constructor, this
+ // constructor shall be a constexpr constructor.
+ template <class T, class... Args,
+ typename std::enable_if<std::is_constructible<
+ variant_internal::UnambiguousTypeOfT<variant, T>,
+ Args...>::value>::type* = nullptr>
+ constexpr explicit variant(in_place_type_t<T>, Args&&... args)
+ : Base(variant_internal::EmplaceTag<
+ variant_internal::UnambiguousIndexOf<variant, T>::value>(),
+ absl::forward<Args>(args)...) {}
+
+ // Constructs a variant of an alternative type from an initializer list
+ // and other arguments through direct-initialization.
+ //
+ // Note: If the selected constructor is a constexpr constructor, this
+ // constructor shall be a constexpr constructor.
+ template <class T, class U, class... Args,
+ typename std::enable_if<std::is_constructible<
+ variant_internal::UnambiguousTypeOfT<variant, T>,
+ std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+ constexpr explicit variant(in_place_type_t<T>, std::initializer_list<U> il,
+ Args&&... args)
+ : Base(variant_internal::EmplaceTag<
+ variant_internal::UnambiguousIndexOf<variant, T>::value>(),
+ il, absl::forward<Args>(args)...) {}
+
+ // Constructs a variant of an alternative type from a provided index,
+ // through value-initialization using the provided forwarded arguments.
+ template <std::size_t I, class... Args,
+ typename std::enable_if<std::is_constructible<
+ variant_internal::VariantAlternativeSfinaeT<I, variant>,
+ Args...>::value>::type* = nullptr>
+ constexpr explicit variant(in_place_index_t<I>, Args&&... args)
+ : Base(variant_internal::EmplaceTag<I>(), absl::forward<Args>(args)...) {}
+
+ // Constructs a variant of an alternative type from a provided index,
+ // through value-initialization of an initializer list and the provided
+ // forwarded arguments.
+ template <std::size_t I, class U, class... Args,
+ typename std::enable_if<std::is_constructible<
+ variant_internal::VariantAlternativeSfinaeT<I, variant>,
+ std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+ constexpr explicit variant(in_place_index_t<I>, std::initializer_list<U> il,
+ Args&&... args)
+ : Base(variant_internal::EmplaceTag<I>(), il,
+ absl::forward<Args>(args)...) {}
+
+ // Destructors
+
+ // Destroys the variant's currently contained value, provided that
+ // `absl::valueless_by_exception()` is false.
+ ~variant() = default;
+
+ // Assignment Operators
+
+ // Copy assignement operator
+ variant& operator=(const variant& other) = default;
+
+ // Move assignment operator
+ variant& operator=(variant&& other) /*noexcept(see above)*/ = default;
+
+ // Converting assignment operator
+ //
+ // NOTE: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0608r1.html
+ // has been voted passed the design phase in the C++ standard meeting in Mar
+ // 2018. It will be implemented and integrated into `absl::variant`.
+ template <
+ class T,
+ std::size_t I = std::enable_if<
+ !std::is_same<absl::decay_t<T>, variant>::value,
+ variant_internal::IndexOfConstructedType<variant, T>>::type::value,
+ class Tj = absl::variant_alternative_t<I, variant>,
+ typename std::enable_if<std::is_assignable<Tj&, T>::value &&
+ std::is_constructible<Tj, T>::value>::type* =
+ nullptr>
+ variant& operator=(T&& t) noexcept(
+ std::is_nothrow_assignable<Tj&, T>::value&&
+ std::is_nothrow_constructible<Tj, T>::value) {
+ variant_internal::visit_indices<sizeof...(Tn) + 1>(
+ variant_internal::VariantCoreAccess::MakeConversionAssignVisitor(
+ this, absl::forward<T>(t)),
+ index());
+
+ return *this;
+ }
+
+
+ // emplace() Functions
+
+ // Constructs a value of the given alternative type T within the variant.
+ //
+ // Example:
+ //
+ // absl::variant<std::vector<int>, int, std::string> v;
+ // v.emplace<int>(99);
+ // v.emplace<std::string>("abc");
+ template <
+ class T, class... Args,
+ typename std::enable_if<std::is_constructible<
+ absl::variant_alternative_t<
+ variant_internal::UnambiguousIndexOf<variant, T>::value, variant>,
+ Args...>::value>::type* = nullptr>
+ T& emplace(Args&&... args) {
+ return variant_internal::VariantCoreAccess::Replace<
+ variant_internal::UnambiguousIndexOf<variant, T>::value>(
+ this, absl::forward<Args>(args)...);
+ }
+
+ // Constructs a value of the given alternative type T within the variant using
+ // an initializer list.
+ //
+ // Example:
+ //
+ // absl::variant<std::vector<int>, int, std::string> v;
+ // v.emplace<std::vector<int>>({0, 1, 2});
+ template <
+ class T, class U, class... Args,
+ typename std::enable_if<std::is_constructible<
+ absl::variant_alternative_t<
+ variant_internal::UnambiguousIndexOf<variant, T>::value, variant>,
+ std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+ T& emplace(std::initializer_list<U> il, Args&&... args) {
+ return variant_internal::VariantCoreAccess::Replace<
+ variant_internal::UnambiguousIndexOf<variant, T>::value>(
+ this, il, absl::forward<Args>(args)...);
+ }
+
+ // Destroys the current value of the variant (provided that
+ // `absl::valueless_by_exception()` is false, and constructs a new value at
+ // the given index.
+ //
+ // Example:
+ //
+ // absl::variant<std::vector<int>, int, int> v;
+ // v.emplace<1>(99);
+ // v.emplace<2>(98);
+ // v.emplace<int>(99); // Won't compile. 'int' isn't a unique type.
+ template <std::size_t I, class... Args,
+ typename std::enable_if<
+ std::is_constructible<absl::variant_alternative_t<I, variant>,
+ Args...>::value>::type* = nullptr>
+ absl::variant_alternative_t<I, variant>& emplace(Args&&... args) {
+ return variant_internal::VariantCoreAccess::Replace<I>(
+ this, absl::forward<Args>(args)...);
+ }
+
+ // Destroys the current value of the variant (provided that
+ // `absl::valueless_by_exception()` is false, and constructs a new value at
+ // the given index using an initializer list and the provided arguments.
+ //
+ // Example:
+ //
+ // absl::variant<std::vector<int>, int, int> v;
+ // v.emplace<0>({0, 1, 2});
+ template <std::size_t I, class U, class... Args,
+ typename std::enable_if<std::is_constructible<
+ absl::variant_alternative_t<I, variant>,
+ std::initializer_list<U>&, Args...>::value>::type* = nullptr>
+ absl::variant_alternative_t<I, variant>& emplace(std::initializer_list<U> il,
+ Args&&... args) {
+ return variant_internal::VariantCoreAccess::Replace<I>(
+ this, il, absl::forward<Args>(args)...);
+ }
+
+ // variant::valueless_by_exception()
+ //
+ // Returns false if and only if the variant currently holds a valid value.
+ constexpr bool valueless_by_exception() const noexcept {
+ return this->index_ == absl::variant_npos;
+ }
+
+ // variant::index()
+ //
+ // Returns the index value of the variant's currently selected alternative
+ // type.
+ constexpr std::size_t index() const noexcept { return this->index_; }
+
+ // variant::swap()
+ //
+ // Swaps the values of two variant objects.
+ //
+ // TODO(calabrese)
+ // `variant::swap()` and `swap()` rely on `std::is_(nothrow)_swappable()`
+ // which is introduced in C++17. So we assume `is_swappable()` is always
+ // true and `is_nothrow_swappable()` is same as `std::is_trivial()`.
+ void swap(variant& rhs) noexcept(
+ absl::conjunction<std::is_trivial<T0>, std::is_trivial<Tn>...>::value) {
+ return variant_internal::visit_indices<sizeof...(Tn) + 1>(
+ variant_internal::Swap<T0, Tn...>{this, &rhs}, rhs.index());
+ }
+};
+
+// We need a valid declaration of variant<> for SFINAE and overload resolution
+// to work properly above, but we don't need a full declaration since this type
+// will never be constructed. This declaration, though incomplete, suffices.
+template <>
+class variant<>;
+
+//------------------------------------------------------------------------------
+// Relational Operators
+//------------------------------------------------------------------------------
+//
+// If neither operand is in the `variant::valueless_by_exception` state:
+//
+// * If the index of both variants is the same, the relational operator
+// returns the result of the corresponding relational operator for the
+// corresponding alternative type.
+// * If the index of both variants is not the same, the relational operator
+// returns the result of that operation applied to the value of the left
+// operand's index and the value of the right operand's index.
+// * If at least one operand is in the valueless_by_exception state:
+// - A variant in the valueless_by_exception state is only considered equal
+// to another variant in the valueless_by_exception state.
+// - If exactly one operand is in the valueless_by_exception state, the
+// variant in the valueless_by_exception state is less than the variant
+// that is not in the valueless_by_exception state.
+//
+// Note: The value 1 is added to each index in the relational comparisons such
+// that the index corresponding to the valueless_by_exception state wraps around
+// to 0 (the lowest value for the index type), and the remaining indices stay in
+// the same relative order.
+
+// Equal-to operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveEqualT<Types...> operator==(
+ const variant<Types...>& a, const variant<Types...>& b) {
+ return (a.index() == b.index()) &&
+ variant_internal::visit_indices<sizeof...(Types)>(
+ variant_internal::EqualsOp<Types...>{&a, &b}, a.index());
+}
+
+// Not equal operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveNotEqualT<Types...> operator!=(
+ const variant<Types...>& a, const variant<Types...>& b) {
+ return (a.index() != b.index()) ||
+ variant_internal::visit_indices<sizeof...(Types)>(
+ variant_internal::NotEqualsOp<Types...>{&a, &b}, a.index());
+}
+
+// Less-than operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveLessThanT<Types...> operator<(
+ const variant<Types...>& a, const variant<Types...>& b) {
+ return (a.index() != b.index())
+ ? (a.index() + 1) < (b.index() + 1)
+ : variant_internal::visit_indices<sizeof...(Types)>(
+ variant_internal::LessThanOp<Types...>{&a, &b}, a.index());
+}
+
+// Greater-than operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveGreaterThanT<Types...> operator>(
+ const variant<Types...>& a, const variant<Types...>& b) {
+ return (a.index() != b.index())
+ ? (a.index() + 1) > (b.index() + 1)
+ : variant_internal::visit_indices<sizeof...(Types)>(
+ variant_internal::GreaterThanOp<Types...>{&a, &b},
+ a.index());
+}
+
+// Less-than or equal-to operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveLessThanOrEqualT<Types...> operator<=(
+ const variant<Types...>& a, const variant<Types...>& b) {
+ return (a.index() != b.index())
+ ? (a.index() + 1) < (b.index() + 1)
+ : variant_internal::visit_indices<sizeof...(Types)>(
+ variant_internal::LessThanOrEqualsOp<Types...>{&a, &b},
+ a.index());
+}
+
+// Greater-than or equal-to operator
+template <typename... Types>
+constexpr variant_internal::RequireAllHaveGreaterThanOrEqualT<Types...>
+operator>=(const variant<Types...>& a, const variant<Types...>& b) {
+ return (a.index() != b.index())
+ ? (a.index() + 1) > (b.index() + 1)
+ : variant_internal::visit_indices<sizeof...(Types)>(
+ variant_internal::GreaterThanOrEqualsOp<Types...>{&a, &b},
+ a.index());
+}
+
+} // namespace absl
+
+namespace std {
+
+// hash()
+template <> // NOLINT
+struct hash<absl::monostate> {
+ std::size_t operator()(absl::monostate) const { return 0; }
+};
+
+template <class... T> // NOLINT
+struct hash<absl::variant<T...>>
+ : absl::variant_internal::VariantHashBase<absl::variant<T...>, void,
+ absl::remove_const_t<T>...> {};
+
+} // namespace std
+
+#endif // ABSL_HAVE_STD_VARIANT
+
+namespace absl {
+namespace variant_internal {
+
+// Helper visitor for converting a variant<Ts...>` into another type (mostly
+// variant) that can be constructed from any type.
+template <typename To>
+struct ConversionVisitor {
+ template <typename T>
+ To operator()(T&& v) const {
+ return To(std::forward<T>(v));
+ }
+};
+
+} // namespace variant_internal
+
+// ConvertVariantTo()
+//
+// Helper functions to convert an `absl::variant` to a variant of another set of
+// types, provided that the alternative type of the new variant type can be
+// converted from any type in the source variant.
+//
+// Example:
+//
+// absl::variant<name1, name2, float> InternalReq(const Req&);
+//
+// // name1 and name2 are convertible to name
+// absl::variant<name, float> ExternalReq(const Req& req) {
+// return absl::ConvertVariantTo<absl::variant<name, float>>(
+// InternalReq(req));
+// }
+template <typename To, typename Variant>
+To ConvertVariantTo(Variant&& variant) {
+ return absl::visit(variant_internal::ConversionVisitor<To>{},
+ std::forward<Variant>(variant));
+}
+
+} // namespace absl
+
+#endif // ABSL_TYPES_VARIANT_H_
[24/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/kernel_timeout.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/kernel_timeout.h b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/kernel_timeout.h
new file mode 100644
index 0000000..0d132d9
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/kernel_timeout.h
@@ -0,0 +1,149 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// An optional absolute timeout, with nanosecond granularity,
+// compatible with absl::Time. Suitable for in-register
+// parameter-passing (e.g. syscalls.)
+// Constructible from a absl::Time (for a timeout to be respected) or {}
+// (for "no timeout".)
+// This is a private low-level API for use by a handful of low-level
+// components that are friends of this class. Higher-level components
+// should build APIs based on absl::Time and absl::Duration.
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
+
+#ifdef _WIN32
+#include <intsafe.h>
+#endif
+#include <time.h>
+#include <algorithm>
+#include <limits>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+namespace absl {
+namespace synchronization_internal {
+
+class Futex;
+class Waiter;
+
+class KernelTimeout {
+ public:
+ // A timeout that should expire at <t>. Any value, in the full
+ // InfinitePast() to InfiniteFuture() range, is valid here and will be
+ // respected.
+ explicit KernelTimeout(absl::Time t) : ns_(MakeNs(t)) {}
+ // No timeout.
+ KernelTimeout() : ns_(0) {}
+
+ // A more explicit factory for those who prefer it. Equivalent to {}.
+ static KernelTimeout Never() { return {}; }
+
+ // We explicitly do not support other custom formats: timespec, int64_t nanos.
+ // Unify on this and absl::Time, please.
+ bool has_timeout() const { return ns_ != 0; }
+
+ private:
+ // internal rep, not user visible: ns after unix epoch.
+ // zero = no timeout.
+ // Negative we treat as an unlikely (and certainly expired!) but valid
+ // timeout.
+ int64_t ns_;
+
+ static int64_t MakeNs(absl::Time t) {
+ // optimization--InfiniteFuture is common "no timeout" value
+ // and cheaper to compare than convert.
+ if (t == absl::InfiniteFuture()) return 0;
+ int64_t x = ToUnixNanos(t);
+
+ // A timeout that lands exactly on the epoch (x=0) needs to be respected,
+ // so we alter it unnoticably to 1. Negative timeouts are in
+ // theory supported, but handled poorly by the kernel (long
+ // delays) so push them forward too; since all such times have
+ // already passed, it's indistinguishable.
+ if (x <= 0) x = 1;
+ // A time larger than what can be represented to the kernel is treated
+ // as no timeout.
+ if (x == std::numeric_limits<int64_t>::max()) x = 0;
+ return x;
+ }
+
+ // Convert to parameter for sem_timedwait/futex/similar. Only for approved
+ // users. Do not call if !has_timeout.
+ struct timespec MakeAbsTimespec() {
+ int64_t n = ns_;
+ static const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
+ if (n == 0) {
+ ABSL_RAW_LOG(
+ ERROR,
+ "Tried to create a timespec from a non-timeout; never do this.");
+ // But we'll try to continue sanely. no-timeout ~= saturated timeout.
+ n = std::numeric_limits<int64_t>::max();
+ }
+
+ // Kernel APIs validate timespecs as being at or after the epoch,
+ // despite the kernel time type being signed. However, no one can
+ // tell the difference between a timeout at or before the epoch (since
+ // all such timeouts have expired!)
+ if (n < 0) n = 0;
+
+ struct timespec abstime;
+ int64_t seconds = std::min(n / kNanosPerSecond,
+ int64_t{std::numeric_limits<time_t>::max()});
+ abstime.tv_sec = static_cast<time_t>(seconds);
+ abstime.tv_nsec =
+ static_cast<decltype(abstime.tv_nsec)>(n % kNanosPerSecond);
+ return abstime;
+ }
+
+#ifdef _WIN32
+ // Converts to milliseconds from now, or INFINITE when
+ // !has_timeout(). For use by SleepConditionVariableSRW on
+ // Windows. Callers should recognize that the return value is a
+ // relative duration (it should be recomputed by calling this method
+ // in the case of a spurious wakeup).
+ DWORD InMillisecondsFromNow() const {
+ if (!has_timeout()) {
+ return INFINITE;
+ }
+ // The use of absl::Now() to convert from absolute time to
+ // relative time means that absl::Now() cannot use anything that
+ // depends on KernelTimeout (for example, Mutex) on Windows.
+ int64_t now = ToUnixNanos(absl::Now());
+ if (ns_ >= now) {
+ // Round up so that Now() + ms_from_now >= ns_.
+ constexpr uint64_t max_nanos =
+ std::numeric_limits<int64_t>::max() - 999999u;
+ uint64_t ms_from_now =
+ (std::min<uint64_t>(max_nanos, ns_ - now) + 999999u) / 1000000u;
+ if (ms_from_now > std::numeric_limits<DWORD>::max()) {
+ return INFINITE;
+ }
+ return static_cast<DWORD>(ms_from_now);
+ }
+ return 0;
+ }
+#endif
+
+ friend class Futex;
+ friend class Waiter;
+};
+
+} // namespace synchronization_internal
+} // namespace absl
+#endif // ABSL_SYNCHRONIZATION_INTERNAL_KERNEL_TIMEOUT_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/mutex_nonprod.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/mutex_nonprod.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/mutex_nonprod.cc
new file mode 100644
index 0000000..45c6032
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/mutex_nonprod.cc
@@ -0,0 +1,318 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Implementation of a small subset of Mutex and CondVar functionality
+// for platforms where the production implementation hasn't been fully
+// ported yet.
+
+#include "absl/synchronization/mutex.h"
+
+#if defined(_WIN32)
+#include <chrono> // NOLINT(build/c++11)
+#else
+#include <sys/time.h>
+#include <time.h>
+#endif
+
+#include <algorithm>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/time/time.h"
+
+namespace absl {
+namespace synchronization_internal {
+
+namespace {
+
+// Return the current time plus the timeout.
+absl::Time DeadlineFromTimeout(absl::Duration timeout) {
+ return absl::Now() + timeout;
+}
+
+// Limit the deadline to a positive, 32-bit time_t value to accommodate
+// implementation restrictions. This also deals with InfinitePast and
+// InfiniteFuture.
+absl::Time LimitedDeadline(absl::Time deadline) {
+ deadline = std::max(absl::FromTimeT(0), deadline);
+ deadline = std::min(deadline, absl::FromTimeT(0x7fffffff));
+ return deadline;
+}
+
+} // namespace
+
+#if defined(_WIN32)
+
+MutexImpl::MutexImpl() {}
+
+MutexImpl::~MutexImpl() {
+ if (locked_) {
+ std_mutex_.unlock();
+ }
+}
+
+void MutexImpl::Lock() {
+ std_mutex_.lock();
+ locked_ = true;
+}
+
+bool MutexImpl::TryLock() {
+ bool locked = std_mutex_.try_lock();
+ if (locked) locked_ = true;
+ return locked;
+}
+
+void MutexImpl::Unlock() {
+ locked_ = false;
+ released_.SignalAll();
+ std_mutex_.unlock();
+}
+
+CondVarImpl::CondVarImpl() {}
+
+CondVarImpl::~CondVarImpl() {}
+
+void CondVarImpl::Signal() { std_cv_.notify_one(); }
+
+void CondVarImpl::SignalAll() { std_cv_.notify_all(); }
+
+void CondVarImpl::Wait(MutexImpl* mu) {
+ mu->released_.SignalAll();
+ std_cv_.wait(mu->std_mutex_);
+}
+
+bool CondVarImpl::WaitWithDeadline(MutexImpl* mu, absl::Time deadline) {
+ mu->released_.SignalAll();
+ time_t when = ToTimeT(deadline);
+ int64_t nanos = ToInt64Nanoseconds(deadline - absl::FromTimeT(when));
+ std::chrono::system_clock::time_point deadline_tp =
+ std::chrono::system_clock::from_time_t(when) +
+ std::chrono::duration_cast<std::chrono::system_clock::duration>(
+ std::chrono::nanoseconds(nanos));
+ auto deadline_since_epoch =
+ std::chrono::duration_cast<std::chrono::duration<double>>(
+ deadline_tp - std::chrono::system_clock::from_time_t(0));
+ return std_cv_.wait_until(mu->std_mutex_, deadline_tp) ==
+ std::cv_status::timeout;
+}
+
+#else // ! _WIN32
+
+MutexImpl::MutexImpl() {
+ ABSL_RAW_CHECK(pthread_mutex_init(&pthread_mutex_, nullptr) == 0,
+ "pthread error");
+}
+
+MutexImpl::~MutexImpl() {
+ if (locked_) {
+ ABSL_RAW_CHECK(pthread_mutex_unlock(&pthread_mutex_) == 0, "pthread error");
+ }
+ ABSL_RAW_CHECK(pthread_mutex_destroy(&pthread_mutex_) == 0, "pthread error");
+}
+
+void MutexImpl::Lock() {
+ ABSL_RAW_CHECK(pthread_mutex_lock(&pthread_mutex_) == 0, "pthread error");
+ locked_ = true;
+}
+
+bool MutexImpl::TryLock() {
+ bool locked = (0 == pthread_mutex_trylock(&pthread_mutex_));
+ if (locked) locked_ = true;
+ return locked;
+}
+
+void MutexImpl::Unlock() {
+ locked_ = false;
+ released_.SignalAll();
+ ABSL_RAW_CHECK(pthread_mutex_unlock(&pthread_mutex_) == 0, "pthread error");
+}
+
+CondVarImpl::CondVarImpl() {
+ ABSL_RAW_CHECK(pthread_cond_init(&pthread_cv_, nullptr) == 0,
+ "pthread error");
+}
+
+CondVarImpl::~CondVarImpl() {
+ ABSL_RAW_CHECK(pthread_cond_destroy(&pthread_cv_) == 0, "pthread error");
+}
+
+void CondVarImpl::Signal() {
+ ABSL_RAW_CHECK(pthread_cond_signal(&pthread_cv_) == 0, "pthread error");
+}
+
+void CondVarImpl::SignalAll() {
+ ABSL_RAW_CHECK(pthread_cond_broadcast(&pthread_cv_) == 0, "pthread error");
+}
+
+void CondVarImpl::Wait(MutexImpl* mu) {
+ mu->released_.SignalAll();
+ ABSL_RAW_CHECK(pthread_cond_wait(&pthread_cv_, &mu->pthread_mutex_) == 0,
+ "pthread error");
+}
+
+bool CondVarImpl::WaitWithDeadline(MutexImpl* mu, absl::Time deadline) {
+ mu->released_.SignalAll();
+ struct timespec ts = ToTimespec(deadline);
+ int rc = pthread_cond_timedwait(&pthread_cv_, &mu->pthread_mutex_, &ts);
+ if (rc == ETIMEDOUT) return true;
+ ABSL_RAW_CHECK(rc == 0, "pthread error");
+ return false;
+}
+
+#endif // ! _WIN32
+
+void MutexImpl::Await(const Condition& cond) {
+ if (cond.Eval()) return;
+ released_.SignalAll();
+ do {
+ released_.Wait(this);
+ } while (!cond.Eval());
+}
+
+bool MutexImpl::AwaitWithDeadline(const Condition& cond, absl::Time deadline) {
+ if (cond.Eval()) return true;
+ released_.SignalAll();
+ while (true) {
+ if (released_.WaitWithDeadline(this, deadline)) return false;
+ if (cond.Eval()) return true;
+ }
+}
+
+} // namespace synchronization_internal
+
+Mutex::Mutex() {}
+
+Mutex::~Mutex() {}
+
+void Mutex::Lock() { impl()->Lock(); }
+
+void Mutex::Unlock() { impl()->Unlock(); }
+
+bool Mutex::TryLock() { return impl()->TryLock(); }
+
+void Mutex::ReaderLock() { Lock(); }
+
+void Mutex::ReaderUnlock() { Unlock(); }
+
+void Mutex::Await(const Condition& cond) { impl()->Await(cond); }
+
+void Mutex::LockWhen(const Condition& cond) {
+ Lock();
+ Await(cond);
+}
+
+bool Mutex::AwaitWithDeadline(const Condition& cond, absl::Time deadline) {
+ return impl()->AwaitWithDeadline(
+ cond, synchronization_internal::LimitedDeadline(deadline));
+}
+
+bool Mutex::AwaitWithTimeout(const Condition& cond, absl::Duration timeout) {
+ return AwaitWithDeadline(
+ cond, synchronization_internal::DeadlineFromTimeout(timeout));
+}
+
+bool Mutex::LockWhenWithDeadline(const Condition& cond, absl::Time deadline) {
+ Lock();
+ return AwaitWithDeadline(cond, deadline);
+}
+
+bool Mutex::LockWhenWithTimeout(const Condition& cond, absl::Duration timeout) {
+ return LockWhenWithDeadline(
+ cond, synchronization_internal::DeadlineFromTimeout(timeout));
+}
+
+void Mutex::ReaderLockWhen(const Condition& cond) {
+ ReaderLock();
+ Await(cond);
+}
+
+bool Mutex::ReaderLockWhenWithTimeout(const Condition& cond,
+ absl::Duration timeout) {
+ return LockWhenWithTimeout(cond, timeout);
+}
+bool Mutex::ReaderLockWhenWithDeadline(const Condition& cond,
+ absl::Time deadline) {
+ return LockWhenWithDeadline(cond, deadline);
+}
+
+void Mutex::EnableDebugLog(const char*) {}
+void Mutex::EnableInvariantDebugging(void (*)(void*), void*) {}
+void Mutex::ForgetDeadlockInfo() {}
+void Mutex::AssertHeld() const {}
+void Mutex::AssertReaderHeld() const {}
+void Mutex::AssertNotHeld() const {}
+
+CondVar::CondVar() {}
+
+CondVar::~CondVar() {}
+
+void CondVar::Signal() { impl()->Signal(); }
+
+void CondVar::SignalAll() { impl()->SignalAll(); }
+
+void CondVar::Wait(Mutex* mu) { return impl()->Wait(mu->impl()); }
+
+bool CondVar::WaitWithDeadline(Mutex* mu, absl::Time deadline) {
+ return impl()->WaitWithDeadline(
+ mu->impl(), synchronization_internal::LimitedDeadline(deadline));
+}
+
+bool CondVar::WaitWithTimeout(Mutex* mu, absl::Duration timeout) {
+ return WaitWithDeadline(mu, absl::Now() + timeout);
+}
+
+void CondVar::EnableDebugLog(const char*) {}
+
+#ifdef THREAD_SANITIZER
+extern "C" void __tsan_read1(void *addr);
+#else
+#define __tsan_read1(addr) // do nothing if TSan not enabled
+#endif
+
+// A function that just returns its argument, dereferenced
+static bool Dereference(void *arg) {
+ // ThreadSanitizer does not instrument this file for memory accesses.
+ // This function dereferences a user variable that can participate
+ // in a data race, so we need to manually tell TSan about this memory access.
+ __tsan_read1(arg);
+ return *(static_cast<bool *>(arg));
+}
+
+Condition::Condition() {} // null constructor, used for kTrue only
+const Condition Condition::kTrue;
+
+Condition::Condition(bool (*func)(void *), void *arg)
+ : eval_(&CallVoidPtrFunction),
+ function_(func),
+ method_(nullptr),
+ arg_(arg) {}
+
+bool Condition::CallVoidPtrFunction(const Condition *c) {
+ return (*c->function_)(c->arg_);
+}
+
+Condition::Condition(const bool *cond)
+ : eval_(CallVoidPtrFunction),
+ function_(Dereference),
+ method_(nullptr),
+ // const_cast is safe since Dereference does not modify arg
+ arg_(const_cast<bool *>(cond)) {}
+
+bool Condition::Eval() const {
+ // eval_ == null for kTrue
+ return (this->eval_ == nullptr) || (*this->eval_)(this);
+}
+
+void RegisterSymbolizer(bool (*)(const void*, char*, int)) {}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/mutex_nonprod.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/mutex_nonprod.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/mutex_nonprod.inc
new file mode 100644
index 0000000..0aab3d1
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/mutex_nonprod.inc
@@ -0,0 +1,256 @@
+// Do not include. This is an implementation detail of base/mutex.h.
+//
+// Declares three classes:
+//
+// base::internal::MutexImpl - implementation helper for Mutex
+// base::internal::CondVarImpl - implementation helper for CondVar
+// base::internal::SynchronizationStorage<T> - implementation helper for
+// Mutex, CondVar
+
+#include <type_traits>
+
+#if defined(_WIN32)
+#include <condition_variable>
+#include <mutex>
+#else
+#include <pthread.h>
+#endif
+
+#include "absl/base/call_once.h"
+#include "absl/time/time.h"
+
+// Declare that Mutex::ReaderLock is actually Lock(). Intended primarily
+// for tests, and even then as a last resort.
+#ifdef ABSL_MUTEX_READER_LOCK_IS_EXCLUSIVE
+#error ABSL_MUTEX_READER_LOCK_IS_EXCLUSIVE cannot be directly set
+#else
+#define ABSL_MUTEX_READER_LOCK_IS_EXCLUSIVE 1
+#endif
+
+// Declare that Mutex::EnableInvariantDebugging is not implemented.
+// Intended primarily for tests, and even then as a last resort.
+#ifdef ABSL_MUTEX_ENABLE_INVARIANT_DEBUGGING_NOT_IMPLEMENTED
+#error ABSL_MUTEX_ENABLE_INVARIANT_DEBUGGING_NOT_IMPLEMENTED cannot be directly set
+#else
+#define ABSL_MUTEX_ENABLE_INVARIANT_DEBUGGING_NOT_IMPLEMENTED 1
+#endif
+
+namespace absl {
+class Condition;
+
+namespace synchronization_internal {
+
+class MutexImpl;
+
+// Do not use this implementation detail of CondVar. Provides most of the
+// implementation, but should not be placed directly in static storage
+// because it will not linker initialize properly. See
+// SynchronizationStorage<T> below for what we mean by linker
+// initialization.
+class CondVarImpl {
+ public:
+ CondVarImpl();
+ CondVarImpl(const CondVarImpl&) = delete;
+ CondVarImpl& operator=(const CondVarImpl&) = delete;
+ ~CondVarImpl();
+
+ void Signal();
+ void SignalAll();
+ void Wait(MutexImpl* mutex);
+ bool WaitWithDeadline(MutexImpl* mutex, absl::Time deadline);
+
+ private:
+#if defined(_WIN32)
+ std::condition_variable_any std_cv_;
+#else
+ pthread_cond_t pthread_cv_;
+#endif
+};
+
+// Do not use this implementation detail of Mutex. Provides most of the
+// implementation, but should not be placed directly in static storage
+// because it will not linker initialize properly. See
+// SynchronizationStorage<T> below for what we mean by linker
+// initialization.
+class MutexImpl {
+ public:
+ MutexImpl();
+ MutexImpl(const MutexImpl&) = delete;
+ MutexImpl& operator=(const MutexImpl&) = delete;
+ ~MutexImpl();
+
+ void Lock();
+ bool TryLock();
+ void Unlock();
+ void Await(const Condition& cond);
+ bool AwaitWithDeadline(const Condition& cond, absl::Time deadline);
+
+ private:
+ friend class CondVarImpl;
+
+#if defined(_WIN32)
+ std::mutex std_mutex_;
+#else
+ pthread_mutex_t pthread_mutex_;
+#endif
+
+ // True if the underlying mutex is locked. If the destructor is entered
+ // while locked_, the underlying mutex is unlocked. Mutex supports
+ // destruction while locked, but the same is undefined behavior for both
+ // pthread_mutex_t and std::mutex.
+ bool locked_ = false;
+
+ // Signaled before releasing the lock, in support of Await.
+ CondVarImpl released_;
+};
+
+// Do not use this implementation detail of CondVar and Mutex. A storage
+// space for T that supports a LinkerInitialized constructor. T must
+// have a default constructor, which is called by the first call to
+// get(). T's destructor is never called if the LinkerInitialized
+// constructor is called.
+//
+// Objects constructed with the default constructor are constructed and
+// destructed like any other object, and should never be allocated in
+// static storage.
+//
+// Objects constructed with the LinkerInitialized constructor should
+// always be in static storage. For such objects, calls to get() are always
+// valid, except from signal handlers.
+//
+// Note that this implementation relies on undefined language behavior that
+// are known to hold for the set of supported compilers. An analysis
+// follows.
+//
+// From the C++11 standard:
+//
+// [basic.life] says an object has non-trivial initialization if it is of
+// class type and it is initialized by a constructor other than a trivial
+// default constructor. (the LinkerInitialized constructor is
+// non-trivial)
+//
+// [basic.life] says the lifetime of an object with a non-trivial
+// constructor begins when the call to the constructor is complete.
+//
+// [basic.life] says the lifetime of an object with non-trivial destructor
+// ends when the call to the destructor begins.
+//
+// [basic.life] p5 specifies undefined behavior when accessing non-static
+// members of an instance outside its
+// lifetime. (SynchronizationStorage::get() access non-static members)
+//
+// So, LinkerInitialized object of SynchronizationStorage uses a
+// non-trivial constructor, which is called at some point during dynamic
+// initialization, and is therefore subject to order of dynamic
+// initialization bugs, where get() is called before the object's
+// constructor is, resulting in undefined behavior.
+//
+// Similarly, a LinkerInitialized SynchronizationStorage object has a
+// non-trivial destructor, and so its lifetime ends at some point during
+// destruction of objects with static storage duration [basic.start.term]
+// p4. There is a window where other exit code could call get() after this
+// occurs, resulting in undefined behavior.
+//
+// Combined, these statements imply that LinkerInitialized instances
+// of SynchronizationStorage<T> rely on undefined behavior.
+//
+// However, in practice, the implementation works on all supported
+// compilers. Specifically, we rely on:
+//
+// a) zero-initialization being sufficient to initialize
+// LinkerInitialized instances for the purposes of calling
+// get(), regardless of when the constructor is called. This is
+// because the is_dynamic_ boolean is correctly zero-initialized to
+// false.
+//
+// b) the LinkerInitialized constructor is a NOP, and immaterial to
+// even to concurrent calls to get().
+//
+// c) the destructor being a NOP for LinkerInitialized objects
+// (guaranteed by a check for !is_dynamic_), and so any concurrent and
+// subsequent calls to get() functioning as if the destructor were not
+// called, by virtue of the instances' storage remaining valid after the
+// destructor runs.
+//
+// d) That a-c apply transitively when SynchronizationStorage<T> is the
+// only member of a class allocated in static storage.
+//
+// Nothing in the language standard guarantees that a-d hold. In practice,
+// these hold in all supported compilers.
+//
+// Future direction:
+//
+// Ideally, we would simply use std::mutex or a similar class, which when
+// allocated statically would support use immediately after static
+// initialization up until static storage is reclaimed (i.e. the properties
+// we require of all "linker initialized" instances).
+//
+// Regarding construction in static storage, std::mutex is required to
+// provide a constexpr default constructor [thread.mutex.class], which
+// ensures the instance's lifetime begins with static initialization
+// [basic.start.init], and so is immune to any problems caused by the order
+// of dynamic initialization. However, as of this writing Microsoft's
+// Visual Studio does not provide a constexpr constructor for std::mutex.
+// See
+// https://blogs.msdn.microsoft.com/vcblog/2015/06/02/constexpr-complete-for-vs-2015-rtm-c11-compiler-c17-stl/
+//
+// Regarding destruction of instances in static storage, [basic.life] does
+// say an object ends when storage in which the occupies is released, in
+// the case of non-trivial destructor. However, std::mutex is not specified
+// to have a trivial destructor.
+//
+// So, we would need a class with a constexpr default constructor and a
+// trivial destructor. Today, we can achieve neither desired property using
+// std::mutex directly.
+template <typename T>
+class SynchronizationStorage {
+ public:
+ // Instances allocated on the heap or on the stack should use the default
+ // constructor.
+ SynchronizationStorage()
+ : is_dynamic_(true), once_() {}
+
+ // Instances allocated in static storage (not on the heap, not on the
+ // stack) should use this constructor.
+ explicit SynchronizationStorage(base_internal::LinkerInitialized) {}
+
+ SynchronizationStorage(SynchronizationStorage&) = delete;
+ SynchronizationStorage& operator=(SynchronizationStorage&) = delete;
+
+ ~SynchronizationStorage() {
+ if (is_dynamic_) {
+ get()->~T();
+ }
+ }
+
+ // Retrieve the object in storage. This is fast and thread safe, but does
+ // incur the cost of absl::call_once().
+ //
+ // For instances in static storage constructed with the
+ // LinkerInitialized constructor, may be called at any time without
+ // regard for order of dynamic initialization or destruction of objects
+ // in static storage. See the class comment for caveats.
+ T* get() {
+ absl::call_once(once_, SynchronizationStorage::Construct, this);
+ return reinterpret_cast<T*>(&space_);
+ }
+
+ private:
+ static void Construct(SynchronizationStorage<T>* self) {
+ new (&self->space_) T();
+ }
+
+ // When true, T's destructor is run when this is destructed.
+ //
+ // The LinkerInitialized constructor assumes this value will be set
+ // false by static initialization.
+ bool is_dynamic_;
+
+ absl::once_flag once_;
+
+ // An aligned space for T.
+ typename std::aligned_storage<sizeof(T), alignof(T)>::type space_;
+};
+
+} // namespace synchronization_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem.cc
new file mode 100644
index 0000000..caa2baf
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem.cc
@@ -0,0 +1,99 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file is a no-op if the required LowLevelAlloc support is missing.
+#include "absl/base/internal/low_level_alloc.h"
+#ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
+
+#include "absl/synchronization/internal/per_thread_sem.h"
+
+#include <atomic>
+
+#include "absl/base/attributes.h"
+#include "absl/base/internal/thread_identity.h"
+#include "absl/synchronization/internal/waiter.h"
+
+namespace absl {
+namespace synchronization_internal {
+
+void PerThreadSem::SetThreadBlockedCounter(std::atomic<int> *counter) {
+ base_internal::ThreadIdentity *identity;
+ identity = GetOrCreateCurrentThreadIdentity();
+ identity->blocked_count_ptr = counter;
+}
+
+std::atomic<int> *PerThreadSem::GetThreadBlockedCounter() {
+ base_internal::ThreadIdentity *identity;
+ identity = GetOrCreateCurrentThreadIdentity();
+ return identity->blocked_count_ptr;
+}
+
+void PerThreadSem::Init(base_internal::ThreadIdentity *identity) {
+ Waiter::GetWaiter(identity)->Init();
+ identity->ticker.store(0, std::memory_order_relaxed);
+ identity->wait_start.store(0, std::memory_order_relaxed);
+ identity->is_idle.store(false, std::memory_order_relaxed);
+}
+
+void PerThreadSem::Tick(base_internal::ThreadIdentity *identity) {
+ const int ticker =
+ identity->ticker.fetch_add(1, std::memory_order_relaxed) + 1;
+ const int wait_start = identity->wait_start.load(std::memory_order_relaxed);
+ const bool is_idle = identity->is_idle.load(std::memory_order_relaxed);
+ if (wait_start && (ticker - wait_start > Waiter::kIdlePeriods) && !is_idle) {
+ // Wakeup the waiting thread since it is time for it to become idle.
+ Waiter::GetWaiter(identity)->Poke();
+ }
+}
+
+} // namespace synchronization_internal
+} // namespace absl
+
+extern "C" {
+
+ABSL_ATTRIBUTE_WEAK void AbslInternalPerThreadSemPost(
+ absl::base_internal::ThreadIdentity *identity) {
+ absl::synchronization_internal::Waiter::GetWaiter(identity)->Post();
+}
+
+ABSL_ATTRIBUTE_WEAK bool AbslInternalPerThreadSemWait(
+ absl::synchronization_internal::KernelTimeout t) {
+ bool timeout = false;
+ absl::base_internal::ThreadIdentity *identity;
+ identity = absl::synchronization_internal::GetOrCreateCurrentThreadIdentity();
+
+ // Ensure wait_start != 0.
+ int ticker = identity->ticker.load(std::memory_order_relaxed);
+ identity->wait_start.store(ticker ? ticker : 1, std::memory_order_relaxed);
+ identity->is_idle.store(false, std::memory_order_relaxed);
+
+ if (identity->blocked_count_ptr != nullptr) {
+ // Increment count of threads blocked in a given thread pool.
+ identity->blocked_count_ptr->fetch_add(1, std::memory_order_relaxed);
+ }
+
+ timeout =
+ !absl::synchronization_internal::Waiter::GetWaiter(identity)->Wait(t);
+
+ if (identity->blocked_count_ptr != nullptr) {
+ identity->blocked_count_ptr->fetch_sub(1, std::memory_order_relaxed);
+ }
+ identity->is_idle.store(false, std::memory_order_relaxed);
+ identity->wait_start.store(0, std::memory_order_relaxed);
+ return !timeout;
+}
+
+} // extern "C"
+
+#endif // ABSL_LOW_LEVEL_ALLOC_MISSING
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem.h b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem.h
new file mode 100644
index 0000000..678b69e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem.h
@@ -0,0 +1,107 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// PerThreadSem is a low-level synchronization primitive controlling the
+// runnability of a single thread, used internally by Mutex and CondVar.
+//
+// This is NOT a general-purpose synchronization mechanism, and should not be
+// used directly by applications. Applications should use Mutex and CondVar.
+//
+// The semantics of PerThreadSem are the same as that of a counting semaphore.
+// Each thread maintains an abstract "count" value associated with its identity.
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
+
+#include <atomic>
+
+#include "absl/base/internal/thread_identity.h"
+#include "absl/synchronization/internal/create_thread_identity.h"
+#include "absl/synchronization/internal/kernel_timeout.h"
+
+namespace absl {
+
+class Mutex;
+
+namespace synchronization_internal {
+
+class PerThreadSem {
+ public:
+ PerThreadSem() = delete;
+ PerThreadSem(const PerThreadSem&) = delete;
+ PerThreadSem& operator=(const PerThreadSem&) = delete;
+
+ // Routine invoked periodically (once a second) by a background thread.
+ // Has no effect on user-visible state.
+ static void Tick(base_internal::ThreadIdentity* identity);
+
+ // ---------------------------------------------------------------------------
+ // Routines used by autosizing threadpools to detect when threads are
+ // blocked. Each thread has a counter pointer, initially zero. If non-zero,
+ // the implementation atomically increments the counter when it blocks on a
+ // semaphore, a decrements it again when it wakes. This allows a threadpool
+ // to keep track of how many of its threads are blocked.
+ // SetThreadBlockedCounter() should be used only by threadpool
+ // implementations. GetThreadBlockedCounter() should be used by modules that
+ // block threads; if the pointer returned is non-zero, the location should be
+ // incremented before the thread blocks, and decremented after it wakes.
+ static void SetThreadBlockedCounter(std::atomic<int> *counter);
+ static std::atomic<int> *GetThreadBlockedCounter();
+
+ private:
+ // Create the PerThreadSem associated with "identity". Initializes count=0.
+ // REQUIRES: May only be called by ThreadIdentity.
+ static void Init(base_internal::ThreadIdentity* identity);
+
+ // Increments "identity"'s count.
+ static inline void Post(base_internal::ThreadIdentity* identity);
+
+ // Waits until either our count > 0 or t has expired.
+ // If count > 0, decrements count and returns true. Otherwise returns false.
+ // !t.has_timeout() => Wait(t) will return true.
+ static inline bool Wait(KernelTimeout t);
+
+ // White-listed callers.
+ friend class PerThreadSemTest;
+ friend class absl::Mutex;
+ friend absl::base_internal::ThreadIdentity* CreateThreadIdentity();
+};
+
+} // namespace synchronization_internal
+} // namespace absl
+
+// In some build configurations we pass --detect-odr-violations to the
+// gold linker. This causes it to flag weak symbol overrides as ODR
+// violations. Because ODR only applies to C++ and not C,
+// --detect-odr-violations ignores symbols not mangled with C++ names.
+// By changing our extension points to be extern "C", we dodge this
+// check.
+extern "C" {
+void AbslInternalPerThreadSemPost(
+ absl::base_internal::ThreadIdentity* identity);
+bool AbslInternalPerThreadSemWait(
+ absl::synchronization_internal::KernelTimeout t);
+} // extern "C"
+
+void absl::synchronization_internal::PerThreadSem::Post(
+ absl::base_internal::ThreadIdentity* identity) {
+ AbslInternalPerThreadSemPost(identity);
+}
+
+bool absl::synchronization_internal::PerThreadSem::Wait(
+ absl::synchronization_internal::KernelTimeout t) {
+ return AbslInternalPerThreadSemWait(t);
+}
+#endif // ABSL_SYNCHRONIZATION_INTERNAL_PER_THREAD_SEM_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem_test.cc
new file mode 100644
index 0000000..2b52ea7
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/per_thread_sem_test.cc
@@ -0,0 +1,172 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/internal/per_thread_sem.h"
+
+#include <atomic>
+#include <condition_variable> // NOLINT(build/c++11)
+#include <functional>
+#include <limits>
+#include <mutex> // NOLINT(build/c++11)
+#include <string>
+#include <thread> // NOLINT(build/c++11)
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/cycleclock.h"
+#include "absl/base/internal/thread_identity.h"
+#include "absl/strings/str_cat.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+// In this test we explicitly avoid the use of synchronization
+// primitives which might use PerThreadSem, most notably absl::Mutex.
+
+namespace absl {
+namespace synchronization_internal {
+
+class SimpleSemaphore {
+ public:
+ SimpleSemaphore() : count_(0) {}
+
+ // Decrements (locks) the semaphore. If the semaphore's value is
+ // greater than zero, then the decrement proceeds, and the function
+ // returns, immediately. If the semaphore currently has the value
+ // zero, then the call blocks until it becomes possible to perform
+ // the decrement.
+ void Wait() {
+ std::unique_lock<std::mutex> lock(mu_);
+ cv_.wait(lock, [this]() { return count_ > 0; });
+ --count_;
+ cv_.notify_one();
+ }
+
+ // Increments (unlocks) the semaphore. If the semaphore's value
+ // consequently becomes greater than zero, then another thread
+ // blocked Wait() call will be woken up and proceed to lock the
+ // semaphore.
+ void Post() {
+ std::lock_guard<std::mutex> lock(mu_);
+ ++count_;
+ cv_.notify_one();
+ }
+
+ private:
+ std::mutex mu_;
+ std::condition_variable cv_;
+ int count_;
+};
+
+struct ThreadData {
+ int num_iterations; // Number of replies to send.
+ SimpleSemaphore identity2_written; // Posted by thread writing identity2.
+ base_internal::ThreadIdentity *identity1; // First Post()-er.
+ base_internal::ThreadIdentity *identity2; // First Wait()-er.
+ KernelTimeout timeout;
+};
+
+// Need friendship with PerThreadSem.
+class PerThreadSemTest : public testing::Test {
+ public:
+ static void TimingThread(ThreadData* t) {
+ t->identity2 = GetOrCreateCurrentThreadIdentity();
+ t->identity2_written.Post();
+ while (t->num_iterations--) {
+ Wait(t->timeout);
+ Post(t->identity1);
+ }
+ }
+
+ void TestTiming(const char *msg, bool timeout) {
+ static const int kNumIterations = 100;
+ ThreadData t;
+ t.num_iterations = kNumIterations;
+ t.timeout = timeout ?
+ KernelTimeout(absl::Now() + absl::Seconds(10000)) // far in the future
+ : KernelTimeout::Never();
+ t.identity1 = GetOrCreateCurrentThreadIdentity();
+
+ // We can't use the Thread class here because it uses the Mutex
+ // class which will invoke PerThreadSem, so we use std::thread instead.
+ std::thread partner_thread(std::bind(TimingThread, &t));
+
+ // Wait for our partner thread to register their identity.
+ t.identity2_written.Wait();
+
+ int64_t min_cycles = std::numeric_limits<int64_t>::max();
+ int64_t total_cycles = 0;
+ for (int i = 0; i < kNumIterations; ++i) {
+ absl::SleepFor(absl::Milliseconds(20));
+ int64_t cycles = base_internal::CycleClock::Now();
+ Post(t.identity2);
+ Wait(t.timeout);
+ cycles = base_internal::CycleClock::Now() - cycles;
+ min_cycles = std::min(min_cycles, cycles);
+ total_cycles += cycles;
+ }
+ std::string out =
+ StrCat(msg, "min cycle count=", min_cycles, " avg cycle count=",
+ absl::SixDigits(static_cast<double>(total_cycles) /
+ kNumIterations));
+ printf("%s\n", out.c_str());
+
+ partner_thread.join();
+ }
+
+ protected:
+ static void Post(base_internal::ThreadIdentity *id) {
+ PerThreadSem::Post(id);
+ }
+ static bool Wait(KernelTimeout t) {
+ return PerThreadSem::Wait(t);
+ }
+
+ // convenience overload
+ static bool Wait(absl::Time t) {
+ return Wait(KernelTimeout(t));
+ }
+
+ static void Tick(base_internal::ThreadIdentity *identity) {
+ PerThreadSem::Tick(identity);
+ }
+};
+
+namespace {
+
+TEST_F(PerThreadSemTest, WithoutTimeout) {
+ PerThreadSemTest::TestTiming("Without timeout: ", false);
+}
+
+TEST_F(PerThreadSemTest, WithTimeout) {
+ PerThreadSemTest::TestTiming("With timeout: ", true);
+}
+
+TEST_F(PerThreadSemTest, Timeouts) {
+ absl::Time timeout = absl::Now() + absl::Milliseconds(50);
+ EXPECT_FALSE(Wait(timeout));
+ EXPECT_LE(timeout, absl::Now());
+
+ absl::Time negative_timeout = absl::UnixEpoch() - absl::Milliseconds(100);
+ EXPECT_FALSE(Wait(negative_timeout));
+ EXPECT_LE(negative_timeout, absl::Now()); // trivially true :)
+
+ Post(GetOrCreateCurrentThreadIdentity());
+ // The wait here has an expired timeout, but we have a wake to consume,
+ // so this should succeed
+ EXPECT_TRUE(Wait(negative_timeout));
+}
+
+} // namespace
+
+} // namespace synchronization_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/thread_pool.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/thread_pool.h b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/thread_pool.h
new file mode 100644
index 0000000..8464042
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/thread_pool.h
@@ -0,0 +1,90 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
+
+#include <cassert>
+#include <functional>
+#include <queue>
+#include <thread> // NOLINT(build/c++11)
+#include <vector>
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+namespace synchronization_internal {
+
+// A simple ThreadPool implementation for tests.
+class ThreadPool {
+ public:
+ explicit ThreadPool(int num_threads) {
+ for (int i = 0; i < num_threads; ++i) {
+ threads_.push_back(std::thread(&ThreadPool::WorkLoop, this));
+ }
+ }
+
+ ThreadPool(const ThreadPool &) = delete;
+ ThreadPool &operator=(const ThreadPool &) = delete;
+
+ ~ThreadPool() {
+ {
+ absl::MutexLock l(&mu_);
+ for (int i = 0; i < threads_.size(); ++i) {
+ queue_.push(nullptr); // Shutdown signal.
+ }
+ }
+ for (auto &t : threads_) {
+ t.join();
+ }
+ }
+
+ // Schedule a function to be run on a ThreadPool thread immediately.
+ void Schedule(std::function<void()> func) {
+ assert(func != nullptr);
+ absl::MutexLock l(&mu_);
+ queue_.push(std::move(func));
+ }
+
+ private:
+ bool WorkAvailable() const EXCLUSIVE_LOCKS_REQUIRED(mu_) {
+ return !queue_.empty();
+ }
+
+ void WorkLoop() {
+ while (true) {
+ std::function<void()> func;
+ {
+ absl::MutexLock l(&mu_);
+ mu_.Await(absl::Condition(this, &ThreadPool::WorkAvailable));
+ func = std::move(queue_.front());
+ queue_.pop();
+ }
+ if (func == nullptr) { // Shutdown signal.
+ break;
+ }
+ func();
+ }
+ }
+
+ absl::Mutex mu_;
+ std::queue<std::function<void()>> queue_ GUARDED_BY(mu_);
+ std::vector<std::thread> threads_;
+};
+
+} // namespace synchronization_internal
+} // namespace absl
+
+#endif // ABSL_SYNCHRONIZATION_INTERNAL_THREAD_POOL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/waiter.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/waiter.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/waiter.cc
new file mode 100644
index 0000000..768c520
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/waiter.cc
@@ -0,0 +1,412 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/internal/waiter.h"
+
+#include "absl/base/config.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <pthread.h>
+#include <sys/time.h>
+#include <unistd.h>
+#endif
+
+#ifdef __linux__
+#include <linux/futex.h>
+#include <sys/syscall.h>
+#endif
+
+#ifdef ABSL_HAVE_SEMAPHORE_H
+#include <semaphore.h>
+#endif
+
+#include <errno.h>
+#include <stdio.h>
+#include <time.h>
+
+#include <atomic>
+#include <cassert>
+#include <cstdint>
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/thread_identity.h"
+#include "absl/base/optimization.h"
+#include "absl/synchronization/internal/kernel_timeout.h"
+
+namespace absl {
+namespace synchronization_internal {
+
+static void MaybeBecomeIdle() {
+ base_internal::ThreadIdentity *identity =
+ base_internal::CurrentThreadIdentityIfPresent();
+ assert(identity != nullptr);
+ const bool is_idle = identity->is_idle.load(std::memory_order_relaxed);
+ const int ticker = identity->ticker.load(std::memory_order_relaxed);
+ const int wait_start = identity->wait_start.load(std::memory_order_relaxed);
+ if (!is_idle && ticker - wait_start > Waiter::kIdlePeriods) {
+ identity->is_idle.store(true, std::memory_order_relaxed);
+ }
+}
+
+#if ABSL_WAITER_MODE == ABSL_WAITER_MODE_FUTEX
+
+// Some Android headers are missing these definitions even though they
+// support these futex operations.
+#ifdef __BIONIC__
+#ifndef SYS_futex
+#define SYS_futex __NR_futex
+#endif
+#ifndef FUTEX_WAIT_BITSET
+#define FUTEX_WAIT_BITSET 9
+#endif
+#ifndef FUTEX_PRIVATE_FLAG
+#define FUTEX_PRIVATE_FLAG 128
+#endif
+#ifndef FUTEX_CLOCK_REALTIME
+#define FUTEX_CLOCK_REALTIME 256
+#endif
+#ifndef FUTEX_BITSET_MATCH_ANY
+#define FUTEX_BITSET_MATCH_ANY 0xFFFFFFFF
+#endif
+#endif
+class Futex {
+ public:
+ static int WaitUntil(std::atomic<int32_t> *v, int32_t val,
+ KernelTimeout t) {
+ int err = 0;
+ if (t.has_timeout()) {
+ // https://locklessinc.com/articles/futex_cheat_sheet/
+ // Unlike FUTEX_WAIT, FUTEX_WAIT_BITSET uses absolute time.
+ struct timespec abs_timeout = t.MakeAbsTimespec();
+ // Atomically check that the futex value is still 0, and if it
+ // is, sleep until abs_timeout or until woken by FUTEX_WAKE.
+ err = syscall(
+ SYS_futex, reinterpret_cast<int32_t *>(v),
+ FUTEX_WAIT_BITSET | FUTEX_PRIVATE_FLAG | FUTEX_CLOCK_REALTIME, val,
+ &abs_timeout, nullptr, FUTEX_BITSET_MATCH_ANY);
+ } else {
+ // Atomically check that the futex value is still 0, and if it
+ // is, sleep until woken by FUTEX_WAKE.
+ err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
+ FUTEX_WAIT | FUTEX_PRIVATE_FLAG, val, nullptr);
+ }
+ if (err != 0) {
+ err = -errno;
+ }
+ return err;
+ }
+
+ static int Wake(std::atomic<int32_t> *v, int32_t count) {
+ int err = syscall(SYS_futex, reinterpret_cast<int32_t *>(v),
+ FUTEX_WAKE | FUTEX_PRIVATE_FLAG, count);
+ if (ABSL_PREDICT_FALSE(err < 0)) {
+ err = -errno;
+ }
+ return err;
+ }
+};
+
+void Waiter::Init() {
+ futex_.store(0, std::memory_order_relaxed);
+}
+
+bool Waiter::Wait(KernelTimeout t) {
+ // Loop until we can atomically decrement futex from a positive
+ // value, waiting on a futex while we believe it is zero.
+ while (true) {
+ int32_t x = futex_.load(std::memory_order_relaxed);
+ if (x != 0) {
+ if (!futex_.compare_exchange_weak(x, x - 1,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ continue; // Raced with someone, retry.
+ }
+ return true; // Consumed a wakeup, we are done.
+ }
+
+ const int err = Futex::WaitUntil(&futex_, 0, t);
+ if (err != 0) {
+ if (err == -EINTR || err == -EWOULDBLOCK) {
+ // Do nothing, the loop will retry.
+ } else if (err == -ETIMEDOUT) {
+ return false;
+ } else {
+ ABSL_RAW_LOG(FATAL, "Futex operation failed with error %d\n", err);
+ }
+ }
+
+ MaybeBecomeIdle();
+ }
+}
+
+void Waiter::Post() {
+ if (futex_.fetch_add(1, std::memory_order_release) == 0) {
+ // We incremented from 0, need to wake a potential waker.
+ Poke();
+ }
+}
+
+void Waiter::Poke() {
+ // Wake one thread waiting on the futex.
+ const int err = Futex::Wake(&futex_, 1);
+ if (ABSL_PREDICT_FALSE(err < 0)) {
+ ABSL_RAW_LOG(FATAL, "Futex operation failed with error %d\n", err);
+ }
+}
+
+#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_CONDVAR
+
+class PthreadMutexHolder {
+ public:
+ explicit PthreadMutexHolder(pthread_mutex_t *mu) : mu_(mu) {
+ const int err = pthread_mutex_lock(mu_);
+ if (err != 0) {
+ ABSL_RAW_LOG(FATAL, "pthread_mutex_lock failed: %d", err);
+ }
+ }
+
+ PthreadMutexHolder(const PthreadMutexHolder &rhs) = delete;
+ PthreadMutexHolder &operator=(const PthreadMutexHolder &rhs) = delete;
+
+ ~PthreadMutexHolder() {
+ const int err = pthread_mutex_unlock(mu_);
+ if (err != 0) {
+ ABSL_RAW_LOG(FATAL, "pthread_mutex_unlock failed: %d", err);
+ }
+ }
+
+ private:
+ pthread_mutex_t *mu_;
+};
+
+void Waiter::Init() {
+ const int err = pthread_mutex_init(&mu_, 0);
+ if (err != 0) {
+ ABSL_RAW_LOG(FATAL, "pthread_mutex_init failed: %d", err);
+ }
+
+ const int err2 = pthread_cond_init(&cv_, 0);
+ if (err2 != 0) {
+ ABSL_RAW_LOG(FATAL, "pthread_cond_init failed: %d", err2);
+ }
+
+ waiter_count_.store(0, std::memory_order_relaxed);
+ wakeup_count_.store(0, std::memory_order_relaxed);
+}
+
+bool Waiter::Wait(KernelTimeout t) {
+ struct timespec abs_timeout;
+ if (t.has_timeout()) {
+ abs_timeout = t.MakeAbsTimespec();
+ }
+
+ PthreadMutexHolder h(&mu_);
+ waiter_count_.fetch_add(1, std::memory_order_relaxed);
+ // Loop until we find a wakeup to consume or timeout.
+ while (true) {
+ int x = wakeup_count_.load(std::memory_order_relaxed);
+ if (x != 0) {
+ if (!wakeup_count_.compare_exchange_weak(x, x - 1,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ continue; // Raced with someone, retry.
+ }
+ // Successfully consumed a wakeup, we're done.
+ waiter_count_.fetch_sub(1, std::memory_order_relaxed);
+ return true;
+ }
+
+ // No wakeups available, time to wait.
+ if (!t.has_timeout()) {
+ const int err = pthread_cond_wait(&cv_, &mu_);
+ if (err != 0) {
+ ABSL_RAW_LOG(FATAL, "pthread_cond_wait failed: %d", err);
+ }
+ } else {
+ const int err = pthread_cond_timedwait(&cv_, &mu_, &abs_timeout);
+ if (err == ETIMEDOUT) {
+ waiter_count_.fetch_sub(1, std::memory_order_relaxed);
+ return false;
+ }
+ if (err != 0) {
+ ABSL_RAW_LOG(FATAL, "pthread_cond_wait failed: %d", err);
+ }
+ }
+ MaybeBecomeIdle();
+ }
+}
+
+void Waiter::Post() {
+ wakeup_count_.fetch_add(1, std::memory_order_release);
+ Poke();
+}
+
+void Waiter::Poke() {
+ if (waiter_count_.load(std::memory_order_relaxed) == 0) {
+ return;
+ }
+ // Potentially a waker. Take the lock and check again.
+ PthreadMutexHolder h(&mu_);
+ if (waiter_count_.load(std::memory_order_relaxed) == 0) {
+ return;
+ }
+ const int err = pthread_cond_signal(&cv_);
+ if (err != 0) {
+ ABSL_RAW_LOG(FATAL, "pthread_cond_signal failed: %d", err);
+ }
+}
+
+#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_SEM
+
+void Waiter::Init() {
+ if (sem_init(&sem_, 0, 0) != 0) {
+ ABSL_RAW_LOG(FATAL, "sem_init failed with errno %d\n", errno);
+ }
+ wakeups_.store(0, std::memory_order_relaxed);
+}
+
+bool Waiter::Wait(KernelTimeout t) {
+ struct timespec abs_timeout;
+ if (t.has_timeout()) {
+ abs_timeout = t.MakeAbsTimespec();
+ }
+
+ // Loop until we timeout or consume a wakeup.
+ while (true) {
+ int x = wakeups_.load(std::memory_order_relaxed);
+ if (x != 0) {
+ if (!wakeups_.compare_exchange_weak(x, x - 1,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ continue; // Raced with someone, retry.
+ }
+ // Successfully consumed a wakeup, we're done.
+ return true;
+ }
+
+ // Nothing to consume, wait (looping on EINTR).
+ while (true) {
+ if (!t.has_timeout()) {
+ if (sem_wait(&sem_) == 0) break;
+ if (errno == EINTR) continue;
+ ABSL_RAW_LOG(FATAL, "sem_wait failed: %d", errno);
+ } else {
+ if (sem_timedwait(&sem_, &abs_timeout) == 0) break;
+ if (errno == EINTR) continue;
+ if (errno == ETIMEDOUT) return false;
+ ABSL_RAW_LOG(FATAL, "sem_timedwait failed: %d", errno);
+ }
+ }
+ MaybeBecomeIdle();
+ }
+}
+
+void Waiter::Post() {
+ wakeups_.fetch_add(1, std::memory_order_release); // Post a wakeup.
+ Poke();
+}
+
+void Waiter::Poke() {
+ if (sem_post(&sem_) != 0) { // Wake any semaphore waiter.
+ ABSL_RAW_LOG(FATAL, "sem_post failed with errno %d\n", errno);
+ }
+}
+
+#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_WIN32
+
+class LockHolder {
+ public:
+ explicit LockHolder(SRWLOCK* mu) : mu_(mu) {
+ AcquireSRWLockExclusive(mu_);
+ }
+
+ LockHolder(const LockHolder&) = delete;
+ LockHolder& operator=(const LockHolder&) = delete;
+
+ ~LockHolder() {
+ ReleaseSRWLockExclusive(mu_);
+ }
+
+ private:
+ SRWLOCK* mu_;
+};
+
+void Waiter::Init() {
+ InitializeSRWLock(&mu_);
+ InitializeConditionVariable(&cv_);
+ waiter_count_.store(0, std::memory_order_relaxed);
+ wakeup_count_.store(0, std::memory_order_relaxed);
+}
+
+bool Waiter::Wait(KernelTimeout t) {
+ LockHolder h(&mu_);
+ waiter_count_.fetch_add(1, std::memory_order_relaxed);
+
+ // Loop until we find a wakeup to consume or timeout.
+ while (true) {
+ int x = wakeup_count_.load(std::memory_order_relaxed);
+ if (x != 0) {
+ if (!wakeup_count_.compare_exchange_weak(x, x - 1,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ continue; // Raced with someone, retry.
+ }
+ // Successfully consumed a wakeup, we're done.
+ waiter_count_.fetch_sub(1, std::memory_order_relaxed);
+ return true;
+ }
+
+ // No wakeups available, time to wait.
+ if (!SleepConditionVariableSRW(
+ &cv_, &mu_, t.InMillisecondsFromNow(), 0)) {
+ // GetLastError() returns a Win32 DWORD, but we assign to
+ // unsigned long to simplify the ABSL_RAW_LOG case below. The uniform
+ // initialization guarantees this is not a narrowing conversion.
+ const unsigned long err{GetLastError()}; // NOLINT(runtime/int)
+ if (err == ERROR_TIMEOUT) {
+ waiter_count_.fetch_sub(1, std::memory_order_relaxed);
+ return false;
+ } else {
+ ABSL_RAW_LOG(FATAL, "SleepConditionVariableSRW failed: %lu", err);
+ }
+ }
+
+ MaybeBecomeIdle();
+ }
+}
+
+void Waiter::Post() {
+ wakeup_count_.fetch_add(1, std::memory_order_release);
+ Poke();
+}
+
+void Waiter::Poke() {
+ if (waiter_count_.load(std::memory_order_relaxed) == 0) {
+ return;
+ }
+ // Potentially a waker. Take the lock and check again.
+ LockHolder h(&mu_);
+ if (waiter_count_.load(std::memory_order_relaxed) == 0) {
+ return;
+ }
+ WakeConditionVariable(&cv_);
+}
+
+#else
+#error Unknown ABSL_WAITER_MODE
+#endif
+
+} // namespace synchronization_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/waiter.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/waiter.h b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/waiter.h
new file mode 100644
index 0000000..23166f4
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/waiter.h
@@ -0,0 +1,139 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
+
+#include "absl/base/config.h"
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <pthread.h>
+#endif
+
+#ifdef ABSL_HAVE_SEMAPHORE_H
+#include <semaphore.h>
+#endif
+
+#include <atomic>
+#include <cstdint>
+
+#include "absl/base/internal/thread_identity.h"
+#include "absl/synchronization/internal/kernel_timeout.h"
+
+// May be chosen at compile time via -DABSL_FORCE_WAITER_MODE=<index>
+#define ABSL_WAITER_MODE_FUTEX 0
+#define ABSL_WAITER_MODE_SEM 1
+#define ABSL_WAITER_MODE_CONDVAR 2
+#define ABSL_WAITER_MODE_WIN32 3
+
+#if defined(ABSL_FORCE_WAITER_MODE)
+#define ABSL_WAITER_MODE ABSL_FORCE_WAITER_MODE
+#elif defined(_WIN32)
+#define ABSL_WAITER_MODE ABSL_WAITER_MODE_WIN32
+#elif defined(__linux__)
+#define ABSL_WAITER_MODE ABSL_WAITER_MODE_FUTEX
+#elif defined(ABSL_HAVE_SEMAPHORE_H)
+#define ABSL_WAITER_MODE ABSL_WAITER_MODE_SEM
+#else
+#define ABSL_WAITER_MODE ABSL_WAITER_MODE_CONDVAR
+#endif
+
+namespace absl {
+namespace synchronization_internal {
+
+// Waiter is an OS-specific semaphore.
+class Waiter {
+ public:
+ // No constructor, instances use the reserved space in ThreadIdentity.
+ // All initialization logic belongs in `Init()`.
+ Waiter() = delete;
+ Waiter(const Waiter&) = delete;
+ Waiter& operator=(const Waiter&) = delete;
+
+ // Prepare any data to track waits.
+ void Init();
+
+ // Blocks the calling thread until a matching call to `Post()` or
+ // `t` has passed. Returns `true` if woken (`Post()` called),
+ // `false` on timeout.
+ bool Wait(KernelTimeout t);
+
+ // Restart the caller of `Wait()` as with a normal semaphore.
+ void Post();
+
+ // If anyone is waiting, wake them up temporarily and cause them to
+ // call `MaybeBecomeIdle()`. They will then return to waiting for a
+ // `Post()` or timeout.
+ void Poke();
+
+ // Returns the Waiter associated with the identity.
+ static Waiter* GetWaiter(base_internal::ThreadIdentity* identity) {
+ static_assert(
+ sizeof(Waiter) <= sizeof(base_internal::ThreadIdentity::WaiterState),
+ "Insufficient space for Waiter");
+ return reinterpret_cast<Waiter*>(identity->waiter_state.data);
+ }
+
+ // How many periods to remain idle before releasing resources
+#ifndef THREAD_SANITIZER
+ static const int kIdlePeriods = 60;
+#else
+ // Memory consumption under ThreadSanitizer is a serious concern,
+ // so we release resources sooner. The value of 1 leads to 1 to 2 second
+ // delay before marking a thread as idle.
+ static const int kIdlePeriods = 1;
+#endif
+
+ private:
+#if ABSL_WAITER_MODE == ABSL_WAITER_MODE_FUTEX
+ // Futexes are defined by specification to be 32-bits.
+ // Thus std::atomic<int32_t> must be just an int32_t with lockfree methods.
+ std::atomic<int32_t> futex_;
+ static_assert(sizeof(int32_t) == sizeof(futex_), "Wrong size for futex");
+
+#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_CONDVAR
+ pthread_mutex_t mu_;
+ pthread_cond_t cv_;
+ std::atomic<int> waiter_count_;
+ std::atomic<int> wakeup_count_; // Unclaimed wakeups, written under lock.
+
+#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_SEM
+ sem_t sem_;
+ // This seems superfluous, but for Poke() we need to cause spurious
+ // wakeups on the semaphore. Hence we can't actually use the
+ // semaphore's count.
+ std::atomic<int> wakeups_;
+
+#elif ABSL_WAITER_MODE == ABSL_WAITER_MODE_WIN32
+ // The Windows API has lots of choices for synchronization
+ // primivitives. We are using SRWLOCK and CONDITION_VARIABLE
+ // because they don't require a destructor to release system
+ // resources.
+ SRWLOCK mu_;
+ CONDITION_VARIABLE cv_;
+ std::atomic<int> waiter_count_;
+ std::atomic<int> wakeup_count_;
+
+#else
+ #error Unknown ABSL_WAITER_MODE
+#endif
+};
+
+} // namespace synchronization_internal
+} // namespace absl
+
+#endif // ABSL_SYNCHRONIZATION_INTERNAL_WAITER_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/lifetime_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/lifetime_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/lifetime_test.cc
new file mode 100644
index 0000000..90c9009
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/lifetime_test.cc
@@ -0,0 +1,132 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <cstdlib>
+#include <thread> // NOLINT(build/c++11), Abseil test
+#include <type_traits>
+
+#include "absl/base/attributes.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/synchronization/notification.h"
+
+namespace {
+
+// A two-threaded test which checks that Mutex, CondVar, and Notification have
+// correct basic functionality. The intent is to establish that they
+// function correctly in various phases of construction and destruction.
+//
+// Thread one acquires a lock on 'mutex', wakes thread two via 'notification',
+// then waits for 'state' to be set, as signalled by 'condvar'.
+//
+// Thread two waits on 'notification', then sets 'state' inside the 'mutex',
+// signalling the change via 'condvar'.
+//
+// These tests use ABSL_RAW_CHECK to validate invariants, rather than EXPECT or
+// ASSERT from gUnit, because we need to invoke them during global destructors,
+// when gUnit teardown would have already begun.
+void ThreadOne(absl::Mutex* mutex, absl::CondVar* condvar,
+ absl::Notification* notification, bool* state) {
+ // Test that the notification is in a valid initial state.
+ ABSL_RAW_CHECK(!notification->HasBeenNotified(), "invalid Notification");
+ ABSL_RAW_CHECK(*state == false, "*state not initialized");
+
+ {
+ absl::MutexLock lock(mutex);
+
+ notification->Notify();
+ ABSL_RAW_CHECK(notification->HasBeenNotified(), "invalid Notification");
+
+ while (*state == false) {
+ condvar->Wait(mutex);
+ }
+ }
+}
+
+void ThreadTwo(absl::Mutex* mutex, absl::CondVar* condvar,
+ absl::Notification* notification, bool* state) {
+ ABSL_RAW_CHECK(*state == false, "*state not initialized");
+
+ // Wake thread one
+ notification->WaitForNotification();
+ ABSL_RAW_CHECK(notification->HasBeenNotified(), "invalid Notification");
+ {
+ absl::MutexLock lock(mutex);
+ *state = true;
+ condvar->Signal();
+ }
+}
+
+// Launch thread 1 and thread 2, and block on their completion.
+// If any of 'mutex', 'condvar', or 'notification' is nullptr, use a locally
+// constructed instance instead.
+void RunTests(absl::Mutex* mutex, absl::CondVar* condvar,
+ absl::Notification* notification) {
+ absl::Mutex default_mutex;
+ absl::CondVar default_condvar;
+ absl::Notification default_notification;
+ if (!mutex) {
+ mutex = &default_mutex;
+ }
+ if (!condvar) {
+ condvar = &default_condvar;
+ }
+ if (!notification) {
+ notification = &default_notification;
+ }
+ bool state = false;
+ std::thread thread_one(ThreadOne, mutex, condvar, notification, &state);
+ std::thread thread_two(ThreadTwo, mutex, condvar, notification, &state);
+ thread_one.join();
+ thread_two.join();
+}
+
+void TestLocals() {
+ absl::Mutex mutex;
+ absl::CondVar condvar;
+ absl::Notification notification;
+ RunTests(&mutex, &condvar, ¬ification);
+}
+
+// Global variables during start and termination
+//
+// In a translation unit, static storage duration variables are initialized in
+// the order of their definitions, and destroyed in the reverse order of their
+// definitions. We can use this to arrange for tests to be run on these objects
+// before they are created, and after they are destroyed.
+
+using Function = void (*)();
+
+class OnConstruction {
+ public:
+ explicit OnConstruction(Function fn) { fn(); }
+};
+
+class OnDestruction {
+ public:
+ explicit OnDestruction(Function fn) : fn_(fn) {}
+ ~OnDestruction() { fn_(); }
+ private:
+ Function fn_;
+};
+
+} // namespace
+
+int main() {
+ TestLocals();
+ // Explicitly call exit(0) here, to make it clear that we intend for the
+ // above global object destructors to run.
+ std::exit(0);
+}
[05/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional.h b/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional.h
new file mode 100644
index 0000000..98b29e5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/types/optional.h
@@ -0,0 +1,1131 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// optional.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines the `absl::optional` type for holding a value which
+// may or may not be present. This type is useful for providing value semantics
+// for operations that may either wish to return or hold "something-or-nothing".
+//
+// Example:
+//
+// // A common way to signal operation failure is to provide an output
+// // parameter and a bool return type:
+// bool AcquireResource(const Input&, Resource * out);
+//
+// // Providing an absl::optional return type provides a cleaner API:
+// absl::optional<Resource> AcquireResource(const Input&);
+//
+// `absl::optional` is a C++11 compatible version of the C++17 `std::optional`
+// abstraction and is designed to be a drop-in replacement for code compliant
+// with C++17.
+#ifndef ABSL_TYPES_OPTIONAL_H_
+#define ABSL_TYPES_OPTIONAL_H_
+
+#include "absl/base/config.h"
+#include "absl/utility/utility.h"
+
+#ifdef ABSL_HAVE_STD_OPTIONAL
+
+#include <optional>
+
+namespace absl {
+using std::bad_optional_access;
+using std::optional;
+using std::make_optional;
+using std::nullopt_t;
+using std::nullopt;
+}
+
+#else // ABSL_HAVE_STD_OPTIONAL
+
+#include <cassert>
+#include <functional>
+#include <initializer_list>
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/memory/memory.h"
+#include "absl/meta/type_traits.h"
+#include "absl/types/bad_optional_access.h"
+
+// ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+//
+// Inheriting constructors is supported in GCC 4.8+, Clang 3.3+ and MSVC 2015.
+// __cpp_inheriting_constructors is a predefined macro and a recommended way to
+// check for this language feature, but GCC doesn't support it until 5.0 and
+// Clang doesn't support it until 3.6.
+// Also, MSVC 2015 has a bug: it doesn't inherit the constexpr template
+// constructor. For example, the following code won't work on MSVC 2015 Update3:
+// struct Base {
+// int t;
+// template <typename T>
+// constexpr Base(T t_) : t(t_) {}
+// };
+// struct Foo : Base {
+// using Base::Base;
+// }
+// constexpr Foo foo(0); // doesn't work on MSVC 2015
+#if defined(__clang__)
+#if __has_feature(cxx_inheriting_constructors)
+#define ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
+#endif
+#elif (defined(__GNUC__) && \
+ (__GNUC__ > 4 || __GNUC__ == 4 && __GNUC_MINOR__ >= 8)) || \
+ (__cpp_inheriting_constructors >= 200802) || \
+ (defined(_MSC_VER) && _MSC_VER >= 1910)
+#define ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS 1
+#endif
+
+namespace absl {
+
+// -----------------------------------------------------------------------------
+// absl::optional
+// -----------------------------------------------------------------------------
+//
+// A value of type `absl::optional<T>` holds either a value of `T` or an
+// "empty" value. When it holds a value of `T`, it stores it as a direct
+// sub-object, so `sizeof(optional<T>)` is approximately
+// `sizeof(T) + sizeof(bool)`.
+//
+// This implementation is based on the specification in the latest draft of the
+// C++17 `std::optional` specification as of May 2017, section 20.6.
+//
+// Differences between `absl::optional<T>` and `std::optional<T>` include:
+//
+// * `constexpr` is not used for non-const member functions.
+// (dependency on some differences between C++11 and C++14.)
+// * `absl::nullopt` and `absl::in_place` are not declared `constexpr`. We
+// need the inline variable support in C++17 for external linkage.
+// * Throws `absl::bad_optional_access` instead of
+// `std::bad_optional_access`.
+// * `optional::swap()` and `absl::swap()` relies on
+// `std::is_(nothrow_)swappable()`, which has been introduced in C++17.
+// As a workaround, we assume `is_swappable()` is always `true`
+// and `is_nothrow_swappable()` is the same as `std::is_trivial()`.
+// * `make_optional()` cannot be declared `constexpr` due to the absence of
+// guaranteed copy elision.
+// * The move constructor's `noexcept` specification is stronger, i.e. if the
+// default allocator is non-throwing (via setting
+// `ABSL_ALLOCATOR_NOTHROW`), it evaluates to `noexcept(true)`, because
+// we assume
+// a) move constructors should only throw due to allocation failure and
+// b) if T's move constructor allocates, it uses the same allocation
+// function as the default allocator.
+template <typename T>
+class optional;
+
+// nullopt_t
+//
+// Class type for `absl::nullopt` used to indicate an `absl::optional<T>` type
+// that does not contain a value.
+struct nullopt_t {
+ struct init_t {};
+ static init_t init;
+
+ // It must not be default-constructible to avoid ambiguity for opt = {}.
+ // Note the non-const reference, which is to eliminate ambiguity for code
+ // like:
+ //
+ // struct S { int value; };
+ //
+ // void Test() {
+ // optional<S> opt;
+ // opt = {{}};
+ // }
+ explicit constexpr nullopt_t(init_t& /*unused*/) {}
+};
+
+// nullopt
+//
+// A tag constant of type `absl::nullopt_t` used to indicate an empty
+// `absl::optional` in certain functions, such as construction or assignment.
+extern const nullopt_t nullopt;
+
+namespace optional_internal {
+
+struct empty_struct {};
+// This class stores the data in optional<T>.
+// It is specialized based on whether T is trivially destructible.
+// This is the specialization for non trivially destructible type.
+template <typename T, bool = std::is_trivially_destructible<T>::value>
+class optional_data_dtor_base {
+ struct dummy_type {
+ static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
+ // Use an array to avoid GCC 6 placement-new warning.
+ empty_struct data[sizeof(T) / sizeof(empty_struct)];
+ };
+
+ protected:
+ // Whether there is data or not.
+ bool engaged_;
+ // Data storage
+ union {
+ dummy_type dummy_;
+ T data_;
+ };
+
+ void destruct() noexcept {
+ if (engaged_) {
+ data_.~T();
+ engaged_ = false;
+ }
+ }
+
+ // dummy_ must be initialized for constexpr constructor.
+ constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
+
+ template <typename... Args>
+ constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
+ : engaged_(true), data_(absl::forward<Args>(args)...) {}
+
+ ~optional_data_dtor_base() { destruct(); }
+};
+
+// Specialization for trivially destructible type.
+template <typename T>
+class optional_data_dtor_base<T, true> {
+ struct dummy_type {
+ static_assert(sizeof(T) % sizeof(empty_struct) == 0, "");
+ // Use array to avoid GCC 6 placement-new warning.
+ empty_struct data[sizeof(T) / sizeof(empty_struct)];
+ };
+
+ protected:
+ // Whether there is data or not.
+ bool engaged_;
+ // Data storage
+ union {
+ dummy_type dummy_;
+ T data_;
+ };
+ void destruct() noexcept { engaged_ = false; }
+
+ // dummy_ must be initialized for constexpr constructor.
+ constexpr optional_data_dtor_base() noexcept : engaged_(false), dummy_{{}} {}
+
+ template <typename... Args>
+ constexpr explicit optional_data_dtor_base(in_place_t, Args&&... args)
+ : engaged_(true), data_(absl::forward<Args>(args)...) {}
+};
+
+template <typename T>
+class optional_data_base : public optional_data_dtor_base<T> {
+ protected:
+ using base = optional_data_dtor_base<T>;
+#if ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+ using base::base;
+#else
+ optional_data_base() = default;
+
+ template <typename... Args>
+ constexpr explicit optional_data_base(in_place_t t, Args&&... args)
+ : base(t, absl::forward<Args>(args)...) {}
+#endif
+
+ template <typename... Args>
+ void construct(Args&&... args) {
+ // Use dummy_'s address to work around casting cv-qualified T* to void*.
+ ::new (static_cast<void*>(&this->dummy_)) T(std::forward<Args>(args)...);
+ this->engaged_ = true;
+ }
+
+ template <typename U>
+ void assign(U&& u) {
+ if (this->engaged_) {
+ this->data_ = std::forward<U>(u);
+ } else {
+ construct(std::forward<U>(u));
+ }
+ }
+};
+
+// TODO(absl-team): Add another class using
+// std::is_trivially_move_constructible trait when available to match
+// http://cplusplus.github.io/LWG/lwg-defects.html#2900, for types that
+// have trivial move but nontrivial copy.
+// Also, we should be checking is_trivially_copyable here, which is not
+// supported now, so we use is_trivially_* traits instead.
+template <typename T, bool = absl::is_trivially_copy_constructible<T>::value&&
+ absl::is_trivially_copy_assignable<
+ typename std::remove_cv<T>::type>::value&&
+ std::is_trivially_destructible<T>::value>
+class optional_data;
+
+// Trivially copyable types
+template <typename T>
+class optional_data<T, true> : public optional_data_base<T> {
+ protected:
+#if ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+ using optional_data_base<T>::optional_data_base;
+#else
+ optional_data() = default;
+
+ template <typename... Args>
+ constexpr explicit optional_data(in_place_t t, Args&&... args)
+ : optional_data_base<T>(t, absl::forward<Args>(args)...) {}
+#endif
+};
+
+template <typename T>
+class optional_data<T, false> : public optional_data_base<T> {
+ protected:
+#if ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+ using optional_data_base<T>::optional_data_base;
+#else
+ template <typename... Args>
+ constexpr explicit optional_data(in_place_t t, Args&&... args)
+ : optional_data_base<T>(t, absl::forward<Args>(args)...) {}
+#endif
+
+ optional_data() = default;
+
+ optional_data(const optional_data& rhs) {
+ if (rhs.engaged_) {
+ this->construct(rhs.data_);
+ }
+ }
+
+ optional_data(optional_data&& rhs) noexcept(
+ absl::default_allocator_is_nothrow::value ||
+ std::is_nothrow_move_constructible<T>::value) {
+ if (rhs.engaged_) {
+ this->construct(std::move(rhs.data_));
+ }
+ }
+
+ optional_data& operator=(const optional_data& rhs) {
+ if (rhs.engaged_) {
+ this->assign(rhs.data_);
+ } else {
+ this->destruct();
+ }
+ return *this;
+ }
+
+ optional_data& operator=(optional_data&& rhs) noexcept(
+ std::is_nothrow_move_assignable<T>::value&&
+ std::is_nothrow_move_constructible<T>::value) {
+ if (rhs.engaged_) {
+ this->assign(std::move(rhs.data_));
+ } else {
+ this->destruct();
+ }
+ return *this;
+ }
+};
+
+// Ordered by level of restriction, from low to high.
+// Copyable implies movable.
+enum class copy_traits { copyable = 0, movable = 1, non_movable = 2 };
+
+// Base class for enabling/disabling copy/move constructor.
+template <copy_traits>
+class optional_ctor_base;
+
+template <>
+class optional_ctor_base<copy_traits::copyable> {
+ public:
+ constexpr optional_ctor_base() = default;
+ optional_ctor_base(const optional_ctor_base&) = default;
+ optional_ctor_base(optional_ctor_base&&) = default;
+ optional_ctor_base& operator=(const optional_ctor_base&) = default;
+ optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+template <>
+class optional_ctor_base<copy_traits::movable> {
+ public:
+ constexpr optional_ctor_base() = default;
+ optional_ctor_base(const optional_ctor_base&) = delete;
+ optional_ctor_base(optional_ctor_base&&) = default;
+ optional_ctor_base& operator=(const optional_ctor_base&) = default;
+ optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+template <>
+class optional_ctor_base<copy_traits::non_movable> {
+ public:
+ constexpr optional_ctor_base() = default;
+ optional_ctor_base(const optional_ctor_base&) = delete;
+ optional_ctor_base(optional_ctor_base&&) = delete;
+ optional_ctor_base& operator=(const optional_ctor_base&) = default;
+ optional_ctor_base& operator=(optional_ctor_base&&) = default;
+};
+
+// Base class for enabling/disabling copy/move assignment.
+template <copy_traits>
+class optional_assign_base;
+
+template <>
+class optional_assign_base<copy_traits::copyable> {
+ public:
+ constexpr optional_assign_base() = default;
+ optional_assign_base(const optional_assign_base&) = default;
+ optional_assign_base(optional_assign_base&&) = default;
+ optional_assign_base& operator=(const optional_assign_base&) = default;
+ optional_assign_base& operator=(optional_assign_base&&) = default;
+};
+
+template <>
+class optional_assign_base<copy_traits::movable> {
+ public:
+ constexpr optional_assign_base() = default;
+ optional_assign_base(const optional_assign_base&) = default;
+ optional_assign_base(optional_assign_base&&) = default;
+ optional_assign_base& operator=(const optional_assign_base&) = delete;
+ optional_assign_base& operator=(optional_assign_base&&) = default;
+};
+
+template <>
+class optional_assign_base<copy_traits::non_movable> {
+ public:
+ constexpr optional_assign_base() = default;
+ optional_assign_base(const optional_assign_base&) = default;
+ optional_assign_base(optional_assign_base&&) = default;
+ optional_assign_base& operator=(const optional_assign_base&) = delete;
+ optional_assign_base& operator=(optional_assign_base&&) = delete;
+};
+
+template <typename T>
+constexpr copy_traits get_ctor_copy_traits() {
+ return std::is_copy_constructible<T>::value
+ ? copy_traits::copyable
+ : std::is_move_constructible<T>::value ? copy_traits::movable
+ : copy_traits::non_movable;
+}
+
+template <typename T>
+constexpr copy_traits get_assign_copy_traits() {
+ return std::is_copy_assignable<T>::value &&
+ std::is_copy_constructible<T>::value
+ ? copy_traits::copyable
+ : std::is_move_assignable<T>::value &&
+ std::is_move_constructible<T>::value
+ ? copy_traits::movable
+ : copy_traits::non_movable;
+}
+
+// Whether T is constructible or convertible from optional<U>.
+template <typename T, typename U>
+struct is_constructible_convertible_from_optional
+ : std::integral_constant<
+ bool, std::is_constructible<T, optional<U>&>::value ||
+ std::is_constructible<T, optional<U>&&>::value ||
+ std::is_constructible<T, const optional<U>&>::value ||
+ std::is_constructible<T, const optional<U>&&>::value ||
+ std::is_convertible<optional<U>&, T>::value ||
+ std::is_convertible<optional<U>&&, T>::value ||
+ std::is_convertible<const optional<U>&, T>::value ||
+ std::is_convertible<const optional<U>&&, T>::value> {};
+
+// Whether T is constructible or convertible or assignable from optional<U>.
+template <typename T, typename U>
+struct is_constructible_convertible_assignable_from_optional
+ : std::integral_constant<
+ bool, is_constructible_convertible_from_optional<T, U>::value ||
+ std::is_assignable<T&, optional<U>&>::value ||
+ std::is_assignable<T&, optional<U>&&>::value ||
+ std::is_assignable<T&, const optional<U>&>::value ||
+ std::is_assignable<T&, const optional<U>&&>::value> {};
+
+// Helper function used by [optional.relops], [optional.comp_with_t],
+// for checking whether an expression is convertible to bool.
+bool convertible_to_bool(bool);
+
+// Base class for std::hash<absl::optional<T>>:
+// If std::hash<std::remove_const_t<T>> is enabled, it provides operator() to
+// compute the hash; Otherwise, it is disabled.
+// Reference N4659 23.14.15 [unord.hash].
+template <typename T, typename = size_t>
+struct optional_hash_base {
+ optional_hash_base() = delete;
+ optional_hash_base(const optional_hash_base&) = delete;
+ optional_hash_base(optional_hash_base&&) = delete;
+ optional_hash_base& operator=(const optional_hash_base&) = delete;
+ optional_hash_base& operator=(optional_hash_base&&) = delete;
+};
+
+template <typename T>
+struct optional_hash_base<T, decltype(std::hash<absl::remove_const_t<T> >()(
+ std::declval<absl::remove_const_t<T> >()))> {
+ using argument_type = absl::optional<T>;
+ using result_type = size_t;
+ size_t operator()(const absl::optional<T>& opt) const {
+ if (opt) {
+ return std::hash<absl::remove_const_t<T> >()(*opt);
+ } else {
+ return static_cast<size_t>(0x297814aaad196e6dULL);
+ }
+ }
+};
+
+} // namespace optional_internal
+
+// -----------------------------------------------------------------------------
+// absl::optional class definition
+// -----------------------------------------------------------------------------
+
+template <typename T>
+class optional : private optional_internal::optional_data<T>,
+ private optional_internal::optional_ctor_base<
+ optional_internal::get_ctor_copy_traits<T>()>,
+ private optional_internal::optional_assign_base<
+ optional_internal::get_assign_copy_traits<T>()> {
+ using data_base = optional_internal::optional_data<T>;
+
+ public:
+ typedef T value_type;
+
+ // Constructors
+
+ // Constructs an `optional` holding an empty value, NOT a default constructed
+ // `T`.
+ constexpr optional() noexcept {}
+
+ // Constructs an `optional` initialized with `nullopt` to hold an empty value.
+ constexpr optional(nullopt_t) noexcept {} // NOLINT(runtime/explicit)
+
+ // Copy constructor, standard semantics
+ optional(const optional& src) = default;
+
+ // Move constructor, standard semantics
+ optional(optional&& src) = default;
+
+ // Constructs a non-empty `optional` direct-initialized value of type `T` from
+ // the arguments `std::forward<Args>(args)...` within the `optional`.
+ // (The `in_place_t` is a tag used to indicate that the contained object
+ // should be constructed in-place.)
+ //
+ // TODO(absl-team): Add std::is_constructible<T, Args&&...> SFINAE.
+ template <typename... Args>
+ constexpr explicit optional(in_place_t, Args&&... args)
+ : data_base(in_place_t(), absl::forward<Args>(args)...) {}
+
+ // Constructs a non-empty `optional` direct-initialized value of type `T` from
+ // the arguments of an initializer_list and `std::forward<Args>(args)...`.
+ // (The `in_place_t` is a tag used to indicate that the contained object
+ // should be constructed in-place.)
+ template <typename U, typename... Args,
+ typename = typename std::enable_if<std::is_constructible<
+ T, std::initializer_list<U>&, Args&&...>::value>::type>
+ constexpr explicit optional(in_place_t, std::initializer_list<U> il,
+ Args&&... args)
+ : data_base(in_place_t(), il, absl::forward<Args>(args)...) {
+ }
+
+ // Value constructor (implicit)
+ template <
+ typename U = T,
+ typename std::enable_if<
+ absl::conjunction<absl::negation<std::is_same<
+ in_place_t, typename std::decay<U>::type> >,
+ absl::negation<std::is_same<
+ optional<T>, typename std::decay<U>::type> >,
+ std::is_convertible<U&&, T>,
+ std::is_constructible<T, U&&> >::value,
+ bool>::type = false>
+ constexpr optional(U&& v) : data_base(in_place_t(), absl::forward<U>(v)) {}
+
+ // Value constructor (explicit)
+ template <
+ typename U = T,
+ typename std::enable_if<
+ absl::conjunction<absl::negation<std::is_same<
+ in_place_t, typename std::decay<U>::type>>,
+ absl::negation<std::is_same<
+ optional<T>, typename std::decay<U>::type>>,
+ absl::negation<std::is_convertible<U&&, T>>,
+ std::is_constructible<T, U&&>>::value,
+ bool>::type = false>
+ explicit constexpr optional(U&& v)
+ : data_base(in_place_t(), absl::forward<U>(v)) {}
+
+ // Converting copy constructor (implicit)
+ template <typename U,
+ typename std::enable_if<
+ absl::conjunction<
+ absl::negation<std::is_same<T, U> >,
+ std::is_constructible<T, const U&>,
+ absl::negation<
+ optional_internal::
+ is_constructible_convertible_from_optional<T, U> >,
+ std::is_convertible<const U&, T> >::value,
+ bool>::type = false>
+ optional(const optional<U>& rhs) {
+ if (rhs) {
+ this->construct(*rhs);
+ }
+ }
+
+ // Converting copy constructor (explicit)
+ template <typename U,
+ typename std::enable_if<
+ absl::conjunction<
+ absl::negation<std::is_same<T, U>>,
+ std::is_constructible<T, const U&>,
+ absl::negation<
+ optional_internal::
+ is_constructible_convertible_from_optional<T, U>>,
+ absl::negation<std::is_convertible<const U&, T>>>::value,
+ bool>::type = false>
+ explicit optional(const optional<U>& rhs) {
+ if (rhs) {
+ this->construct(*rhs);
+ }
+ }
+
+ // Converting move constructor (implicit)
+ template <typename U,
+ typename std::enable_if<
+ absl::conjunction<
+ absl::negation<std::is_same<T, U> >,
+ std::is_constructible<T, U&&>,
+ absl::negation<
+ optional_internal::
+ is_constructible_convertible_from_optional<T, U> >,
+ std::is_convertible<U&&, T> >::value,
+ bool>::type = false>
+ optional(optional<U>&& rhs) {
+ if (rhs) {
+ this->construct(std::move(*rhs));
+ }
+ }
+
+ // Converting move constructor (explicit)
+ template <
+ typename U,
+ typename std::enable_if<
+ absl::conjunction<
+ absl::negation<std::is_same<T, U>>, std::is_constructible<T, U&&>,
+ absl::negation<
+ optional_internal::is_constructible_convertible_from_optional<
+ T, U>>,
+ absl::negation<std::is_convertible<U&&, T>>>::value,
+ bool>::type = false>
+ explicit optional(optional<U>&& rhs) {
+ if (rhs) {
+ this->construct(std::move(*rhs));
+ }
+ }
+
+ // Destructor. Trivial if `T` is trivially destructible.
+ ~optional() = default;
+
+ // Assignment Operators
+
+ // Assignment from `nullopt`
+ //
+ // Example:
+ //
+ // struct S { int value; };
+ // optional<S> opt = absl::nullopt; // Could also use opt = { };
+ optional& operator=(nullopt_t) noexcept {
+ this->destruct();
+ return *this;
+ }
+
+ // Copy assignment operator, standard semantics
+ optional& operator=(const optional& src) = default;
+
+ // Move assignment operator, standard semantics
+ optional& operator=(optional&& src) = default;
+
+ // Value assignment operators
+ template <
+ typename U = T,
+ typename = typename std::enable_if<absl::conjunction<
+ absl::negation<
+ std::is_same<optional<T>, typename std::decay<U>::type>>,
+ absl::negation<
+ absl::conjunction<std::is_scalar<T>,
+ std::is_same<T, typename std::decay<U>::type>>>,
+ std::is_constructible<T, U>, std::is_assignable<T&, U>>::value>::type>
+ optional& operator=(U&& v) {
+ this->assign(std::forward<U>(v));
+ return *this;
+ }
+
+ template <
+ typename U,
+ typename = typename std::enable_if<absl::conjunction<
+ absl::negation<std::is_same<T, U>>,
+ std::is_constructible<T, const U&>, std::is_assignable<T&, const U&>,
+ absl::negation<
+ optional_internal::
+ is_constructible_convertible_assignable_from_optional<
+ T, U>>>::value>::type>
+ optional& operator=(const optional<U>& rhs) {
+ if (rhs) {
+ this->assign(*rhs);
+ } else {
+ this->destruct();
+ }
+ return *this;
+ }
+
+ template <typename U,
+ typename = typename std::enable_if<absl::conjunction<
+ absl::negation<std::is_same<T, U>>, std::is_constructible<T, U>,
+ std::is_assignable<T&, U>,
+ absl::negation<
+ optional_internal::
+ is_constructible_convertible_assignable_from_optional<
+ T, U>>>::value>::type>
+ optional& operator=(optional<U>&& rhs) {
+ if (rhs) {
+ this->assign(std::move(*rhs));
+ } else {
+ this->destruct();
+ }
+ return *this;
+ }
+
+ // Modifiers
+
+ // optional::reset()
+ //
+ // Destroys the inner `T` value of an `absl::optional` if one is present.
+ void reset() noexcept { this->destruct(); }
+
+ // optional::emplace()
+ //
+ // (Re)constructs the underlying `T` in-place with the given forwarded
+ // arguments.
+ //
+ // Example:
+ //
+ // optional<Foo> opt;
+ // opt.emplace(arg1,arg2,arg3); // Constructs Foo(arg1,arg2,arg3)
+ //
+ // If the optional is non-empty, and the `args` refer to subobjects of the
+ // current object, then behaviour is undefined, because the current object
+ // will be destructed before the new object is constructed with `args`.
+ template <typename... Args,
+ typename = typename std::enable_if<
+ std::is_constructible<T, Args&&...>::value>::type>
+ T& emplace(Args&&... args) {
+ this->destruct();
+ this->construct(std::forward<Args>(args)...);
+ return reference();
+ }
+
+ // Emplace reconstruction overload for an initializer list and the given
+ // forwarded arguments.
+ //
+ // Example:
+ //
+ // struct Foo {
+ // Foo(std::initializer_list<int>);
+ // };
+ //
+ // optional<Foo> opt;
+ // opt.emplace({1,2,3}); // Constructs Foo({1,2,3})
+ template <typename U, typename... Args,
+ typename = typename std::enable_if<std::is_constructible<
+ T, std::initializer_list<U>&, Args&&...>::value>::type>
+ T& emplace(std::initializer_list<U> il, Args&&... args) {
+ this->destruct();
+ this->construct(il, std::forward<Args>(args)...);
+ return reference();
+ }
+
+ // Swaps
+
+ // Swap, standard semantics
+ void swap(optional& rhs) noexcept(
+ std::is_nothrow_move_constructible<T>::value&&
+ std::is_trivial<T>::value) {
+ if (*this) {
+ if (rhs) {
+ using std::swap;
+ swap(**this, *rhs);
+ } else {
+ rhs.construct(std::move(**this));
+ this->destruct();
+ }
+ } else {
+ if (rhs) {
+ this->construct(std::move(*rhs));
+ rhs.destruct();
+ } else {
+ // No effect (swap(disengaged, disengaged)).
+ }
+ }
+ }
+
+ // Observers
+
+ // optional::operator->()
+ //
+ // Accesses the underlying `T` value's member `m` of an `optional`. If the
+ // `optional` is empty, behavior is undefined.
+ //
+ // If you need myOpt->foo in constexpr, use (*myOpt).foo instead.
+ const T* operator->() const { return this->pointer(); }
+ T* operator->() {
+ assert(this->engaged_);
+ return this->pointer();
+ }
+
+ // optional::operator*()
+ //
+ // Accesses the underlying `T` value of an `optional`. If the `optional` is
+ // empty, behavior is undefined.
+ constexpr const T& operator*() const & { return reference(); }
+ T& operator*() & {
+ assert(this->engaged_);
+ return reference();
+ }
+ constexpr const T&& operator*() const && {
+ return absl::move(reference());
+ }
+ T&& operator*() && {
+ assert(this->engaged_);
+ return std::move(reference());
+ }
+
+ // optional::operator bool()
+ //
+ // Returns false if and only if the `optional` is empty.
+ //
+ // if (opt) {
+ // // do something with opt.value();
+ // } else {
+ // // opt is empty.
+ // }
+ //
+ constexpr explicit operator bool() const noexcept { return this->engaged_; }
+
+ // optional::has_value()
+ //
+ // Determines whether the `optional` contains a value. Returns `false` if and
+ // only if `*this` is empty.
+ constexpr bool has_value() const noexcept { return this->engaged_; }
+
+ // optional::value()
+ //
+ // Returns a reference to an `optional`s underlying value. The constness
+ // and lvalue/rvalue-ness of the `optional` is preserved to the view of
+ // the `T` sub-object. Throws `absl::bad_optional_access` when the `optional`
+ // is empty.
+ constexpr const T& value() const & {
+ return static_cast<bool>(*this)
+ ? reference()
+ : (optional_internal::throw_bad_optional_access(), reference());
+ }
+ T& value() & {
+ return static_cast<bool>(*this)
+ ? reference()
+ : (optional_internal::throw_bad_optional_access(), reference());
+ }
+ T&& value() && { // NOLINT(build/c++11)
+ return std::move(
+ static_cast<bool>(*this)
+ ? reference()
+ : (optional_internal::throw_bad_optional_access(), reference()));
+ }
+ constexpr const T&& value() const && { // NOLINT(build/c++11)
+ return absl::move(
+ static_cast<bool>(*this)
+ ? reference()
+ : (optional_internal::throw_bad_optional_access(), reference()));
+ }
+
+ // optional::value_or()
+ //
+ // Returns either the value of `T` or a passed default `v` if the `optional`
+ // is empty.
+ template <typename U>
+ constexpr T value_or(U&& v) const& {
+ static_assert(std::is_copy_constructible<value_type>::value,
+ "optional<T>::value_or: T must by copy constructible");
+ static_assert(std::is_convertible<U&&, value_type>::value,
+ "optional<T>::value_or: U must be convertible to T");
+ return static_cast<bool>(*this)
+ ? **this
+ : static_cast<T>(absl::forward<U>(v));
+ }
+ template <typename U>
+ T value_or(U&& v) && { // NOLINT(build/c++11)
+ static_assert(std::is_move_constructible<value_type>::value,
+ "optional<T>::value_or: T must by copy constructible");
+ static_assert(std::is_convertible<U&&, value_type>::value,
+ "optional<T>::value_or: U must be convertible to T");
+ return static_cast<bool>(*this) ? std::move(**this)
+ : static_cast<T>(std::forward<U>(v));
+ }
+
+ private:
+ // Private accessors for internal storage viewed as pointer to T.
+ const T* pointer() const { return std::addressof(this->data_); }
+ T* pointer() { return std::addressof(this->data_); }
+
+ // Private accessors for internal storage viewed as reference to T.
+ constexpr const T& reference() const { return this->data_; }
+ T& reference() { return this->data_; }
+
+ // T constraint checks. You can't have an optional of nullopt_t, in_place_t
+ // or a reference.
+ static_assert(
+ !std::is_same<nullopt_t, typename std::remove_cv<T>::type>::value,
+ "optional<nullopt_t> is not allowed.");
+ static_assert(
+ !std::is_same<in_place_t, typename std::remove_cv<T>::type>::value,
+ "optional<in_place_t> is not allowed.");
+ static_assert(!std::is_reference<T>::value,
+ "optional<reference> is not allowed.");
+};
+
+// Non-member functions
+
+// swap()
+//
+// Performs a swap between two `absl::optional` objects, using standard
+// semantics.
+//
+// NOTE: we assume `is_swappable()` is always `true`. A compile error will
+// result if this is not the case.
+template <typename T,
+ typename std::enable_if<std::is_move_constructible<T>::value,
+ bool>::type = false>
+void swap(optional<T>& a, optional<T>& b) noexcept(noexcept(a.swap(b))) {
+ a.swap(b);
+}
+
+// make_optional()
+//
+// Creates a non-empty `optional<T>` where the type of `T` is deduced. An
+// `absl::optional` can also be explicitly instantiated with
+// `make_optional<T>(v)`.
+//
+// Note: `make_optional()` constructions may be declared `constexpr` for
+// trivially copyable types `T`. Non-trivial types require copy elision
+// support in C++17 for `make_optional` to support `constexpr` on such
+// non-trivial types.
+//
+// Example:
+//
+// constexpr absl::optional<int> opt = absl::make_optional(1);
+// static_assert(opt.value() == 1, "");
+template <typename T>
+constexpr optional<typename std::decay<T>::type> make_optional(T&& v) {
+ return optional<typename std::decay<T>::type>(absl::forward<T>(v));
+}
+
+template <typename T, typename... Args>
+constexpr optional<T> make_optional(Args&&... args) {
+ return optional<T>(in_place_t(), absl::forward<Args>(args)...);
+}
+
+template <typename T, typename U, typename... Args>
+constexpr optional<T> make_optional(std::initializer_list<U> il,
+ Args&&... args) {
+ return optional<T>(in_place_t(), il,
+ absl::forward<Args>(args)...);
+}
+
+// Relational operators [optional.relops]
+
+// Empty optionals are considered equal to each other and less than non-empty
+// optionals. Supports relations between optional<T> and optional<U>, between
+// optional<T> and U, and between optional<T> and nullopt.
+//
+// Note: We're careful to support T having non-bool relationals.
+
+// Requires: The expression, e.g. "*x == *y" shall be well-formed and its result
+// shall be convertible to bool.
+// The C++17 (N4606) "Returns:" statements are translated into
+// code in an obvious way here, and the original text retained as function docs.
+// Returns: If bool(x) != bool(y), false; otherwise if bool(x) == false, true;
+// otherwise *x == *y.
+template <typename T, typename U>
+constexpr auto operator==(const optional<T>& x, const optional<U>& y)
+ -> decltype(optional_internal::convertible_to_bool(*x == *y)) {
+ return static_cast<bool>(x) != static_cast<bool>(y)
+ ? false
+ : static_cast<bool>(x) == false ? true : *x == *y;
+}
+
+// Returns: If bool(x) != bool(y), true; otherwise, if bool(x) == false, false;
+// otherwise *x != *y.
+template <typename T, typename U>
+constexpr auto operator!=(const optional<T>& x, const optional<U>& y)
+ -> decltype(optional_internal::convertible_to_bool(*x != *y)) {
+ return static_cast<bool>(x) != static_cast<bool>(y)
+ ? true
+ : static_cast<bool>(x) == false ? false : *x != *y;
+}
+// Returns: If !y, false; otherwise, if !x, true; otherwise *x < *y.
+template <typename T, typename U>
+constexpr auto operator<(const optional<T>& x, const optional<U>& y)
+ -> decltype(optional_internal::convertible_to_bool(*x < *y)) {
+ return !y ? false : !x ? true : *x < *y;
+}
+// Returns: If !x, false; otherwise, if !y, true; otherwise *x > *y.
+template <typename T, typename U>
+constexpr auto operator>(const optional<T>& x, const optional<U>& y)
+ -> decltype(optional_internal::convertible_to_bool(*x > *y)) {
+ return !x ? false : !y ? true : *x > *y;
+}
+// Returns: If !x, true; otherwise, if !y, false; otherwise *x <= *y.
+template <typename T, typename U>
+constexpr auto operator<=(const optional<T>& x, const optional<U>& y)
+ -> decltype(optional_internal::convertible_to_bool(*x <= *y)) {
+ return !x ? true : !y ? false : *x <= *y;
+}
+// Returns: If !y, true; otherwise, if !x, false; otherwise *x >= *y.
+template <typename T, typename U>
+constexpr auto operator>=(const optional<T>& x, const optional<U>& y)
+ -> decltype(optional_internal::convertible_to_bool(*x >= *y)) {
+ return !y ? true : !x ? false : *x >= *y;
+}
+
+// Comparison with nullopt [optional.nullops]
+// The C++17 (N4606) "Returns:" statements are used directly here.
+template <typename T>
+constexpr bool operator==(const optional<T>& x, nullopt_t) noexcept {
+ return !x;
+}
+template <typename T>
+constexpr bool operator==(nullopt_t, const optional<T>& x) noexcept {
+ return !x;
+}
+template <typename T>
+constexpr bool operator!=(const optional<T>& x, nullopt_t) noexcept {
+ return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator!=(nullopt_t, const optional<T>& x) noexcept {
+ return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator<(const optional<T>&, nullopt_t) noexcept {
+ return false;
+}
+template <typename T>
+constexpr bool operator<(nullopt_t, const optional<T>& x) noexcept {
+ return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator<=(const optional<T>& x, nullopt_t) noexcept {
+ return !x;
+}
+template <typename T>
+constexpr bool operator<=(nullopt_t, const optional<T>&) noexcept {
+ return true;
+}
+template <typename T>
+constexpr bool operator>(const optional<T>& x, nullopt_t) noexcept {
+ return static_cast<bool>(x);
+}
+template <typename T>
+constexpr bool operator>(nullopt_t, const optional<T>&) noexcept {
+ return false;
+}
+template <typename T>
+constexpr bool operator>=(const optional<T>&, nullopt_t) noexcept {
+ return true;
+}
+template <typename T>
+constexpr bool operator>=(nullopt_t, const optional<T>& x) noexcept {
+ return !x;
+}
+
+// Comparison with T [optional.comp_with_t]
+
+// Requires: The expression, e.g. "*x == v" shall be well-formed and its result
+// shall be convertible to bool.
+// The C++17 (N4606) "Equivalent to:" statements are used directly here.
+template <typename T, typename U>
+constexpr auto operator==(const optional<T>& x, const U& v)
+ -> decltype(optional_internal::convertible_to_bool(*x == v)) {
+ return static_cast<bool>(x) ? *x == v : false;
+}
+template <typename T, typename U>
+constexpr auto operator==(const U& v, const optional<T>& x)
+ -> decltype(optional_internal::convertible_to_bool(v == *x)) {
+ return static_cast<bool>(x) ? v == *x : false;
+}
+template <typename T, typename U>
+constexpr auto operator!=(const optional<T>& x, const U& v)
+ -> decltype(optional_internal::convertible_to_bool(*x != v)) {
+ return static_cast<bool>(x) ? *x != v : true;
+}
+template <typename T, typename U>
+constexpr auto operator!=(const U& v, const optional<T>& x)
+ -> decltype(optional_internal::convertible_to_bool(v != *x)) {
+ return static_cast<bool>(x) ? v != *x : true;
+}
+template <typename T, typename U>
+constexpr auto operator<(const optional<T>& x, const U& v)
+ -> decltype(optional_internal::convertible_to_bool(*x < v)) {
+ return static_cast<bool>(x) ? *x < v : true;
+}
+template <typename T, typename U>
+constexpr auto operator<(const U& v, const optional<T>& x)
+ -> decltype(optional_internal::convertible_to_bool(v < *x)) {
+ return static_cast<bool>(x) ? v < *x : false;
+}
+template <typename T, typename U>
+constexpr auto operator<=(const optional<T>& x, const U& v)
+ -> decltype(optional_internal::convertible_to_bool(*x <= v)) {
+ return static_cast<bool>(x) ? *x <= v : true;
+}
+template <typename T, typename U>
+constexpr auto operator<=(const U& v, const optional<T>& x)
+ -> decltype(optional_internal::convertible_to_bool(v <= *x)) {
+ return static_cast<bool>(x) ? v <= *x : false;
+}
+template <typename T, typename U>
+constexpr auto operator>(const optional<T>& x, const U& v)
+ -> decltype(optional_internal::convertible_to_bool(*x > v)) {
+ return static_cast<bool>(x) ? *x > v : false;
+}
+template <typename T, typename U>
+constexpr auto operator>(const U& v, const optional<T>& x)
+ -> decltype(optional_internal::convertible_to_bool(v > *x)) {
+ return static_cast<bool>(x) ? v > *x : true;
+}
+template <typename T, typename U>
+constexpr auto operator>=(const optional<T>& x, const U& v)
+ -> decltype(optional_internal::convertible_to_bool(*x >= v)) {
+ return static_cast<bool>(x) ? *x >= v : false;
+}
+template <typename T, typename U>
+constexpr auto operator>=(const U& v, const optional<T>& x)
+ -> decltype(optional_internal::convertible_to_bool(v >= *x)) {
+ return static_cast<bool>(x) ? v >= *x : true;
+}
+
+} // namespace absl
+
+namespace std {
+
+// std::hash specialization for absl::optional.
+template <typename T>
+struct hash<absl::optional<T> >
+ : absl::optional_internal::optional_hash_base<T> {};
+
+} // namespace std
+
+#undef ABSL_OPTIONAL_USE_INHERITING_CONSTRUCTORS
+#undef ABSL_MSVC_CONSTEXPR_BUG_IN_UNION_LIKE_CLASS
+
+#endif // ABSL_HAVE_STD_OPTIONAL
+
+#endif // ABSL_TYPES_OPTIONAL_H_
[21/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex_test.cc
new file mode 100644
index 0000000..53b9378
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/mutex_test.cc
@@ -0,0 +1,1539 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/mutex.h"
+
+#ifdef WIN32
+#include <windows.h>
+#endif
+
+#include <algorithm>
+#include <atomic>
+#include <cstdlib>
+#include <functional>
+#include <memory>
+#include <random>
+#include <string>
+#include <thread> // NOLINT(build/c++11)
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/sysinfo.h"
+#include "absl/memory/memory.h"
+#include "absl/synchronization/internal/thread_pool.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+namespace {
+
+// TODO(dmauro): Replace with a commandline flag.
+static constexpr bool kExtendedTest = false;
+
+std::unique_ptr<absl::synchronization_internal::ThreadPool> CreatePool(
+ int threads) {
+ return absl::make_unique<absl::synchronization_internal::ThreadPool>(threads);
+}
+
+std::unique_ptr<absl::synchronization_internal::ThreadPool>
+CreateDefaultPool() {
+ return CreatePool(kExtendedTest ? 32 : 10);
+}
+
+// Hack to schedule a function to run on a thread pool thread after a
+// duration has elapsed.
+static void ScheduleAfter(absl::synchronization_internal::ThreadPool *tp,
+ const std::function<void()> &func,
+ absl::Duration after) {
+ tp->Schedule([func, after] {
+ absl::SleepFor(after);
+ func();
+ });
+}
+
+struct TestContext {
+ int iterations;
+ int threads;
+ int g0; // global 0
+ int g1; // global 1
+ absl::Mutex mu;
+ absl::CondVar cv;
+};
+
+// To test whether the invariant check call occurs
+static std::atomic<bool> invariant_checked;
+
+static bool GetInvariantChecked() {
+ return invariant_checked.load(std::memory_order_relaxed);
+}
+
+static void SetInvariantChecked(bool new_value) {
+ invariant_checked.store(new_value, std::memory_order_relaxed);
+}
+
+static void CheckSumG0G1(void *v) {
+ TestContext *cxt = static_cast<TestContext *>(v);
+ ABSL_RAW_CHECK(cxt->g0 == -cxt->g1, "Error in CheckSumG0G1");
+ SetInvariantChecked(true);
+}
+
+static void TestMu(TestContext *cxt, int c) {
+ for (int i = 0; i != cxt->iterations; i++) {
+ absl::MutexLock l(&cxt->mu);
+ int a = cxt->g0 + 1;
+ cxt->g0 = a;
+ cxt->g1--;
+ }
+}
+
+static void TestTry(TestContext *cxt, int c) {
+ for (int i = 0; i != cxt->iterations; i++) {
+ do {
+ std::this_thread::yield();
+ } while (!cxt->mu.TryLock());
+ int a = cxt->g0 + 1;
+ cxt->g0 = a;
+ cxt->g1--;
+ cxt->mu.Unlock();
+ }
+}
+
+static void TestR20ms(TestContext *cxt, int c) {
+ for (int i = 0; i != cxt->iterations; i++) {
+ absl::ReaderMutexLock l(&cxt->mu);
+ absl::SleepFor(absl::Milliseconds(20));
+ cxt->mu.AssertReaderHeld();
+ }
+}
+
+static void TestRW(TestContext *cxt, int c) {
+ if ((c & 1) == 0) {
+ for (int i = 0; i != cxt->iterations; i++) {
+ absl::WriterMutexLock l(&cxt->mu);
+ cxt->g0++;
+ cxt->g1--;
+ cxt->mu.AssertHeld();
+ cxt->mu.AssertReaderHeld();
+ }
+ } else {
+ for (int i = 0; i != cxt->iterations; i++) {
+ absl::ReaderMutexLock l(&cxt->mu);
+ ABSL_RAW_CHECK(cxt->g0 == -cxt->g1, "Error in TestRW");
+ cxt->mu.AssertReaderHeld();
+ }
+ }
+}
+
+struct MyContext {
+ int target;
+ TestContext *cxt;
+ bool MyTurn();
+};
+
+bool MyContext::MyTurn() {
+ TestContext *cxt = this->cxt;
+ return cxt->g0 == this->target || cxt->g0 == cxt->iterations;
+}
+
+static void TestAwait(TestContext *cxt, int c) {
+ MyContext mc;
+ mc.target = c;
+ mc.cxt = cxt;
+ absl::MutexLock l(&cxt->mu);
+ cxt->mu.AssertHeld();
+ while (cxt->g0 < cxt->iterations) {
+ cxt->mu.Await(absl::Condition(&mc, &MyContext::MyTurn));
+ ABSL_RAW_CHECK(mc.MyTurn(), "Error in TestAwait");
+ cxt->mu.AssertHeld();
+ if (cxt->g0 < cxt->iterations) {
+ int a = cxt->g0 + 1;
+ cxt->g0 = a;
+ mc.target += cxt->threads;
+ }
+ }
+}
+
+static void TestSignalAll(TestContext *cxt, int c) {
+ int target = c;
+ absl::MutexLock l(&cxt->mu);
+ cxt->mu.AssertHeld();
+ while (cxt->g0 < cxt->iterations) {
+ while (cxt->g0 != target && cxt->g0 != cxt->iterations) {
+ cxt->cv.Wait(&cxt->mu);
+ }
+ if (cxt->g0 < cxt->iterations) {
+ int a = cxt->g0 + 1;
+ cxt->g0 = a;
+ cxt->cv.SignalAll();
+ target += cxt->threads;
+ }
+ }
+}
+
+static void TestSignal(TestContext *cxt, int c) {
+ ABSL_RAW_CHECK(cxt->threads == 2, "TestSignal should use 2 threads");
+ int target = c;
+ absl::MutexLock l(&cxt->mu);
+ cxt->mu.AssertHeld();
+ while (cxt->g0 < cxt->iterations) {
+ while (cxt->g0 != target && cxt->g0 != cxt->iterations) {
+ cxt->cv.Wait(&cxt->mu);
+ }
+ if (cxt->g0 < cxt->iterations) {
+ int a = cxt->g0 + 1;
+ cxt->g0 = a;
+ cxt->cv.Signal();
+ target += cxt->threads;
+ }
+ }
+}
+
+static void TestCVTimeout(TestContext *cxt, int c) {
+ int target = c;
+ absl::MutexLock l(&cxt->mu);
+ cxt->mu.AssertHeld();
+ while (cxt->g0 < cxt->iterations) {
+ while (cxt->g0 != target && cxt->g0 != cxt->iterations) {
+ cxt->cv.WaitWithTimeout(&cxt->mu, absl::Seconds(100));
+ }
+ if (cxt->g0 < cxt->iterations) {
+ int a = cxt->g0 + 1;
+ cxt->g0 = a;
+ cxt->cv.SignalAll();
+ target += cxt->threads;
+ }
+ }
+}
+
+static bool G0GE2(TestContext *cxt) { return cxt->g0 >= 2; }
+
+static void TestTime(TestContext *cxt, int c, bool use_cv) {
+ ABSL_RAW_CHECK(cxt->iterations == 1, "TestTime should only use 1 iteration");
+ ABSL_RAW_CHECK(cxt->threads > 2, "TestTime should use more than 2 threads");
+ const bool kFalse = false;
+ absl::Condition false_cond(&kFalse);
+ absl::Condition g0ge2(G0GE2, cxt);
+ if (c == 0) {
+ absl::MutexLock l(&cxt->mu);
+
+ absl::Time start = absl::Now();
+ if (use_cv) {
+ cxt->cv.WaitWithTimeout(&cxt->mu, absl::Seconds(1));
+ } else {
+ ABSL_RAW_CHECK(!cxt->mu.AwaitWithTimeout(false_cond, absl::Seconds(1)),
+ "TestTime failed");
+ }
+ absl::Duration elapsed = absl::Now() - start;
+ ABSL_RAW_CHECK(
+ absl::Seconds(0.9) <= elapsed && elapsed <= absl::Seconds(2.0),
+ "TestTime failed");
+ ABSL_RAW_CHECK(cxt->g0 == 1, "TestTime failed");
+
+ start = absl::Now();
+ if (use_cv) {
+ cxt->cv.WaitWithTimeout(&cxt->mu, absl::Seconds(1));
+ } else {
+ ABSL_RAW_CHECK(!cxt->mu.AwaitWithTimeout(false_cond, absl::Seconds(1)),
+ "TestTime failed");
+ }
+ elapsed = absl::Now() - start;
+ ABSL_RAW_CHECK(
+ absl::Seconds(0.9) <= elapsed && elapsed <= absl::Seconds(2.0),
+ "TestTime failed");
+ cxt->g0++;
+ if (use_cv) {
+ cxt->cv.Signal();
+ }
+
+ start = absl::Now();
+ if (use_cv) {
+ cxt->cv.WaitWithTimeout(&cxt->mu, absl::Seconds(4));
+ } else {
+ ABSL_RAW_CHECK(!cxt->mu.AwaitWithTimeout(false_cond, absl::Seconds(4)),
+ "TestTime failed");
+ }
+ elapsed = absl::Now() - start;
+ ABSL_RAW_CHECK(
+ absl::Seconds(3.9) <= elapsed && elapsed <= absl::Seconds(6.0),
+ "TestTime failed");
+ ABSL_RAW_CHECK(cxt->g0 >= 3, "TestTime failed");
+
+ start = absl::Now();
+ if (use_cv) {
+ cxt->cv.WaitWithTimeout(&cxt->mu, absl::Seconds(1));
+ } else {
+ ABSL_RAW_CHECK(!cxt->mu.AwaitWithTimeout(false_cond, absl::Seconds(1)),
+ "TestTime failed");
+ }
+ elapsed = absl::Now() - start;
+ ABSL_RAW_CHECK(
+ absl::Seconds(0.9) <= elapsed && elapsed <= absl::Seconds(2.0),
+ "TestTime failed");
+ if (use_cv) {
+ cxt->cv.SignalAll();
+ }
+
+ start = absl::Now();
+ if (use_cv) {
+ cxt->cv.WaitWithTimeout(&cxt->mu, absl::Seconds(1));
+ } else {
+ ABSL_RAW_CHECK(!cxt->mu.AwaitWithTimeout(false_cond, absl::Seconds(1)),
+ "TestTime failed");
+ }
+ elapsed = absl::Now() - start;
+ ABSL_RAW_CHECK(absl::Seconds(0.9) <= elapsed &&
+ elapsed <= absl::Seconds(2.0), "TestTime failed");
+ ABSL_RAW_CHECK(cxt->g0 == cxt->threads, "TestTime failed");
+
+ } else if (c == 1) {
+ absl::MutexLock l(&cxt->mu);
+ const absl::Time start = absl::Now();
+ if (use_cv) {
+ cxt->cv.WaitWithTimeout(&cxt->mu, absl::Milliseconds(500));
+ } else {
+ ABSL_RAW_CHECK(
+ !cxt->mu.AwaitWithTimeout(false_cond, absl::Milliseconds(500)),
+ "TestTime failed");
+ }
+ const absl::Duration elapsed = absl::Now() - start;
+ ABSL_RAW_CHECK(
+ absl::Seconds(0.4) <= elapsed && elapsed <= absl::Seconds(0.9),
+ "TestTime failed");
+ cxt->g0++;
+ } else if (c == 2) {
+ absl::MutexLock l(&cxt->mu);
+ if (use_cv) {
+ while (cxt->g0 < 2) {
+ cxt->cv.WaitWithTimeout(&cxt->mu, absl::Seconds(100));
+ }
+ } else {
+ ABSL_RAW_CHECK(cxt->mu.AwaitWithTimeout(g0ge2, absl::Seconds(100)),
+ "TestTime failed");
+ }
+ cxt->g0++;
+ } else {
+ absl::MutexLock l(&cxt->mu);
+ if (use_cv) {
+ while (cxt->g0 < 2) {
+ cxt->cv.Wait(&cxt->mu);
+ }
+ } else {
+ cxt->mu.Await(g0ge2);
+ }
+ cxt->g0++;
+ }
+}
+
+static void TestMuTime(TestContext *cxt, int c) { TestTime(cxt, c, false); }
+
+static void TestCVTime(TestContext *cxt, int c) { TestTime(cxt, c, true); }
+
+static void EndTest(int *c0, int *c1, absl::Mutex *mu, absl::CondVar *cv,
+ const std::function<void(int)>& cb) {
+ mu->Lock();
+ int c = (*c0)++;
+ mu->Unlock();
+ cb(c);
+ absl::MutexLock l(mu);
+ (*c1)++;
+ cv->Signal();
+}
+
+// Code common to RunTest() and RunTestWithInvariantDebugging().
+static int RunTestCommon(TestContext *cxt, void (*test)(TestContext *cxt, int),
+ int threads, int iterations, int operations) {
+ absl::Mutex mu2;
+ absl::CondVar cv2;
+ int c0 = 0;
+ int c1 = 0;
+ cxt->g0 = 0;
+ cxt->g1 = 0;
+ cxt->iterations = iterations;
+ cxt->threads = threads;
+ absl::synchronization_internal::ThreadPool tp(threads);
+ for (int i = 0; i != threads; i++) {
+ tp.Schedule(std::bind(&EndTest, &c0, &c1, &mu2, &cv2,
+ std::function<void(int)>(
+ std::bind(test, cxt, std::placeholders::_1))));
+ }
+ mu2.Lock();
+ while (c1 != threads) {
+ cv2.Wait(&mu2);
+ }
+ mu2.Unlock();
+ return cxt->g0;
+}
+
+// Basis for the parameterized tests configured below.
+static int RunTest(void (*test)(TestContext *cxt, int), int threads,
+ int iterations, int operations) {
+ TestContext cxt;
+ return RunTestCommon(&cxt, test, threads, iterations, operations);
+}
+
+// Like RunTest(), but sets an invariant on the tested Mutex and
+// verifies that the invariant check happened. The invariant function
+// will be passed the TestContext* as its arg and must call
+// SetInvariantChecked(true);
+#if !defined(ABSL_MUTEX_ENABLE_INVARIANT_DEBUGGING_NOT_IMPLEMENTED)
+static int RunTestWithInvariantDebugging(void (*test)(TestContext *cxt, int),
+ int threads, int iterations,
+ int operations,
+ void (*invariant)(void *)) {
+ absl::EnableMutexInvariantDebugging(true);
+ SetInvariantChecked(false);
+ TestContext cxt;
+ cxt.mu.EnableInvariantDebugging(invariant, &cxt);
+ int ret = RunTestCommon(&cxt, test, threads, iterations, operations);
+ ABSL_RAW_CHECK(GetInvariantChecked(), "Invariant not checked");
+ absl::EnableMutexInvariantDebugging(false); // Restore.
+ return ret;
+}
+#endif
+
+// --------------------------------------------------------
+// Test for fix of bug in TryRemove()
+struct TimeoutBugStruct {
+ absl::Mutex mu;
+ bool a;
+ int a_waiter_count;
+};
+
+static void WaitForA(TimeoutBugStruct *x) {
+ x->mu.LockWhen(absl::Condition(&x->a));
+ x->a_waiter_count--;
+ x->mu.Unlock();
+}
+
+static bool NoAWaiters(TimeoutBugStruct *x) { return x->a_waiter_count == 0; }
+
+// Test that a CondVar.Wait(&mutex) can un-block a call to mutex.Await() in
+// another thread.
+TEST(Mutex, CondVarWaitSignalsAwait) {
+ // Use a struct so the lock annotations apply.
+ struct {
+ absl::Mutex barrier_mu;
+ bool barrier GUARDED_BY(barrier_mu) = false;
+
+ absl::Mutex release_mu;
+ bool release GUARDED_BY(release_mu) = false;
+ absl::CondVar released_cv;
+ } state;
+
+ auto pool = CreateDefaultPool();
+
+ // Thread A. Sets barrier, waits for release using Mutex::Await, then
+ // signals released_cv.
+ pool->Schedule([&state] {
+ state.release_mu.Lock();
+
+ state.barrier_mu.Lock();
+ state.barrier = true;
+ state.barrier_mu.Unlock();
+
+ state.release_mu.Await(absl::Condition(&state.release));
+ state.released_cv.Signal();
+ state.release_mu.Unlock();
+ });
+
+ state.barrier_mu.LockWhen(absl::Condition(&state.barrier));
+ state.barrier_mu.Unlock();
+ state.release_mu.Lock();
+ // Thread A is now blocked on release by way of Mutex::Await().
+
+ // Set release. Calling released_cv.Wait() should un-block thread A,
+ // which will signal released_cv. If not, the test will hang.
+ state.release = true;
+ state.released_cv.Wait(&state.release_mu);
+ state.release_mu.Unlock();
+}
+
+// Test that a CondVar.WaitWithTimeout(&mutex) can un-block a call to
+// mutex.Await() in another thread.
+TEST(Mutex, CondVarWaitWithTimeoutSignalsAwait) {
+ // Use a struct so the lock annotations apply.
+ struct {
+ absl::Mutex barrier_mu;
+ bool barrier GUARDED_BY(barrier_mu) = false;
+
+ absl::Mutex release_mu;
+ bool release GUARDED_BY(release_mu) = false;
+ absl::CondVar released_cv;
+ } state;
+
+ auto pool = CreateDefaultPool();
+
+ // Thread A. Sets barrier, waits for release using Mutex::Await, then
+ // signals released_cv.
+ pool->Schedule([&state] {
+ state.release_mu.Lock();
+
+ state.barrier_mu.Lock();
+ state.barrier = true;
+ state.barrier_mu.Unlock();
+
+ state.release_mu.Await(absl::Condition(&state.release));
+ state.released_cv.Signal();
+ state.release_mu.Unlock();
+ });
+
+ state.barrier_mu.LockWhen(absl::Condition(&state.barrier));
+ state.barrier_mu.Unlock();
+ state.release_mu.Lock();
+ // Thread A is now blocked on release by way of Mutex::Await().
+
+ // Set release. Calling released_cv.Wait() should un-block thread A,
+ // which will signal released_cv. If not, the test will hang.
+ state.release = true;
+ EXPECT_TRUE(
+ !state.released_cv.WaitWithTimeout(&state.release_mu, absl::Seconds(10)))
+ << "; Unrecoverable test failure: CondVar::WaitWithTimeout did not "
+ "unblock the absl::Mutex::Await call in another thread.";
+
+ state.release_mu.Unlock();
+}
+
+// Test for regression of a bug in loop of TryRemove()
+TEST(Mutex, MutexTimeoutBug) {
+ auto tp = CreateDefaultPool();
+
+ TimeoutBugStruct x;
+ x.a = false;
+ x.a_waiter_count = 2;
+ tp->Schedule(std::bind(&WaitForA, &x));
+ tp->Schedule(std::bind(&WaitForA, &x));
+ absl::SleepFor(absl::Seconds(1)); // Allow first two threads to hang.
+ // The skip field of the second will point to the first because there are
+ // only two.
+
+ // Now cause a thread waiting on an always-false to time out
+ // This would deadlock when the bug was present.
+ bool always_false = false;
+ x.mu.LockWhenWithTimeout(absl::Condition(&always_false),
+ absl::Milliseconds(500));
+
+ // if we get here, the bug is not present. Cleanup the state.
+
+ x.a = true; // wakeup the two waiters on A
+ x.mu.Await(absl::Condition(&NoAWaiters, &x)); // wait for them to exit
+ x.mu.Unlock();
+}
+
+struct CondVarWaitDeadlock : testing::TestWithParam<int> {
+ absl::Mutex mu;
+ absl::CondVar cv;
+ bool cond1 = false;
+ bool cond2 = false;
+ bool read_lock1;
+ bool read_lock2;
+ bool signal_unlocked;
+
+ CondVarWaitDeadlock() {
+ read_lock1 = GetParam() & (1 << 0);
+ read_lock2 = GetParam() & (1 << 1);
+ signal_unlocked = GetParam() & (1 << 2);
+ }
+
+ void Waiter1() {
+ if (read_lock1) {
+ mu.ReaderLock();
+ while (!cond1) {
+ cv.Wait(&mu);
+ }
+ mu.ReaderUnlock();
+ } else {
+ mu.Lock();
+ while (!cond1) {
+ cv.Wait(&mu);
+ }
+ mu.Unlock();
+ }
+ }
+
+ void Waiter2() {
+ if (read_lock2) {
+ mu.ReaderLockWhen(absl::Condition(&cond2));
+ mu.ReaderUnlock();
+ } else {
+ mu.LockWhen(absl::Condition(&cond2));
+ mu.Unlock();
+ }
+ }
+};
+
+// Test for a deadlock bug in Mutex::Fer().
+// The sequence of events that lead to the deadlock is:
+// 1. waiter1 blocks on cv in read mode (mu bits = 0).
+// 2. waiter2 blocks on mu in either mode (mu bits = kMuWait).
+// 3. main thread locks mu, sets cond1, unlocks mu (mu bits = kMuWait).
+// 4. main thread signals on cv and this eventually calls Mutex::Fer().
+// Currently Fer wakes waiter1 since mu bits = kMuWait (mutex is unlocked).
+// Before the bug fix Fer neither woke waiter1 nor queued it on mutex,
+// which resulted in deadlock.
+TEST_P(CondVarWaitDeadlock, Test) {
+ auto waiter1 = CreatePool(1);
+ auto waiter2 = CreatePool(1);
+ waiter1->Schedule([this] { this->Waiter1(); });
+ waiter2->Schedule([this] { this->Waiter2(); });
+
+ // Wait while threads block (best-effort is fine).
+ absl::SleepFor(absl::Milliseconds(100));
+
+ // Wake condwaiter.
+ mu.Lock();
+ cond1 = true;
+ if (signal_unlocked) {
+ mu.Unlock();
+ cv.Signal();
+ } else {
+ cv.Signal();
+ mu.Unlock();
+ }
+ waiter1.reset(); // "join" waiter1
+
+ // Wake waiter.
+ mu.Lock();
+ cond2 = true;
+ mu.Unlock();
+ waiter2.reset(); // "join" waiter2
+}
+
+INSTANTIATE_TEST_CASE_P(CondVarWaitDeadlockTest, CondVarWaitDeadlock,
+ ::testing::Range(0, 8),
+ ::testing::PrintToStringParamName());
+
+// --------------------------------------------------------
+// Test for fix of bug in DequeueAllWakeable()
+// Bug was that if there was more than one waiting reader
+// and all should be woken, the most recently blocked one
+// would not be.
+
+struct DequeueAllWakeableBugStruct {
+ absl::Mutex mu;
+ absl::Mutex mu2; // protects all fields below
+ int unfinished_count; // count of unfinished readers; under mu2
+ bool done1; // unfinished_count == 0; under mu2
+ int finished_count; // count of finished readers, under mu2
+ bool done2; // finished_count == 0; under mu2
+};
+
+// Test for regression of a bug in loop of DequeueAllWakeable()
+static void AcquireAsReader(DequeueAllWakeableBugStruct *x) {
+ x->mu.ReaderLock();
+ x->mu2.Lock();
+ x->unfinished_count--;
+ x->done1 = (x->unfinished_count == 0);
+ x->mu2.Unlock();
+ // make sure that both readers acquired mu before we release it.
+ absl::SleepFor(absl::Seconds(2));
+ x->mu.ReaderUnlock();
+
+ x->mu2.Lock();
+ x->finished_count--;
+ x->done2 = (x->finished_count == 0);
+ x->mu2.Unlock();
+}
+
+// Test for regression of a bug in loop of DequeueAllWakeable()
+TEST(Mutex, MutexReaderWakeupBug) {
+ auto tp = CreateDefaultPool();
+
+ DequeueAllWakeableBugStruct x;
+ x.unfinished_count = 2;
+ x.done1 = false;
+ x.finished_count = 2;
+ x.done2 = false;
+ x.mu.Lock(); // acquire mu exclusively
+ // queue two thread that will block on reader locks on x.mu
+ tp->Schedule(std::bind(&AcquireAsReader, &x));
+ tp->Schedule(std::bind(&AcquireAsReader, &x));
+ absl::SleepFor(absl::Seconds(1)); // give time for reader threads to block
+ x.mu.Unlock(); // wake them up
+
+ // both readers should finish promptly
+ EXPECT_TRUE(
+ x.mu2.LockWhenWithTimeout(absl::Condition(&x.done1), absl::Seconds(10)));
+ x.mu2.Unlock();
+
+ EXPECT_TRUE(
+ x.mu2.LockWhenWithTimeout(absl::Condition(&x.done2), absl::Seconds(10)));
+ x.mu2.Unlock();
+}
+
+struct LockWhenTestStruct {
+ absl::Mutex mu1;
+ bool cond = false;
+
+ absl::Mutex mu2;
+ bool waiting = false;
+};
+
+static bool LockWhenTestIsCond(LockWhenTestStruct* s) {
+ s->mu2.Lock();
+ s->waiting = true;
+ s->mu2.Unlock();
+ return s->cond;
+}
+
+static void LockWhenTestWaitForIsCond(LockWhenTestStruct* s) {
+ s->mu1.LockWhen(absl::Condition(&LockWhenTestIsCond, s));
+ s->mu1.Unlock();
+}
+
+TEST(Mutex, LockWhen) {
+ LockWhenTestStruct s;
+
+ std::thread t(LockWhenTestWaitForIsCond, &s);
+ s.mu2.LockWhen(absl::Condition(&s.waiting));
+ s.mu2.Unlock();
+
+ s.mu1.Lock();
+ s.cond = true;
+ s.mu1.Unlock();
+
+ t.join();
+}
+
+// --------------------------------------------------------
+// The following test requires Mutex::ReaderLock to be a real shared
+// lock, which is not the case in all builds.
+#if !defined(ABSL_MUTEX_READER_LOCK_IS_EXCLUSIVE)
+
+// Test for fix of bug in UnlockSlow() that incorrectly decremented the reader
+// count when putting a thread to sleep waiting for a false condition when the
+// lock was not held.
+
+// For this bug to strike, we make a thread wait on a free mutex with no
+// waiters by causing its wakeup condition to be false. Then the
+// next two acquirers must be readers. The bug causes the lock
+// to be released when one reader unlocks, rather than both.
+
+struct ReaderDecrementBugStruct {
+ bool cond; // to delay first thread (under mu)
+ int done; // reference count (under mu)
+ absl::Mutex mu;
+
+ bool waiting_on_cond; // under mu2
+ bool have_reader_lock; // under mu2
+ bool complete; // under mu2
+ absl::Mutex mu2; // > mu
+};
+
+// L >= mu, L < mu_waiting_on_cond
+static bool IsCond(void *v) {
+ ReaderDecrementBugStruct *x = reinterpret_cast<ReaderDecrementBugStruct *>(v);
+ x->mu2.Lock();
+ x->waiting_on_cond = true;
+ x->mu2.Unlock();
+ return x->cond;
+}
+
+// L >= mu
+static bool AllDone(void *v) {
+ ReaderDecrementBugStruct *x = reinterpret_cast<ReaderDecrementBugStruct *>(v);
+ return x->done == 0;
+}
+
+// L={}
+static void WaitForCond(ReaderDecrementBugStruct *x) {
+ absl::Mutex dummy;
+ absl::MutexLock l(&dummy);
+ x->mu.LockWhen(absl::Condition(&IsCond, x));
+ x->done--;
+ x->mu.Unlock();
+}
+
+// L={}
+static void GetReadLock(ReaderDecrementBugStruct *x) {
+ x->mu.ReaderLock();
+ x->mu2.Lock();
+ x->have_reader_lock = true;
+ x->mu2.Await(absl::Condition(&x->complete));
+ x->mu2.Unlock();
+ x->mu.ReaderUnlock();
+ x->mu.Lock();
+ x->done--;
+ x->mu.Unlock();
+}
+
+// Test for reader counter being decremented incorrectly by waiter
+// with false condition.
+TEST(Mutex, MutexReaderDecrementBug) NO_THREAD_SAFETY_ANALYSIS {
+ ReaderDecrementBugStruct x;
+ x.cond = false;
+ x.waiting_on_cond = false;
+ x.have_reader_lock = false;
+ x.complete = false;
+ x.done = 2; // initial ref count
+
+ // Run WaitForCond() and wait for it to sleep
+ std::thread thread1(WaitForCond, &x);
+ x.mu2.LockWhen(absl::Condition(&x.waiting_on_cond));
+ x.mu2.Unlock();
+
+ // Run GetReadLock(), and wait for it to get the read lock
+ std::thread thread2(GetReadLock, &x);
+ x.mu2.LockWhen(absl::Condition(&x.have_reader_lock));
+ x.mu2.Unlock();
+
+ // Get the reader lock ourselves, and release it.
+ x.mu.ReaderLock();
+ x.mu.ReaderUnlock();
+
+ // The lock should be held in read mode by GetReadLock().
+ // If we have the bug, the lock will be free.
+ x.mu.AssertReaderHeld();
+
+ // Wake up all the threads.
+ x.mu2.Lock();
+ x.complete = true;
+ x.mu2.Unlock();
+
+ // TODO(delesley): turn on analysis once lock upgrading is supported.
+ // (This call upgrades the lock from shared to exclusive.)
+ x.mu.Lock();
+ x.cond = true;
+ x.mu.Await(absl::Condition(&AllDone, &x));
+ x.mu.Unlock();
+
+ thread1.join();
+ thread2.join();
+}
+#endif // !ABSL_MUTEX_READER_LOCK_IS_EXCLUSIVE
+
+// Test that we correctly handle the situation when a lock is
+// held and then destroyed (w/o unlocking).
+TEST(Mutex, LockedMutexDestructionBug) NO_THREAD_SAFETY_ANALYSIS {
+ for (int i = 0; i != 10; i++) {
+ // Create, lock and destroy 10 locks.
+ const int kNumLocks = 10;
+ auto mu = absl::make_unique<absl::Mutex[]>(kNumLocks);
+ for (int j = 0; j != kNumLocks; j++) {
+ if ((j % 2) == 0) {
+ mu[j].WriterLock();
+ } else {
+ mu[j].ReaderLock();
+ }
+ }
+ }
+}
+
+// --------------------------------------------------------
+// Test for bug with pattern of readers using a condvar. The bug was that if a
+// reader went to sleep on a condition variable while one or more other readers
+// held the lock, but there were no waiters, the reader count (held in the
+// mutex word) would be lost. (This is because Enqueue() had at one time
+// always placed the thread on the Mutex queue. Later (CL 4075610), to
+// tolerate re-entry into Mutex from a Condition predicate, Enqueue() was
+// changed so that it could also place a thread on a condition-variable. This
+// introduced the case where Enqueue() returned with an empty queue, and this
+// case was handled incorrectly in one place.)
+
+static void ReaderForReaderOnCondVar(absl::Mutex *mu, absl::CondVar *cv,
+ int *running) {
+ std::random_device dev;
+ std::mt19937 gen(dev());
+ std::uniform_int_distribution<int> random_millis(0, 15);
+ mu->ReaderLock();
+ while (*running == 3) {
+ absl::SleepFor(absl::Milliseconds(random_millis(gen)));
+ cv->WaitWithTimeout(mu, absl::Milliseconds(random_millis(gen)));
+ }
+ mu->ReaderUnlock();
+ mu->Lock();
+ (*running)--;
+ mu->Unlock();
+}
+
+struct True {
+ template <class... Args>
+ bool operator()(Args...) const {
+ return true;
+ }
+};
+
+struct DerivedTrue : True {};
+
+TEST(Mutex, FunctorCondition) {
+ { // Variadic
+ True f;
+ EXPECT_TRUE(absl::Condition(&f).Eval());
+ }
+
+ { // Inherited
+ DerivedTrue g;
+ EXPECT_TRUE(absl::Condition(&g).Eval());
+ }
+
+ { // lambda
+ int value = 3;
+ auto is_zero = [&value] { return value == 0; };
+ absl::Condition c(&is_zero);
+ EXPECT_FALSE(c.Eval());
+ value = 0;
+ EXPECT_TRUE(c.Eval());
+ }
+
+ { // bind
+ int value = 0;
+ auto is_positive = std::bind(std::less<int>(), 0, std::cref(value));
+ absl::Condition c(&is_positive);
+ EXPECT_FALSE(c.Eval());
+ value = 1;
+ EXPECT_TRUE(c.Eval());
+ }
+
+ { // std::function
+ int value = 3;
+ std::function<bool()> is_zero = [&value] { return value == 0; };
+ absl::Condition c(&is_zero);
+ EXPECT_FALSE(c.Eval());
+ value = 0;
+ EXPECT_TRUE(c.Eval());
+ }
+}
+
+static bool IntIsZero(int *x) { return *x == 0; }
+
+// Test for reader waiting condition variable when there are other readers
+// but no waiters.
+TEST(Mutex, TestReaderOnCondVar) {
+ auto tp = CreateDefaultPool();
+ absl::Mutex mu;
+ absl::CondVar cv;
+ int running = 3;
+ tp->Schedule(std::bind(&ReaderForReaderOnCondVar, &mu, &cv, &running));
+ tp->Schedule(std::bind(&ReaderForReaderOnCondVar, &mu, &cv, &running));
+ absl::SleepFor(absl::Seconds(2));
+ mu.Lock();
+ running--;
+ mu.Await(absl::Condition(&IntIsZero, &running));
+ mu.Unlock();
+}
+
+// --------------------------------------------------------
+struct AcquireFromConditionStruct {
+ absl::Mutex mu0; // protects value, done
+ int value; // times condition function is called; under mu0,
+ bool done; // done with test? under mu0
+ absl::Mutex mu1; // used to attempt to mess up state of mu0
+ absl::CondVar cv; // so the condition function can be invoked from
+ // CondVar::Wait().
+};
+
+static bool ConditionWithAcquire(AcquireFromConditionStruct *x) {
+ x->value++; // count times this function is called
+
+ if (x->value == 2 || x->value == 3) {
+ // On the second and third invocation of this function, sleep for 100ms,
+ // but with the side-effect of altering the state of a Mutex other than
+ // than one for which this is a condition. The spec now explicitly allows
+ // this side effect; previously it did not. it was illegal.
+ bool always_false = false;
+ x->mu1.LockWhenWithTimeout(absl::Condition(&always_false),
+ absl::Milliseconds(100));
+ x->mu1.Unlock();
+ }
+ ABSL_RAW_CHECK(x->value < 4, "should not be invoked a fourth time");
+
+ // We arrange for the condition to return true on only the 2nd and 3rd calls.
+ return x->value == 2 || x->value == 3;
+}
+
+static void WaitForCond2(AcquireFromConditionStruct *x) {
+ // wait for cond0 to become true
+ x->mu0.LockWhen(absl::Condition(&ConditionWithAcquire, x));
+ x->done = true;
+ x->mu0.Unlock();
+}
+
+// Test for Condition whose function acquires other Mutexes
+TEST(Mutex, AcquireFromCondition) {
+ auto tp = CreateDefaultPool();
+
+ AcquireFromConditionStruct x;
+ x.value = 0;
+ x.done = false;
+ tp->Schedule(
+ std::bind(&WaitForCond2, &x)); // run WaitForCond2() in a thread T
+ // T will hang because the first invocation of ConditionWithAcquire() will
+ // return false.
+ absl::SleepFor(absl::Milliseconds(500)); // allow T time to hang
+
+ x.mu0.Lock();
+ x.cv.WaitWithTimeout(&x.mu0, absl::Milliseconds(500)); // wake T
+ // T will be woken because the Wait() will call ConditionWithAcquire()
+ // for the second time, and it will return true.
+
+ x.mu0.Unlock();
+
+ // T will then acquire the lock and recheck its own condition.
+ // It will find the condition true, as this is the third invocation,
+ // but the use of another Mutex by the calling function will
+ // cause the old mutex implementation to think that the outer
+ // LockWhen() has timed out because the inner LockWhenWithTimeout() did.
+ // T will then check the condition a fourth time because it finds a
+ // timeout occurred. This should not happen in the new
+ // implementation that allows the Condition function to use Mutexes.
+
+ // It should also succeed, even though the Condition function
+ // is being invoked from CondVar::Wait, and thus this thread
+ // is conceptually waiting both on the condition variable, and on mu2.
+
+ x.mu0.LockWhen(absl::Condition(&x.done));
+ x.mu0.Unlock();
+}
+
+// The deadlock detector is not part of non-prod builds, so do not test it.
+#if !defined(ABSL_INTERNAL_USE_NONPROD_MUTEX)
+
+TEST(Mutex, DeadlockDetector) {
+ absl::SetMutexDeadlockDetectionMode(absl::OnDeadlockCycle::kAbort);
+
+ // check that we can call ForgetDeadlockInfo() on a lock with the lock held
+ absl::Mutex m1;
+ absl::Mutex m2;
+ absl::Mutex m3;
+ absl::Mutex m4;
+
+ m1.Lock(); // m1 gets ID1
+ m2.Lock(); // m2 gets ID2
+ m3.Lock(); // m3 gets ID3
+ m3.Unlock();
+ m2.Unlock();
+ // m1 still held
+ m1.ForgetDeadlockInfo(); // m1 loses ID
+ m2.Lock(); // m2 gets ID2
+ m3.Lock(); // m3 gets ID3
+ m4.Lock(); // m4 gets ID4
+ m3.Unlock();
+ m2.Unlock();
+ m4.Unlock();
+ m1.Unlock();
+}
+
+// Bazel has a test "warning" file that programs can write to if the
+// test should pass with a warning. This class disables the warning
+// file until it goes out of scope.
+class ScopedDisableBazelTestWarnings {
+ public:
+ ScopedDisableBazelTestWarnings() {
+#ifdef WIN32
+ char file[MAX_PATH];
+ if (GetEnvironmentVariable(kVarName, file, sizeof(file)) < sizeof(file)) {
+ warnings_output_file_ = file;
+ SetEnvironmentVariable(kVarName, nullptr);
+ }
+#else
+ const char *file = getenv(kVarName);
+ if (file != nullptr) {
+ warnings_output_file_ = file;
+ unsetenv(kVarName);
+ }
+#endif
+ }
+
+ ~ScopedDisableBazelTestWarnings() {
+ if (!warnings_output_file_.empty()) {
+#ifdef WIN32
+ SetEnvironmentVariable(kVarName, warnings_output_file_.c_str());
+#else
+ setenv(kVarName, warnings_output_file_.c_str(), 0);
+#endif
+ }
+ }
+
+ private:
+ static const char kVarName[];
+ std::string warnings_output_file_;
+};
+const char ScopedDisableBazelTestWarnings::kVarName[] =
+ "TEST_WARNINGS_OUTPUT_FILE";
+
+TEST(Mutex, DeadlockDetectorBazelWarning) {
+ absl::SetMutexDeadlockDetectionMode(absl::OnDeadlockCycle::kReport);
+
+ // Cause deadlock detection to detect something, if it's
+ // compiled in and enabled. But turn off the bazel warning.
+ ScopedDisableBazelTestWarnings disable_bazel_test_warnings;
+
+ absl::Mutex mu0;
+ absl::Mutex mu1;
+ bool got_mu0 = mu0.TryLock();
+ mu1.Lock(); // acquire mu1 while holding mu0
+ if (got_mu0) {
+ mu0.Unlock();
+ }
+ if (mu0.TryLock()) { // try lock shouldn't cause deadlock detector to fire
+ mu0.Unlock();
+ }
+ mu0.Lock(); // acquire mu0 while holding mu1; should get one deadlock
+ // report here
+ mu0.Unlock();
+ mu1.Unlock();
+
+ absl::SetMutexDeadlockDetectionMode(absl::OnDeadlockCycle::kAbort);
+}
+
+// This test is tagged with NO_THREAD_SAFETY_ANALYSIS because the
+// annotation-based static thread-safety analysis is not currently
+// predicate-aware and cannot tell if the two for-loops that acquire and
+// release the locks have the same predicates.
+TEST(Mutex, DeadlockDetectorStessTest) NO_THREAD_SAFETY_ANALYSIS {
+ // Stress test: Here we create a large number of locks and use all of them.
+ // If a deadlock detector keeps a full graph of lock acquisition order,
+ // it will likely be too slow for this test to pass.
+ const int n_locks = 1 << 17;
+ auto array_of_locks = absl::make_unique<absl::Mutex[]>(n_locks);
+ for (int i = 0; i < n_locks; i++) {
+ int end = std::min(n_locks, i + 5);
+ // acquire and then release locks i, i+1, ..., i+4
+ for (int j = i; j < end; j++) {
+ array_of_locks[j].Lock();
+ }
+ for (int j = i; j < end; j++) {
+ array_of_locks[j].Unlock();
+ }
+ }
+}
+
+TEST(Mutex, DeadlockIdBug) NO_THREAD_SAFETY_ANALYSIS {
+ // Test a scenario where a cached deadlock graph node id in the
+ // list of held locks is not invalidated when the corresponding
+ // mutex is deleted.
+ absl::SetMutexDeadlockDetectionMode(absl::OnDeadlockCycle::kAbort);
+ // Mutex that will be destroyed while being held
+ absl::Mutex *a = new absl::Mutex;
+ // Other mutexes needed by test
+ absl::Mutex b, c;
+
+ // Hold mutex.
+ a->Lock();
+
+ // Force deadlock id assignment by acquiring another lock.
+ b.Lock();
+ b.Unlock();
+
+ // Delete the mutex. The Mutex destructor tries to remove held locks,
+ // but the attempt isn't foolproof. It can fail if:
+ // (a) Deadlock detection is currently disabled.
+ // (b) The destruction is from another thread.
+ // We exploit (a) by temporarily disabling deadlock detection.
+ absl::SetMutexDeadlockDetectionMode(absl::OnDeadlockCycle::kIgnore);
+ delete a;
+ absl::SetMutexDeadlockDetectionMode(absl::OnDeadlockCycle::kAbort);
+
+ // Now acquire another lock which will force a deadlock id assignment.
+ // We should end up getting assigned the same deadlock id that was
+ // freed up when "a" was deleted, which will cause a spurious deadlock
+ // report if the held lock entry for "a" was not invalidated.
+ c.Lock();
+ c.Unlock();
+}
+#endif // !defined(ABSL_INTERNAL_USE_NONPROD_MUTEX)
+
+// --------------------------------------------------------
+// Test for timeouts/deadlines on condition waits that are specified using
+// absl::Duration and absl::Time. For each waiting function we test with
+// a timeout/deadline that has already expired/passed, one that is infinite
+// and so never expires/passes, and one that will expire/pass in the near
+// future.
+
+// Encapsulate a Mutex-protected bool with its associated Condition/CondVar.
+class Cond {
+ public:
+ explicit Cond(bool use_deadline) : use_deadline_(use_deadline), c_(&b_) {}
+
+ void Set(bool v) {
+ absl::MutexLock lock(&mu_);
+ b_ = v;
+ }
+
+ bool AwaitWithTimeout(absl::Duration timeout) {
+ absl::MutexLock lock(&mu_);
+ return use_deadline_ ? mu_.AwaitWithDeadline(c_, absl::Now() + timeout)
+ : mu_.AwaitWithTimeout(c_, timeout);
+ }
+
+ bool LockWhenWithTimeout(absl::Duration timeout) {
+ bool b = use_deadline_ ? mu_.LockWhenWithDeadline(c_, absl::Now() + timeout)
+ : mu_.LockWhenWithTimeout(c_, timeout);
+ mu_.Unlock();
+ return b;
+ }
+
+ bool ReaderLockWhenWithTimeout(absl::Duration timeout) {
+ bool b = use_deadline_
+ ? mu_.ReaderLockWhenWithDeadline(c_, absl::Now() + timeout)
+ : mu_.ReaderLockWhenWithTimeout(c_, timeout);
+ mu_.ReaderUnlock();
+ return b;
+ }
+
+ void Await() {
+ absl::MutexLock lock(&mu_);
+ mu_.Await(c_);
+ }
+
+ void Signal(bool v) {
+ absl::MutexLock lock(&mu_);
+ b_ = v;
+ cv_.Signal();
+ }
+
+ bool WaitWithTimeout(absl::Duration timeout) {
+ absl::MutexLock lock(&mu_);
+ absl::Time deadline = absl::Now() + timeout;
+ if (use_deadline_) {
+ while (!b_ && !cv_.WaitWithDeadline(&mu_, deadline)) {
+ }
+ } else {
+ while (!b_ && !cv_.WaitWithTimeout(&mu_, timeout)) {
+ timeout = deadline - absl::Now(); // recompute timeout
+ }
+ }
+ return b_;
+ }
+
+ void Wait() {
+ absl::MutexLock lock(&mu_);
+ while (!b_) cv_.Wait(&mu_);
+ }
+
+ private:
+ const bool use_deadline_;
+
+ bool b_;
+ absl::Condition c_;
+ absl::CondVar cv_;
+ absl::Mutex mu_;
+};
+
+class OperationTimer {
+ public:
+ OperationTimer() : start_(absl::Now()) {}
+ absl::Duration Get() const { return absl::Now() - start_; }
+
+ private:
+ const absl::Time start_;
+};
+
+static void CheckResults(bool exp_result, bool act_result,
+ absl::Duration exp_duration,
+ absl::Duration act_duration) {
+ ABSL_RAW_CHECK(exp_result == act_result, "CheckResults failed");
+ // Allow for some worse-case scheduling delay and clock skew.
+ if ((exp_duration - absl::Milliseconds(40) > act_duration) ||
+ (exp_duration + absl::Milliseconds(150) < act_duration)) {
+ ABSL_RAW_LOG(FATAL, "CheckResults failed: operation took %s, expected %s",
+ absl::FormatDuration(act_duration).c_str(),
+ absl::FormatDuration(exp_duration).c_str());
+ }
+}
+
+static void TestAwaitTimeout(Cond *cp, absl::Duration timeout, bool exp_result,
+ absl::Duration exp_duration) {
+ OperationTimer t;
+ bool act_result = cp->AwaitWithTimeout(timeout);
+ CheckResults(exp_result, act_result, exp_duration, t.Get());
+}
+
+static void TestLockWhenTimeout(Cond *cp, absl::Duration timeout,
+ bool exp_result, absl::Duration exp_duration) {
+ OperationTimer t;
+ bool act_result = cp->LockWhenWithTimeout(timeout);
+ CheckResults(exp_result, act_result, exp_duration, t.Get());
+}
+
+static void TestReaderLockWhenTimeout(Cond *cp, absl::Duration timeout,
+ bool exp_result,
+ absl::Duration exp_duration) {
+ OperationTimer t;
+ bool act_result = cp->ReaderLockWhenWithTimeout(timeout);
+ CheckResults(exp_result, act_result, exp_duration, t.Get());
+}
+
+static void TestWaitTimeout(Cond *cp, absl::Duration timeout, bool exp_result,
+ absl::Duration exp_duration) {
+ OperationTimer t;
+ bool act_result = cp->WaitWithTimeout(timeout);
+ CheckResults(exp_result, act_result, exp_duration, t.Get());
+}
+
+// Tests with a negative timeout (deadline in the past), which should
+// immediately return the current state of the condition.
+static void TestNegativeTimeouts(absl::synchronization_internal::ThreadPool *tp,
+ Cond *cp) {
+ const absl::Duration negative = -absl::InfiniteDuration();
+ const absl::Duration immediate = absl::ZeroDuration();
+
+ // The condition is already true:
+ cp->Set(true);
+ TestAwaitTimeout(cp, negative, true, immediate);
+ TestLockWhenTimeout(cp, negative, true, immediate);
+ TestReaderLockWhenTimeout(cp, negative, true, immediate);
+ TestWaitTimeout(cp, negative, true, immediate);
+
+ // The condition becomes true, but the timeout has already expired:
+ const absl::Duration delay = absl::Milliseconds(200);
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), 3 * delay);
+ TestAwaitTimeout(cp, negative, false, immediate);
+ TestLockWhenTimeout(cp, negative, false, immediate);
+ TestReaderLockWhenTimeout(cp, negative, false, immediate);
+ cp->Await(); // wait for the scheduled Set() to complete
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay);
+ TestWaitTimeout(cp, negative, false, immediate);
+ cp->Wait(); // wait for the scheduled Signal() to complete
+
+ // The condition never becomes true:
+ cp->Set(false);
+ TestAwaitTimeout(cp, negative, false, immediate);
+ TestLockWhenTimeout(cp, negative, false, immediate);
+ TestReaderLockWhenTimeout(cp, negative, false, immediate);
+ TestWaitTimeout(cp, negative, false, immediate);
+}
+
+// Tests with an infinite timeout (deadline in the infinite future), which
+// should only return when the condition becomes true.
+static void TestInfiniteTimeouts(absl::synchronization_internal::ThreadPool *tp,
+ Cond *cp) {
+ const absl::Duration infinite = absl::InfiniteDuration();
+ const absl::Duration immediate = absl::ZeroDuration();
+
+ // The condition is already true:
+ cp->Set(true);
+ TestAwaitTimeout(cp, infinite, true, immediate);
+ TestLockWhenTimeout(cp, infinite, true, immediate);
+ TestReaderLockWhenTimeout(cp, infinite, true, immediate);
+ TestWaitTimeout(cp, infinite, true, immediate);
+
+ // The condition becomes true before the (infinite) expiry:
+ const absl::Duration delay = absl::Milliseconds(200);
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay);
+ TestAwaitTimeout(cp, infinite, true, delay);
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay);
+ TestLockWhenTimeout(cp, infinite, true, delay);
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay);
+ TestReaderLockWhenTimeout(cp, infinite, true, delay);
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay);
+ TestWaitTimeout(cp, infinite, true, delay);
+}
+
+// Tests with a (small) finite timeout (deadline soon), with the condition
+// becoming true both before and after its expiry.
+static void TestFiniteTimeouts(absl::synchronization_internal::ThreadPool *tp,
+ Cond *cp) {
+ const absl::Duration finite = absl::Milliseconds(400);
+ const absl::Duration immediate = absl::ZeroDuration();
+
+ // The condition is already true:
+ cp->Set(true);
+ TestAwaitTimeout(cp, finite, true, immediate);
+ TestLockWhenTimeout(cp, finite, true, immediate);
+ TestReaderLockWhenTimeout(cp, finite, true, immediate);
+ TestWaitTimeout(cp, finite, true, immediate);
+
+ // The condition becomes true before the expiry:
+ const absl::Duration delay1 = finite / 2;
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay1);
+ TestAwaitTimeout(cp, finite, true, delay1);
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay1);
+ TestLockWhenTimeout(cp, finite, true, delay1);
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), delay1);
+ TestReaderLockWhenTimeout(cp, finite, true, delay1);
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay1);
+ TestWaitTimeout(cp, finite, true, delay1);
+
+ // The condition becomes true, but the timeout has already expired:
+ const absl::Duration delay2 = finite * 2;
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Set, cp, true), 3 * delay2);
+ TestAwaitTimeout(cp, finite, false, finite);
+ TestLockWhenTimeout(cp, finite, false, finite);
+ TestReaderLockWhenTimeout(cp, finite, false, finite);
+ cp->Await(); // wait for the scheduled Set() to complete
+ cp->Set(false);
+ ScheduleAfter(tp, std::bind(&Cond::Signal, cp, true), delay2);
+ TestWaitTimeout(cp, finite, false, finite);
+ cp->Wait(); // wait for the scheduled Signal() to complete
+
+ // The condition never becomes true:
+ cp->Set(false);
+ TestAwaitTimeout(cp, finite, false, finite);
+ TestLockWhenTimeout(cp, finite, false, finite);
+ TestReaderLockWhenTimeout(cp, finite, false, finite);
+ TestWaitTimeout(cp, finite, false, finite);
+}
+
+TEST(Mutex, Timeouts) {
+ auto tp = CreateDefaultPool();
+ for (bool use_deadline : {false, true}) {
+ Cond cond(use_deadline);
+ TestNegativeTimeouts(tp.get(), &cond);
+ TestInfiniteTimeouts(tp.get(), &cond);
+ TestFiniteTimeouts(tp.get(), &cond);
+ }
+}
+
+TEST(Mutex, Logging) {
+ // Allow user to look at logging output
+ absl::Mutex logged_mutex;
+ logged_mutex.EnableDebugLog("fido_mutex");
+ absl::CondVar logged_cv;
+ logged_cv.EnableDebugLog("rover_cv");
+ logged_mutex.Lock();
+ logged_cv.WaitWithTimeout(&logged_mutex, absl::Milliseconds(20));
+ logged_mutex.Unlock();
+ logged_mutex.ReaderLock();
+ logged_mutex.ReaderUnlock();
+ logged_mutex.Lock();
+ logged_mutex.Unlock();
+ logged_cv.Signal();
+ logged_cv.SignalAll();
+}
+
+// --------------------------------------------------------
+
+// Generate the vector of thread counts for tests parameterized on thread count.
+static std::vector<int> AllThreadCountValues() {
+ if (kExtendedTest) {
+ return {2, 4, 8, 10, 16, 20, 24, 30, 32};
+ }
+ return {2, 4, 10};
+}
+
+// A test fixture parameterized by thread count.
+class MutexVariableThreadCountTest : public ::testing::TestWithParam<int> {};
+
+// Instantiate the above with AllThreadCountOptions().
+INSTANTIATE_TEST_CASE_P(ThreadCounts, MutexVariableThreadCountTest,
+ ::testing::ValuesIn(AllThreadCountValues()),
+ ::testing::PrintToStringParamName());
+
+// Reduces iterations by some factor for slow platforms
+// (determined empirically).
+static int ScaleIterations(int x) {
+ // ABSL_MUTEX_READER_LOCK_IS_EXCLUSIVE is set in the implementation
+ // of Mutex that uses either std::mutex or pthread_mutex_t. Use
+ // these as keys to determine the slow implementation.
+#if defined(ABSL_MUTEX_READER_LOCK_IS_EXCLUSIVE)
+ return x / 10;
+#else
+ return x;
+#endif
+}
+
+TEST_P(MutexVariableThreadCountTest, Mutex) {
+ int threads = GetParam();
+ int iterations = ScaleIterations(10000000) / threads;
+ int operations = threads * iterations;
+ EXPECT_EQ(RunTest(&TestMu, threads, iterations, operations), operations);
+#if !defined(ABSL_MUTEX_ENABLE_INVARIANT_DEBUGGING_NOT_IMPLEMENTED)
+ iterations = std::min(iterations, 10);
+ operations = threads * iterations;
+ EXPECT_EQ(RunTestWithInvariantDebugging(&TestMu, threads, iterations,
+ operations, CheckSumG0G1),
+ operations);
+#endif
+}
+
+TEST_P(MutexVariableThreadCountTest, Try) {
+ int threads = GetParam();
+ int iterations = 1000000 / threads;
+ int operations = iterations * threads;
+ EXPECT_EQ(RunTest(&TestTry, threads, iterations, operations), operations);
+#if !defined(ABSL_MUTEX_ENABLE_INVARIANT_DEBUGGING_NOT_IMPLEMENTED)
+ iterations = std::min(iterations, 10);
+ operations = threads * iterations;
+ EXPECT_EQ(RunTestWithInvariantDebugging(&TestTry, threads, iterations,
+ operations, CheckSumG0G1),
+ operations);
+#endif
+}
+
+TEST_P(MutexVariableThreadCountTest, R20ms) {
+ int threads = GetParam();
+ int iterations = 100;
+ int operations = iterations * threads;
+ EXPECT_EQ(RunTest(&TestR20ms, threads, iterations, operations), 0);
+}
+
+TEST_P(MutexVariableThreadCountTest, RW) {
+ int threads = GetParam();
+ int iterations = ScaleIterations(20000000) / threads;
+ int operations = iterations * threads;
+ EXPECT_EQ(RunTest(&TestRW, threads, iterations, operations), operations / 2);
+#if !defined(ABSL_MUTEX_ENABLE_INVARIANT_DEBUGGING_NOT_IMPLEMENTED)
+ iterations = std::min(iterations, 10);
+ operations = threads * iterations;
+ EXPECT_EQ(RunTestWithInvariantDebugging(&TestRW, threads, iterations,
+ operations, CheckSumG0G1),
+ operations / 2);
+#endif
+}
+
+TEST_P(MutexVariableThreadCountTest, Await) {
+ int threads = GetParam();
+ int iterations = ScaleIterations(500000);
+ int operations = iterations;
+ EXPECT_EQ(RunTest(&TestAwait, threads, iterations, operations), operations);
+}
+
+TEST_P(MutexVariableThreadCountTest, SignalAll) {
+ int threads = GetParam();
+ int iterations = 200000 / threads;
+ int operations = iterations;
+ EXPECT_EQ(RunTest(&TestSignalAll, threads, iterations, operations),
+ operations);
+}
+
+TEST(Mutex, Signal) {
+ int threads = 2; // TestSignal must use two threads
+ int iterations = 200000;
+ int operations = iterations;
+ EXPECT_EQ(RunTest(&TestSignal, threads, iterations, operations), operations);
+}
+
+TEST(Mutex, Timed) {
+ int threads = 10; // Use a fixed thread count of 10
+ int iterations = 1000;
+ int operations = iterations;
+ EXPECT_EQ(RunTest(&TestCVTimeout, threads, iterations, operations),
+ operations);
+}
+
+TEST(Mutex, CVTime) {
+ int threads = 10; // Use a fixed thread count of 10
+ int iterations = 1;
+ EXPECT_EQ(RunTest(&TestCVTime, threads, iterations, 1),
+ threads * iterations);
+}
+
+TEST(Mutex, MuTime) {
+ int threads = 10; // Use a fixed thread count of 10
+ int iterations = 1;
+ EXPECT_EQ(RunTest(&TestMuTime, threads, iterations, 1), threads * iterations);
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification.cc
new file mode 100644
index 0000000..ed8cc90
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification.cc
@@ -0,0 +1,84 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/notification.h"
+
+#include <atomic>
+
+#include "absl/base/attributes.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/time.h"
+
+namespace absl {
+void Notification::Notify() {
+ MutexLock l(&this->mutex_);
+
+#ifndef NDEBUG
+ if (ABSL_PREDICT_FALSE(notified_yet_.load(std::memory_order_relaxed))) {
+ ABSL_RAW_LOG(
+ FATAL,
+ "Notify() method called more than once for Notification object %p",
+ static_cast<void *>(this));
+ }
+#endif
+
+ notified_yet_.store(true, std::memory_order_release);
+}
+
+Notification::~Notification() {
+ // Make sure that the thread running Notify() exits before the object is
+ // destructed.
+ MutexLock l(&this->mutex_);
+}
+
+static inline bool HasBeenNotifiedInternal(
+ const std::atomic<bool> *notified_yet) {
+ return notified_yet->load(std::memory_order_acquire);
+}
+
+bool Notification::HasBeenNotified() const {
+ return HasBeenNotifiedInternal(&this->notified_yet_);
+}
+
+void Notification::WaitForNotification() const {
+ if (!HasBeenNotifiedInternal(&this->notified_yet_)) {
+ this->mutex_.LockWhen(Condition(&HasBeenNotifiedInternal,
+ &this->notified_yet_));
+ this->mutex_.Unlock();
+ }
+}
+
+bool Notification::WaitForNotificationWithTimeout(
+ absl::Duration timeout) const {
+ bool notified = HasBeenNotifiedInternal(&this->notified_yet_);
+ if (!notified) {
+ notified = this->mutex_.LockWhenWithTimeout(
+ Condition(&HasBeenNotifiedInternal, &this->notified_yet_), timeout);
+ this->mutex_.Unlock();
+ }
+ return notified;
+}
+
+bool Notification::WaitForNotificationWithDeadline(absl::Time deadline) const {
+ bool notified = HasBeenNotifiedInternal(&this->notified_yet_);
+ if (!notified) {
+ notified = this->mutex_.LockWhenWithDeadline(
+ Condition(&HasBeenNotifiedInternal, &this->notified_yet_), deadline);
+ this->mutex_.Unlock();
+ }
+ return notified;
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification.h b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification.h
new file mode 100644
index 0000000..107932f
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification.h
@@ -0,0 +1,112 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// notification.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines a `Notification` abstraction, which allows threads
+// to receive notification of a single occurrence of a single event.
+//
+// The `Notification` object maintains a private boolean "notified" state that
+// transitions to `true` at most once. The `Notification` class provides the
+// following primary member functions:
+// * `HasBeenNotified() `to query its state
+// * `WaitForNotification*()` to have threads wait until the "notified" state
+// is `true`.
+// * `Notify()` to set the notification's "notified" state to `true` and
+// notify all waiting threads that the event has occurred.
+// This method may only be called once.
+//
+// Note that while `Notify()` may only be called once, it is perfectly valid to
+// call any of the `WaitForNotification*()` methods multiple times, from
+// multiple threads -- even after the notification's "notified" state has been
+// set -- in which case those methods will immediately return.
+//
+// Note that the lifetime of a `Notification` requires careful consideration;
+// it might not be safe to destroy a notification after calling `Notify()` since
+// it is still legal for other threads to call `WaitForNotification*()` methods
+// on the notification. However, observers responding to a "notified" state of
+// `true` can safely delete the notification without interfering with the call
+// to `Notify()` in the other thread.
+//
+// Memory ordering: For any threads X and Y, if X calls `Notify()`, then any
+// action taken by X before it calls `Notify()` is visible to thread Y after:
+// * Y returns from `WaitForNotification()`, or
+// * Y receives a `true` return value from either `HasBeenNotified()` or
+// `WaitForNotificationWithTimeout()`.
+
+#ifndef ABSL_SYNCHRONIZATION_NOTIFICATION_H_
+#define ABSL_SYNCHRONIZATION_NOTIFICATION_H_
+
+#include <atomic>
+
+#include "absl/synchronization/mutex.h"
+#include "absl/time/time.h"
+
+namespace absl {
+
+// -----------------------------------------------------------------------------
+// Notification
+// -----------------------------------------------------------------------------
+class Notification {
+ public:
+ // Initializes the "notified" state to unnotified.
+ Notification() : notified_yet_(false) {}
+ explicit Notification(bool prenotify) : notified_yet_(prenotify) {}
+ Notification(const Notification&) = delete;
+ Notification& operator=(const Notification&) = delete;
+ ~Notification();
+
+ // Notification::HasBeenNotified()
+ //
+ // Returns the value of the notification's internal "notified" state.
+ bool HasBeenNotified() const;
+
+ // Notification::WaitForNotification()
+ //
+ // Blocks the calling thread until the notification's "notified" state is
+ // `true`. Note that if `Notify()` has been previously called on this
+ // notification, this function will immediately return.
+ void WaitForNotification() const;
+
+ // Notification::WaitForNotificationWithTimeout()
+ //
+ // Blocks until either the notification's "notified" state is `true` (which
+ // may occur immediately) or the timeout has elapsed, returning the value of
+ // its "notified" state in either case.
+ bool WaitForNotificationWithTimeout(absl::Duration timeout) const;
+
+ // Notification::WaitForNotificationWithDeadline()
+ //
+ // Blocks until either the notification's "notified" state is `true` (which
+ // may occur immediately) or the deadline has expired, returning the value of
+ // its "notified" state in either case.
+ bool WaitForNotificationWithDeadline(absl::Time deadline) const;
+
+ // Notification::Notify()
+ //
+ // Sets the "notified" state of this notification to `true` and wakes waiting
+ // threads. Note: do not call `Notify()` multiple times on the same
+ // `Notification`; calling `Notify()` more than once on the same notification
+ // results in undefined behavior.
+ void Notify();
+
+ private:
+ mutable Mutex mutex_;
+ std::atomic<bool> notified_yet_; // written under mutex_
+};
+
+} // namespace absl
+#endif // ABSL_SYNCHRONIZATION_NOTIFICATION_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification_test.cc
new file mode 100644
index 0000000..9b3b6a5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/notification_test.cc
@@ -0,0 +1,124 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/notification.h"
+
+#include <thread> // NOLINT(build/c++11)
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+
+// A thread-safe class that holds a counter.
+class ThreadSafeCounter {
+ public:
+ ThreadSafeCounter() : count_(0) {}
+
+ void Increment() {
+ MutexLock lock(&mutex_);
+ ++count_;
+ }
+
+ int Get() const {
+ MutexLock lock(&mutex_);
+ return count_;
+ }
+
+ void WaitUntilGreaterOrEqual(int n) {
+ MutexLock lock(&mutex_);
+ auto cond = [this, n]() { return count_ >= n; };
+ mutex_.Await(Condition(&cond));
+ }
+
+ private:
+ mutable Mutex mutex_;
+ int count_;
+};
+
+// Runs the |i|'th worker thread for the tests in BasicTests(). Increments the
+// |ready_counter|, waits on the |notification|, and then increments the
+// |done_counter|.
+static void RunWorker(int i, ThreadSafeCounter* ready_counter,
+ Notification* notification,
+ ThreadSafeCounter* done_counter) {
+ ready_counter->Increment();
+ notification->WaitForNotification();
+ done_counter->Increment();
+}
+
+// Tests that the |notification| properly blocks and awakens threads. Assumes
+// that the |notification| is not yet triggered. If |notify_before_waiting| is
+// true, the |notification| is triggered before any threads are created, so the
+// threads never block in WaitForNotification(). Otherwise, the |notification|
+// is triggered at a later point when most threads are likely to be blocking in
+// WaitForNotification().
+static void BasicTests(bool notify_before_waiting, Notification* notification) {
+ EXPECT_FALSE(notification->HasBeenNotified());
+ EXPECT_FALSE(
+ notification->WaitForNotificationWithTimeout(absl::Milliseconds(0)));
+ EXPECT_FALSE(notification->WaitForNotificationWithDeadline(absl::Now()));
+
+ absl::Time start = absl::Now();
+ EXPECT_FALSE(
+ notification->WaitForNotificationWithTimeout(absl::Milliseconds(50)));
+ EXPECT_LE(start + absl::Milliseconds(50), absl::Now());
+
+ ThreadSafeCounter ready_counter;
+ ThreadSafeCounter done_counter;
+
+ if (notify_before_waiting) {
+ notification->Notify();
+ }
+
+ // Create a bunch of threads that increment the |done_counter| after being
+ // notified.
+ const int kNumThreads = 10;
+ std::vector<std::thread> workers;
+ for (int i = 0; i < kNumThreads; ++i) {
+ workers.push_back(std::thread(&RunWorker, i, &ready_counter, notification,
+ &done_counter));
+ }
+
+ if (!notify_before_waiting) {
+ ready_counter.WaitUntilGreaterOrEqual(kNumThreads);
+
+ // Workers have not been notified yet, so the |done_counter| should be
+ // unmodified.
+ EXPECT_EQ(0, done_counter.Get());
+
+ notification->Notify();
+ }
+
+ // After notifying and then joining the workers, both counters should be
+ // fully incremented.
+ notification->WaitForNotification(); // should exit immediately
+ EXPECT_TRUE(notification->HasBeenNotified());
+ EXPECT_TRUE(notification->WaitForNotificationWithTimeout(absl::Seconds(0)));
+ EXPECT_TRUE(notification->WaitForNotificationWithDeadline(absl::Now()));
+ for (std::thread& worker : workers) {
+ worker.join();
+ }
+ EXPECT_EQ(kNumThreads, ready_counter.Get());
+ EXPECT_EQ(kNumThreads, done_counter.Get());
+}
+
+TEST(NotificationTest, SanityTest) {
+ Notification local_notification1, local_notification2;
+ BasicTests(false, &local_notification1);
+ BasicTests(true, &local_notification2);
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/time/BUILD.bazel
new file mode 100644
index 0000000..d4f653f
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/BUILD.bazel
@@ -0,0 +1,97 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "time",
+ srcs = [
+ "clock.cc",
+ "duration.cc",
+ "format.cc",
+ "internal/get_current_time_ios.inc",
+ "internal/get_current_time_posix.inc",
+ "internal/get_current_time_windows.inc",
+ "time.cc",
+ ],
+ hdrs = [
+ "clock.h",
+ "time.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/base",
+ "//absl/base:core_headers",
+ "//absl/numeric:int128",
+ "//absl/time/internal/cctz:civil_time",
+ "//absl/time/internal/cctz:time_zone",
+ ],
+)
+
+cc_library(
+ name = "test_util",
+ srcs = [
+ "internal/test_util.cc",
+ "internal/zoneinfo.inc",
+ ],
+ hdrs = ["internal/test_util.h"],
+ copts = ABSL_DEFAULT_COPTS,
+ visibility = [
+ "//absl/time:__pkg__",
+ ],
+ deps = [
+ ":time",
+ "//absl/base",
+ "//absl/time/internal/cctz:time_zone",
+ ],
+)
+
+cc_test(
+ name = "time_test",
+ srcs = [
+ "clock_test.cc",
+ "duration_test.cc",
+ "format_test.cc",
+ "time_norm_test.cc",
+ "time_test.cc",
+ "time_zone_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS,
+ tags = [
+ "no_test_android_arm",
+ "no_test_android_arm64",
+ "no_test_android_x86",
+ "no_test_ios_x86_64",
+ "no_test_loonix",
+ ],
+ deps = [
+ ":test_util",
+ ":time",
+ "//absl/base",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/time/internal/cctz:time_zone",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/time/CMakeLists.txt
new file mode 100644
index 0000000..72bb4d2
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/CMakeLists.txt
@@ -0,0 +1,96 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+list(APPEND TIME_PUBLIC_HEADERS
+ "clock.h"
+ "time.h"
+)
+
+
+list(APPEND TIME_INTERNAL_HEADERS
+ "internal/test_util.h"
+ "internal/cctz/include/cctz/civil_time.h"
+ "internal/cctz/include/cctz/civil_time_detail.h"
+ "internal/cctz/include/cctz/time_zone.h"
+ "internal/cctz/include/cctz/zone_info_source.h"
+)
+
+list(APPEND TIME_SRC
+ "time.cc"
+ "clock.cc"
+ "duration.cc"
+ "format.cc"
+ "internal/cctz/src/civil_time_detail.cc"
+ "internal/cctz/src/time_zone_fixed.cc"
+ "internal/cctz/src/time_zone_fixed.h"
+ "internal/cctz/src/time_zone_format.cc"
+ "internal/cctz/src/time_zone_if.cc"
+ "internal/cctz/src/time_zone_if.h"
+ "internal/cctz/src/time_zone_impl.cc"
+ "internal/cctz/src/time_zone_impl.h"
+ "internal/cctz/src/time_zone_info.cc"
+ "internal/cctz/src/time_zone_info.h"
+ "internal/cctz/src/time_zone_libc.cc"
+ "internal/cctz/src/time_zone_libc.h"
+ "internal/cctz/src/time_zone_lookup.cc"
+ "internal/cctz/src/time_zone_posix.cc"
+ "internal/cctz/src/time_zone_posix.h"
+ "internal/cctz/src/tzfile.h"
+ "internal/cctz/src/zone_info_source.cc"
+ ${TIME_PUBLIC_HEADERS}
+ ${TIME_INTERNAL_HEADERS}
+)
+set(TIME_PUBLIC_LIBRARIES absl::base absl::stacktrace absl::int128)
+
+absl_library(
+ TARGET
+ absl_time
+ SOURCES
+ ${TIME_SRC}
+ PUBLIC_LIBRARIES
+ ${TIME_PUBLIC_LIBRARIES}
+ EXPORT_NAME
+ time
+)
+
+
+
+#
+## TESTS
+#
+
+# test time_test
+list(APPEND TIME_TEST_SRC
+ "time_test.cc"
+ "clock_test.cc"
+ "duration_test.cc"
+ "format_test.cc"
+ "time_norm_test.cc"
+ "time_test.cc"
+ "time_zone_test.cc"
+ "internal/test_util.cc"
+)
+set(TIME_TEST_PUBLIC_LIBRARIES absl::time)
+
+absl_test(
+ TARGET
+ time_test
+ SOURCES
+ ${TIME_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${TIME_TEST_PUBLIC_LIBRARIES}
+)
+
[08/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/time.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/time.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/time.cc
new file mode 100644
index 0000000..1dde40d
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/time.cc
@@ -0,0 +1,385 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The implementation of the absl::Time class, which is declared in
+// //absl/time.h.
+//
+// The representation for an absl::Time is an absl::Duration offset from the
+// epoch. We use the traditional Unix epoch (1970-01-01 00:00:00 +0000)
+// for convenience, but this is not exposed in the API and could be changed.
+//
+// NOTE: To keep type verbosity to a minimum, the following variable naming
+// conventions are used throughout this file.
+//
+// cz: A cctz::time_zone
+// tz: An absl::TimeZone
+// cl: A cctz::time_zone::civil_lookup
+// al: A cctz::time_zone::absolute_lookup
+// cd: A cctz::civil_day
+// cs: A cctz::civil_second
+// bd: An absl::Time::Breakdown
+
+#include "absl/time/time.h"
+
+#include <cstring>
+#include <ctime>
+#include <limits>
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+namespace cctz = absl::time_internal::cctz;
+namespace absl {
+
+namespace {
+
+inline cctz::time_point<cctz::sys_seconds> unix_epoch() {
+ return std::chrono::time_point_cast<cctz::sys_seconds>(
+ std::chrono::system_clock::from_time_t(0));
+}
+
+// Floors d to the next unit boundary closer to negative infinity.
+inline int64_t FloorToUnit(absl::Duration d, absl::Duration unit) {
+ absl::Duration rem;
+ int64_t q = absl::IDivDuration(d, unit, &rem);
+ return (q > 0 ||
+ rem >= ZeroDuration() ||
+ q == std::numeric_limits<int64_t>::min()) ? q : q - 1;
+}
+
+inline absl::Time::Breakdown InfiniteFutureBreakdown() {
+ absl::Time::Breakdown bd;
+ bd.year = std::numeric_limits<int64_t>::max();
+ bd.month = 12;
+ bd.day = 31;
+ bd.hour = 23;
+ bd.minute = 59;
+ bd.second = 59;
+ bd.subsecond = absl::InfiniteDuration();
+ bd.weekday = 4;
+ bd.yearday = 365;
+ bd.offset = 0;
+ bd.is_dst = false;
+ bd.zone_abbr = "-0000";
+ return bd;
+}
+
+inline Time::Breakdown InfinitePastBreakdown() {
+ Time::Breakdown bd;
+ bd.year = std::numeric_limits<int64_t>::min();
+ bd.month = 1;
+ bd.day = 1;
+ bd.hour = 0;
+ bd.minute = 0;
+ bd.second = 0;
+ bd.subsecond = -absl::InfiniteDuration();
+ bd.weekday = 7;
+ bd.yearday = 1;
+ bd.offset = 0;
+ bd.is_dst = false;
+ bd.zone_abbr = "-0000";
+ return bd;
+}
+
+inline absl::TimeConversion InfiniteFutureTimeConversion() {
+ absl::TimeConversion tc;
+ tc.pre = tc.trans = tc.post = absl::InfiniteFuture();
+ tc.kind = absl::TimeConversion::UNIQUE;
+ tc.normalized = true;
+ return tc;
+}
+
+inline TimeConversion InfinitePastTimeConversion() {
+ absl::TimeConversion tc;
+ tc.pre = tc.trans = tc.post = absl::InfinitePast();
+ tc.kind = absl::TimeConversion::UNIQUE;
+ tc.normalized = true;
+ return tc;
+}
+
+// Makes a Time from sec, overflowing to InfiniteFuture/InfinitePast as
+// necessary. If sec is min/max, then consult cs+tz to check for overlow.
+Time MakeTimeWithOverflow(const cctz::time_point<cctz::sys_seconds>& sec,
+ const cctz::civil_second& cs,
+ const cctz::time_zone& tz,
+ bool* normalized = nullptr) {
+ const auto max = cctz::time_point<cctz::sys_seconds>::max();
+ const auto min = cctz::time_point<cctz::sys_seconds>::min();
+ if (sec == max) {
+ const auto al = tz.lookup(max);
+ if (cs > al.cs) {
+ if (normalized) *normalized = true;
+ return absl::InfiniteFuture();
+ }
+ }
+ if (sec == min) {
+ const auto al = tz.lookup(min);
+ if (cs < al.cs) {
+ if (normalized) *normalized = true;
+ return absl::InfinitePast();
+ }
+ }
+ const auto hi = (sec - unix_epoch()).count();
+ return time_internal::FromUnixDuration(time_internal::MakeDuration(hi));
+}
+
+inline absl::TimeConversion::Kind MapKind(
+ const cctz::time_zone::civil_lookup::civil_kind& kind) {
+ switch (kind) {
+ case cctz::time_zone::civil_lookup::UNIQUE:
+ return absl::TimeConversion::UNIQUE;
+ case cctz::time_zone::civil_lookup::SKIPPED:
+ return absl::TimeConversion::SKIPPED;
+ case cctz::time_zone::civil_lookup::REPEATED:
+ return absl::TimeConversion::REPEATED;
+ }
+ return absl::TimeConversion::UNIQUE;
+}
+
+// Returns Mon=1..Sun=7.
+inline int MapWeekday(const cctz::weekday& wd) {
+ switch (wd) {
+ case cctz::weekday::monday:
+ return 1;
+ case cctz::weekday::tuesday:
+ return 2;
+ case cctz::weekday::wednesday:
+ return 3;
+ case cctz::weekday::thursday:
+ return 4;
+ case cctz::weekday::friday:
+ return 5;
+ case cctz::weekday::saturday:
+ return 6;
+ case cctz::weekday::sunday:
+ return 7;
+ }
+ return 1;
+}
+
+} // namespace
+
+absl::Time::Breakdown Time::In(absl::TimeZone tz) const {
+ if (*this == absl::InfiniteFuture()) return absl::InfiniteFutureBreakdown();
+ if (*this == absl::InfinitePast()) return absl::InfinitePastBreakdown();
+
+ const auto tp =
+ unix_epoch() + cctz::sys_seconds(time_internal::GetRepHi(rep_));
+ const auto al = cctz::time_zone(tz).lookup(tp);
+ const auto cs = al.cs;
+ const auto cd = cctz::civil_day(cs);
+
+ absl::Time::Breakdown bd;
+ bd.year = cs.year();
+ bd.month = cs.month();
+ bd.day = cs.day();
+ bd.hour = cs.hour();
+ bd.minute = cs.minute();
+ bd.second = cs.second();
+ bd.subsecond = time_internal::MakeDuration(0, time_internal::GetRepLo(rep_));
+ bd.weekday = MapWeekday(get_weekday(cd));
+ bd.yearday = get_yearday(cd);
+ bd.offset = al.offset;
+ bd.is_dst = al.is_dst;
+ bd.zone_abbr = al.abbr;
+ return bd;
+}
+
+absl::Time FromTM(const struct tm& tm, absl::TimeZone tz) {
+ const auto cz = cctz::time_zone(tz);
+ const auto cs =
+ cctz::civil_second(tm.tm_year + 1900, tm.tm_mon + 1, tm.tm_mday,
+ tm.tm_hour, tm.tm_min, tm.tm_sec);
+ const auto cl = cz.lookup(cs);
+ const auto tp = tm.tm_isdst == 0 ? cl.post : cl.pre;
+ return MakeTimeWithOverflow(tp, cs, cz);
+}
+
+struct tm ToTM(absl::Time t, absl::TimeZone tz) {
+ const absl::Time::Breakdown bd = t.In(tz);
+ struct tm tm;
+ std::memset(&tm, 0, sizeof(tm));
+ tm.tm_sec = bd.second;
+ tm.tm_min = bd.minute;
+ tm.tm_hour = bd.hour;
+ tm.tm_mday = bd.day;
+ tm.tm_mon = bd.month - 1;
+
+ // Saturates tm.tm_year in cases of over/underflow, accounting for the fact
+ // that tm.tm_year is years since 1900.
+ if (bd.year < std::numeric_limits<int>::min() + 1900) {
+ tm.tm_year = std::numeric_limits<int>::min();
+ } else if (bd.year > std::numeric_limits<int>::max()) {
+ tm.tm_year = std::numeric_limits<int>::max() - 1900;
+ } else {
+ tm.tm_year = static_cast<int>(bd.year - 1900);
+ }
+
+ tm.tm_wday = bd.weekday % 7;
+ tm.tm_yday = bd.yearday - 1;
+ tm.tm_isdst = bd.is_dst ? 1 : 0;
+
+ return tm;
+}
+
+//
+// Factory functions.
+//
+
+absl::TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour,
+ int min, int sec, TimeZone tz) {
+ // Avoids years that are too extreme for civil_second to normalize.
+ if (year > 300000000000) return InfiniteFutureTimeConversion();
+ if (year < -300000000000) return InfinitePastTimeConversion();
+ const auto cz = cctz::time_zone(tz);
+ const auto cs = cctz::civil_second(year, mon, day, hour, min, sec);
+ absl::TimeConversion tc;
+ tc.normalized = year != cs.year() || mon != cs.month() || day != cs.day() ||
+ hour != cs.hour() || min != cs.minute() || sec != cs.second();
+ const auto cl = cz.lookup(cs);
+ // Converts the civil_lookup struct to a TimeConversion.
+ tc.pre = MakeTimeWithOverflow(cl.pre, cs, cz, &tc.normalized);
+ tc.trans = MakeTimeWithOverflow(cl.trans, cs, cz, &tc.normalized);
+ tc.post = MakeTimeWithOverflow(cl.post, cs, cz, &tc.normalized);
+ tc.kind = MapKind(cl.kind);
+ return tc;
+}
+
+absl::Time FromDateTime(int64_t year, int mon, int day, int hour, int min,
+ int sec, TimeZone tz) {
+ if (year > 300000000000) return InfiniteFuture();
+ if (year < -300000000000) return InfinitePast();
+ const auto cz = cctz::time_zone(tz);
+ const auto cs = cctz::civil_second(year, mon, day, hour, min, sec);
+ const auto cl = cz.lookup(cs);
+ return MakeTimeWithOverflow(cl.pre, cs, cz);
+}
+
+absl::Time TimeFromTimespec(timespec ts) {
+ return time_internal::FromUnixDuration(absl::DurationFromTimespec(ts));
+}
+
+absl::Time TimeFromTimeval(timeval tv) {
+ return time_internal::FromUnixDuration(absl::DurationFromTimeval(tv));
+}
+
+absl::Time FromUDate(double udate) {
+ return time_internal::FromUnixDuration(absl::Milliseconds(udate));
+}
+
+absl::Time FromUniversal(int64_t universal) {
+ return absl::UniversalEpoch() + 100 * absl::Nanoseconds(universal);
+}
+
+//
+// Conversion to other time types.
+//
+
+int64_t ToUnixNanos(Time t) {
+ if (time_internal::GetRepHi(time_internal::ToUnixDuration(t)) >= 0 &&
+ time_internal::GetRepHi(time_internal::ToUnixDuration(t)) >> 33 == 0) {
+ return (time_internal::GetRepHi(time_internal::ToUnixDuration(t)) *
+ 1000 * 1000 * 1000) +
+ (time_internal::GetRepLo(time_internal::ToUnixDuration(t)) / 4);
+ }
+ return FloorToUnit(time_internal::ToUnixDuration(t), absl::Nanoseconds(1));
+}
+
+int64_t ToUnixMicros(Time t) {
+ if (time_internal::GetRepHi(time_internal::ToUnixDuration(t)) >= 0 &&
+ time_internal::GetRepHi(time_internal::ToUnixDuration(t)) >> 43 == 0) {
+ return (time_internal::GetRepHi(time_internal::ToUnixDuration(t)) *
+ 1000 * 1000) +
+ (time_internal::GetRepLo(time_internal::ToUnixDuration(t)) / 4000);
+ }
+ return FloorToUnit(time_internal::ToUnixDuration(t), absl::Microseconds(1));
+}
+
+int64_t ToUnixMillis(Time t) {
+ if (time_internal::GetRepHi(time_internal::ToUnixDuration(t)) >= 0 &&
+ time_internal::GetRepHi(time_internal::ToUnixDuration(t)) >> 53 == 0) {
+ return (time_internal::GetRepHi(time_internal::ToUnixDuration(t)) * 1000) +
+ (time_internal::GetRepLo(time_internal::ToUnixDuration(t)) /
+ (4000 * 1000));
+ }
+ return FloorToUnit(time_internal::ToUnixDuration(t), absl::Milliseconds(1));
+}
+
+int64_t ToUnixSeconds(Time t) {
+ return time_internal::GetRepHi(time_internal::ToUnixDuration(t));
+}
+
+time_t ToTimeT(Time t) { return absl::ToTimespec(t).tv_sec; }
+
+timespec ToTimespec(Time t) {
+ timespec ts;
+ absl::Duration d = time_internal::ToUnixDuration(t);
+ if (!time_internal::IsInfiniteDuration(d)) {
+ ts.tv_sec = time_internal::GetRepHi(d);
+ if (ts.tv_sec == time_internal::GetRepHi(d)) { // no time_t narrowing
+ ts.tv_nsec = time_internal::GetRepLo(d) / 4; // floor
+ return ts;
+ }
+ }
+ if (d >= absl::ZeroDuration()) {
+ ts.tv_sec = std::numeric_limits<time_t>::max();
+ ts.tv_nsec = 1000 * 1000 * 1000 - 1;
+ } else {
+ ts.tv_sec = std::numeric_limits<time_t>::min();
+ ts.tv_nsec = 0;
+ }
+ return ts;
+}
+
+timeval ToTimeval(Time t) {
+ timeval tv;
+ timespec ts = absl::ToTimespec(t);
+ tv.tv_sec = ts.tv_sec;
+ if (tv.tv_sec != ts.tv_sec) { // narrowing
+ if (ts.tv_sec < 0) {
+ tv.tv_sec = std::numeric_limits<decltype(tv.tv_sec)>::min();
+ tv.tv_usec = 0;
+ } else {
+ tv.tv_sec = std::numeric_limits<decltype(tv.tv_sec)>::max();
+ tv.tv_usec = 1000 * 1000 - 1;
+ }
+ return tv;
+ }
+ tv.tv_usec = static_cast<int>(ts.tv_nsec / 1000); // suseconds_t
+ return tv;
+}
+
+double ToUDate(Time t) {
+ return absl::FDivDuration(time_internal::ToUnixDuration(t),
+ absl::Milliseconds(1));
+}
+
+int64_t ToUniversal(absl::Time t) {
+ return absl::FloorToUnit(t - absl::UniversalEpoch(), absl::Nanoseconds(100));
+}
+
+Time FromChrono(const std::chrono::system_clock::time_point& tp) {
+ return time_internal::FromUnixDuration(time_internal::FromChrono(
+ tp - std::chrono::system_clock::from_time_t(0)));
+}
+
+std::chrono::system_clock::time_point ToChronoTime(absl::Time t) {
+ using D = std::chrono::system_clock::duration;
+ auto d = time_internal::ToUnixDuration(t);
+ if (d < ZeroDuration()) d = Floor(d, FromChrono(D{1}));
+ return std::chrono::system_clock::from_time_t(0) +
+ time_internal::ToChronoDuration<D>(d);
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/time.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/time.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/time.h
new file mode 100644
index 0000000..c50d69a
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/time.h
@@ -0,0 +1,1342 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: time.h
+// -----------------------------------------------------------------------------
+//
+// This header file defines abstractions for computing with absolute points
+// in time, durations of time, and formatting and parsing time within a given
+// time zone. The following abstractions are defined:
+//
+// * `absl::Time` defines an absolute, specific instance in time
+// * `absl::Duration` defines a signed, fixed-length span of time
+// * `absl::TimeZone` defines geopolitical time zone regions (as collected
+// within the IANA Time Zone database (https://www.iana.org/time-zones)).
+//
+// Example:
+//
+// absl::TimeZone nyc;
+//
+// // LoadTimeZone may fail so it's always better to check for success.
+// if (!absl::LoadTimeZone("America/New_York", &nyc)) {
+// // handle error case
+// }
+//
+// // My flight leaves NYC on Jan 2, 2017 at 03:04:05
+// absl::Time takeoff = absl::FromDateTime(2017, 1, 2, 3, 4, 5, nyc);
+// absl::Duration flight_duration = absl::Hours(21) + absl::Minutes(35);
+// absl::Time landing = takeoff + flight_duration;
+//
+// absl::TimeZone syd;
+// if (!absl::LoadTimeZone("Australia/Sydney", &syd)) {
+// // handle error case
+// }
+// std::string s = absl::FormatTime(
+// "My flight will land in Sydney on %Y-%m-%d at %H:%M:%S",
+// landing, syd);
+//
+#ifndef ABSL_TIME_TIME_H_
+#define ABSL_TIME_TIME_H_
+
+#if !defined(_WIN32)
+#include <sys/time.h>
+#else
+#include <winsock2.h>
+#endif
+#include <chrono> // NOLINT(build/c++11)
+#include <cstdint>
+#include <ctime>
+#include <ostream>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/port.h" // Needed for string vs std::string
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+namespace absl {
+
+class Duration; // Defined below
+class Time; // Defined below
+class TimeZone; // Defined below
+
+namespace time_internal {
+int64_t IDivDuration(bool satq, Duration num, Duration den, Duration* rem);
+constexpr Time FromUnixDuration(Duration d);
+constexpr Duration ToUnixDuration(Time t);
+constexpr int64_t GetRepHi(Duration d);
+constexpr uint32_t GetRepLo(Duration d);
+constexpr Duration MakeDuration(int64_t hi, uint32_t lo);
+constexpr Duration MakeDuration(int64_t hi, int64_t lo);
+constexpr int64_t kTicksPerNanosecond = 4;
+constexpr int64_t kTicksPerSecond = 1000 * 1000 * 1000 * kTicksPerNanosecond;
+template <typename T>
+using IsFloatingPoint =
+ typename std::enable_if<std::is_floating_point<T>::value, int>::type;
+} // namespace time_internal
+
+// Duration
+//
+// The `absl::Duration` class represents a signed, fixed-length span of time.
+// A `Duration` is generated using a unit-specific factory function, or is
+// the result of subtracting one `absl::Time` from another. Durations behave
+// like unit-safe integers and they support all the natural integer-like
+// arithmetic operations. Arithmetic overflows and saturates at +/- infinity.
+// `Duration` should be passed by value rather than const reference.
+//
+// Factory functions `Nanoseconds()`, `Microseconds()`, `Milliseconds()`,
+// `Seconds()`, `Minutes()`, `Hours()` and `InfiniteDuration()` allow for
+// creation of constexpr `Duration` values
+//
+// Examples:
+//
+// constexpr absl::Duration ten_ns = absl::Nanoseconds(10);
+// constexpr absl::Duration min = absl::Minutes(1);
+// constexpr absl::Duration hour = absl::Hours(1);
+// absl::Duration dur = 60 * min; // dur == hour
+// absl::Duration half_sec = absl::Milliseconds(500);
+// absl::Duration quarter_sec = 0.25 * absl::Seconds(1);
+//
+// `Duration` values can be easily converted to an integral number of units
+// using the division operator.
+//
+// Example:
+//
+// constexpr absl::Duration dur = absl::Milliseconds(1500);
+// int64_t ns = dur / absl::Nanoseconds(1); // ns == 1500000000
+// int64_t ms = dur / absl::Milliseconds(1); // ms == 1500
+// int64_t sec = dur / absl::Seconds(1); // sec == 1 (subseconds truncated)
+// int64_t min = dur / absl::Minutes(1); // min == 0
+//
+// See the `IDivDuration()` and `FDivDuration()` functions below for details on
+// how to access the fractional parts of the quotient.
+//
+// Alternatively, conversions can be performed using helpers such as
+// `ToInt64Microseconds()` and `ToDoubleSeconds()`.
+class Duration {
+ public:
+ // Value semantics.
+ constexpr Duration() : rep_hi_(0), rep_lo_(0) {} // zero-length duration
+
+ // Compound assignment operators.
+ Duration& operator+=(Duration d);
+ Duration& operator-=(Duration d);
+ Duration& operator*=(int64_t r);
+ Duration& operator*=(double r);
+ Duration& operator/=(int64_t r);
+ Duration& operator/=(double r);
+ Duration& operator%=(Duration rhs);
+
+ // Overloads that forward to either the int64_t or double overloads above.
+ template <typename T>
+ Duration& operator*=(T r) {
+ int64_t x = r;
+ return *this *= x;
+ }
+ template <typename T>
+ Duration& operator/=(T r) {
+ int64_t x = r;
+ return *this /= x;
+ }
+ Duration& operator*=(float r) { return *this *= static_cast<double>(r); }
+ Duration& operator/=(float r) { return *this /= static_cast<double>(r); }
+
+ private:
+ friend constexpr int64_t time_internal::GetRepHi(Duration d);
+ friend constexpr uint32_t time_internal::GetRepLo(Duration d);
+ friend constexpr Duration time_internal::MakeDuration(int64_t hi,
+ uint32_t lo);
+ constexpr Duration(int64_t hi, uint32_t lo) : rep_hi_(hi), rep_lo_(lo) {}
+ int64_t rep_hi_;
+ uint32_t rep_lo_;
+};
+
+// Relational Operators
+constexpr bool operator<(Duration lhs, Duration rhs);
+constexpr bool operator>(Duration lhs, Duration rhs) { return rhs < lhs; }
+constexpr bool operator>=(Duration lhs, Duration rhs) { return !(lhs < rhs); }
+constexpr bool operator<=(Duration lhs, Duration rhs) { return !(rhs < lhs); }
+constexpr bool operator==(Duration lhs, Duration rhs);
+constexpr bool operator!=(Duration lhs, Duration rhs) { return !(lhs == rhs); }
+
+// Additive Operators
+constexpr Duration operator-(Duration d);
+inline Duration operator+(Duration lhs, Duration rhs) { return lhs += rhs; }
+inline Duration operator-(Duration lhs, Duration rhs) { return lhs -= rhs; }
+
+// Multiplicative Operators
+template <typename T>
+inline Duration operator*(Duration lhs, T rhs) {
+ return lhs *= rhs;
+}
+template <typename T>
+inline Duration operator*(T lhs, Duration rhs) {
+ return rhs *= lhs;
+}
+template <typename T>
+inline Duration operator/(Duration lhs, T rhs) {
+ return lhs /= rhs;
+}
+inline int64_t operator/(Duration lhs, Duration rhs) {
+ return time_internal::IDivDuration(true, lhs, rhs,
+ &lhs); // trunc towards zero
+}
+inline Duration operator%(Duration lhs, Duration rhs) { return lhs %= rhs; }
+
+// IDivDuration()
+//
+// Divides a numerator `Duration` by a denominator `Duration`, returning the
+// quotient and remainder. The remainder always has the same sign as the
+// numerator. The returned quotient and remainder respect the identity:
+//
+// numerator = denominator * quotient + remainder
+//
+// Returned quotients are capped to the range of `int64_t`, with the difference
+// spilling into the remainder to uphold the above identity. This means that the
+// remainder returned could differ from the remainder returned by
+// `Duration::operator%` for huge quotients.
+//
+// See also the notes on `InfiniteDuration()` below regarding the behavior of
+// division involving zero and infinite durations.
+//
+// Example:
+//
+// constexpr absl::Duration a =
+// absl::Seconds(std::numeric_limits<int64_t>::max()); // big
+// constexpr absl::Duration b = absl::Nanoseconds(1); // small
+//
+// absl::Duration rem = a % b;
+// // rem == absl::ZeroDuration()
+//
+// // Here, q would overflow int64_t, so rem accounts for the difference.
+// int64_t q = absl::IDivDuration(a, b, &rem);
+// // q == std::numeric_limits<int64_t>::max(), rem == a - b * q
+inline int64_t IDivDuration(Duration num, Duration den, Duration* rem) {
+ return time_internal::IDivDuration(true, num, den,
+ rem); // trunc towards zero
+}
+
+// FDivDuration()
+//
+// Divides a `Duration` numerator into a fractional number of units of a
+// `Duration` denominator.
+//
+// See also the notes on `InfiniteDuration()` below regarding the behavior of
+// division involving zero and infinite durations.
+//
+// Example:
+//
+// double d = absl::FDivDuration(absl::Milliseconds(1500), absl::Seconds(1));
+// // d == 1.5
+double FDivDuration(Duration num, Duration den);
+
+// ZeroDuration()
+//
+// Returns a zero-length duration. This function behaves just like the default
+// constructor, but the name helps make the semantics clear at call sites.
+constexpr Duration ZeroDuration() { return Duration(); }
+
+// AbsDuration()
+//
+// Returns the absolute value of a duration.
+inline Duration AbsDuration(Duration d) {
+ return (d < ZeroDuration()) ? -d : d;
+}
+
+// Trunc()
+//
+// Truncates a duration (toward zero) to a multiple of a non-zero unit.
+//
+// Example:
+//
+// absl::Duration d = absl::Nanoseconds(123456789);
+// absl::Duration a = absl::Trunc(d, absl::Microseconds(1)); // 123456us
+Duration Trunc(Duration d, Duration unit);
+
+// Floor()
+//
+// Floors a duration using the passed duration unit to its largest value not
+// greater than the duration.
+//
+// Example:
+//
+// absl::Duration d = absl::Nanoseconds(123456789);
+// absl::Duration b = absl::Floor(d, absl::Microseconds(1)); // 123456us
+Duration Floor(Duration d, Duration unit);
+
+// Ceil()
+//
+// Returns the ceiling of a duration using the passed duration unit to its
+// smallest value not less than the duration.
+//
+// Example:
+//
+// absl::Duration d = absl::Nanoseconds(123456789);
+// absl::Duration c = absl::Ceil(d, absl::Microseconds(1)); // 123457us
+Duration Ceil(Duration d, Duration unit);
+
+// Nanoseconds()
+// Microseconds()
+// Milliseconds()
+// Seconds()
+// Minutes()
+// Hours()
+//
+// Factory functions for constructing `Duration` values from an integral number
+// of the unit indicated by the factory function's name.
+//
+// Note: no "Days()" factory function exists because "a day" is ambiguous. Civil
+// days are not always 24 hours long, and a 24-hour duration often does not
+// correspond with a civil day. If a 24-hour duration is needed, use
+// `absl::Hours(24)`.
+//
+//
+// Example:
+//
+// absl::Duration a = absl::Seconds(60);
+// absl::Duration b = absl::Minutes(1); // b == a
+constexpr Duration Nanoseconds(int64_t n);
+constexpr Duration Microseconds(int64_t n);
+constexpr Duration Milliseconds(int64_t n);
+constexpr Duration Seconds(int64_t n);
+constexpr Duration Minutes(int64_t n);
+constexpr Duration Hours(int64_t n);
+
+// Factory overloads for constructing `Duration` values from a floating-point
+// number of the unit indicated by the factory function's name. These functions
+// exist for convenience, but they are not as efficient as the integral
+// factories, which should be preferred.
+//
+// Example:
+// auto a = absl::Seconds(1.5); // OK
+// auto b = absl::Milliseconds(1500); // BETTER
+template <typename T, time_internal::IsFloatingPoint<T> = 0>
+Duration Nanoseconds(T n) {
+ return n * Nanoseconds(1);
+}
+template <typename T, time_internal::IsFloatingPoint<T> = 0>
+Duration Microseconds(T n) {
+ return n * Microseconds(1);
+}
+template <typename T, time_internal::IsFloatingPoint<T> = 0>
+Duration Milliseconds(T n) {
+ return n * Milliseconds(1);
+}
+template <typename T, time_internal::IsFloatingPoint<T> = 0>
+Duration Seconds(T n) {
+ return n * Seconds(1);
+}
+template <typename T, time_internal::IsFloatingPoint<T> = 0>
+Duration Minutes(T n) {
+ return n * Minutes(1);
+}
+template <typename T, time_internal::IsFloatingPoint<T> = 0>
+Duration Hours(T n) {
+ return n * Hours(1);
+}
+
+// ToInt64Nanoseconds()
+// ToInt64Microseconds()
+// ToInt64Milliseconds()
+// ToInt64Seconds()
+// ToInt64Minutes()
+// ToInt64Hours()
+//
+// Helper functions that convert a Duration to an integral count of the
+// indicated unit. These functions are shorthand for the `IDivDuration()`
+// function above; see its documentation for details about overflow, etc.
+//
+// Example:
+//
+// absl::Duration d = absl::Milliseconds(1500);
+// int64_t isec = absl::ToInt64Seconds(d); // isec == 1
+int64_t ToInt64Nanoseconds(Duration d);
+int64_t ToInt64Microseconds(Duration d);
+int64_t ToInt64Milliseconds(Duration d);
+int64_t ToInt64Seconds(Duration d);
+int64_t ToInt64Minutes(Duration d);
+int64_t ToInt64Hours(Duration d);
+
+// ToDoubleNanoSeconds()
+// ToDoubleMicroseconds()
+// ToDoubleMilliseconds()
+// ToDoubleSeconds()
+// ToDoubleMinutes()
+// ToDoubleHours()
+//
+// Helper functions that convert a Duration to a floating point count of the
+// indicated unit. These functions are shorthand for the `FDivDuration()`
+// function above; see its documentation for details about overflow, etc.
+//
+// Example:
+//
+// absl::Duration d = absl::Milliseconds(1500);
+// double dsec = absl::ToDoubleSeconds(d); // dsec == 1.5
+double ToDoubleNanoseconds(Duration d);
+double ToDoubleMicroseconds(Duration d);
+double ToDoubleMilliseconds(Duration d);
+double ToDoubleSeconds(Duration d);
+double ToDoubleMinutes(Duration d);
+double ToDoubleHours(Duration d);
+
+// FromChrono()
+//
+// Converts any of the pre-defined std::chrono durations to an absl::Duration.
+//
+// Example:
+//
+// std::chrono::milliseconds ms(123);
+// absl::Duration d = absl::FromChrono(ms);
+constexpr Duration FromChrono(const std::chrono::nanoseconds& d);
+constexpr Duration FromChrono(const std::chrono::microseconds& d);
+constexpr Duration FromChrono(const std::chrono::milliseconds& d);
+constexpr Duration FromChrono(const std::chrono::seconds& d);
+constexpr Duration FromChrono(const std::chrono::minutes& d);
+constexpr Duration FromChrono(const std::chrono::hours& d);
+
+// ToChronoNanoseconds()
+// ToChronoMicroseconds()
+// ToChronoMilliseconds()
+// ToChronoSeconds()
+// ToChronoMinutes()
+// ToChronoHours()
+//
+// Converts an absl::Duration to any of the pre-defined std::chrono durations.
+// If overflow would occur, the returned value will saturate at the min/max
+// chrono duration value instead.
+//
+// Example:
+//
+// absl::Duration d = absl::Microseconds(123);
+// auto x = absl::ToChronoMicroseconds(d);
+// auto y = absl::ToChronoNanoseconds(d); // x == y
+// auto z = absl::ToChronoSeconds(absl::InfiniteDuration());
+// // z == std::chrono::seconds::max()
+std::chrono::nanoseconds ToChronoNanoseconds(Duration d);
+std::chrono::microseconds ToChronoMicroseconds(Duration d);
+std::chrono::milliseconds ToChronoMilliseconds(Duration d);
+std::chrono::seconds ToChronoSeconds(Duration d);
+std::chrono::minutes ToChronoMinutes(Duration d);
+std::chrono::hours ToChronoHours(Duration d);
+
+// InfiniteDuration()
+//
+// Returns an infinite `Duration`. To get a `Duration` representing negative
+// infinity, use `-InfiniteDuration()`.
+//
+// Duration arithmetic overflows to +/- infinity and saturates. In general,
+// arithmetic with `Duration` infinities is similar to IEEE 754 infinities
+// except where IEEE 754 NaN would be involved, in which case +/-
+// `InfiniteDuration()` is used in place of a "nan" Duration.
+//
+// Examples:
+//
+// constexpr absl::Duration inf = absl::InfiniteDuration();
+// const absl::Duration d = ... any finite duration ...
+//
+// inf == inf + inf
+// inf == inf + d
+// inf == inf - inf
+// -inf == d - inf
+//
+// inf == d * 1e100
+// inf == inf / 2
+// 0 == d / inf
+// INT64_MAX == inf / d
+//
+// // Division by zero returns infinity, or INT64_MIN/MAX where appropriate.
+// inf == d / 0
+// INT64_MAX == d / absl::ZeroDuration()
+//
+// The examples involving the `/` operator above also apply to `IDivDuration()`
+// and `FDivDuration()`.
+constexpr Duration InfiniteDuration();
+
+// FormatDuration()
+//
+// Returns a std::string representing the duration in the form "72h3m0.5s".
+// Returns "inf" or "-inf" for +/- `InfiniteDuration()`.
+std::string FormatDuration(Duration d);
+
+// Output stream operator.
+inline std::ostream& operator<<(std::ostream& os, Duration d) {
+ return os << FormatDuration(d);
+}
+
+// ParseDuration()
+//
+// Parses a duration std::string consisting of a possibly signed sequence of
+// decimal numbers, each with an optional fractional part and a unit
+// suffix. The valid suffixes are "ns", "us" "ms", "s", "m", and "h".
+// Simple examples include "300ms", "-1.5h", and "2h45m". Parses "0" as
+// `ZeroDuration()`. Parses "inf" and "-inf" as +/- `InfiniteDuration()`.
+bool ParseDuration(const std::string& dur_string, Duration* d);
+
+// Flag Support
+// TODO(absl-team): Remove once dependencies are removed.
+
+// ParseFlag()
+//
+bool ParseFlag(const std::string& text, Duration* dst, std::string* error);
+
+// UnparseFlag()
+//
+std::string UnparseFlag(Duration d);
+
+// Time
+//
+// An `absl::Time` represents a specific instant in time. Arithmetic operators
+// are provided for naturally expressing time calculations. Instances are
+// created using `absl::Now()` and the `absl::From*()` factory functions that
+// accept the gamut of other time representations. Formatting and parsing
+// functions are provided for conversion to and from strings. `absl::Time`
+// should be passed by value rather than const reference.
+//
+// `absl::Time` assumes there are 60 seconds in a minute, which means the
+// underlying time scales must be "smeared" to eliminate leap seconds.
+// See https://developers.google.com/time/smear.
+//
+// Even though `absl::Time` supports a wide range of timestamps, exercise
+// caution when using values in the distant past. `absl::Time` uses the
+// Proleptic Gregorian calendar, which extends the Gregorian calendar backward
+// to dates before its introduction in 1582.
+// See https://en.wikipedia.org/wiki/Proleptic_Gregorian_calendar
+// for more information. Use the ICU calendar classes to convert a date in
+// some other calendar (http://userguide.icu-project.org/datetime/calendar).
+//
+// Similarly, standardized time zones are a reasonably recent innovation, with
+// the Greenwich prime meridian being established in 1884. The TZ database
+// itself does not profess accurate offsets for timestamps prior to 1970. The
+// breakdown of future timestamps is subject to the whim of regional
+// governments.
+//
+// The `absl::Time` class represents an instant in time as a count of clock
+// ticks of some granularity (resolution) from some starting point (epoch).
+//
+//
+// `absl::Time` uses a resolution that is high enough to avoid loss in
+// precision, and a range that is wide enough to avoid overflow, when
+// converting between tick counts in most Google time scales (i.e., precision
+// of at least one nanosecond, and range +/-100 billion years). Conversions
+// between the time scales are performed by truncating (towards negative
+// infinity) to the nearest representable point.
+//
+// Examples:
+//
+// absl::Time t1 = ...;
+// absl::Time t2 = t1 + absl::Minutes(2);
+// absl::Duration d = t2 - t1; // == absl::Minutes(2)
+// absl::Time::Breakdown bd = t1.In(absl::LocalTimeZone());
+//
+class Time {
+ public:
+ // Value semantics.
+
+ // Returns the Unix epoch. However, those reading your code may not know
+ // or expect the Unix epoch as the default value, so make your code more
+ // readable by explicitly initializing all instances before use.
+ //
+ // Example:
+ // absl::Time t = absl::UnixEpoch();
+ // absl::Time t = absl::Now();
+ // absl::Time t = absl::TimeFromTimeval(tv);
+ // absl::Time t = absl::InfinitePast();
+ constexpr Time() {}
+
+ // Assignment operators.
+ Time& operator+=(Duration d) {
+ rep_ += d;
+ return *this;
+ }
+ Time& operator-=(Duration d) {
+ rep_ -= d;
+ return *this;
+ }
+
+ // Time::Breakdown
+ //
+ // The calendar and wall-clock (aka "civil time") components of an
+ // `absl::Time` in a certain `absl::TimeZone`. This struct is not
+ // intended to represent an instant in time. So, rather than passing
+ // a `Time::Breakdown` to a function, pass an `absl::Time` and an
+ // `absl::TimeZone`.
+ struct Breakdown {
+ int64_t year; // year (e.g., 2013)
+ int month; // month of year [1:12]
+ int day; // day of month [1:31]
+ int hour; // hour of day [0:23]
+ int minute; // minute of hour [0:59]
+ int second; // second of minute [0:59]
+ Duration subsecond; // [Seconds(0):Seconds(1)) if finite
+ int weekday; // 1==Mon, ..., 7=Sun
+ int yearday; // day of year [1:366]
+
+ // Note: The following fields exist for backward compatibility
+ // with older APIs. Accessing these fields directly is a sign of
+ // imprudent logic in the calling code. Modern time-related code
+ // should only access this data indirectly by way of FormatTime().
+ // These fields are undefined for InfiniteFuture() and InfinitePast().
+ int offset; // seconds east of UTC
+ bool is_dst; // is offset non-standard?
+ const char* zone_abbr; // time-zone abbreviation (e.g., "PST")
+ };
+
+ // Time::In()
+ //
+ // Returns the breakdown of this instant in the given TimeZone.
+ Breakdown In(TimeZone tz) const;
+
+ private:
+ friend constexpr Time time_internal::FromUnixDuration(Duration d);
+ friend constexpr Duration time_internal::ToUnixDuration(Time t);
+ friend constexpr bool operator<(Time lhs, Time rhs);
+ friend constexpr bool operator==(Time lhs, Time rhs);
+ friend Duration operator-(Time lhs, Time rhs);
+ friend constexpr Time UniversalEpoch();
+ friend constexpr Time InfiniteFuture();
+ friend constexpr Time InfinitePast();
+ constexpr explicit Time(Duration rep) : rep_(rep) {}
+ Duration rep_;
+};
+
+// Relational Operators
+constexpr bool operator<(Time lhs, Time rhs) { return lhs.rep_ < rhs.rep_; }
+constexpr bool operator>(Time lhs, Time rhs) { return rhs < lhs; }
+constexpr bool operator>=(Time lhs, Time rhs) { return !(lhs < rhs); }
+constexpr bool operator<=(Time lhs, Time rhs) { return !(rhs < lhs); }
+constexpr bool operator==(Time lhs, Time rhs) { return lhs.rep_ == rhs.rep_; }
+constexpr bool operator!=(Time lhs, Time rhs) { return !(lhs == rhs); }
+
+// Additive Operators
+inline Time operator+(Time lhs, Duration rhs) { return lhs += rhs; }
+inline Time operator+(Duration lhs, Time rhs) { return rhs += lhs; }
+inline Time operator-(Time lhs, Duration rhs) { return lhs -= rhs; }
+inline Duration operator-(Time lhs, Time rhs) { return lhs.rep_ - rhs.rep_; }
+
+// UnixEpoch()
+//
+// Returns the `absl::Time` representing "1970-01-01 00:00:00.0 +0000".
+constexpr Time UnixEpoch() { return Time(); }
+
+// UniversalEpoch()
+//
+// Returns the `absl::Time` representing "0001-01-01 00:00:00.0 +0000", the
+// epoch of the ICU Universal Time Scale.
+constexpr Time UniversalEpoch() {
+ // 719162 is the number of days from 0001-01-01 to 1970-01-01,
+ // assuming the Gregorian calendar.
+ return Time(time_internal::MakeDuration(-24 * 719162 * int64_t{3600}, 0U));
+}
+
+// InfiniteFuture()
+//
+// Returns an `absl::Time` that is infinitely far in the future.
+constexpr Time InfiniteFuture() {
+ return Time(
+ time_internal::MakeDuration(std::numeric_limits<int64_t>::max(), ~0U));
+}
+
+// InfinitePast()
+//
+// Returns an `absl::Time` that is infinitely far in the past.
+constexpr Time InfinitePast() {
+ return Time(
+ time_internal::MakeDuration(std::numeric_limits<int64_t>::min(), ~0U));
+}
+
+// TimeConversion
+//
+// An `absl::TimeConversion` represents the conversion of year, month, day,
+// hour, minute, and second values (i.e., a civil time), in a particular
+// `absl::TimeZone`, to a time instant (an absolute time), as returned by
+// `absl::ConvertDateTime()`. (Subseconds must be handled separately.)
+//
+// It is possible, though, for a caller to try to convert values that
+// do not represent an actual or unique instant in time (due to a shift
+// in UTC offset in the `absl::TimeZone`, which results in a discontinuity in
+// the civil-time components). For example, a daylight-saving-time
+// transition skips or repeats civil times---in the United States, March
+// 13, 2011 02:15 never occurred, while November 6, 2011 01:15 occurred
+// twice---so requests for such times are not well-defined.
+//
+// To account for these possibilities, `absl::TimeConversion` is richer
+// than just a single `absl::Time`. When the civil time is skipped or
+// repeated, `absl::ConvertDateTime()` returns times calculated using the
+// pre-transition and post-transition UTC offsets, plus the transition
+// time itself.
+//
+// Examples:
+//
+// absl::TimeZone lax;
+// if (!absl::LoadTimeZone("America/Los_Angeles", &lax)) { ... }
+//
+// // A unique civil time
+// absl::TimeConversion jan01 =
+// absl::ConvertDateTime(2011, 1, 1, 0, 0, 0, lax);
+// // jan01.kind == TimeConversion::UNIQUE
+// // jan01.pre is 2011/01/01 00:00:00 -0800
+// // jan01.trans is 2011/01/01 00:00:00 -0800
+// // jan01.post is 2011/01/01 00:00:00 -0800
+//
+// // A Spring DST transition, when there is a gap in civil time
+// absl::TimeConversion mar13 =
+// absl::ConvertDateTime(2011, 3, 13, 2, 15, 0, lax);
+// // mar13.kind == TimeConversion::SKIPPED
+// // mar13.pre is 2011/03/13 03:15:00 -0700
+// // mar13.trans is 2011/03/13 03:00:00 -0700
+// // mar13.post is 2011/03/13 01:15:00 -0800
+//
+// // A Fall DST transition, when civil times are repeated
+// absl::TimeConversion nov06 =
+// absl::ConvertDateTime(2011, 11, 6, 1, 15, 0, lax);
+// // nov06.kind == TimeConversion::REPEATED
+// // nov06.pre is 2011/11/06 01:15:00 -0700
+// // nov06.trans is 2011/11/06 01:00:00 -0800
+// // nov06.post is 2011/11/06 01:15:00 -0800
+//
+// The input month, day, hour, minute, and second values can also be
+// outside of their valid ranges, in which case they will be "normalized"
+// during the conversion.
+//
+// Example:
+//
+// // "October 32" normalizes to "November 1".
+// absl::TimeZone tz = absl::LocalTimeZone();
+// absl::TimeConversion tc =
+// absl::ConvertDateTime(2013, 10, 32, 8, 30, 0, tz);
+// // tc.kind == TimeConversion::UNIQUE && tc.normalized == true
+// // tc.pre.In(tz).month == 11 && tc.pre.In(tz).day == 1
+struct TimeConversion {
+ Time pre; // time calculated using the pre-transition offset
+ Time trans; // when the civil-time discontinuity occurred
+ Time post; // time calculated using the post-transition offset
+
+ enum Kind {
+ UNIQUE, // the civil time was singular (pre == trans == post)
+ SKIPPED, // the civil time did not exist
+ REPEATED, // the civil time was ambiguous
+ };
+ Kind kind;
+
+ bool normalized; // input values were outside their valid ranges
+};
+
+// ConvertDateTime()
+//
+// The full generality of a civil time to absl::Time conversion.
+TimeConversion ConvertDateTime(int64_t year, int mon, int day, int hour,
+ int min, int sec, TimeZone tz);
+
+// FromDateTime()
+//
+// A convenience wrapper for `absl::ConvertDateTime()` that simply returns the
+// "pre" `absl::Time`. That is, the unique result, or the instant that
+// is correct using the pre-transition offset (as if the transition
+// never happened). This is typically the answer that humans expected when
+// faced with non-unique times, such as near daylight-saving time transitions.
+//
+// Example:
+//
+// absl::TimeZone seattle;
+// if (!absl::LoadTimeZone("America/Los_Angeles", &seattle)) { ... }
+// absl::Time t = absl::FromDateTime(2017, 9, 26, 9, 30, 0, seattle);
+Time FromDateTime(int64_t year, int mon, int day, int hour, int min, int sec,
+ TimeZone tz);
+
+// FromTM()
+//
+// Converts the `tm_year`, `tm_mon`, `tm_mday`, `tm_hour`, `tm_min`, and
+// `tm_sec` fields to an `absl::Time` using the given time zone. See ctime(3)
+// for a description of the expected values of the tm fields. IFF the indicated
+// time instant is not unique (see `absl::ConvertDateTime()` above), the
+// `tm_isdst` field is consulted to select the desired instant (`tm_isdst` > 0
+// means DST, `tm_isdst` == 0 means no DST, `tm_isdst` < 0 means use the default
+// like `absl::FromDateTime()`).
+Time FromTM(const struct tm& tm, TimeZone tz);
+
+// ToTM()
+//
+// Converts the given `absl::Time` to a struct tm using the given time zone.
+// See ctime(3) for a description of the values of the tm fields.
+struct tm ToTM(Time t, TimeZone tz);
+
+// FromUnixNanos()
+// FromUnixMicros()
+// FromUnixMillis()
+// FromUnixSeconds()
+// FromTimeT()
+// FromUDate()
+// FromUniversal()
+//
+// Creates an `absl::Time` from a variety of other representations.
+constexpr Time FromUnixNanos(int64_t ns);
+constexpr Time FromUnixMicros(int64_t us);
+constexpr Time FromUnixMillis(int64_t ms);
+constexpr Time FromUnixSeconds(int64_t s);
+constexpr Time FromTimeT(time_t t);
+Time FromUDate(double udate);
+Time FromUniversal(int64_t universal);
+
+// ToUnixNanos()
+// ToUnixMicros()
+// ToUnixMillis()
+// ToUnixSeconds()
+// ToTimeT()
+// ToUDate()
+// ToUniversal()
+//
+// Converts an `absl::Time` to a variety of other representations. Note that
+// these operations round down toward negative infinity where necessary to
+// adjust to the resolution of the result type. Beware of possible time_t
+// over/underflow in ToTime{T,val,spec}() on 32-bit platforms.
+int64_t ToUnixNanos(Time t);
+int64_t ToUnixMicros(Time t);
+int64_t ToUnixMillis(Time t);
+int64_t ToUnixSeconds(Time t);
+time_t ToTimeT(Time t);
+double ToUDate(Time t);
+int64_t ToUniversal(Time t);
+
+// DurationFromTimespec()
+// DurationFromTimeval()
+// ToTimespec()
+// ToTimeval()
+// TimeFromTimespec()
+// TimeFromTimeval()
+// ToTimespec()
+// ToTimeval()
+//
+// Some APIs use a timespec or a timeval as a Duration (e.g., nanosleep(2)
+// and select(2)), while others use them as a Time (e.g. clock_gettime(2)
+// and gettimeofday(2)), so conversion functions are provided for both cases.
+// The "to timespec/val" direction is easily handled via overloading, but
+// for "from timespec/val" the desired type is part of the function name.
+Duration DurationFromTimespec(timespec ts);
+Duration DurationFromTimeval(timeval tv);
+timespec ToTimespec(Duration d);
+timeval ToTimeval(Duration d);
+Time TimeFromTimespec(timespec ts);
+Time TimeFromTimeval(timeval tv);
+timespec ToTimespec(Time t);
+timeval ToTimeval(Time t);
+
+// FromChrono()
+//
+// Converts a std::chrono::system_clock::time_point to an absl::Time.
+//
+// Example:
+//
+// auto tp = std::chrono::system_clock::from_time_t(123);
+// absl::Time t = absl::FromChrono(tp);
+// // t == absl::FromTimeT(123)
+Time FromChrono(const std::chrono::system_clock::time_point& tp);
+
+// ToChronoTime()
+//
+// Converts an absl::Time to a std::chrono::system_clock::time_point. If
+// overflow would occur, the returned value will saturate at the min/max time
+// point value instead.
+//
+// Example:
+//
+// absl::Time t = absl::FromTimeT(123);
+// auto tp = absl::ToChronoTime(t);
+// // tp == std::chrono::system_clock::from_time_t(123);
+std::chrono::system_clock::time_point ToChronoTime(Time);
+
+// RFC3339_full
+// RFC3339_sec
+//
+// FormatTime()/ParseTime() format specifiers for RFC3339 date/time strings,
+// with trailing zeros trimmed or with fractional seconds omitted altogether.
+//
+// Note that RFC3339_sec[] matches an ISO 8601 extended format for date
+// and time with UTC offset.
+extern const char RFC3339_full[]; // %Y-%m-%dT%H:%M:%E*S%Ez
+extern const char RFC3339_sec[]; // %Y-%m-%dT%H:%M:%S%Ez
+
+// RFC1123_full
+// RFC1123_no_wday
+//
+// FormatTime()/ParseTime() format specifiers for RFC1123 date/time strings.
+extern const char RFC1123_full[]; // %a, %d %b %E4Y %H:%M:%S %z
+extern const char RFC1123_no_wday[]; // %d %b %E4Y %H:%M:%S %z
+
+// FormatTime()
+//
+// Formats the given `absl::Time` in the `absl::TimeZone` according to the
+// provided format std::string. Uses strftime()-like formatting options, with
+// the following extensions:
+//
+// - %Ez - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
+// - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
+// - %E#S - Seconds with # digits of fractional precision
+// - %E*S - Seconds with full fractional precision (a literal '*')
+// - %E#f - Fractional seconds with # digits of precision
+// - %E*f - Fractional seconds with full precision (a literal '*')
+// - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
+//
+// Note that %E0S behaves like %S, and %E0f produces no characters. In
+// contrast %E*f always produces at least one digit, which may be '0'.
+//
+// Note that %Y produces as many characters as it takes to fully render the
+// year. A year outside of [-999:9999] when formatted with %E4Y will produce
+// more than four characters, just like %Y.
+//
+// We recommend that format strings include the UTC offset (%z, %Ez, or %E*z)
+// so that the result uniquely identifies a time instant.
+//
+// Example:
+//
+// absl::TimeZone lax;
+// if (!absl::LoadTimeZone("America/Los_Angeles", &lax)) { ... }
+// absl::Time t = absl::FromDateTime(2013, 1, 2, 3, 4, 5, lax);
+//
+// std::string f = absl::FormatTime("%H:%M:%S", t, lax); // "03:04:05"
+// f = absl::FormatTime("%H:%M:%E3S", t, lax); // "03:04:05.000"
+//
+// Note: If the given `absl::Time` is `absl::InfiniteFuture()`, the returned
+// std::string will be exactly "infinite-future". If the given `absl::Time` is
+// `absl::InfinitePast()`, the returned std::string will be exactly "infinite-past".
+// In both cases the given format std::string and `absl::TimeZone` are ignored.
+//
+std::string FormatTime(const std::string& format, Time t, TimeZone tz);
+
+// Convenience functions that format the given time using the RFC3339_full
+// format. The first overload uses the provided TimeZone, while the second
+// uses LocalTimeZone().
+std::string FormatTime(Time t, TimeZone tz);
+std::string FormatTime(Time t);
+
+// Output stream operator.
+inline std::ostream& operator<<(std::ostream& os, Time t) {
+ return os << FormatTime(t);
+}
+
+// ParseTime()
+//
+// Parses an input std::string according to the provided format std::string and
+// returns the corresponding `absl::Time`. Uses strftime()-like formatting
+// options, with the same extensions as FormatTime(), but with the
+// exceptions that %E#S is interpreted as %E*S, and %E#f as %E*f. %Ez
+// and %E*z also accept the same inputs.
+//
+// %Y consumes as many numeric characters as it can, so the matching data
+// should always be terminated with a non-numeric. %E4Y always consumes
+// exactly four characters, including any sign.
+//
+// Unspecified fields are taken from the default date and time of ...
+//
+// "1970-01-01 00:00:00.0 +0000"
+//
+// For example, parsing a std::string of "15:45" (%H:%M) will return an absl::Time
+// that represents "1970-01-01 15:45:00.0 +0000".
+//
+// Note that since ParseTime() returns time instants, it makes the most sense
+// to parse fully-specified date/time strings that include a UTC offset (%z,
+// %Ez, or %E*z).
+//
+// Note also that `absl::ParseTime()` only heeds the fields year, month, day,
+// hour, minute, (fractional) second, and UTC offset. Other fields, like
+// weekday (%a or %A), while parsed for syntactic validity, are ignored
+// in the conversion.
+//
+// Date and time fields that are out-of-range will be treated as errors
+// rather than normalizing them like `absl::FromDateTime()` does. For example,
+// it is an error to parse the date "Oct 32, 2013" because 32 is out of range.
+//
+// A leap second of ":60" is normalized to ":00" of the following minute
+// with fractional seconds discarded. The following table shows how the
+// given seconds and subseconds will be parsed:
+//
+// "59.x" -> 59.x // exact
+// "60.x" -> 00.0 // normalized
+// "00.x" -> 00.x // exact
+//
+// Errors are indicated by returning false and assigning an error message
+// to the "err" out param if it is non-null.
+//
+// Note: If the input std::string is exactly "infinite-future", the returned
+// `absl::Time` will be `absl::InfiniteFuture()` and `true` will be returned.
+// If the input std::string is "infinite-past", the returned `absl::Time` will be
+// `absl::InfinitePast()` and `true` will be returned.
+//
+bool ParseTime(const std::string& format, const std::string& input, Time* time,
+ std::string* err);
+
+// Like ParseTime() above, but if the format std::string does not contain a UTC
+// offset specification (%z/%Ez/%E*z) then the input is interpreted in the
+// given TimeZone. This means that the input, by itself, does not identify a
+// unique instant. Being time-zone dependent, it also admits the possibility
+// of ambiguity or non-existence, in which case the "pre" time (as defined
+// for ConvertDateTime()) is returned. For these reasons we recommend that
+// all date/time strings include a UTC offset so they're context independent.
+bool ParseTime(const std::string& format, const std::string& input, TimeZone tz,
+ Time* time, std::string* err);
+
+// TODO(absl-team): Remove once dependencies are removed.
+
+// ParseFlag()
+// UnparseFlag()
+//
+// Support for flag values of type Time. Time flags must be specified in a
+// format that matches absl::RFC3339_full. For example:
+//
+// --start_time=2016-01-02T03:04:05.678+08:00
+//
+// Note: A UTC offset (or 'Z' indicating a zero-offset from UTC) is required.
+//
+// Additionally, if you'd like to specify a time as a count of
+// seconds/milliseconds/etc from the Unix epoch, use an absl::Duration flag
+// and add that duration to absl::UnixEpoch() to get an absl::Time.
+bool ParseFlag(const std::string& text, Time* t, std::string* error);
+std::string UnparseFlag(Time t);
+
+// TimeZone
+//
+// The `absl::TimeZone` is an opaque, small, value-type class representing a
+// geo-political region within which particular rules are used for converting
+// between absolute and civil times (see https://git.io/v59Ly). `absl::TimeZone`
+// values are named using the TZ identifiers from the IANA Time Zone Database,
+// such as "America/Los_Angeles" or "Australia/Sydney". `absl::TimeZone` values
+// are created from factory functions such as `absl::LoadTimeZone()`. Note:
+// strings like "PST" and "EDT" are not valid TZ identifiers. Prefer to pass by
+// value rather than const reference.
+//
+// For more on the fundamental concepts of time zones, absolute times, and civil
+// times, see https://github.com/google/cctz#fundamental-concepts
+//
+// Examples:
+//
+// absl::TimeZone utc = absl::UTCTimeZone();
+// absl::TimeZone pst = absl::FixedTimeZone(-8 * 60 * 60);
+// absl::TimeZone loc = absl::LocalTimeZone();
+// absl::TimeZone lax;
+// if (!absl::LoadTimeZone("America/Los_Angeles", &lax)) { ... }
+//
+// See also:
+// - https://github.com/google/cctz
+// - http://www.iana.org/time-zones
+// - http://en.wikipedia.org/wiki/Zoneinfo
+class TimeZone {
+ public:
+ explicit TimeZone(time_internal::cctz::time_zone tz) : cz_(tz) {}
+ TimeZone() = default; // UTC, but prefer UTCTimeZone() to be explicit.
+ TimeZone(const TimeZone&) = default;
+ TimeZone& operator=(const TimeZone&) = default;
+
+ explicit operator time_internal::cctz::time_zone() const { return cz_; }
+
+ std::string name() const { return cz_.name(); }
+
+ private:
+ friend bool operator==(TimeZone a, TimeZone b) { return a.cz_ == b.cz_; }
+ friend bool operator!=(TimeZone a, TimeZone b) { return a.cz_ != b.cz_; }
+ friend std::ostream& operator<<(std::ostream& os, TimeZone tz) {
+ return os << tz.name();
+ }
+
+ time_internal::cctz::time_zone cz_;
+};
+
+// LoadTimeZone()
+//
+// Loads the named zone. May perform I/O on the initial load of the named
+// zone. If the name is invalid, or some other kind of error occurs, returns
+// `false` and `*tz` is set to the UTC time zone.
+inline bool LoadTimeZone(const std::string& name, TimeZone* tz) {
+ if (name == "localtime") {
+ *tz = TimeZone(time_internal::cctz::local_time_zone());
+ return true;
+ }
+ time_internal::cctz::time_zone cz;
+ const bool b = time_internal::cctz::load_time_zone(name, &cz);
+ *tz = TimeZone(cz);
+ return b;
+}
+
+// FixedTimeZone()
+//
+// Returns a TimeZone that is a fixed offset (seconds east) from UTC.
+// Note: If the absolute value of the offset is greater than 24 hours
+// you'll get UTC (i.e., no offset) instead.
+inline TimeZone FixedTimeZone(int seconds) {
+ return TimeZone(
+ time_internal::cctz::fixed_time_zone(std::chrono::seconds(seconds)));
+}
+
+// UTCTimeZone()
+//
+// Convenience method returning the UTC time zone.
+inline TimeZone UTCTimeZone() {
+ return TimeZone(time_internal::cctz::utc_time_zone());
+}
+
+// LocalTimeZone()
+//
+// Convenience method returning the local time zone, or UTC if there is
+// no configured local zone. Warning: Be wary of using LocalTimeZone(),
+// and particularly so in a server process, as the zone configured for the
+// local machine should be irrelevant. Prefer an explicit zone name.
+inline TimeZone LocalTimeZone() {
+ return TimeZone(time_internal::cctz::local_time_zone());
+}
+
+// ============================================================================
+// Implementation Details Follow
+// ============================================================================
+
+namespace time_internal {
+
+// Creates a Duration with a given representation.
+// REQUIRES: hi,lo is a valid representation of a Duration as specified
+// in time/duration.cc.
+constexpr Duration MakeDuration(int64_t hi, uint32_t lo = 0) {
+ return Duration(hi, lo);
+}
+
+constexpr Duration MakeDuration(int64_t hi, int64_t lo) {
+ return MakeDuration(hi, static_cast<uint32_t>(lo));
+}
+
+// Creates a normalized Duration from an almost-normalized (sec,ticks)
+// pair. sec may be positive or negative. ticks must be in the range
+// -kTicksPerSecond < *ticks < kTicksPerSecond. If ticks is negative it
+// will be normalized to a positive value in the resulting Duration.
+constexpr Duration MakeNormalizedDuration(int64_t sec, int64_t ticks) {
+ return (ticks < 0) ? MakeDuration(sec - 1, ticks + kTicksPerSecond)
+ : MakeDuration(sec, ticks);
+}
+// Provide access to the Duration representation.
+constexpr int64_t GetRepHi(Duration d) { return d.rep_hi_; }
+constexpr uint32_t GetRepLo(Duration d) { return d.rep_lo_; }
+constexpr bool IsInfiniteDuration(Duration d) { return GetRepLo(d) == ~0U; }
+
+// Returns an infinite Duration with the opposite sign.
+// REQUIRES: IsInfiniteDuration(d)
+constexpr Duration OppositeInfinity(Duration d) {
+ return GetRepHi(d) < 0
+ ? MakeDuration(std::numeric_limits<int64_t>::max(), ~0U)
+ : MakeDuration(std::numeric_limits<int64_t>::min(), ~0U);
+}
+
+// Returns (-n)-1 (equivalently -(n+1)) without avoidable overflow.
+constexpr int64_t NegateAndSubtractOne(int64_t n) {
+ // Note: Good compilers will optimize this expression to ~n when using
+ // a two's-complement representation (which is required for int64_t).
+ return (n < 0) ? -(n + 1) : (-n) - 1;
+}
+
+// Map between a Time and a Duration since the Unix epoch. Note that these
+// functions depend on the above mentioned choice of the Unix epoch for the
+// Time representation (and both need to be Time friends). Without this
+// knowledge, we would need to add-in/subtract-out UnixEpoch() respectively.
+constexpr Time FromUnixDuration(Duration d) { return Time(d); }
+constexpr Duration ToUnixDuration(Time t) { return t.rep_; }
+
+template <std::intmax_t N>
+constexpr Duration FromInt64(int64_t v, std::ratio<1, N>) {
+ static_assert(0 < N && N <= 1000 * 1000 * 1000, "Unsupported ratio");
+ // Subsecond ratios cannot overflow.
+ return MakeNormalizedDuration(
+ v / N, v % N * kTicksPerNanosecond * 1000 * 1000 * 1000 / N);
+}
+constexpr Duration FromInt64(int64_t v, std::ratio<60>) {
+ return Minutes(v);
+}
+constexpr Duration FromInt64(int64_t v, std::ratio<3600>) {
+ return Hours(v);
+}
+
+// IsValidRep64<T>(0) is true if the expression `int64_t{std::declval<T>()}` is
+// valid. That is, if a T can be assigned to an int64_t without narrowing.
+template <typename T>
+constexpr auto IsValidRep64(int)
+ -> decltype(int64_t{std::declval<T>()}, bool()) {
+ return true;
+}
+template <typename T>
+constexpr auto IsValidRep64(char) -> bool {
+ return false;
+}
+
+// Converts a std::chrono::duration to an absl::Duration.
+template <typename Rep, typename Period>
+constexpr Duration FromChrono(const std::chrono::duration<Rep, Period>& d) {
+ static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
+ return FromInt64(int64_t{d.count()}, Period{});
+}
+
+template <typename Ratio>
+int64_t ToInt64(Duration d, Ratio) {
+ // Note: This may be used on MSVC, which may have a system_clock period of
+ // std::ratio<1, 10 * 1000 * 1000>
+ return ToInt64Seconds(d * Ratio::den / Ratio::num);
+}
+// Fastpath implementations for the 6 common duration units.
+inline int64_t ToInt64(Duration d, std::nano) {
+ return ToInt64Nanoseconds(d);
+}
+inline int64_t ToInt64(Duration d, std::micro) {
+ return ToInt64Microseconds(d);
+}
+inline int64_t ToInt64(Duration d, std::milli) {
+ return ToInt64Milliseconds(d);
+}
+inline int64_t ToInt64(Duration d, std::ratio<1>) {
+ return ToInt64Seconds(d);
+}
+inline int64_t ToInt64(Duration d, std::ratio<60>) {
+ return ToInt64Minutes(d);
+}
+inline int64_t ToInt64(Duration d, std::ratio<3600>) {
+ return ToInt64Hours(d);
+}
+
+// Converts an absl::Duration to a chrono duration of type T.
+template <typename T>
+T ToChronoDuration(Duration d) {
+ using Rep = typename T::rep;
+ using Period = typename T::period;
+ static_assert(IsValidRep64<Rep>(0), "duration::rep is invalid");
+ if (time_internal::IsInfiniteDuration(d))
+ return d < ZeroDuration() ? T::min() : T::max();
+ const auto v = ToInt64(d, Period{});
+ if (v > std::numeric_limits<Rep>::max()) return T::max();
+ if (v < std::numeric_limits<Rep>::min()) return T::min();
+ return T{v};
+}
+
+} // namespace time_internal
+
+constexpr bool operator<(Duration lhs, Duration rhs) {
+ return time_internal::GetRepHi(lhs) != time_internal::GetRepHi(rhs)
+ ? time_internal::GetRepHi(lhs) < time_internal::GetRepHi(rhs)
+ : time_internal::GetRepHi(lhs) == std::numeric_limits<int64_t>::min()
+ ? time_internal::GetRepLo(lhs) + 1 <
+ time_internal::GetRepLo(rhs) + 1
+ : time_internal::GetRepLo(lhs) <
+ time_internal::GetRepLo(rhs);
+}
+
+constexpr bool operator==(Duration lhs, Duration rhs) {
+ return time_internal::GetRepHi(lhs) == time_internal::GetRepHi(rhs) &&
+ time_internal::GetRepLo(lhs) == time_internal::GetRepLo(rhs);
+}
+
+constexpr Duration operator-(Duration d) {
+ // This is a little interesting because of the special cases.
+ //
+ // If rep_lo_ is zero, we have it easy; it's safe to negate rep_hi_, we're
+ // dealing with an integral number of seconds, and the only special case is
+ // the maximum negative finite duration, which can't be negated.
+ //
+ // Infinities stay infinite, and just change direction.
+ //
+ // Finally we're in the case where rep_lo_ is non-zero, and we can borrow
+ // a second's worth of ticks and avoid overflow (as negating int64_t-min + 1
+ // is safe).
+ return time_internal::GetRepLo(d) == 0
+ ? time_internal::GetRepHi(d) == std::numeric_limits<int64_t>::min()
+ ? InfiniteDuration()
+ : time_internal::MakeDuration(-time_internal::GetRepHi(d))
+ : time_internal::IsInfiniteDuration(d)
+ ? time_internal::OppositeInfinity(d)
+ : time_internal::MakeDuration(
+ time_internal::NegateAndSubtractOne(
+ time_internal::GetRepHi(d)),
+ time_internal::kTicksPerSecond -
+ time_internal::GetRepLo(d));
+}
+
+constexpr Duration Nanoseconds(int64_t n) {
+ return time_internal::MakeNormalizedDuration(
+ n / (1000 * 1000 * 1000),
+ n % (1000 * 1000 * 1000) * time_internal::kTicksPerNanosecond);
+}
+
+constexpr Duration Microseconds(int64_t n) {
+ return time_internal::MakeNormalizedDuration(
+ n / (1000 * 1000),
+ n % (1000 * 1000) * (1000 * time_internal::kTicksPerNanosecond));
+}
+
+constexpr Duration Milliseconds(int64_t n) {
+ return time_internal::MakeNormalizedDuration(
+ n / 1000, n % 1000 * (1000 * 1000 * time_internal::kTicksPerNanosecond));
+}
+
+constexpr Duration Seconds(int64_t n) { return time_internal::MakeDuration(n); }
+
+constexpr Duration Minutes(int64_t n) {
+ return (n <= std::numeric_limits<int64_t>::max() / 60 &&
+ n >= std::numeric_limits<int64_t>::min() / 60)
+ ? time_internal::MakeDuration(n * 60)
+ : n > 0 ? InfiniteDuration() : -InfiniteDuration();
+}
+
+constexpr Duration Hours(int64_t n) {
+ return (n <= std::numeric_limits<int64_t>::max() / 3600 &&
+ n >= std::numeric_limits<int64_t>::min() / 3600)
+ ? time_internal::MakeDuration(n * 3600)
+ : n > 0 ? InfiniteDuration() : -InfiniteDuration();
+}
+
+constexpr Duration InfiniteDuration() {
+ return time_internal::MakeDuration(std::numeric_limits<int64_t>::max(), ~0U);
+}
+
+constexpr Duration FromChrono(const std::chrono::nanoseconds& d) {
+ return time_internal::FromChrono(d);
+}
+constexpr Duration FromChrono(const std::chrono::microseconds& d) {
+ return time_internal::FromChrono(d);
+}
+constexpr Duration FromChrono(const std::chrono::milliseconds& d) {
+ return time_internal::FromChrono(d);
+}
+constexpr Duration FromChrono(const std::chrono::seconds& d) {
+ return time_internal::FromChrono(d);
+}
+constexpr Duration FromChrono(const std::chrono::minutes& d) {
+ return time_internal::FromChrono(d);
+}
+constexpr Duration FromChrono(const std::chrono::hours& d) {
+ return time_internal::FromChrono(d);
+}
+
+constexpr Time FromUnixNanos(int64_t ns) {
+ return time_internal::FromUnixDuration(Nanoseconds(ns));
+}
+
+constexpr Time FromUnixMicros(int64_t us) {
+ return time_internal::FromUnixDuration(Microseconds(us));
+}
+
+constexpr Time FromUnixMillis(int64_t ms) {
+ return time_internal::FromUnixDuration(Milliseconds(ms));
+}
+
+constexpr Time FromUnixSeconds(int64_t s) {
+ return time_internal::FromUnixDuration(Seconds(s));
+}
+
+constexpr Time FromTimeT(time_t t) {
+ return time_internal::FromUnixDuration(Seconds(t));
+}
+
+} // namespace absl
+
+#endif // ABSL_TIME_TIME_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_norm_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_norm_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_norm_test.cc
new file mode 100644
index 0000000..005756e
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/time_norm_test.cc
@@ -0,0 +1,306 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// This file contains tests for FromDateTime() normalization, which is
+// time-zone independent so we just use UTC throughout.
+
+#include <cstdint>
+#include <limits>
+
+#include "gtest/gtest.h"
+#include "absl/time/internal/test_util.h"
+#include "absl/time/time.h"
+
+namespace {
+
+TEST(TimeNormCase, SimpleOverflow) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+
+ absl::TimeConversion tc =
+ absl::ConvertDateTime(2013, 11, 15, 16, 32, 59 + 1, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ absl::Time::Breakdown bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 16, 33, 0, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11, 15, 16, 59 + 1, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 17, 0, 14, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11, 15, 23 + 1, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 16, 0, 32, 14, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11, 30 + 1, 16, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 12, 1, 16, 32, 14, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 12 + 1, 15, 16, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2014, 1, 15, 16, 32, 14, 0, false, "UTC");
+}
+
+TEST(TimeNormCase, SimpleUnderflow) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+
+ absl::TimeConversion tc = ConvertDateTime(2013, 11, 15, 16, 32, 0 - 1, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ absl::Time::Breakdown bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 16, 31, 59, 0, false, "UTC");
+
+ tc = ConvertDateTime(2013, 11, 15, 16, 0 - 1, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 15, 15, 59, 14, 0, false, "UTC");
+
+ tc = ConvertDateTime(2013, 11, 15, 0 - 1, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 14, 23, 32, 14, 0, false, "UTC");
+
+ tc = ConvertDateTime(2013, 11, 1 - 1, 16, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 10, 31, 16, 32, 14, 0, false, "UTC");
+
+ tc = ConvertDateTime(2013, 1 - 1, 15, 16, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2012, 12, 15, 16, 32, 14, 0, false, "UTC");
+}
+
+TEST(TimeNormCase, MultipleOverflow) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+ absl::TimeConversion tc = ConvertDateTime(2013, 12, 31, 23, 59, 59 + 1, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ absl::Time::Breakdown bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2014, 1, 1, 0, 0, 0, 0, false, "UTC");
+}
+
+TEST(TimeNormCase, MultipleUnderflow) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+ absl::TimeConversion tc = absl::ConvertDateTime(2014, 1, 1, 0, 0, 0 - 1, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ absl::Time::Breakdown bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 12, 31, 23, 59, 59, 0, false, "UTC");
+}
+
+TEST(TimeNormCase, OverflowLimits) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+ absl::TimeConversion tc;
+ absl::Time::Breakdown bd;
+
+ const int kintmax = std::numeric_limits<int>::max();
+ tc = absl::ConvertDateTime(0, kintmax, kintmax, kintmax, kintmax, kintmax,
+ utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 185085715, 11, 27, 12, 21, 7, 0, false, "UTC");
+
+ const int kintmin = std::numeric_limits<int>::min();
+ tc = absl::ConvertDateTime(0, kintmin, kintmin, kintmin, kintmin, kintmin,
+ utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, -185085717, 10, 31, 10, 37, 52, 0, false,
+ "UTC");
+
+ const int64_t max_year = std::numeric_limits<int64_t>::max();
+ tc = absl::ConvertDateTime(max_year, 12, 31, 23, 59, 59, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ EXPECT_EQ(absl::InfiniteFuture(), tc.pre);
+
+ const int64_t min_year = std::numeric_limits<int64_t>::min();
+ tc = absl::ConvertDateTime(min_year, 1, 1, 0, 0, 0, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ EXPECT_EQ(absl::InfinitePast(), tc.pre);
+}
+
+TEST(TimeNormCase, ComplexOverflow) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+
+ absl::TimeConversion tc =
+ ConvertDateTime(2013, 11, 15, 16, 32, 14 + 123456789, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ absl::Time::Breakdown bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2017, 10, 14, 14, 5, 23, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11, 15, 16, 32 + 1234567, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2016, 3, 22, 0, 39, 14, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11, 15, 16 + 123456, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2027, 12, 16, 16, 32, 14, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11, 15 + 1234, 16, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2017, 4, 2, 16, 32, 14, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11 + 123, 15, 16, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2024, 2, 15, 16, 32, 14, 0, false, "UTC");
+}
+
+TEST(TimeNormCase, ComplexUnderflow) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+
+ absl::TimeConversion tc =
+ absl::ConvertDateTime(1999, 3, 0, 0, 0, 0, utc); // year 400
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ absl::Time::Breakdown bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 1999, 2, 28, 0, 0, 0, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11, 15, 16, 32, 14 - 123456789, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2009, 12, 17, 18, 59, 5, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11, 15, 16, 32 - 1234567, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2011, 7, 12, 8, 25, 14, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11, 15, 16 - 123456, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 1999, 10, 16, 16, 32, 14, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11, 15 - 1234, 16, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2010, 6, 30, 16, 32, 14, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11 - 123, 15, 16, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2003, 8, 15, 16, 32, 14, 0, false, "UTC");
+}
+
+TEST(TimeNormCase, Mishmash) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+
+ absl::TimeConversion tc =
+ absl::ConvertDateTime(2013, 11 - 123, 15 + 1234, 16 - 123456,
+ 32 + 1234567, 14 - 123456789, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ absl::Time::Breakdown bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 1991, 5, 9, 3, 6, 5, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2013, 11 + 123, 15 - 1234, 16 + 123456,
+ 32 - 1234567, 14 + 123456789, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2036, 5, 24, 5, 58, 23, 0, false, "UTC");
+
+ // Here is a normalization case we got wrong for a while. Because the
+ // day is converted to "1" within a 400-year (146097-day) period, we
+ // didn't need to roll the month and so we didn't mark it as normalized.
+ tc = absl::ConvertDateTime(2013, 11, -146097 + 1, 16, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 1613, 11, 1, 16, 32, 14, 0, false, "UTC");
+
+ // Even though the month overflow compensates for the day underflow,
+ // this should still be marked as normalized.
+ tc = absl::ConvertDateTime(2013, 11 + 400 * 12, -146097 + 1, 16, 32, 14, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 11, 1, 16, 32, 14, 0, false, "UTC");
+}
+
+TEST(TimeNormCase, LeapYears) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+
+ absl::TimeConversion tc =
+ absl::ConvertDateTime(2013, 2, 28 + 1, 0, 0, 0, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ absl::Time::Breakdown bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2013, 3, 1, 0, 0, 0, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2012, 2, 28 + 1, 0, 0, 0, utc);
+ EXPECT_FALSE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2012, 2, 29, 0, 0, 0, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(2000, 2, 28 + 1, 0, 0, 0, utc);
+ EXPECT_FALSE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 2000, 2, 29, 0, 0, 0, 0, false, "UTC");
+
+ tc = absl::ConvertDateTime(1900, 2, 28 + 1, 0, 0, 0, utc);
+ EXPECT_TRUE(tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ bd = tc.pre.In(utc);
+ ABSL_INTERNAL_EXPECT_TIME(bd, 1900, 3, 1, 0, 0, 0, 0, false, "UTC");
+}
+
+// Convert all the days from 1970-1-1 to 1970-1-146097 (aka 2369-12-31)
+// and check that they normalize to the expected time. 146097 days span
+// the 400-year Gregorian cycle used during normalization.
+TEST(TimeNormCase, AllTheDays) {
+ const absl::TimeZone utc = absl::UTCTimeZone();
+ absl::Time exp_time = absl::UnixEpoch();
+
+ for (int day = 1; day <= 146097; ++day) {
+ absl::TimeConversion tc = absl::ConvertDateTime(1970, 1, day, 0, 0, 0, utc);
+ EXPECT_EQ(day > 31, tc.normalized);
+ EXPECT_EQ(absl::TimeConversion::UNIQUE, tc.kind);
+ EXPECT_EQ(exp_time, tc.pre);
+ exp_time += absl::Hours(24);
+ }
+}
+
+} // namespace
[25/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute_test.cc
new file mode 100644
index 0000000..144df01
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/substitute_test.cc
@@ -0,0 +1,192 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/substitute.h"
+
+#include <cstdint>
+
+#include "gtest/gtest.h"
+#include "absl/strings/str_cat.h"
+
+namespace {
+
+TEST(SubstituteTest, Substitute) {
+ // Basic.
+ EXPECT_EQ("Hello, world!", absl::Substitute("$0, $1!", "Hello", "world"));
+
+ // Non-char* types.
+ EXPECT_EQ("123 0.2 0.1 foo true false x",
+ absl::Substitute("$0 $1 $2 $3 $4 $5 $6", 123, 0.2, 0.1f,
+ std::string("foo"), true, false, 'x'));
+
+ // All int types.
+ EXPECT_EQ(
+ "-32767 65535 "
+ "-1234567890 3234567890 "
+ "-1234567890 3234567890 "
+ "-1234567890123456789 9234567890123456789",
+ absl::Substitute(
+ "$0 $1 $2 $3 $4 $5 $6 $7",
+ static_cast<short>(-32767), // NOLINT(runtime/int)
+ static_cast<unsigned short>(65535), // NOLINT(runtime/int)
+ -1234567890, 3234567890U, -1234567890L, 3234567890UL,
+ -int64_t{1234567890123456789}, uint64_t{9234567890123456789u}));
+
+ // Hex format
+ EXPECT_EQ("0 1 f ffff0ffff 0123456789abcdef",
+ absl::Substitute("$0$1$2$3$4 $5", //
+ absl::Hex(0), absl::Hex(1, absl::kSpacePad2),
+ absl::Hex(0xf, absl::kSpacePad2),
+ absl::Hex(int16_t{-1}, absl::kSpacePad5),
+ absl::Hex(int16_t{-1}, absl::kZeroPad5),
+ absl::Hex(0x123456789abcdef, absl::kZeroPad16)));
+
+ // Dec format
+ EXPECT_EQ("0 115 -1-0001 81985529216486895",
+ absl::Substitute("$0$1$2$3$4 $5", //
+ absl::Dec(0), absl::Dec(1, absl::kSpacePad2),
+ absl::Dec(0xf, absl::kSpacePad2),
+ absl::Dec(int16_t{-1}, absl::kSpacePad5),
+ absl::Dec(int16_t{-1}, absl::kZeroPad5),
+ absl::Dec(0x123456789abcdef, absl::kZeroPad16)));
+
+ // Pointer.
+ const int* int_p = reinterpret_cast<const int*>(0x12345);
+ std::string str = absl::Substitute("$0", int_p);
+ EXPECT_EQ(absl::StrCat("0x", absl::Hex(int_p)), str);
+
+ // Volatile Pointer.
+ // Like C++ streamed I/O, such pointers implicitly become bool
+ volatile int vol = 237;
+ volatile int *volatile volptr = &vol;
+ str = absl::Substitute("$0", volptr);
+ EXPECT_EQ("true", str);
+
+ // null is special. StrCat prints 0x0. Substitute prints NULL.
+ const uint64_t* null_p = nullptr;
+ str = absl::Substitute("$0", null_p);
+ EXPECT_EQ("NULL", str);
+
+ // char* is also special.
+ const char* char_p = "print me";
+ str = absl::Substitute("$0", char_p);
+ EXPECT_EQ("print me", str);
+
+ char char_buf[16];
+ strncpy(char_buf, "print me too", sizeof(char_buf));
+ str = absl::Substitute("$0", char_buf);
+ EXPECT_EQ("print me too", str);
+
+ // null char* is "doubly" special. Represented as the empty std::string.
+ char_p = nullptr;
+ str = absl::Substitute("$0", char_p);
+ EXPECT_EQ("", str);
+
+ // Out-of-order.
+ EXPECT_EQ("b, a, c, b", absl::Substitute("$1, $0, $2, $1", "a", "b", "c"));
+
+ // Literal $
+ EXPECT_EQ("$", absl::Substitute("$$"));
+
+ EXPECT_EQ("$1", absl::Substitute("$$1"));
+
+ // Test all overloads.
+ EXPECT_EQ("a", absl::Substitute("$0", "a"));
+ EXPECT_EQ("a b", absl::Substitute("$0 $1", "a", "b"));
+ EXPECT_EQ("a b c", absl::Substitute("$0 $1 $2", "a", "b", "c"));
+ EXPECT_EQ("a b c d", absl::Substitute("$0 $1 $2 $3", "a", "b", "c", "d"));
+ EXPECT_EQ("a b c d e",
+ absl::Substitute("$0 $1 $2 $3 $4", "a", "b", "c", "d", "e"));
+ EXPECT_EQ("a b c d e f", absl::Substitute("$0 $1 $2 $3 $4 $5", "a", "b", "c",
+ "d", "e", "f"));
+ EXPECT_EQ("a b c d e f g", absl::Substitute("$0 $1 $2 $3 $4 $5 $6", "a", "b",
+ "c", "d", "e", "f", "g"));
+ EXPECT_EQ("a b c d e f g h",
+ absl::Substitute("$0 $1 $2 $3 $4 $5 $6 $7", "a", "b", "c", "d", "e",
+ "f", "g", "h"));
+ EXPECT_EQ("a b c d e f g h i",
+ absl::Substitute("$0 $1 $2 $3 $4 $5 $6 $7 $8", "a", "b", "c", "d",
+ "e", "f", "g", "h", "i"));
+ EXPECT_EQ("a b c d e f g h i j",
+ absl::Substitute("$0 $1 $2 $3 $4 $5 $6 $7 $8 $9", "a", "b", "c",
+ "d", "e", "f", "g", "h", "i", "j"));
+ EXPECT_EQ("a b c d e f g h i j b0",
+ absl::Substitute("$0 $1 $2 $3 $4 $5 $6 $7 $8 $9 $10", "a", "b", "c",
+ "d", "e", "f", "g", "h", "i", "j"));
+
+ const char* null_cstring = nullptr;
+ EXPECT_EQ("Text: ''", absl::Substitute("Text: '$0'", null_cstring));
+}
+
+TEST(SubstituteTest, SubstituteAndAppend) {
+ std::string str = "Hello";
+ absl::SubstituteAndAppend(&str, ", $0!", "world");
+ EXPECT_EQ("Hello, world!", str);
+
+ // Test all overloads.
+ str.clear();
+ absl::SubstituteAndAppend(&str, "$0", "a");
+ EXPECT_EQ("a", str);
+ str.clear();
+ absl::SubstituteAndAppend(&str, "$0 $1", "a", "b");
+ EXPECT_EQ("a b", str);
+ str.clear();
+ absl::SubstituteAndAppend(&str, "$0 $1 $2", "a", "b", "c");
+ EXPECT_EQ("a b c", str);
+ str.clear();
+ absl::SubstituteAndAppend(&str, "$0 $1 $2 $3", "a", "b", "c", "d");
+ EXPECT_EQ("a b c d", str);
+ str.clear();
+ absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4", "a", "b", "c", "d", "e");
+ EXPECT_EQ("a b c d e", str);
+ str.clear();
+ absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4 $5", "a", "b", "c", "d", "e",
+ "f");
+ EXPECT_EQ("a b c d e f", str);
+ str.clear();
+ absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4 $5 $6", "a", "b", "c", "d",
+ "e", "f", "g");
+ EXPECT_EQ("a b c d e f g", str);
+ str.clear();
+ absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4 $5 $6 $7", "a", "b", "c", "d",
+ "e", "f", "g", "h");
+ EXPECT_EQ("a b c d e f g h", str);
+ str.clear();
+ absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4 $5 $6 $7 $8", "a", "b", "c",
+ "d", "e", "f", "g", "h", "i");
+ EXPECT_EQ("a b c d e f g h i", str);
+ str.clear();
+ absl::SubstituteAndAppend(&str, "$0 $1 $2 $3 $4 $5 $6 $7 $8 $9", "a", "b",
+ "c", "d", "e", "f", "g", "h", "i", "j");
+ EXPECT_EQ("a b c d e f g h i j", str);
+}
+
+#ifdef GTEST_HAS_DEATH_TEST
+
+TEST(SubstituteDeathTest, SubstituteDeath) {
+ EXPECT_DEBUG_DEATH(
+ static_cast<void>(absl::Substitute(absl::string_view("-$2"), "a", "b")),
+ "Invalid strings::Substitute\\(\\) format std::string: asked for \"\\$2\", "
+ "but only 2 args were given.");
+ EXPECT_DEBUG_DEATH(
+ static_cast<void>(absl::Substitute("-$z-")),
+ "Invalid strings::Substitute\\(\\) format std::string: \"-\\$z-\"");
+ EXPECT_DEBUG_DEATH(
+ static_cast<void>(absl::Substitute("-$")),
+ "Invalid strings::Substitute\\(\\) format std::string: \"-\\$\"");
+}
+
+#endif // GTEST_HAS_DEATH_TEST
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/testdata/getline-1.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/testdata/getline-1.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/testdata/getline-1.txt
new file mode 100644
index 0000000..19b9097
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/testdata/getline-1.txt
@@ -0,0 +1,3 @@
+alpha
+
+beta gamma
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/testdata/getline-2.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/testdata/getline-2.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/testdata/getline-2.txt
new file mode 100644
index 0000000..d6842d8
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/testdata/getline-2.txt
@@ -0,0 +1 @@
+one.two.three
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/BUILD.bazel
new file mode 100644
index 0000000..69f9c81
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/BUILD.bazel
@@ -0,0 +1,206 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+)
+
+package(default_visibility = ["//visibility:public"])
+
+licenses(["notice"]) # Apache 2.0
+
+# Internal data structure for efficiently detecting mutex dependency cycles
+cc_library(
+ name = "graphcycles_internal",
+ srcs = [
+ "internal/graphcycles.cc",
+ ],
+ hdrs = [
+ "internal/graphcycles.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ visibility = [
+ "//absl:__subpackages__",
+ ],
+ deps = [
+ "//absl/base",
+ "//absl/base:core_headers",
+ "//absl/base:malloc_internal",
+ ],
+)
+
+cc_library(
+ name = "synchronization",
+ srcs = [
+ "barrier.cc",
+ "blocking_counter.cc",
+ "internal/create_thread_identity.cc",
+ "internal/per_thread_sem.cc",
+ "internal/waiter.cc",
+ "notification.cc",
+ ] + select({
+ "//conditions:default": ["mutex.cc"],
+ }),
+ hdrs = [
+ "barrier.h",
+ "blocking_counter.h",
+ "internal/create_thread_identity.h",
+ "internal/kernel_timeout.h",
+ "internal/mutex_nonprod.inc",
+ "internal/per_thread_sem.h",
+ "internal/waiter.h",
+ "mutex.h",
+ "notification.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":graphcycles_internal",
+ "//absl/base",
+ "//absl/base:base_internal",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/base:dynamic_annotations",
+ "//absl/base:malloc_internal",
+ "//absl/debugging:stacktrace",
+ "//absl/time",
+ ],
+)
+
+cc_test(
+ name = "barrier_test",
+ size = "small",
+ srcs = ["barrier_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":synchronization",
+ "//absl/time",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "blocking_counter_test",
+ size = "small",
+ srcs = ["blocking_counter_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":synchronization",
+ "//absl/time",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "graphcycles_test",
+ size = "medium",
+ srcs = ["internal/graphcycles_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":graphcycles_internal",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "thread_pool",
+ testonly = 1,
+ hdrs = ["internal/thread_pool.h"],
+ deps = [
+ ":synchronization",
+ "//absl/base:core_headers",
+ ],
+)
+
+cc_test(
+ name = "mutex_test",
+ size = "large",
+ srcs = ["mutex_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ tags = [
+ "no_test_loonix", # Too slow.
+ ],
+ deps = [
+ ":synchronization",
+ ":thread_pool",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "//absl/memory",
+ "//absl/time",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "notification_test",
+ size = "small",
+ srcs = ["notification_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":synchronization",
+ "//absl/time",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_library(
+ name = "per_thread_sem_test_common",
+ testonly = 1,
+ srcs = ["internal/per_thread_sem_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":synchronization",
+ "//absl/base",
+ "//absl/strings",
+ "//absl/time",
+ "@com_google_googletest//:gtest",
+ ],
+ alwayslink = 1,
+)
+
+cc_test(
+ name = "per_thread_sem_test",
+ size = "medium",
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":per_thread_sem_test_common",
+ ":synchronization",
+ "//absl/base",
+ "//absl/strings",
+ "//absl/time",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "lifetime_test",
+ srcs = [
+ "lifetime_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS,
+ linkopts = select({
+ "//absl:windows": [],
+ "//conditions:default": ["-pthread"],
+ }),
+ deps = [
+ ":synchronization",
+ "//absl/base",
+ "//absl/base:core_headers",
+ ],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/CMakeLists.txt
new file mode 100644
index 0000000..c8f84fa
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/CMakeLists.txt
@@ -0,0 +1,154 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+list(APPEND SYNCHRONIZATION_PUBLIC_HEADERS
+ "barrier.h"
+ "blocking_counter.h"
+ "mutex.h"
+ "notification.h"
+)
+
+
+list(APPEND SYNCHRONIZATION_INTERNAL_HEADERS
+ "internal/create_thread_identity.h"
+ "internal/graphcycles.h"
+ "internal/kernel_timeout.h"
+ "internal/per_thread_sem.h"
+ "internal/thread_pool.h"
+ "internal/waiter.h"
+)
+
+
+
+# syncrhonisation library
+list(APPEND SYNCHRONIZATION_SRC
+ "barrier.cc"
+ "blocking_counter.cc"
+ "internal/create_thread_identity.cc"
+ "internal/per_thread_sem.cc"
+ "internal/waiter.cc"
+ "internal/graphcycles.cc"
+ "notification.cc"
+ "mutex.cc"
+)
+set(SYNCHRONIZATION_PUBLIC_LIBRARIES absl::base absl::time)
+
+absl_library(
+ TARGET
+ absl_synchronization
+ SOURCES
+ ${SYNCHRONIZATION_SRC}
+ PUBLIC_LIBRARIES
+ ${SYNCHRONIZATION_PUBLIC_LIBRARIES}
+ EXPORT_NAME
+ synchronization
+)
+
+
+#
+## TESTS
+#
+
+
+# test barrier_test
+set(BARRIER_TEST_SRC "barrier_test.cc")
+set(BARRIER_TEST_PUBLIC_LIBRARIES absl::synchronization)
+
+absl_test(
+ TARGET
+ barrier_test
+ SOURCES
+ ${BARRIER_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${BARRIER_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test blocking_counter_test
+set(BLOCKING_COUNTER_TEST_SRC "blocking_counter_test.cc")
+set(BLOCKING_COUNTER_TEST_PUBLIC_LIBRARIES absl::synchronization)
+
+absl_test(
+ TARGET
+ blocking_counter_test
+ SOURCES
+ ${BLOCKING_COUNTER_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${BLOCKING_COUNTER_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test graphcycles_test
+set(GRAPHCYCLES_TEST_SRC "internal/graphcycles_test.cc")
+set(GRAPHCYCLES_TEST_PUBLIC_LIBRARIES absl::synchronization)
+
+absl_test(
+ TARGET
+ graphcycles_test
+ SOURCES
+ ${GRAPHCYCLES_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${GRAPHCYCLES_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test mutex_test
+set(MUTEX_TEST_SRC "mutex_test.cc")
+set(MUTEX_TEST_PUBLIC_LIBRARIES absl::synchronization)
+
+absl_test(
+ TARGET
+ mutex_test
+ SOURCES
+ ${MUTEX_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${MUTEX_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test notification_test
+set(NOTIFICATION_TEST_SRC "notification_test.cc")
+set(NOTIFICATION_TEST_PUBLIC_LIBRARIES absl::synchronization)
+
+absl_test(
+ TARGET
+ notification_test
+ SOURCES
+ ${NOTIFICATION_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${NOTIFICATION_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test per_thread_sem_test_common
+set(PER_THREAD_SEM_TEST_COMMON_SRC "internal/per_thread_sem_test.cc")
+set(PER_THREAD_SEM_TEST_COMMON_PUBLIC_LIBRARIES absl::synchronization absl::strings)
+
+absl_test(
+ TARGET
+ per_thread_sem_test_common
+ SOURCES
+ ${PER_THREAD_SEM_TEST_COMMON_SRC}
+ PUBLIC_LIBRARIES
+ ${PER_THREAD_SEM_TEST_COMMON_PUBLIC_LIBRARIES}
+)
+
+
+
+
+
+
+
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier.cc
new file mode 100644
index 0000000..a1b3ad5
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier.cc
@@ -0,0 +1,50 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/barrier.h"
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+
+// Return whether int *arg is zero.
+static bool IsZero(void *arg) {
+ return 0 == *reinterpret_cast<int *>(arg);
+}
+
+bool Barrier::Block() {
+ MutexLock l(&this->lock_);
+
+ this->num_to_block_--;
+ if (this->num_to_block_ < 0) {
+ ABSL_RAW_LOG(
+ FATAL,
+ "Block() called too many times. num_to_block_=%d out of total=%d",
+ this->num_to_block_, this->num_to_exit_);
+ }
+
+ this->lock_.Await(Condition(IsZero, &this->num_to_block_));
+
+ // Determine which thread can safely delete this Barrier object
+ this->num_to_exit_--;
+ ABSL_RAW_CHECK(this->num_to_exit_ >= 0, "barrier underflow");
+
+ // If num_to_exit_ == 0 then all other threads in the barrier have
+ // exited the Wait() and have released the Mutex so this thread is
+ // free to delete the barrier.
+ return this->num_to_exit_ == 0;
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier.h b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier.h
new file mode 100644
index 0000000..f834fee
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier.h
@@ -0,0 +1,77 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// barrier.h
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_SYNCHRONIZATION_BARRIER_H_
+#define ABSL_SYNCHRONIZATION_BARRIER_H_
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+
+// Barrier
+//
+// This class creates a barrier which blocks threads until a prespecified
+// threshold of threads (`num_threads`) utilizes the barrier. A thread utilizes
+// the `Barrier` by calling `Block()` on the barrier, which will block that
+// thread; no call to `Block()` will return until `num_threads` threads have
+// called it.
+//
+// Exactly one call to `Block()` will return `true`, which is then responsible
+// for destroying the barrier; because stack allocation will cause the barrier
+// to be deleted when it is out of scope, barriers should not be stack
+// allocated.
+//
+// Example:
+//
+// // Main thread creates a `Barrier`:
+// barrier = new Barrier(num_threads);
+//
+// // Each participating thread could then call:
+// if (barrier->Block()) delete barrier; // Exactly one call to `Block()`
+// // returns `true`; that call
+// // deletes the barrier.
+class Barrier {
+ public:
+ // `num_threads` is the number of threads that will participate in the barrier
+ explicit Barrier(int num_threads)
+ : num_to_block_(num_threads), num_to_exit_(num_threads) {}
+
+ Barrier(const Barrier&) = delete;
+ Barrier& operator=(const Barrier&) = delete;
+
+ // Barrier::Block()
+ //
+ // Blocks the current thread, and returns only when the `num_threads`
+ // threshold of threads utilizing this barrier has been reached. `Block()`
+ // returns `true` for precisely one caller, which may then destroy the
+ // barrier.
+ //
+ // Memory ordering: For any threads X and Y, any action taken by X
+ // before X calls `Block()` will be visible to Y after Y returns from
+ // `Block()`.
+ bool Block();
+
+ private:
+ Mutex lock_;
+ int num_to_block_ GUARDED_BY(lock_);
+ int num_to_exit_ GUARDED_BY(lock_);
+};
+
+} // namespace absl
+#endif // ABSL_SYNCHRONIZATION_BARRIER_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier_test.cc
new file mode 100644
index 0000000..d6cabab
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/barrier_test.cc
@@ -0,0 +1,75 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/barrier.h"
+
+#include <thread> // NOLINT(build/c++11)
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/synchronization/mutex.h"
+#include "absl/time/clock.h"
+
+
+TEST(Barrier, SanityTest) {
+ constexpr int kNumThreads = 10;
+ absl::Barrier* barrier = new absl::Barrier(kNumThreads);
+
+ absl::Mutex mutex;
+ int counter = 0; // Guarded by mutex.
+
+ auto thread_func = [&] {
+ if (barrier->Block()) {
+ // This thread is the last thread to reach the barrier so it is
+ // responsible for deleting it.
+ delete barrier;
+ }
+
+ // Increment the counter.
+ absl::MutexLock lock(&mutex);
+ ++counter;
+ };
+
+ // Start (kNumThreads - 1) threads running thread_func.
+ std::vector<std::thread> threads;
+ for (int i = 0; i < kNumThreads - 1; ++i) {
+ threads.push_back(std::thread(thread_func));
+ }
+
+ // Give (kNumThreads - 1) threads a chance to reach the barrier.
+ // This test assumes at least one thread will have run after the
+ // sleep has elapsed. Sleeping in a test is usually bad form, but we
+ // need to make sure that we are testing the barrier instead of some
+ // other synchronization method.
+ absl::SleepFor(absl::Seconds(1));
+
+ // The counter should still be zero since no thread should have
+ // been able to pass the barrier yet.
+ {
+ absl::MutexLock lock(&mutex);
+ EXPECT_EQ(counter, 0);
+ }
+
+ // Start 1 more thread. This should make all threads pass the barrier.
+ threads.push_back(std::thread(thread_func));
+
+ // All threads should now be able to proceed and finish.
+ for (auto& thread : threads) {
+ thread.join();
+ }
+
+ // All threads should now have incremented the counter.
+ absl::MutexLock lock(&mutex);
+ EXPECT_EQ(counter, kNumThreads);
+}
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter.cc
new file mode 100644
index 0000000..7e68e96
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter.cc
@@ -0,0 +1,55 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/blocking_counter.h"
+
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+
+// Return whether int *arg is zero.
+static bool IsZero(void *arg) {
+ return 0 == *reinterpret_cast<int *>(arg);
+}
+
+bool BlockingCounter::DecrementCount() {
+ MutexLock l(&lock_);
+ count_--;
+ if (count_ < 0) {
+ ABSL_RAW_LOG(
+ FATAL,
+ "BlockingCounter::DecrementCount() called too many times. count=%d",
+ count_);
+ }
+ return count_ == 0;
+}
+
+void BlockingCounter::Wait() {
+ MutexLock l(&this->lock_);
+ ABSL_RAW_CHECK(count_ >= 0, "BlockingCounter underflow");
+
+ // only one thread may call Wait(). To support more than one thread,
+ // implement a counter num_to_exit, like in the Barrier class.
+ ABSL_RAW_CHECK(num_waiting_ == 0, "multiple threads called Wait()");
+ num_waiting_++;
+
+ this->lock_.Await(Condition(IsZero, &this->count_));
+
+ // At this point, We know that all threads executing DecrementCount have
+ // released the lock, and so will not touch this object again.
+ // Therefore, the thread calling this method is free to delete the object
+ // after we return from this method.
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter.h b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter.h
new file mode 100644
index 0000000..557ed02
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter.h
@@ -0,0 +1,97 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// blocking_counter.h
+// -----------------------------------------------------------------------------
+
+#ifndef ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
+#define ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
+
+#include "absl/base/thread_annotations.h"
+#include "absl/synchronization/mutex.h"
+
+namespace absl {
+
+// BlockingCounter
+//
+// This class allows a thread to block for a pre-specified number of actions.
+// `BlockingCounter` maintains a single non-negative abstract integer "count"
+// with an initial value `initial_count`. A thread can then call `Wait()` on
+// this blocking counter to block until the specified number of events occur;
+// worker threads then call 'DecrementCount()` on the counter upon completion of
+// their work. Once the counter's internal "count" reaches zero, the blocked
+// thread unblocks.
+//
+// A `BlockingCounter` requires the following:
+// - its `initial_count` is non-negative.
+// - the number of calls to `DecrementCount()` on it is at most
+// `initial_count`.
+// - `Wait()` is called at most once on it.
+//
+// Given the above requirements, a `BlockingCounter` provides the following
+// guarantees:
+// - Once its internal "count" reaches zero, no legal action on the object
+// can further change the value of "count".
+// - When `Wait()` returns, it is legal to destroy the `BlockingCounter`.
+// - When `Wait()` returns, the number of calls to `DecrementCount()` on
+// this blocking counter exactly equals `initial_count`.
+//
+// Example:
+// BlockingCounter bcount(N); // there are N items of work
+// ... Allow worker threads to start.
+// ... On completing each work item, workers do:
+// ... bcount.DecrementCount(); // an item of work has been completed
+//
+// bcount.Wait(); // wait for all work to be complete
+//
+class BlockingCounter {
+ public:
+ explicit BlockingCounter(int initial_count)
+ : count_(initial_count), num_waiting_(0) {}
+
+ BlockingCounter(const BlockingCounter&) = delete;
+ BlockingCounter& operator=(const BlockingCounter&) = delete;
+
+ // BlockingCounter::DecrementCount()
+ //
+ // Decrements the counter's "count" by one, and return "count == 0". This
+ // function requires that "count != 0" when it is called.
+ //
+ // Memory ordering: For any threads X and Y, any action taken by X
+ // before it calls `DecrementCount()` is visible to thread Y after
+ // Y's call to `DecrementCount()`, provided Y's call returns `true`.
+ bool DecrementCount();
+
+ // BlockingCounter::Wait()
+ //
+ // Blocks until the counter reaches zero. This function may be called at most
+ // once. On return, `DecrementCount()` will have been called "initial_count"
+ // times and the blocking counter may be destroyed.
+ //
+ // Memory ordering: For any threads X and Y, any action taken by X
+ // before X calls `DecrementCount()` is visible to Y after Y returns
+ // from `Wait()`.
+ void Wait();
+
+ private:
+ Mutex lock_;
+ int count_ GUARDED_BY(lock_);
+ int num_waiting_ GUARDED_BY(lock_);
+};
+
+} // namespace absl
+
+#endif // ABSL_SYNCHRONIZATION_BLOCKING_COUNTER_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter_test.cc
new file mode 100644
index 0000000..e8223f8
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/blocking_counter_test.cc
@@ -0,0 +1,66 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/blocking_counter.h"
+
+#include <thread> // NOLINT(build/c++11)
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/time/clock.h"
+#include "absl/time/time.h"
+
+namespace absl {
+namespace {
+
+void PauseAndDecreaseCounter(BlockingCounter* counter, int* done) {
+ absl::SleepFor(absl::Seconds(1));
+ *done = 1;
+ counter->DecrementCount();
+}
+
+TEST(BlockingCounterTest, BasicFunctionality) {
+ // This test verifies that BlockingCounter functions correctly. Starts a
+ // number of threads that just sleep for a second and decrement a counter.
+
+ // Initialize the counter.
+ const int num_workers = 10;
+ BlockingCounter counter(num_workers);
+
+ std::vector<std::thread> workers;
+ std::vector<int> done(num_workers, 0);
+
+ // Start a number of parallel tasks that will just wait for a seconds and
+ // then decrement the count.
+ workers.reserve(num_workers);
+ for (int k = 0; k < num_workers; k++) {
+ workers.emplace_back(
+ [&counter, &done, k] { PauseAndDecreaseCounter(&counter, &done[k]); });
+ }
+
+ // Wait for the threads to have all finished.
+ counter.Wait();
+
+ // Check that all the workers have completed.
+ for (int k = 0; k < num_workers; k++) {
+ EXPECT_EQ(1, done[k]);
+ }
+
+ for (std::thread& w : workers) {
+ w.join();
+ }
+}
+
+} // namespace
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/create_thread_identity.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/create_thread_identity.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/create_thread_identity.cc
new file mode 100644
index 0000000..e7a65cd
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/create_thread_identity.cc
@@ -0,0 +1,112 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <stdint.h>
+#include <new>
+
+// This file is a no-op if the required LowLevelAlloc support is missing.
+#include "absl/base/internal/low_level_alloc.h"
+#ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
+
+#include <string.h>
+
+#include "absl/base/attributes.h"
+#include "absl/base/internal/spinlock.h"
+#include "absl/base/internal/thread_identity.h"
+#include "absl/synchronization/internal/per_thread_sem.h"
+
+namespace absl {
+namespace synchronization_internal {
+
+// ThreadIdentity storage is persistent, we maintain a free-list of previously
+// released ThreadIdentity objects.
+static base_internal::SpinLock freelist_lock(base_internal::kLinkerInitialized);
+static base_internal::ThreadIdentity* thread_identity_freelist;
+
+// A per-thread destructor for reclaiming associated ThreadIdentity objects.
+// Since we must preserve their storage we cache them for re-use.
+static void ReclaimThreadIdentity(void* v) {
+ base_internal::ThreadIdentity* identity =
+ static_cast<base_internal::ThreadIdentity*>(v);
+
+ // all_locks might have been allocated by the Mutex implementation.
+ // We free it here when we are notified that our thread is dying.
+ if (identity->per_thread_synch.all_locks != nullptr) {
+ base_internal::LowLevelAlloc::Free(identity->per_thread_synch.all_locks);
+ }
+
+ // We must explicitly clear the current thread's identity:
+ // (a) Subsequent (unrelated) per-thread destructors may require an identity.
+ // We must guarantee a new identity is used in this case (this instructor
+ // will be reinvoked up to PTHREAD_DESTRUCTOR_ITERATIONS in this case).
+ // (b) ThreadIdentity implementations may depend on memory that is not
+ // reinitialized before reuse. We must allow explicit clearing of the
+ // association state in this case.
+ base_internal::ClearCurrentThreadIdentity();
+ {
+ base_internal::SpinLockHolder l(&freelist_lock);
+ identity->next = thread_identity_freelist;
+ thread_identity_freelist = identity;
+ }
+}
+
+// Return value rounded up to next multiple of align.
+// Align must be a power of two.
+static intptr_t RoundUp(intptr_t addr, intptr_t align) {
+ return (addr + align - 1) & ~(align - 1);
+}
+
+static base_internal::ThreadIdentity* NewThreadIdentity() {
+ base_internal::ThreadIdentity* identity = nullptr;
+
+ {
+ // Re-use a previously released object if possible.
+ base_internal::SpinLockHolder l(&freelist_lock);
+ if (thread_identity_freelist) {
+ identity = thread_identity_freelist; // Take list-head.
+ thread_identity_freelist = thread_identity_freelist->next;
+ }
+ }
+
+ if (identity == nullptr) {
+ // Allocate enough space to align ThreadIdentity to a multiple of
+ // PerThreadSynch::kAlignment. This space is never released (it is
+ // added to a freelist by ReclaimThreadIdentity instead).
+ void* allocation = base_internal::LowLevelAlloc::Alloc(
+ sizeof(*identity) + base_internal::PerThreadSynch::kAlignment - 1);
+ // Round up the address to the required alignment.
+ identity = reinterpret_cast<base_internal::ThreadIdentity*>(
+ RoundUp(reinterpret_cast<intptr_t>(allocation),
+ base_internal::PerThreadSynch::kAlignment));
+ }
+ memset(identity, 0, sizeof(*identity));
+
+ return identity;
+}
+
+// Allocates and attaches ThreadIdentity object for the calling thread. Returns
+// the new identity.
+// REQUIRES: CurrentThreadIdentity(false) == nullptr
+base_internal::ThreadIdentity* CreateThreadIdentity() {
+ base_internal::ThreadIdentity* identity = NewThreadIdentity();
+ PerThreadSem::Init(identity);
+ // Associate the value with the current thread, and attach our destructor.
+ base_internal::SetCurrentThreadIdentity(identity, ReclaimThreadIdentity);
+ return identity;
+}
+
+} // namespace synchronization_internal
+} // namespace absl
+
+#endif // ABSL_LOW_LEVEL_ALLOC_MISSING
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/create_thread_identity.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/create_thread_identity.h b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/create_thread_identity.h
new file mode 100644
index 0000000..1bb87de
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/create_thread_identity.h
@@ -0,0 +1,53 @@
+/*
+ * Copyright 2017 The Abseil Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// Interface for getting the current ThreadIdentity, creating one if necessary.
+// See thread_identity.h.
+//
+// This file is separate from thread_identity.h because creating a new
+// ThreadIdentity requires slightly higher level libraries (per_thread_sem
+// and low_level_alloc) than accessing an existing one. This separation allows
+// us to have a smaller //absl/base:base.
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
+
+#include "absl/base/internal/thread_identity.h"
+#include "absl/base/port.h"
+
+namespace absl {
+namespace synchronization_internal {
+
+// Allocates and attaches a ThreadIdentity object for the calling thread.
+// For private use only.
+base_internal::ThreadIdentity* CreateThreadIdentity();
+
+// Returns the ThreadIdentity object representing the calling thread; guaranteed
+// to be unique for its lifetime. The returned object will remain valid for the
+// program's lifetime; although it may be re-assigned to a subsequent thread.
+// If one does not exist for the calling thread, allocate it now.
+inline base_internal::ThreadIdentity* GetOrCreateCurrentThreadIdentity() {
+ base_internal::ThreadIdentity* identity =
+ base_internal::CurrentThreadIdentityIfPresent();
+ if (ABSL_PREDICT_FALSE(identity == nullptr)) {
+ return CreateThreadIdentity();
+ }
+ return identity;
+}
+
+} // namespace synchronization_internal
+} // namespace absl
+#endif // ABSL_SYNCHRONIZATION_INTERNAL_CREATE_THREAD_IDENTITY_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles.cc
new file mode 100644
index 0000000..28ad172
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles.cc
@@ -0,0 +1,709 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// GraphCycles provides incremental cycle detection on a dynamic
+// graph using the following algorithm:
+//
+// A dynamic topological sort algorithm for directed acyclic graphs
+// David J. Pearce, Paul H. J. Kelly
+// Journal of Experimental Algorithmics (JEA) JEA Homepage archive
+// Volume 11, 2006, Article No. 1.7
+//
+// Brief summary of the algorithm:
+//
+// (1) Maintain a rank for each node that is consistent
+// with the topological sort of the graph. I.e., path from x to y
+// implies rank[x] < rank[y].
+// (2) When a new edge (x->y) is inserted, do nothing if rank[x] < rank[y].
+// (3) Otherwise: adjust ranks in the neighborhood of x and y.
+
+#include "absl/base/attributes.h"
+// This file is a no-op if the required LowLevelAlloc support is missing.
+#include "absl/base/internal/low_level_alloc.h"
+#ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
+
+#include "absl/synchronization/internal/graphcycles.h"
+
+#include <algorithm>
+#include <array>
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/spinlock.h"
+
+// Do not use STL. This module does not use standard memory allocation.
+
+namespace absl {
+namespace synchronization_internal {
+
+namespace {
+
+// Avoid LowLevelAlloc's default arena since it calls malloc hooks in
+// which people are doing things like acquiring Mutexes.
+static absl::base_internal::SpinLock arena_mu(
+ absl::base_internal::kLinkerInitialized);
+static base_internal::LowLevelAlloc::Arena* arena;
+
+static void InitArenaIfNecessary() {
+ arena_mu.Lock();
+ if (arena == nullptr) {
+ arena = base_internal::LowLevelAlloc::NewArena(0);
+ }
+ arena_mu.Unlock();
+}
+
+// Number of inlined elements in Vec. Hash table implementation
+// relies on this being a power of two.
+static const uint32_t kInline = 8;
+
+// A simple LowLevelAlloc based resizable vector with inlined storage
+// for a few elements. T must be a plain type since constructor
+// and destructor are not run on elements of type T managed by Vec.
+template <typename T>
+class Vec {
+ public:
+ Vec() { Init(); }
+ ~Vec() { Discard(); }
+
+ void clear() {
+ Discard();
+ Init();
+ }
+
+ bool empty() const { return size_ == 0; }
+ uint32_t size() const { return size_; }
+ T* begin() { return ptr_; }
+ T* end() { return ptr_ + size_; }
+ const T& operator[](uint32_t i) const { return ptr_[i]; }
+ T& operator[](uint32_t i) { return ptr_[i]; }
+ const T& back() const { return ptr_[size_-1]; }
+ void pop_back() { size_--; }
+
+ void push_back(const T& v) {
+ if (size_ == capacity_) Grow(size_ + 1);
+ ptr_[size_] = v;
+ size_++;
+ }
+
+ void resize(uint32_t n) {
+ if (n > capacity_) Grow(n);
+ size_ = n;
+ }
+
+ void fill(const T& val) {
+ for (uint32_t i = 0; i < size(); i++) {
+ ptr_[i] = val;
+ }
+ }
+
+ // Guarantees src is empty at end.
+ // Provided for the hash table resizing code below.
+ void MoveFrom(Vec<T>* src) {
+ if (src->ptr_ == src->space_) {
+ // Need to actually copy
+ resize(src->size_);
+ std::copy(src->ptr_, src->ptr_ + src->size_, ptr_);
+ src->size_ = 0;
+ } else {
+ Discard();
+ ptr_ = src->ptr_;
+ size_ = src->size_;
+ capacity_ = src->capacity_;
+ src->Init();
+ }
+ }
+
+ private:
+ T* ptr_;
+ T space_[kInline];
+ uint32_t size_;
+ uint32_t capacity_;
+
+ void Init() {
+ ptr_ = space_;
+ size_ = 0;
+ capacity_ = kInline;
+ }
+
+ void Discard() {
+ if (ptr_ != space_) base_internal::LowLevelAlloc::Free(ptr_);
+ }
+
+ void Grow(uint32_t n) {
+ while (capacity_ < n) {
+ capacity_ *= 2;
+ }
+ size_t request = static_cast<size_t>(capacity_) * sizeof(T);
+ T* copy = static_cast<T*>(
+ base_internal::LowLevelAlloc::AllocWithArena(request, arena));
+ std::copy(ptr_, ptr_ + size_, copy);
+ Discard();
+ ptr_ = copy;
+ }
+
+ Vec(const Vec&) = delete;
+ Vec& operator=(const Vec&) = delete;
+};
+
+// A hash set of non-negative int32_t that uses Vec for its underlying storage.
+class NodeSet {
+ public:
+ NodeSet() { Init(); }
+
+ void clear() { Init(); }
+ bool contains(int32_t v) const { return table_[FindIndex(v)] == v; }
+
+ bool insert(int32_t v) {
+ uint32_t i = FindIndex(v);
+ if (table_[i] == v) {
+ return false;
+ }
+ if (table_[i] == kEmpty) {
+ // Only inserting over an empty cell increases the number of occupied
+ // slots.
+ occupied_++;
+ }
+ table_[i] = v;
+ // Double when 75% full.
+ if (occupied_ >= table_.size() - table_.size()/4) Grow();
+ return true;
+ }
+
+ void erase(uint32_t v) {
+ uint32_t i = FindIndex(v);
+ if (static_cast<uint32_t>(table_[i]) == v) {
+ table_[i] = kDel;
+ }
+ }
+
+ // Iteration: is done via HASH_FOR_EACH
+ // Example:
+ // HASH_FOR_EACH(elem, node->out) { ... }
+#define HASH_FOR_EACH(elem, eset) \
+ for (int32_t elem, _cursor = 0; (eset).Next(&_cursor, &elem); )
+ bool Next(int32_t* cursor, int32_t* elem) {
+ while (static_cast<uint32_t>(*cursor) < table_.size()) {
+ int32_t v = table_[*cursor];
+ (*cursor)++;
+ if (v >= 0) {
+ *elem = v;
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private:
+ static const int32_t kEmpty;
+ static const int32_t kDel;
+ Vec<int32_t> table_;
+ uint32_t occupied_; // Count of non-empty slots (includes deleted slots)
+
+ static uint32_t Hash(uint32_t a) { return a * 41; }
+
+ // Return index for storing v. May return an empty index or deleted index
+ int FindIndex(int32_t v) const {
+ // Search starting at hash index.
+ const uint32_t mask = table_.size() - 1;
+ uint32_t i = Hash(v) & mask;
+ int deleted_index = -1; // If >= 0, index of first deleted element we see
+ while (true) {
+ int32_t e = table_[i];
+ if (v == e) {
+ return i;
+ } else if (e == kEmpty) {
+ // Return any previously encountered deleted slot.
+ return (deleted_index >= 0) ? deleted_index : i;
+ } else if (e == kDel && deleted_index < 0) {
+ // Keep searching since v might be present later.
+ deleted_index = i;
+ }
+ i = (i + 1) & mask; // Linear probing; quadratic is slightly slower.
+ }
+ }
+
+ void Init() {
+ table_.clear();
+ table_.resize(kInline);
+ table_.fill(kEmpty);
+ occupied_ = 0;
+ }
+
+ void Grow() {
+ Vec<int32_t> copy;
+ copy.MoveFrom(&table_);
+ occupied_ = 0;
+ table_.resize(copy.size() * 2);
+ table_.fill(kEmpty);
+
+ for (const auto& e : copy) {
+ if (e >= 0) insert(e);
+ }
+ }
+
+ NodeSet(const NodeSet&) = delete;
+ NodeSet& operator=(const NodeSet&) = delete;
+};
+
+const int32_t NodeSet::kEmpty = -1;
+const int32_t NodeSet::kDel = -2;
+
+// We encode a node index and a node version in GraphId. The version
+// number is incremented when the GraphId is freed which automatically
+// invalidates all copies of the GraphId.
+
+inline GraphId MakeId(int32_t index, uint32_t version) {
+ GraphId g;
+ g.handle =
+ (static_cast<uint64_t>(version) << 32) | static_cast<uint32_t>(index);
+ return g;
+}
+
+inline int32_t NodeIndex(GraphId id) {
+ return static_cast<uint32_t>(id.handle & 0xfffffffful);
+}
+
+inline uint32_t NodeVersion(GraphId id) {
+ return static_cast<uint32_t>(id.handle >> 32);
+}
+
+// We need to hide Mutexes (or other deadlock detection's pointers)
+// from the leak detector. Xor with an arbitrary number with high bits set.
+static const uintptr_t kHideMask = static_cast<uintptr_t>(0xF03A5F7BF03A5F7Bll);
+
+static inline uintptr_t MaskPtr(void *ptr) {
+ return reinterpret_cast<uintptr_t>(ptr) ^ kHideMask;
+}
+
+static inline void* UnmaskPtr(uintptr_t word) {
+ return reinterpret_cast<void*>(word ^ kHideMask);
+}
+
+struct Node {
+ int32_t rank; // rank number assigned by Pearce-Kelly algorithm
+ uint32_t version; // Current version number
+ int32_t next_hash; // Next entry in hash table
+ bool visited; // Temporary marker used by depth-first-search
+ uintptr_t masked_ptr; // User-supplied pointer
+ NodeSet in; // List of immediate predecessor nodes in graph
+ NodeSet out; // List of immediate successor nodes in graph
+ int priority; // Priority of recorded stack trace.
+ int nstack; // Depth of recorded stack trace.
+ void* stack[40]; // stack[0,nstack-1] holds stack trace for node.
+};
+
+// Hash table for pointer to node index lookups.
+class PointerMap {
+ public:
+ explicit PointerMap(const Vec<Node*>* nodes) : nodes_(nodes) {
+ table_.fill(-1);
+ }
+
+ int32_t Find(void* ptr) {
+ auto masked = MaskPtr(ptr);
+ for (int32_t i = table_[Hash(ptr)]; i != -1;) {
+ Node* n = (*nodes_)[i];
+ if (n->masked_ptr == masked) return i;
+ i = n->next_hash;
+ }
+ return -1;
+ }
+
+ void Add(void* ptr, int32_t i) {
+ int32_t* head = &table_[Hash(ptr)];
+ (*nodes_)[i]->next_hash = *head;
+ *head = i;
+ }
+
+ int32_t Remove(void* ptr) {
+ // Advance through linked list while keeping track of the
+ // predecessor slot that points to the current entry.
+ auto masked = MaskPtr(ptr);
+ for (int32_t* slot = &table_[Hash(ptr)]; *slot != -1; ) {
+ int32_t index = *slot;
+ Node* n = (*nodes_)[index];
+ if (n->masked_ptr == masked) {
+ *slot = n->next_hash; // Remove n from linked list
+ n->next_hash = -1;
+ return index;
+ }
+ slot = &n->next_hash;
+ }
+ return -1;
+ }
+
+ private:
+ // Number of buckets in hash table for pointer lookups.
+ static constexpr uint32_t kHashTableSize = 8171; // should be prime
+
+ const Vec<Node*>* nodes_;
+ std::array<int32_t, kHashTableSize> table_;
+
+ static uint32_t Hash(void* ptr) {
+ return reinterpret_cast<uintptr_t>(ptr) % kHashTableSize;
+ }
+};
+
+} // namespace
+
+struct GraphCycles::Rep {
+ Vec<Node*> nodes_;
+ Vec<int32_t> free_nodes_; // Indices for unused entries in nodes_
+ PointerMap ptrmap_;
+
+ // Temporary state.
+ Vec<int32_t> deltaf_; // Results of forward DFS
+ Vec<int32_t> deltab_; // Results of backward DFS
+ Vec<int32_t> list_; // All nodes to reprocess
+ Vec<int32_t> merged_; // Rank values to assign to list_ entries
+ Vec<int32_t> stack_; // Emulates recursion stack for depth-first searches
+
+ Rep() : ptrmap_(&nodes_) {}
+};
+
+static Node* FindNode(GraphCycles::Rep* rep, GraphId id) {
+ Node* n = rep->nodes_[NodeIndex(id)];
+ return (n->version == NodeVersion(id)) ? n : nullptr;
+}
+
+GraphCycles::GraphCycles() {
+ InitArenaIfNecessary();
+ rep_ = new (base_internal::LowLevelAlloc::AllocWithArena(sizeof(Rep), arena))
+ Rep;
+}
+
+GraphCycles::~GraphCycles() {
+ for (auto* node : rep_->nodes_) {
+ node->Node::~Node();
+ base_internal::LowLevelAlloc::Free(node);
+ }
+ rep_->Rep::~Rep();
+ base_internal::LowLevelAlloc::Free(rep_);
+}
+
+bool GraphCycles::CheckInvariants() const {
+ Rep* r = rep_;
+ NodeSet ranks; // Set of ranks seen so far.
+ for (uint32_t x = 0; x < r->nodes_.size(); x++) {
+ Node* nx = r->nodes_[x];
+ void* ptr = UnmaskPtr(nx->masked_ptr);
+ if (ptr != nullptr && static_cast<uint32_t>(r->ptrmap_.Find(ptr)) != x) {
+ ABSL_RAW_LOG(FATAL, "Did not find live node in hash table %u %p", x, ptr);
+ }
+ if (nx->visited) {
+ ABSL_RAW_LOG(FATAL, "Did not clear visited marker on node %u", x);
+ }
+ if (!ranks.insert(nx->rank)) {
+ ABSL_RAW_LOG(FATAL, "Duplicate occurrence of rank %d", nx->rank);
+ }
+ HASH_FOR_EACH(y, nx->out) {
+ Node* ny = r->nodes_[y];
+ if (nx->rank >= ny->rank) {
+ ABSL_RAW_LOG(FATAL, "Edge %u->%d has bad rank assignment %d->%d", x, y,
+ nx->rank, ny->rank);
+ }
+ }
+ }
+ return true;
+}
+
+GraphId GraphCycles::GetId(void* ptr) {
+ int32_t i = rep_->ptrmap_.Find(ptr);
+ if (i != -1) {
+ return MakeId(i, rep_->nodes_[i]->version);
+ } else if (rep_->free_nodes_.empty()) {
+ Node* n =
+ new (base_internal::LowLevelAlloc::AllocWithArena(sizeof(Node), arena))
+ Node;
+ n->version = 1; // Avoid 0 since it is used by InvalidGraphId()
+ n->visited = false;
+ n->rank = rep_->nodes_.size();
+ n->masked_ptr = MaskPtr(ptr);
+ n->nstack = 0;
+ n->priority = 0;
+ rep_->nodes_.push_back(n);
+ rep_->ptrmap_.Add(ptr, n->rank);
+ return MakeId(n->rank, n->version);
+ } else {
+ // Preserve preceding rank since the set of ranks in use must be
+ // a permutation of [0,rep_->nodes_.size()-1].
+ int32_t r = rep_->free_nodes_.back();
+ rep_->free_nodes_.pop_back();
+ Node* n = rep_->nodes_[r];
+ n->masked_ptr = MaskPtr(ptr);
+ n->nstack = 0;
+ n->priority = 0;
+ rep_->ptrmap_.Add(ptr, r);
+ return MakeId(r, n->version);
+ }
+}
+
+void GraphCycles::RemoveNode(void* ptr) {
+ int32_t i = rep_->ptrmap_.Remove(ptr);
+ if (i == -1) {
+ return;
+ }
+ Node* x = rep_->nodes_[i];
+ HASH_FOR_EACH(y, x->out) {
+ rep_->nodes_[y]->in.erase(i);
+ }
+ HASH_FOR_EACH(y, x->in) {
+ rep_->nodes_[y]->out.erase(i);
+ }
+ x->in.clear();
+ x->out.clear();
+ x->masked_ptr = MaskPtr(nullptr);
+ if (x->version == std::numeric_limits<uint32_t>::max()) {
+ // Cannot use x any more
+ } else {
+ x->version++; // Invalidates all copies of node.
+ rep_->free_nodes_.push_back(i);
+ }
+}
+
+void* GraphCycles::Ptr(GraphId id) {
+ Node* n = FindNode(rep_, id);
+ return n == nullptr ? nullptr : UnmaskPtr(n->masked_ptr);
+}
+
+bool GraphCycles::HasNode(GraphId node) {
+ return FindNode(rep_, node) != nullptr;
+}
+
+bool GraphCycles::HasEdge(GraphId x, GraphId y) const {
+ Node* xn = FindNode(rep_, x);
+ return xn && FindNode(rep_, y) && xn->out.contains(NodeIndex(y));
+}
+
+void GraphCycles::RemoveEdge(GraphId x, GraphId y) {
+ Node* xn = FindNode(rep_, x);
+ Node* yn = FindNode(rep_, y);
+ if (xn && yn) {
+ xn->out.erase(NodeIndex(y));
+ yn->in.erase(NodeIndex(x));
+ // No need to update the rank assignment since a previous valid
+ // rank assignment remains valid after an edge deletion.
+ }
+}
+
+static bool ForwardDFS(GraphCycles::Rep* r, int32_t n, int32_t upper_bound);
+static void BackwardDFS(GraphCycles::Rep* r, int32_t n, int32_t lower_bound);
+static void Reorder(GraphCycles::Rep* r);
+static void Sort(const Vec<Node*>&, Vec<int32_t>* delta);
+static void MoveToList(
+ GraphCycles::Rep* r, Vec<int32_t>* src, Vec<int32_t>* dst);
+
+bool GraphCycles::InsertEdge(GraphId idx, GraphId idy) {
+ Rep* r = rep_;
+ const int32_t x = NodeIndex(idx);
+ const int32_t y = NodeIndex(idy);
+ Node* nx = FindNode(r, idx);
+ Node* ny = FindNode(r, idy);
+ if (nx == nullptr || ny == nullptr) return true; // Expired ids
+
+ if (nx == ny) return false; // Self edge
+ if (!nx->out.insert(y)) {
+ // Edge already exists.
+ return true;
+ }
+
+ ny->in.insert(x);
+
+ if (nx->rank <= ny->rank) {
+ // New edge is consistent with existing rank assignment.
+ return true;
+ }
+
+ // Current rank assignments are incompatible with the new edge. Recompute.
+ // We only need to consider nodes that fall in the range [ny->rank,nx->rank].
+ if (!ForwardDFS(r, y, nx->rank)) {
+ // Found a cycle. Undo the insertion and tell caller.
+ nx->out.erase(y);
+ ny->in.erase(x);
+ // Since we do not call Reorder() on this path, clear any visited
+ // markers left by ForwardDFS.
+ for (const auto& d : r->deltaf_) {
+ r->nodes_[d]->visited = false;
+ }
+ return false;
+ }
+ BackwardDFS(r, x, ny->rank);
+ Reorder(r);
+ return true;
+}
+
+static bool ForwardDFS(GraphCycles::Rep* r, int32_t n, int32_t upper_bound) {
+ // Avoid recursion since stack space might be limited.
+ // We instead keep a stack of nodes to visit.
+ r->deltaf_.clear();
+ r->stack_.clear();
+ r->stack_.push_back(n);
+ while (!r->stack_.empty()) {
+ n = r->stack_.back();
+ r->stack_.pop_back();
+ Node* nn = r->nodes_[n];
+ if (nn->visited) continue;
+
+ nn->visited = true;
+ r->deltaf_.push_back(n);
+
+ HASH_FOR_EACH(w, nn->out) {
+ Node* nw = r->nodes_[w];
+ if (nw->rank == upper_bound) {
+ return false; // Cycle
+ }
+ if (!nw->visited && nw->rank < upper_bound) {
+ r->stack_.push_back(w);
+ }
+ }
+ }
+ return true;
+}
+
+static void BackwardDFS(GraphCycles::Rep* r, int32_t n, int32_t lower_bound) {
+ r->deltab_.clear();
+ r->stack_.clear();
+ r->stack_.push_back(n);
+ while (!r->stack_.empty()) {
+ n = r->stack_.back();
+ r->stack_.pop_back();
+ Node* nn = r->nodes_[n];
+ if (nn->visited) continue;
+
+ nn->visited = true;
+ r->deltab_.push_back(n);
+
+ HASH_FOR_EACH(w, nn->in) {
+ Node* nw = r->nodes_[w];
+ if (!nw->visited && lower_bound < nw->rank) {
+ r->stack_.push_back(w);
+ }
+ }
+ }
+}
+
+static void Reorder(GraphCycles::Rep* r) {
+ Sort(r->nodes_, &r->deltab_);
+ Sort(r->nodes_, &r->deltaf_);
+
+ // Adds contents of delta lists to list_ (backwards deltas first).
+ r->list_.clear();
+ MoveToList(r, &r->deltab_, &r->list_);
+ MoveToList(r, &r->deltaf_, &r->list_);
+
+ // Produce sorted list of all ranks that will be reassigned.
+ r->merged_.resize(r->deltab_.size() + r->deltaf_.size());
+ std::merge(r->deltab_.begin(), r->deltab_.end(),
+ r->deltaf_.begin(), r->deltaf_.end(),
+ r->merged_.begin());
+
+ // Assign the ranks in order to the collected list.
+ for (uint32_t i = 0; i < r->list_.size(); i++) {
+ r->nodes_[r->list_[i]]->rank = r->merged_[i];
+ }
+}
+
+static void Sort(const Vec<Node*>& nodes, Vec<int32_t>* delta) {
+ struct ByRank {
+ const Vec<Node*>* nodes;
+ bool operator()(int32_t a, int32_t b) const {
+ return (*nodes)[a]->rank < (*nodes)[b]->rank;
+ }
+ };
+ ByRank cmp;
+ cmp.nodes = &nodes;
+ std::sort(delta->begin(), delta->end(), cmp);
+}
+
+static void MoveToList(
+ GraphCycles::Rep* r, Vec<int32_t>* src, Vec<int32_t>* dst) {
+ for (auto& v : *src) {
+ int32_t w = v;
+ v = r->nodes_[w]->rank; // Replace v entry with its rank
+ r->nodes_[w]->visited = false; // Prepare for future DFS calls
+ dst->push_back(w);
+ }
+}
+
+int GraphCycles::FindPath(GraphId idx, GraphId idy, int max_path_len,
+ GraphId path[]) const {
+ Rep* r = rep_;
+ if (FindNode(r, idx) == nullptr || FindNode(r, idy) == nullptr) return 0;
+ const int32_t x = NodeIndex(idx);
+ const int32_t y = NodeIndex(idy);
+
+ // Forward depth first search starting at x until we hit y.
+ // As we descend into a node, we push it onto the path.
+ // As we leave a node, we remove it from the path.
+ int path_len = 0;
+
+ NodeSet seen;
+ r->stack_.clear();
+ r->stack_.push_back(x);
+ while (!r->stack_.empty()) {
+ int32_t n = r->stack_.back();
+ r->stack_.pop_back();
+ if (n < 0) {
+ // Marker to indicate that we are leaving a node
+ path_len--;
+ continue;
+ }
+
+ if (path_len < max_path_len) {
+ path[path_len] = MakeId(n, rep_->nodes_[n]->version);
+ }
+ path_len++;
+ r->stack_.push_back(-1); // Will remove tentative path entry
+
+ if (n == y) {
+ return path_len;
+ }
+
+ HASH_FOR_EACH(w, r->nodes_[n]->out) {
+ if (seen.insert(w)) {
+ r->stack_.push_back(w);
+ }
+ }
+ }
+
+ return 0;
+}
+
+bool GraphCycles::IsReachable(GraphId x, GraphId y) const {
+ return FindPath(x, y, 0, nullptr) > 0;
+}
+
+void GraphCycles::UpdateStackTrace(GraphId id, int priority,
+ int (*get_stack_trace)(void** stack, int)) {
+ Node* n = FindNode(rep_, id);
+ if (n == nullptr || n->priority >= priority) {
+ return;
+ }
+ n->nstack = (*get_stack_trace)(n->stack, ABSL_ARRAYSIZE(n->stack));
+ n->priority = priority;
+}
+
+int GraphCycles::GetStackTrace(GraphId id, void*** ptr) {
+ Node* n = FindNode(rep_, id);
+ if (n == nullptr) {
+ *ptr = nullptr;
+ return 0;
+ } else {
+ *ptr = n->stack;
+ return n->nstack;
+ }
+}
+
+} // namespace synchronization_internal
+} // namespace absl
+
+#endif // ABSL_LOW_LEVEL_ALLOC_MISSING
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles.h b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles.h
new file mode 100644
index 0000000..53474b7
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles.h
@@ -0,0 +1,136 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_SYNCHRONIZATION_INTERNAL_GRAPHCYCLES_H_
+#define ABSL_SYNCHRONIZATION_INTERNAL_GRAPHCYCLES_H_
+
+// GraphCycles detects the introduction of a cycle into a directed
+// graph that is being built up incrementally.
+//
+// Nodes are identified by small integers. It is not possible to
+// record multiple edges with the same (source, destination) pair;
+// requests to add an edge where one already exists are silently
+// ignored.
+//
+// It is also not possible to introduce a cycle; an attempt to insert
+// an edge that would introduce a cycle fails and returns false.
+//
+// GraphCycles uses no internal locking; calls into it should be
+// serialized externally.
+
+// Performance considerations:
+// Works well on sparse graphs, poorly on dense graphs.
+// Extra information is maintained incrementally to detect cycles quickly.
+// InsertEdge() is very fast when the edge already exists, and reasonably fast
+// otherwise.
+// FindPath() is linear in the size of the graph.
+// The current implemenation uses O(|V|+|E|) space.
+
+#include <cstdint>
+
+namespace absl {
+namespace synchronization_internal {
+
+// Opaque identifier for a graph node.
+struct GraphId {
+ uint64_t handle;
+
+ bool operator==(const GraphId& x) const { return handle == x.handle; }
+ bool operator!=(const GraphId& x) const { return handle != x.handle; }
+};
+
+// Return an invalid graph id that will never be assigned by GraphCycles.
+inline GraphId InvalidGraphId() {
+ return GraphId{0};
+}
+
+class GraphCycles {
+ public:
+ GraphCycles();
+ ~GraphCycles();
+
+ // Return the id to use for ptr, assigning one if necessary.
+ // Subsequent calls with the same ptr value will return the same id
+ // until Remove().
+ GraphId GetId(void* ptr);
+
+ // Remove "ptr" from the graph. Its corresponding node and all
+ // edges to and from it are removed.
+ void RemoveNode(void* ptr);
+
+ // Return the pointer associated with id, or nullptr if id is not
+ // currently in the graph.
+ void* Ptr(GraphId id);
+
+ // Attempt to insert an edge from source_node to dest_node. If the
+ // edge would introduce a cycle, return false without making any
+ // changes. Otherwise add the edge and return true.
+ bool InsertEdge(GraphId source_node, GraphId dest_node);
+
+ // Remove any edge that exists from source_node to dest_node.
+ void RemoveEdge(GraphId source_node, GraphId dest_node);
+
+ // Return whether node exists in the graph.
+ bool HasNode(GraphId node);
+
+ // Return whether there is an edge directly from source_node to dest_node.
+ bool HasEdge(GraphId source_node, GraphId dest_node) const;
+
+ // Return whether dest_node is reachable from source_node
+ // by following edges.
+ bool IsReachable(GraphId source_node, GraphId dest_node) const;
+
+ // Find a path from "source" to "dest". If such a path exists,
+ // place the nodes on the path in the array path[], and return
+ // the number of nodes on the path. If the path is longer than
+ // max_path_len nodes, only the first max_path_len nodes are placed
+ // in path[]. The client should compare the return value with
+ // max_path_len" to see when this occurs. If no path exists, return
+ // 0. Any valid path stored in path[] will start with "source" and
+ // end with "dest". There is no guarantee that the path is the
+ // shortest, but no node will appear twice in the path, except the
+ // source and destination node if they are identical; therefore, the
+ // return value is at most one greater than the number of nodes in
+ // the graph.
+ int FindPath(GraphId source, GraphId dest, int max_path_len,
+ GraphId path[]) const;
+
+ // Update the stack trace recorded for id with the current stack
+ // trace if the last time it was updated had a smaller priority
+ // than the priority passed on this call.
+ //
+ // *get_stack_trace is called to get the stack trace.
+ void UpdateStackTrace(GraphId id, int priority,
+ int (*get_stack_trace)(void**, int));
+
+ // Set *ptr to the beginning of the array that holds the recorded
+ // stack trace for id and return the depth of the stack trace.
+ int GetStackTrace(GraphId id, void*** ptr);
+
+ // Check internal invariants. Crashes on failure, returns true on success.
+ // Expensive: should only be called from graphcycles_test.cc.
+ bool CheckInvariants() const;
+
+ // ----------------------------------------------------
+ struct Rep;
+ private:
+ Rep *rep_; // opaque representation
+ GraphCycles(const GraphCycles&) = delete;
+ GraphCycles& operator=(const GraphCycles&) = delete;
+};
+
+} // namespace synchronization_internal
+} // namespace absl
+#endif
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles_test.cc
new file mode 100644
index 0000000..9a85b39
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/synchronization/internal/graphcycles_test.cc
@@ -0,0 +1,462 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/synchronization/internal/graphcycles.h"
+
+#include <map>
+#include <random>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/macros.h"
+
+namespace absl {
+namespace synchronization_internal {
+
+// We emulate a GraphCycles object with a node vector and an edge vector.
+// We then compare the two implementations.
+
+using Nodes = std::vector<int>;
+struct Edge {
+ int from;
+ int to;
+};
+using Edges = std::vector<Edge>;
+using RandomEngine = std::mt19937_64;
+
+// Mapping from integer index to GraphId.
+typedef std::map<int, GraphId> IdMap;
+static GraphId Get(const IdMap& id, int num) {
+ auto iter = id.find(num);
+ return (iter == id.end()) ? InvalidGraphId() : iter->second;
+}
+
+// Return whether "to" is reachable from "from".
+static bool IsReachable(Edges *edges, int from, int to,
+ std::unordered_set<int> *seen) {
+ seen->insert(from); // we are investigating "from"; don't do it again
+ if (from == to) return true;
+ for (const auto &edge : *edges) {
+ if (edge.from == from) {
+ if (edge.to == to) { // success via edge directly
+ return true;
+ } else if (seen->find(edge.to) == seen->end() && // success via edge
+ IsReachable(edges, edge.to, to, seen)) {
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+static void PrintEdges(Edges *edges) {
+ ABSL_RAW_LOG(INFO, "EDGES (%zu)", edges->size());
+ for (const auto &edge : *edges) {
+ int a = edge.from;
+ int b = edge.to;
+ ABSL_RAW_LOG(INFO, "%d %d", a, b);
+ }
+ ABSL_RAW_LOG(INFO, "---");
+}
+
+static void PrintGCEdges(Nodes *nodes, const IdMap &id, GraphCycles *gc) {
+ ABSL_RAW_LOG(INFO, "GC EDGES");
+ for (int a : *nodes) {
+ for (int b : *nodes) {
+ if (gc->HasEdge(Get(id, a), Get(id, b))) {
+ ABSL_RAW_LOG(INFO, "%d %d", a, b);
+ }
+ }
+ }
+ ABSL_RAW_LOG(INFO, "---");
+}
+
+static void PrintTransitiveClosure(Nodes *nodes, Edges *edges) {
+ ABSL_RAW_LOG(INFO, "Transitive closure");
+ for (int a : *nodes) {
+ for (int b : *nodes) {
+ std::unordered_set<int> seen;
+ if (IsReachable(edges, a, b, &seen)) {
+ ABSL_RAW_LOG(INFO, "%d %d", a, b);
+ }
+ }
+ }
+ ABSL_RAW_LOG(INFO, "---");
+}
+
+static void PrintGCTransitiveClosure(Nodes *nodes, const IdMap &id,
+ GraphCycles *gc) {
+ ABSL_RAW_LOG(INFO, "GC Transitive closure");
+ for (int a : *nodes) {
+ for (int b : *nodes) {
+ if (gc->IsReachable(Get(id, a), Get(id, b))) {
+ ABSL_RAW_LOG(INFO, "%d %d", a, b);
+ }
+ }
+ }
+ ABSL_RAW_LOG(INFO, "---");
+}
+
+static void CheckTransitiveClosure(Nodes *nodes, Edges *edges, const IdMap &id,
+ GraphCycles *gc) {
+ std::unordered_set<int> seen;
+ for (const auto &a : *nodes) {
+ for (const auto &b : *nodes) {
+ seen.clear();
+ bool gc_reachable = gc->IsReachable(Get(id, a), Get(id, b));
+ bool reachable = IsReachable(edges, a, b, &seen);
+ if (gc_reachable != reachable) {
+ PrintEdges(edges);
+ PrintGCEdges(nodes, id, gc);
+ PrintTransitiveClosure(nodes, edges);
+ PrintGCTransitiveClosure(nodes, id, gc);
+ ABSL_RAW_LOG(FATAL, "gc_reachable %s reachable %s a %d b %d",
+ gc_reachable ? "true" : "false",
+ reachable ? "true" : "false", a, b);
+ }
+ }
+ }
+}
+
+static void CheckEdges(Nodes *nodes, Edges *edges, const IdMap &id,
+ GraphCycles *gc) {
+ int count = 0;
+ for (const auto &edge : *edges) {
+ int a = edge.from;
+ int b = edge.to;
+ if (!gc->HasEdge(Get(id, a), Get(id, b))) {
+ PrintEdges(edges);
+ PrintGCEdges(nodes, id, gc);
+ ABSL_RAW_LOG(FATAL, "!gc->HasEdge(%d, %d)", a, b);
+ }
+ }
+ for (const auto &a : *nodes) {
+ for (const auto &b : *nodes) {
+ if (gc->HasEdge(Get(id, a), Get(id, b))) {
+ count++;
+ }
+ }
+ }
+ if (count != edges->size()) {
+ PrintEdges(edges);
+ PrintGCEdges(nodes, id, gc);
+ ABSL_RAW_LOG(FATAL, "edges->size() %zu count %d", edges->size(), count);
+ }
+}
+
+static void CheckInvariants(const GraphCycles &gc) {
+ if (ABSL_PREDICT_FALSE(!gc.CheckInvariants()))
+ ABSL_RAW_LOG(FATAL, "CheckInvariants");
+}
+
+// Returns the index of a randomly chosen node in *nodes.
+// Requires *nodes be non-empty.
+static int RandomNode(RandomEngine* rng, Nodes *nodes) {
+ std::uniform_int_distribution<int> uniform(0, nodes->size()-1);
+ return uniform(*rng);
+}
+
+// Returns the index of a randomly chosen edge in *edges.
+// Requires *edges be non-empty.
+static int RandomEdge(RandomEngine* rng, Edges *edges) {
+ std::uniform_int_distribution<int> uniform(0, edges->size()-1);
+ return uniform(*rng);
+}
+
+// Returns the index of edge (from, to) in *edges or -1 if it is not in *edges.
+static int EdgeIndex(Edges *edges, int from, int to) {
+ int i = 0;
+ while (i != edges->size() &&
+ ((*edges)[i].from != from || (*edges)[i].to != to)) {
+ i++;
+ }
+ return i == edges->size()? -1 : i;
+}
+
+TEST(GraphCycles, RandomizedTest) {
+ int next_node = 0;
+ Nodes nodes;
+ Edges edges; // from, to
+ IdMap id;
+ GraphCycles graph_cycles;
+ static const int kMaxNodes = 7; // use <= 7 nodes to keep test short
+ static const int kDataOffset = 17; // an offset to the node-specific data
+ int n = 100000;
+ int op = 0;
+ RandomEngine rng(testing::UnitTest::GetInstance()->random_seed());
+ std::uniform_int_distribution<int> uniform(0, 5);
+
+ auto ptr = [](intptr_t i) {
+ return reinterpret_cast<void*>(i + kDataOffset);
+ };
+
+ for (int iter = 0; iter != n; iter++) {
+ for (const auto &node : nodes) {
+ ASSERT_EQ(graph_cycles.Ptr(Get(id, node)), ptr(node)) << " node " << node;
+ }
+ CheckEdges(&nodes, &edges, id, &graph_cycles);
+ CheckTransitiveClosure(&nodes, &edges, id, &graph_cycles);
+ op = uniform(rng);
+ switch (op) {
+ case 0: // Add a node
+ if (nodes.size() < kMaxNodes) {
+ int new_node = next_node++;
+ GraphId new_gnode = graph_cycles.GetId(ptr(new_node));
+ ASSERT_NE(new_gnode, InvalidGraphId());
+ id[new_node] = new_gnode;
+ ASSERT_EQ(ptr(new_node), graph_cycles.Ptr(new_gnode));
+ nodes.push_back(new_node);
+ }
+ break;
+
+ case 1: // Remove a node
+ if (nodes.size() > 0) {
+ int node_index = RandomNode(&rng, &nodes);
+ int node = nodes[node_index];
+ nodes[node_index] = nodes.back();
+ nodes.pop_back();
+ graph_cycles.RemoveNode(ptr(node));
+ ASSERT_EQ(graph_cycles.Ptr(Get(id, node)), nullptr);
+ id.erase(node);
+ int i = 0;
+ while (i != edges.size()) {
+ if (edges[i].from == node || edges[i].to == node) {
+ edges[i] = edges.back();
+ edges.pop_back();
+ } else {
+ i++;
+ }
+ }
+ }
+ break;
+
+ case 2: // Add an edge
+ if (nodes.size() > 0) {
+ int from = RandomNode(&rng, &nodes);
+ int to = RandomNode(&rng, &nodes);
+ if (EdgeIndex(&edges, nodes[from], nodes[to]) == -1) {
+ if (graph_cycles.InsertEdge(id[nodes[from]], id[nodes[to]])) {
+ Edge new_edge;
+ new_edge.from = nodes[from];
+ new_edge.to = nodes[to];
+ edges.push_back(new_edge);
+ } else {
+ std::unordered_set<int> seen;
+ ASSERT_TRUE(IsReachable(&edges, nodes[to], nodes[from], &seen))
+ << "Edge " << nodes[to] << "->" << nodes[from];
+ }
+ }
+ }
+ break;
+
+ case 3: // Remove an edge
+ if (edges.size() > 0) {
+ int i = RandomEdge(&rng, &edges);
+ int from = edges[i].from;
+ int to = edges[i].to;
+ ASSERT_EQ(i, EdgeIndex(&edges, from, to));
+ edges[i] = edges.back();
+ edges.pop_back();
+ ASSERT_EQ(-1, EdgeIndex(&edges, from, to));
+ graph_cycles.RemoveEdge(id[from], id[to]);
+ }
+ break;
+
+ case 4: // Check a path
+ if (nodes.size() > 0) {
+ int from = RandomNode(&rng, &nodes);
+ int to = RandomNode(&rng, &nodes);
+ GraphId path[2*kMaxNodes];
+ int path_len = graph_cycles.FindPath(id[nodes[from]], id[nodes[to]],
+ ABSL_ARRAYSIZE(path), path);
+ std::unordered_set<int> seen;
+ bool reachable = IsReachable(&edges, nodes[from], nodes[to], &seen);
+ bool gc_reachable =
+ graph_cycles.IsReachable(Get(id, nodes[from]), Get(id, nodes[to]));
+ ASSERT_EQ(path_len != 0, reachable);
+ ASSERT_EQ(path_len != 0, gc_reachable);
+ // In the following line, we add one because a node can appear
+ // twice, if the path is from that node to itself, perhaps via
+ // every other node.
+ ASSERT_LE(path_len, kMaxNodes + 1);
+ if (path_len != 0) {
+ ASSERT_EQ(id[nodes[from]], path[0]);
+ ASSERT_EQ(id[nodes[to]], path[path_len-1]);
+ for (int i = 1; i < path_len; i++) {
+ ASSERT_TRUE(graph_cycles.HasEdge(path[i-1], path[i]));
+ }
+ }
+ }
+ break;
+
+ case 5: // Check invariants
+ CheckInvariants(graph_cycles);
+ break;
+
+ default:
+ ABSL_RAW_LOG(FATAL, "op %d", op);
+ }
+
+ // Very rarely, test graph expansion by adding then removing many nodes.
+ std::bernoulli_distribution one_in_1024(1.0 / 1024);
+ if (one_in_1024(rng)) {
+ CheckEdges(&nodes, &edges, id, &graph_cycles);
+ CheckTransitiveClosure(&nodes, &edges, id, &graph_cycles);
+ for (int i = 0; i != 256; i++) {
+ int new_node = next_node++;
+ GraphId new_gnode = graph_cycles.GetId(ptr(new_node));
+ ASSERT_NE(InvalidGraphId(), new_gnode);
+ id[new_node] = new_gnode;
+ ASSERT_EQ(ptr(new_node), graph_cycles.Ptr(new_gnode));
+ for (const auto &node : nodes) {
+ ASSERT_NE(node, new_node);
+ }
+ nodes.push_back(new_node);
+ }
+ for (int i = 0; i != 256; i++) {
+ ASSERT_GT(nodes.size(), 0);
+ int node_index = RandomNode(&rng, &nodes);
+ int node = nodes[node_index];
+ nodes[node_index] = nodes.back();
+ nodes.pop_back();
+ graph_cycles.RemoveNode(ptr(node));
+ id.erase(node);
+ int j = 0;
+ while (j != edges.size()) {
+ if (edges[j].from == node || edges[j].to == node) {
+ edges[j] = edges.back();
+ edges.pop_back();
+ } else {
+ j++;
+ }
+ }
+ }
+ CheckInvariants(graph_cycles);
+ }
+ }
+}
+
+class GraphCyclesTest : public ::testing::Test {
+ public:
+ IdMap id_;
+ GraphCycles g_;
+
+ static void* Ptr(int i) {
+ return reinterpret_cast<void*>(static_cast<uintptr_t>(i));
+ }
+
+ static int Num(void* ptr) {
+ return static_cast<int>(reinterpret_cast<uintptr_t>(ptr));
+ }
+
+ // Test relies on ith NewNode() call returning Node numbered i
+ GraphCyclesTest() {
+ for (int i = 0; i < 100; i++) {
+ id_[i] = g_.GetId(Ptr(i));
+ }
+ CheckInvariants(g_);
+ }
+
+ bool AddEdge(int x, int y) {
+ return g_.InsertEdge(Get(id_, x), Get(id_, y));
+ }
+
+ void AddMultiples() {
+ // For every node x > 0: add edge to 2*x, 3*x
+ for (int x = 1; x < 25; x++) {
+ EXPECT_TRUE(AddEdge(x, 2*x)) << x;
+ EXPECT_TRUE(AddEdge(x, 3*x)) << x;
+ }
+ CheckInvariants(g_);
+ }
+
+ std::string Path(int x, int y) {
+ GraphId path[5];
+ int np = g_.FindPath(Get(id_, x), Get(id_, y), ABSL_ARRAYSIZE(path), path);
+ std::string result;
+ for (int i = 0; i < np; i++) {
+ if (i >= ABSL_ARRAYSIZE(path)) {
+ result += " ...";
+ break;
+ }
+ if (!result.empty()) result.push_back(' ');
+ char buf[20];
+ snprintf(buf, sizeof(buf), "%d", Num(g_.Ptr(path[i])));
+ result += buf;
+ }
+ return result;
+ }
+};
+
+TEST_F(GraphCyclesTest, NoCycle) {
+ AddMultiples();
+ CheckInvariants(g_);
+}
+
+TEST_F(GraphCyclesTest, SimpleCycle) {
+ AddMultiples();
+ EXPECT_FALSE(AddEdge(8, 4));
+ EXPECT_EQ("4 8", Path(4, 8));
+ CheckInvariants(g_);
+}
+
+TEST_F(GraphCyclesTest, IndirectCycle) {
+ AddMultiples();
+ EXPECT_TRUE(AddEdge(16, 9));
+ CheckInvariants(g_);
+ EXPECT_FALSE(AddEdge(9, 2));
+ EXPECT_EQ("2 4 8 16 9", Path(2, 9));
+ CheckInvariants(g_);
+}
+
+TEST_F(GraphCyclesTest, LongPath) {
+ ASSERT_TRUE(AddEdge(2, 4));
+ ASSERT_TRUE(AddEdge(4, 6));
+ ASSERT_TRUE(AddEdge(6, 8));
+ ASSERT_TRUE(AddEdge(8, 10));
+ ASSERT_TRUE(AddEdge(10, 12));
+ ASSERT_FALSE(AddEdge(12, 2));
+ EXPECT_EQ("2 4 6 8 10 ...", Path(2, 12));
+ CheckInvariants(g_);
+}
+
+TEST_F(GraphCyclesTest, RemoveNode) {
+ ASSERT_TRUE(AddEdge(1, 2));
+ ASSERT_TRUE(AddEdge(2, 3));
+ ASSERT_TRUE(AddEdge(3, 4));
+ ASSERT_TRUE(AddEdge(4, 5));
+ g_.RemoveNode(g_.Ptr(id_[3]));
+ id_.erase(3);
+ ASSERT_TRUE(AddEdge(5, 1));
+}
+
+TEST_F(GraphCyclesTest, ManyEdges) {
+ const int N = 50;
+ for (int i = 0; i < N; i++) {
+ for (int j = 1; j < N; j++) {
+ ASSERT_TRUE(AddEdge(i, i+j));
+ }
+ }
+ CheckInvariants(g_);
+ ASSERT_TRUE(AddEdge(2*N-1, 0));
+ CheckInvariants(g_);
+ ASSERT_FALSE(AddEdge(10, 9));
+ CheckInvariants(g_);
+}
+
+} // namespace synchronization_internal
+} // namespace absl
[17/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/civil_time_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/civil_time_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/civil_time_test.cc
new file mode 100644
index 0000000..6df0395
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/civil_time_test.cc
@@ -0,0 +1,1049 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+
+#include <iomanip>
+#include <limits>
+#include <sstream>
+#include <string>
+#include <type_traits>
+
+#include "gtest/gtest.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+namespace {
+
+template <typename T>
+std::string Format(const T& t) {
+ std::stringstream ss;
+ ss << t;
+ return ss.str();
+}
+
+} // namespace
+
+#if __clang__ && __cpp_constexpr >= 201304
+// Construction constexpr tests
+
+TEST(CivilTime, Normal) {
+ constexpr civil_second css(2016, 1, 28, 17, 14, 12);
+ static_assert(css.second() == 12, "Normal.second");
+ constexpr civil_minute cmm(2016, 1, 28, 17, 14);
+ static_assert(cmm.minute() == 14, "Normal.minute");
+ constexpr civil_hour chh(2016, 1, 28, 17);
+ static_assert(chh.hour() == 17, "Normal.hour");
+ constexpr civil_day cd(2016, 1, 28);
+ static_assert(cd.day() == 28, "Normal.day");
+ constexpr civil_month cm(2016, 1);
+ static_assert(cm.month() == 1, "Normal.month");
+ constexpr civil_year cy(2016);
+ static_assert(cy.year() == 2016, "Normal.year");
+}
+
+TEST(CivilTime, Conversion) {
+ constexpr civil_year cy(2016);
+ static_assert(cy.year() == 2016, "Conversion.year");
+ constexpr civil_month cm(cy);
+ static_assert(cm.month() == 1, "Conversion.month");
+ constexpr civil_day cd(cm);
+ static_assert(cd.day() == 1, "Conversion.day");
+ constexpr civil_hour chh(cd);
+ static_assert(chh.hour() == 0, "Conversion.hour");
+ constexpr civil_minute cmm(chh);
+ static_assert(cmm.minute() == 0, "Conversion.minute");
+ constexpr civil_second css(cmm);
+ static_assert(css.second() == 0, "Conversion.second");
+}
+
+// Normalization constexpr tests
+
+TEST(CivilTime, Normalized) {
+ constexpr civil_second cs(2016, 1, 28, 17, 14, 12);
+ static_assert(cs.year() == 2016, "Normalized.year");
+ static_assert(cs.month() == 1, "Normalized.month");
+ static_assert(cs.day() == 28, "Normalized.day");
+ static_assert(cs.hour() == 17, "Normalized.hour");
+ static_assert(cs.minute() == 14, "Normalized.minute");
+ static_assert(cs.second() == 12, "Normalized.second");
+}
+
+TEST(CivilTime, SecondOverflow) {
+ constexpr civil_second cs(2016, 1, 28, 17, 14, 121);
+ static_assert(cs.year() == 2016, "SecondOverflow.year");
+ static_assert(cs.month() == 1, "SecondOverflow.month");
+ static_assert(cs.day() == 28, "SecondOverflow.day");
+ static_assert(cs.hour() == 17, "SecondOverflow.hour");
+ static_assert(cs.minute() == 16, "SecondOverflow.minute");
+ static_assert(cs.second() == 1, "SecondOverflow.second");
+}
+
+TEST(CivilTime, SecondUnderflow) {
+ constexpr civil_second cs(2016, 1, 28, 17, 14, -121);
+ static_assert(cs.year() == 2016, "SecondUnderflow.year");
+ static_assert(cs.month() == 1, "SecondUnderflow.month");
+ static_assert(cs.day() == 28, "SecondUnderflow.day");
+ static_assert(cs.hour() == 17, "SecondUnderflow.hour");
+ static_assert(cs.minute() == 11, "SecondUnderflow.minute");
+ static_assert(cs.second() == 59, "SecondUnderflow.second");
+}
+
+TEST(CivilTime, MinuteOverflow) {
+ constexpr civil_second cs(2016, 1, 28, 17, 121, 12);
+ static_assert(cs.year() == 2016, "MinuteOverflow.year");
+ static_assert(cs.month() == 1, "MinuteOverflow.month");
+ static_assert(cs.day() == 28, "MinuteOverflow.day");
+ static_assert(cs.hour() == 19, "MinuteOverflow.hour");
+ static_assert(cs.minute() == 1, "MinuteOverflow.minute");
+ static_assert(cs.second() == 12, "MinuteOverflow.second");
+}
+
+TEST(CivilTime, MinuteUnderflow) {
+ constexpr civil_second cs(2016, 1, 28, 17, -121, 12);
+ static_assert(cs.year() == 2016, "MinuteUnderflow.year");
+ static_assert(cs.month() == 1, "MinuteUnderflow.month");
+ static_assert(cs.day() == 28, "MinuteUnderflow.day");
+ static_assert(cs.hour() == 14, "MinuteUnderflow.hour");
+ static_assert(cs.minute() == 59, "MinuteUnderflow.minute");
+ static_assert(cs.second() == 12, "MinuteUnderflow.second");
+}
+
+TEST(CivilTime, HourOverflow) {
+ constexpr civil_second cs(2016, 1, 28, 49, 14, 12);
+ static_assert(cs.year() == 2016, "HourOverflow.year");
+ static_assert(cs.month() == 1, "HourOverflow.month");
+ static_assert(cs.day() == 30, "HourOverflow.day");
+ static_assert(cs.hour() == 1, "HourOverflow.hour");
+ static_assert(cs.minute() == 14, "HourOverflow.minute");
+ static_assert(cs.second() == 12, "HourOverflow.second");
+}
+
+TEST(CivilTime, HourUnderflow) {
+ constexpr civil_second cs(2016, 1, 28, -49, 14, 12);
+ static_assert(cs.year() == 2016, "HourUnderflow.year");
+ static_assert(cs.month() == 1, "HourUnderflow.month");
+ static_assert(cs.day() == 25, "HourUnderflow.day");
+ static_assert(cs.hour() == 23, "HourUnderflow.hour");
+ static_assert(cs.minute() == 14, "HourUnderflow.minute");
+ static_assert(cs.second() == 12, "HourUnderflow.second");
+}
+
+TEST(CivilTime, MonthOverflow) {
+ constexpr civil_second cs(2016, 25, 28, 17, 14, 12);
+ static_assert(cs.year() == 2018, "MonthOverflow.year");
+ static_assert(cs.month() == 1, "MonthOverflow.month");
+ static_assert(cs.day() == 28, "MonthOverflow.day");
+ static_assert(cs.hour() == 17, "MonthOverflow.hour");
+ static_assert(cs.minute() == 14, "MonthOverflow.minute");
+ static_assert(cs.second() == 12, "MonthOverflow.second");
+}
+
+TEST(CivilTime, MonthUnderflow) {
+ constexpr civil_second cs(2016, -25, 28, 17, 14, 12);
+ static_assert(cs.year() == 2013, "MonthUnderflow.year");
+ static_assert(cs.month() == 11, "MonthUnderflow.month");
+ static_assert(cs.day() == 28, "MonthUnderflow.day");
+ static_assert(cs.hour() == 17, "MonthUnderflow.hour");
+ static_assert(cs.minute() == 14, "MonthUnderflow.minute");
+ static_assert(cs.second() == 12, "MonthUnderflow.second");
+}
+
+TEST(CivilTime, C4Overflow) {
+ constexpr civil_second cs(2016, 1, 292195, 17, 14, 12);
+ static_assert(cs.year() == 2816, "C4Overflow.year");
+ static_assert(cs.month() == 1, "C4Overflow.month");
+ static_assert(cs.day() == 1, "C4Overflow.day");
+ static_assert(cs.hour() == 17, "C4Overflow.hour");
+ static_assert(cs.minute() == 14, "C4Overflow.minute");
+ static_assert(cs.second() == 12, "C4Overflow.second");
+}
+
+TEST(CivilTime, C4Underflow) {
+ constexpr civil_second cs(2016, 1, -292195, 17, 14, 12);
+ static_assert(cs.year() == 1215, "C4Underflow.year");
+ static_assert(cs.month() == 12, "C4Underflow.month");
+ static_assert(cs.day() == 30, "C4Underflow.day");
+ static_assert(cs.hour() == 17, "C4Underflow.hour");
+ static_assert(cs.minute() == 14, "C4Underflow.minute");
+ static_assert(cs.second() == 12, "C4Underflow.second");
+}
+
+TEST(CivilTime, MixedNormalization) {
+ constexpr civil_second cs(2016, -42, 122, 99, -147, 4949);
+ static_assert(cs.year() == 2012, "MixedNormalization.year");
+ static_assert(cs.month() == 10, "MixedNormalization.month");
+ static_assert(cs.day() == 4, "MixedNormalization.day");
+ static_assert(cs.hour() == 1, "MixedNormalization.hour");
+ static_assert(cs.minute() == 55, "MixedNormalization.minute");
+ static_assert(cs.second() == 29, "MixedNormalization.second");
+}
+
+// Relational constexpr tests
+
+TEST(CivilTime, Less) {
+ constexpr civil_second cs1(2016, 1, 28, 17, 14, 12);
+ constexpr civil_second cs2(2016, 1, 28, 17, 14, 13);
+ constexpr bool less = cs1 < cs2;
+ static_assert(less, "Less");
+}
+
+// Arithmetic constexpr tests
+
+TEST(CivilTime, Addition) {
+ constexpr civil_second cs1(2016, 1, 28, 17, 14, 12);
+ constexpr civil_second cs2 = cs1 + 50;
+ static_assert(cs2.year() == 2016, "Addition.year");
+ static_assert(cs2.month() == 1, "Addition.month");
+ static_assert(cs2.day() == 28, "Addition.day");
+ static_assert(cs2.hour() == 17, "Addition.hour");
+ static_assert(cs2.minute() == 15, "Addition.minute");
+ static_assert(cs2.second() == 2, "Addition.second");
+}
+
+TEST(CivilTime, Subtraction) {
+ constexpr civil_second cs1(2016, 1, 28, 17, 14, 12);
+ constexpr civil_second cs2 = cs1 - 50;
+ static_assert(cs2.year() == 2016, "Subtraction.year");
+ static_assert(cs2.month() == 1, "Subtraction.month");
+ static_assert(cs2.day() == 28, "Subtraction.day");
+ static_assert(cs2.hour() == 17, "Subtraction.hour");
+ static_assert(cs2.minute() == 13, "Subtraction.minute");
+ static_assert(cs2.second() == 22, "Subtraction.second");
+}
+
+TEST(CivilTime, Difference) {
+ constexpr civil_day cd1(2016, 1, 28);
+ constexpr civil_day cd2(2015, 1, 28);
+ constexpr int diff = cd1 - cd2;
+ static_assert(diff == 365, "Difference");
+}
+
+// NOTE: Run this with --copt=-ftrapv to detect overflow problems.
+TEST(CivilTime, DifferenceWithHugeYear) {
+ {
+ constexpr civil_day d1(9223372036854775807, 1, 1);
+ constexpr civil_day d2(9223372036854775807, 12, 31);
+ static_assert(d2 - d1 == 364, "DifferenceWithHugeYear");
+ }
+ {
+ constexpr civil_day d1(-9223372036854775807 - 1, 1, 1);
+ constexpr civil_day d2(-9223372036854775807 - 1, 12, 31);
+ static_assert(d2 - d1 == 365, "DifferenceWithHugeYear");
+ }
+ {
+ // Check the limits of the return value at the end of the year range.
+ constexpr civil_day d1(9223372036854775807, 1, 1);
+ constexpr civil_day d2(9198119301927009252, 6, 6);
+ static_assert(d1 - d2 == 9223372036854775807, "DifferenceWithHugeYear");
+ static_assert((d2 - 1) - d1 == -9223372036854775807 - 1,
+ "DifferenceWithHugeYear");
+ }
+ {
+ // Check the limits of the return value at the start of the year range.
+ constexpr civil_day d1(-9223372036854775807 - 1, 1, 1);
+ constexpr civil_day d2(-9198119301927009254, 7, 28);
+ static_assert(d2 - d1 == 9223372036854775807, "DifferenceWithHugeYear");
+ static_assert(d1 - (d2 + 1) == -9223372036854775807 - 1,
+ "DifferenceWithHugeYear");
+ }
+ {
+ // Check the limits of the return value from either side of year 0.
+ constexpr civil_day d1(-12626367463883278, 9, 3);
+ constexpr civil_day d2(12626367463883277, 3, 28);
+ static_assert(d2 - d1 == 9223372036854775807, "DifferenceWithHugeYear");
+ static_assert(d1 - (d2 + 1) == -9223372036854775807 - 1,
+ "DifferenceWithHugeYear");
+ }
+}
+
+// NOTE: Run this with --copt=-ftrapv to detect overflow problems.
+TEST(CivilTime, DifferenceNoIntermediateOverflow) {
+ {
+ // The difference up to the minute field would be below the minimum
+ // diff_t, but the 52 extra seconds brings us back to the minimum.
+ constexpr civil_second s1(-292277022657, 1, 27, 8, 29 - 1, 52);
+ constexpr civil_second s2(1970, 1, 1, 0, 0 - 1, 0);
+ static_assert(s1 - s2 == -9223372036854775807 - 1,
+ "DifferenceNoIntermediateOverflow");
+ }
+ {
+ // The difference up to the minute field would be above the maximum
+ // diff_t, but the -53 extra seconds brings us back to the maximum.
+ constexpr civil_second s1(292277026596, 12, 4, 15, 30, 7 - 7);
+ constexpr civil_second s2(1970, 1, 1, 0, 0, 0 - 7);
+ static_assert(s1 - s2 == 9223372036854775807,
+ "DifferenceNoIntermediateOverflow");
+ }
+}
+
+// Helper constexpr tests
+
+TEST(CivilTime, WeekDay) {
+ constexpr civil_day cd(2016, 1, 28);
+ constexpr weekday wd = get_weekday(cd);
+ static_assert(wd == weekday::thursday, "Weekday");
+}
+
+TEST(CivilTime, NextWeekDay) {
+ constexpr civil_day cd(2016, 1, 28);
+ constexpr civil_day next = next_weekday(cd, weekday::thursday);
+ static_assert(next.year() == 2016, "NextWeekDay.year");
+ static_assert(next.month() == 2, "NextWeekDay.month");
+ static_assert(next.day() == 4, "NextWeekDay.day");
+}
+
+TEST(CivilTime, PrevWeekDay) {
+ constexpr civil_day cd(2016, 1, 28);
+ constexpr civil_day prev = prev_weekday(cd, weekday::thursday);
+ static_assert(prev.year() == 2016, "PrevWeekDay.year");
+ static_assert(prev.month() == 1, "PrevWeekDay.month");
+ static_assert(prev.day() == 21, "PrevWeekDay.day");
+}
+
+TEST(CivilTime, YearDay) {
+ constexpr civil_day cd(2016, 1, 28);
+ constexpr int yd = get_yearday(cd);
+ static_assert(yd == 28, "YearDay");
+}
+#endif // __clang__ && __cpp_constexpr >= 201304
+
+// The remaining tests do not use constexpr.
+
+TEST(CivilTime, DefaultConstruction) {
+ civil_second ss;
+ EXPECT_EQ("1970-01-01T00:00:00", Format(ss));
+
+ civil_minute mm;
+ EXPECT_EQ("1970-01-01T00:00", Format(mm));
+
+ civil_hour hh;
+ EXPECT_EQ("1970-01-01T00", Format(hh));
+
+ civil_day d;
+ EXPECT_EQ("1970-01-01", Format(d));
+
+ civil_month m;
+ EXPECT_EQ("1970-01", Format(m));
+
+ civil_year y;
+ EXPECT_EQ("1970", Format(y));
+}
+
+TEST(CivilTime, StructMember) {
+ struct S {
+ civil_day day;
+ };
+ S s = {};
+ EXPECT_EQ(civil_day{}, s.day);
+}
+
+TEST(CivilTime, FieldsConstruction) {
+ EXPECT_EQ("2015-01-02T03:04:05", Format(civil_second(2015, 1, 2, 3, 4, 5)));
+ EXPECT_EQ("2015-01-02T03:04:00", Format(civil_second(2015, 1, 2, 3, 4)));
+ EXPECT_EQ("2015-01-02T03:00:00", Format(civil_second(2015, 1, 2, 3)));
+ EXPECT_EQ("2015-01-02T00:00:00", Format(civil_second(2015, 1, 2)));
+ EXPECT_EQ("2015-01-01T00:00:00", Format(civil_second(2015, 1)));
+ EXPECT_EQ("2015-01-01T00:00:00", Format(civil_second(2015)));
+
+ EXPECT_EQ("2015-01-02T03:04", Format(civil_minute(2015, 1, 2, 3, 4, 5)));
+ EXPECT_EQ("2015-01-02T03:04", Format(civil_minute(2015, 1, 2, 3, 4)));
+ EXPECT_EQ("2015-01-02T03:00", Format(civil_minute(2015, 1, 2, 3)));
+ EXPECT_EQ("2015-01-02T00:00", Format(civil_minute(2015, 1, 2)));
+ EXPECT_EQ("2015-01-01T00:00", Format(civil_minute(2015, 1)));
+ EXPECT_EQ("2015-01-01T00:00", Format(civil_minute(2015)));
+
+ EXPECT_EQ("2015-01-02T03", Format(civil_hour(2015, 1, 2, 3, 4, 5)));
+ EXPECT_EQ("2015-01-02T03", Format(civil_hour(2015, 1, 2, 3, 4)));
+ EXPECT_EQ("2015-01-02T03", Format(civil_hour(2015, 1, 2, 3)));
+ EXPECT_EQ("2015-01-02T00", Format(civil_hour(2015, 1, 2)));
+ EXPECT_EQ("2015-01-01T00", Format(civil_hour(2015, 1)));
+ EXPECT_EQ("2015-01-01T00", Format(civil_hour(2015)));
+
+ EXPECT_EQ("2015-01-02", Format(civil_day(2015, 1, 2, 3, 4, 5)));
+ EXPECT_EQ("2015-01-02", Format(civil_day(2015, 1, 2, 3, 4)));
+ EXPECT_EQ("2015-01-02", Format(civil_day(2015, 1, 2, 3)));
+ EXPECT_EQ("2015-01-02", Format(civil_day(2015, 1, 2)));
+ EXPECT_EQ("2015-01-01", Format(civil_day(2015, 1)));
+ EXPECT_EQ("2015-01-01", Format(civil_day(2015)));
+
+ EXPECT_EQ("2015-01", Format(civil_month(2015, 1, 2, 3, 4, 5)));
+ EXPECT_EQ("2015-01", Format(civil_month(2015, 1, 2, 3, 4)));
+ EXPECT_EQ("2015-01", Format(civil_month(2015, 1, 2, 3)));
+ EXPECT_EQ("2015-01", Format(civil_month(2015, 1, 2)));
+ EXPECT_EQ("2015-01", Format(civil_month(2015, 1)));
+ EXPECT_EQ("2015-01", Format(civil_month(2015)));
+
+ EXPECT_EQ("2015", Format(civil_year(2015, 1, 2, 3, 4, 5)));
+ EXPECT_EQ("2015", Format(civil_year(2015, 1, 2, 3, 4)));
+ EXPECT_EQ("2015", Format(civil_year(2015, 1, 2, 3)));
+ EXPECT_EQ("2015", Format(civil_year(2015, 1, 2)));
+ EXPECT_EQ("2015", Format(civil_year(2015, 1)));
+ EXPECT_EQ("2015", Format(civil_year(2015)));
+}
+
+TEST(CivilTime, FieldsConstructionLimits) {
+ const int kIntMax = std::numeric_limits<int>::max();
+ EXPECT_EQ("2038-01-19T03:14:07",
+ Format(civil_second(1970, 1, 1, 0, 0, kIntMax)));
+ EXPECT_EQ("6121-02-11T05:21:07",
+ Format(civil_second(1970, 1, 1, 0, kIntMax, kIntMax)));
+ EXPECT_EQ("251104-11-20T12:21:07",
+ Format(civil_second(1970, 1, 1, kIntMax, kIntMax, kIntMax)));
+ EXPECT_EQ("6130715-05-30T12:21:07",
+ Format(civil_second(1970, 1, kIntMax, kIntMax, kIntMax, kIntMax)));
+ EXPECT_EQ(
+ "185087685-11-26T12:21:07",
+ Format(civil_second(1970, kIntMax, kIntMax, kIntMax, kIntMax, kIntMax)));
+
+ const int kIntMin = std::numeric_limits<int>::min();
+ EXPECT_EQ("1901-12-13T20:45:52",
+ Format(civil_second(1970, 1, 1, 0, 0, kIntMin)));
+ EXPECT_EQ("-2182-11-20T18:37:52",
+ Format(civil_second(1970, 1, 1, 0, kIntMin, kIntMin)));
+ EXPECT_EQ("-247165-02-11T10:37:52",
+ Format(civil_second(1970, 1, 1, kIntMin, kIntMin, kIntMin)));
+ EXPECT_EQ("-6126776-08-01T10:37:52",
+ Format(civil_second(1970, 1, kIntMin, kIntMin, kIntMin, kIntMin)));
+ EXPECT_EQ(
+ "-185083747-10-31T10:37:52",
+ Format(civil_second(1970, kIntMin, kIntMin, kIntMin, kIntMin, kIntMin)));
+}
+
+TEST(CivilTime, ImplicitCrossAlignment) {
+ civil_year year(2015);
+ civil_month month = year;
+ civil_day day = month;
+ civil_hour hour = day;
+ civil_minute minute = hour;
+ civil_second second = minute;
+
+ second = year;
+ EXPECT_EQ(second, year);
+ second = month;
+ EXPECT_EQ(second, month);
+ second = day;
+ EXPECT_EQ(second, day);
+ second = hour;
+ EXPECT_EQ(second, hour);
+ second = minute;
+ EXPECT_EQ(second, minute);
+
+ minute = year;
+ EXPECT_EQ(minute, year);
+ minute = month;
+ EXPECT_EQ(minute, month);
+ minute = day;
+ EXPECT_EQ(minute, day);
+ minute = hour;
+ EXPECT_EQ(minute, hour);
+
+ hour = year;
+ EXPECT_EQ(hour, year);
+ hour = month;
+ EXPECT_EQ(hour, month);
+ hour = day;
+ EXPECT_EQ(hour, day);
+
+ day = year;
+ EXPECT_EQ(day, year);
+ day = month;
+ EXPECT_EQ(day, month);
+
+ month = year;
+ EXPECT_EQ(month, year);
+
+ // Ensures unsafe conversions are not allowed.
+ EXPECT_FALSE((std::is_convertible<civil_second, civil_minute>::value));
+ EXPECT_FALSE((std::is_convertible<civil_second, civil_hour>::value));
+ EXPECT_FALSE((std::is_convertible<civil_second, civil_day>::value));
+ EXPECT_FALSE((std::is_convertible<civil_second, civil_month>::value));
+ EXPECT_FALSE((std::is_convertible<civil_second, civil_year>::value));
+
+ EXPECT_FALSE((std::is_convertible<civil_minute, civil_hour>::value));
+ EXPECT_FALSE((std::is_convertible<civil_minute, civil_day>::value));
+ EXPECT_FALSE((std::is_convertible<civil_minute, civil_month>::value));
+ EXPECT_FALSE((std::is_convertible<civil_minute, civil_year>::value));
+
+ EXPECT_FALSE((std::is_convertible<civil_hour, civil_day>::value));
+ EXPECT_FALSE((std::is_convertible<civil_hour, civil_month>::value));
+ EXPECT_FALSE((std::is_convertible<civil_hour, civil_year>::value));
+
+ EXPECT_FALSE((std::is_convertible<civil_day, civil_month>::value));
+ EXPECT_FALSE((std::is_convertible<civil_day, civil_year>::value));
+
+ EXPECT_FALSE((std::is_convertible<civil_month, civil_year>::value));
+}
+
+TEST(CivilTime, ExplicitCrossAlignment) {
+ //
+ // Assign from smaller units -> larger units
+ //
+
+ civil_second second(2015, 1, 2, 3, 4, 5);
+ EXPECT_EQ("2015-01-02T03:04:05", Format(second));
+
+ civil_minute minute(second);
+ EXPECT_EQ("2015-01-02T03:04", Format(minute));
+
+ civil_hour hour(minute);
+ EXPECT_EQ("2015-01-02T03", Format(hour));
+
+ civil_day day(hour);
+ EXPECT_EQ("2015-01-02", Format(day));
+
+ civil_month month(day);
+ EXPECT_EQ("2015-01", Format(month));
+
+ civil_year year(month);
+ EXPECT_EQ("2015", Format(year));
+
+ //
+ // Now assign from larger units -> smaller units
+ //
+
+ month = civil_month(year);
+ EXPECT_EQ("2015-01", Format(month));
+
+ day = civil_day(month);
+ EXPECT_EQ("2015-01-01", Format(day));
+
+ hour = civil_hour(day);
+ EXPECT_EQ("2015-01-01T00", Format(hour));
+
+ minute = civil_minute(hour);
+ EXPECT_EQ("2015-01-01T00:00", Format(minute));
+
+ second = civil_second(minute);
+ EXPECT_EQ("2015-01-01T00:00:00", Format(second));
+}
+
+// Metafunction to test whether difference is allowed between two types.
+template <typename T1, typename T2>
+struct HasDifference {
+ template <typename U1, typename U2>
+ static std::false_type test(...);
+ template <typename U1, typename U2>
+ static std::true_type test(decltype(std::declval<U1>() - std::declval<U2>()));
+ static constexpr bool value = decltype(test<T1, T2>(0))::value;
+};
+
+TEST(CivilTime, DisallowCrossAlignedDifference) {
+ // Difference is allowed between types with the same alignment.
+ static_assert(HasDifference<civil_second, civil_second>::value, "");
+ static_assert(HasDifference<civil_minute, civil_minute>::value, "");
+ static_assert(HasDifference<civil_hour, civil_hour>::value, "");
+ static_assert(HasDifference<civil_day, civil_day>::value, "");
+ static_assert(HasDifference<civil_month, civil_month>::value, "");
+ static_assert(HasDifference<civil_year, civil_year>::value, "");
+
+ // Difference is disallowed between types with different alignments.
+ static_assert(!HasDifference<civil_second, civil_minute>::value, "");
+ static_assert(!HasDifference<civil_second, civil_hour>::value, "");
+ static_assert(!HasDifference<civil_second, civil_day>::value, "");
+ static_assert(!HasDifference<civil_second, civil_month>::value, "");
+ static_assert(!HasDifference<civil_second, civil_year>::value, "");
+
+ static_assert(!HasDifference<civil_minute, civil_hour>::value, "");
+ static_assert(!HasDifference<civil_minute, civil_day>::value, "");
+ static_assert(!HasDifference<civil_minute, civil_month>::value, "");
+ static_assert(!HasDifference<civil_minute, civil_year>::value, "");
+
+ static_assert(!HasDifference<civil_hour, civil_day>::value, "");
+ static_assert(!HasDifference<civil_hour, civil_month>::value, "");
+ static_assert(!HasDifference<civil_hour, civil_year>::value, "");
+
+ static_assert(!HasDifference<civil_day, civil_month>::value, "");
+ static_assert(!HasDifference<civil_day, civil_year>::value, "");
+
+ static_assert(!HasDifference<civil_month, civil_year>::value, "");
+}
+
+TEST(CivilTime, ValueSemantics) {
+ const civil_hour a(2015, 1, 2, 3);
+ const civil_hour b = a;
+ const civil_hour c(b);
+ civil_hour d;
+ d = c;
+ EXPECT_EQ("2015-01-02T03", Format(d));
+}
+
+TEST(CivilTime, Relational) {
+ // Tests that the alignment unit is ignored in comparison.
+ const civil_year year(2014);
+ const civil_month month(year);
+ EXPECT_EQ(year, month);
+
+#define TEST_RELATIONAL(OLDER, YOUNGER) \
+ do { \
+ EXPECT_FALSE(OLDER < OLDER); \
+ EXPECT_FALSE(OLDER > OLDER); \
+ EXPECT_TRUE(OLDER >= OLDER); \
+ EXPECT_TRUE(OLDER <= OLDER); \
+ EXPECT_FALSE(YOUNGER < YOUNGER); \
+ EXPECT_FALSE(YOUNGER > YOUNGER); \
+ EXPECT_TRUE(YOUNGER >= YOUNGER); \
+ EXPECT_TRUE(YOUNGER <= YOUNGER); \
+ EXPECT_EQ(OLDER, OLDER); \
+ EXPECT_NE(OLDER, YOUNGER); \
+ EXPECT_LT(OLDER, YOUNGER); \
+ EXPECT_LE(OLDER, YOUNGER); \
+ EXPECT_GT(YOUNGER, OLDER); \
+ EXPECT_GE(YOUNGER, OLDER); \
+ } while (0)
+
+ // Alignment is ignored in comparison (verified above), so kSecond is used
+ // to test comparison in all field positions.
+ TEST_RELATIONAL(civil_second(2014, 1, 1, 0, 0, 0),
+ civil_second(2015, 1, 1, 0, 0, 0));
+ TEST_RELATIONAL(civil_second(2014, 1, 1, 0, 0, 0),
+ civil_second(2014, 2, 1, 0, 0, 0));
+ TEST_RELATIONAL(civil_second(2014, 1, 1, 0, 0, 0),
+ civil_second(2014, 1, 2, 0, 0, 0));
+ TEST_RELATIONAL(civil_second(2014, 1, 1, 0, 0, 0),
+ civil_second(2014, 1, 1, 1, 0, 0));
+ TEST_RELATIONAL(civil_second(2014, 1, 1, 1, 0, 0),
+ civil_second(2014, 1, 1, 1, 1, 0));
+ TEST_RELATIONAL(civil_second(2014, 1, 1, 1, 1, 0),
+ civil_second(2014, 1, 1, 1, 1, 1));
+
+ // Tests the relational operators of two different CivilTime types.
+ TEST_RELATIONAL(civil_day(2014, 1, 1), civil_minute(2014, 1, 1, 1, 1));
+ TEST_RELATIONAL(civil_day(2014, 1, 1), civil_month(2014, 2));
+
+#undef TEST_RELATIONAL
+}
+
+TEST(CivilTime, Arithmetic) {
+ civil_second second(2015, 1, 2, 3, 4, 5);
+ EXPECT_EQ("2015-01-02T03:04:06", Format(second += 1));
+ EXPECT_EQ("2015-01-02T03:04:07", Format(second + 1));
+ EXPECT_EQ("2015-01-02T03:04:08", Format(2 + second));
+ EXPECT_EQ("2015-01-02T03:04:05", Format(second - 1));
+ EXPECT_EQ("2015-01-02T03:04:05", Format(second -= 1));
+ EXPECT_EQ("2015-01-02T03:04:05", Format(second++));
+ EXPECT_EQ("2015-01-02T03:04:07", Format(++second));
+ EXPECT_EQ("2015-01-02T03:04:07", Format(second--));
+ EXPECT_EQ("2015-01-02T03:04:05", Format(--second));
+
+ civil_minute minute(2015, 1, 2, 3, 4);
+ EXPECT_EQ("2015-01-02T03:05", Format(minute += 1));
+ EXPECT_EQ("2015-01-02T03:06", Format(minute + 1));
+ EXPECT_EQ("2015-01-02T03:07", Format(2 + minute));
+ EXPECT_EQ("2015-01-02T03:04", Format(minute - 1));
+ EXPECT_EQ("2015-01-02T03:04", Format(minute -= 1));
+ EXPECT_EQ("2015-01-02T03:04", Format(minute++));
+ EXPECT_EQ("2015-01-02T03:06", Format(++minute));
+ EXPECT_EQ("2015-01-02T03:06", Format(minute--));
+ EXPECT_EQ("2015-01-02T03:04", Format(--minute));
+
+ civil_hour hour(2015, 1, 2, 3);
+ EXPECT_EQ("2015-01-02T04", Format(hour += 1));
+ EXPECT_EQ("2015-01-02T05", Format(hour + 1));
+ EXPECT_EQ("2015-01-02T06", Format(2 + hour));
+ EXPECT_EQ("2015-01-02T03", Format(hour - 1));
+ EXPECT_EQ("2015-01-02T03", Format(hour -= 1));
+ EXPECT_EQ("2015-01-02T03", Format(hour++));
+ EXPECT_EQ("2015-01-02T05", Format(++hour));
+ EXPECT_EQ("2015-01-02T05", Format(hour--));
+ EXPECT_EQ("2015-01-02T03", Format(--hour));
+
+ civil_day day(2015, 1, 2);
+ EXPECT_EQ("2015-01-03", Format(day += 1));
+ EXPECT_EQ("2015-01-04", Format(day + 1));
+ EXPECT_EQ("2015-01-05", Format(2 + day));
+ EXPECT_EQ("2015-01-02", Format(day - 1));
+ EXPECT_EQ("2015-01-02", Format(day -= 1));
+ EXPECT_EQ("2015-01-02", Format(day++));
+ EXPECT_EQ("2015-01-04", Format(++day));
+ EXPECT_EQ("2015-01-04", Format(day--));
+ EXPECT_EQ("2015-01-02", Format(--day));
+
+ civil_month month(2015, 1);
+ EXPECT_EQ("2015-02", Format(month += 1));
+ EXPECT_EQ("2015-03", Format(month + 1));
+ EXPECT_EQ("2015-04", Format(2 + month));
+ EXPECT_EQ("2015-01", Format(month - 1));
+ EXPECT_EQ("2015-01", Format(month -= 1));
+ EXPECT_EQ("2015-01", Format(month++));
+ EXPECT_EQ("2015-03", Format(++month));
+ EXPECT_EQ("2015-03", Format(month--));
+ EXPECT_EQ("2015-01", Format(--month));
+
+ civil_year year(2015);
+ EXPECT_EQ("2016", Format(year += 1));
+ EXPECT_EQ("2017", Format(year + 1));
+ EXPECT_EQ("2018", Format(2 + year));
+ EXPECT_EQ("2015", Format(year - 1));
+ EXPECT_EQ("2015", Format(year -= 1));
+ EXPECT_EQ("2015", Format(year++));
+ EXPECT_EQ("2017", Format(++year));
+ EXPECT_EQ("2017", Format(year--));
+ EXPECT_EQ("2015", Format(--year));
+}
+
+TEST(CivilTime, ArithmeticLimits) {
+ const int kIntMax = std::numeric_limits<int>::max();
+ const int kIntMin = std::numeric_limits<int>::min();
+
+ civil_second second(1970, 1, 1, 0, 0, 0);
+ second += kIntMax;
+ EXPECT_EQ("2038-01-19T03:14:07", Format(second));
+ second -= kIntMax;
+ EXPECT_EQ("1970-01-01T00:00:00", Format(second));
+ second += kIntMin;
+ EXPECT_EQ("1901-12-13T20:45:52", Format(second));
+ second -= kIntMin;
+ EXPECT_EQ("1970-01-01T00:00:00", Format(second));
+
+ civil_minute minute(1970, 1, 1, 0, 0);
+ minute += kIntMax;
+ EXPECT_EQ("6053-01-23T02:07", Format(minute));
+ minute -= kIntMax;
+ EXPECT_EQ("1970-01-01T00:00", Format(minute));
+ minute += kIntMin;
+ EXPECT_EQ("-2114-12-08T21:52", Format(minute));
+ minute -= kIntMin;
+ EXPECT_EQ("1970-01-01T00:00", Format(minute));
+
+ civil_hour hour(1970, 1, 1, 0);
+ hour += kIntMax;
+ EXPECT_EQ("246953-10-09T07", Format(hour));
+ hour -= kIntMax;
+ EXPECT_EQ("1970-01-01T00", Format(hour));
+ hour += kIntMin;
+ EXPECT_EQ("-243014-03-24T16", Format(hour));
+ hour -= kIntMin;
+ EXPECT_EQ("1970-01-01T00", Format(hour));
+
+ civil_day day(1970, 1, 1);
+ day += kIntMax;
+ EXPECT_EQ("5881580-07-11", Format(day));
+ day -= kIntMax;
+ EXPECT_EQ("1970-01-01", Format(day));
+ day += kIntMin;
+ EXPECT_EQ("-5877641-06-23", Format(day));
+ day -= kIntMin;
+ EXPECT_EQ("1970-01-01", Format(day));
+
+ civil_month month(1970, 1);
+ month += kIntMax;
+ EXPECT_EQ("178958940-08", Format(month));
+ month -= kIntMax;
+ EXPECT_EQ("1970-01", Format(month));
+ month += kIntMin;
+ EXPECT_EQ("-178955001-05", Format(month));
+ month -= kIntMin;
+ EXPECT_EQ("1970-01", Format(month));
+
+ civil_year year(0);
+ year += kIntMax;
+ EXPECT_EQ("2147483647", Format(year));
+ year -= kIntMax;
+ EXPECT_EQ("0", Format(year));
+ year += kIntMin;
+ EXPECT_EQ("-2147483648", Format(year));
+ year -= kIntMin;
+ EXPECT_EQ("0", Format(year));
+}
+
+TEST(CivilTime, ArithmeticDifference) {
+ civil_second second(2015, 1, 2, 3, 4, 5);
+ EXPECT_EQ(0, second - second);
+ EXPECT_EQ(10, (second + 10) - second);
+ EXPECT_EQ(-10, (second - 10) - second);
+
+ civil_minute minute(2015, 1, 2, 3, 4);
+ EXPECT_EQ(0, minute - minute);
+ EXPECT_EQ(10, (minute + 10) - minute);
+ EXPECT_EQ(-10, (minute - 10) - minute);
+
+ civil_hour hour(2015, 1, 2, 3);
+ EXPECT_EQ(0, hour - hour);
+ EXPECT_EQ(10, (hour + 10) - hour);
+ EXPECT_EQ(-10, (hour - 10) - hour);
+
+ civil_day day(2015, 1, 2);
+ EXPECT_EQ(0, day - day);
+ EXPECT_EQ(10, (day + 10) - day);
+ EXPECT_EQ(-10, (day - 10) - day);
+
+ civil_month month(2015, 1);
+ EXPECT_EQ(0, month - month);
+ EXPECT_EQ(10, (month + 10) - month);
+ EXPECT_EQ(-10, (month - 10) - month);
+
+ civil_year year(2015);
+ EXPECT_EQ(0, year - year);
+ EXPECT_EQ(10, (year + 10) - year);
+ EXPECT_EQ(-10, (year - 10) - year);
+}
+
+TEST(CivilTime, DifferenceLimits) {
+ const int kIntMax = std::numeric_limits<int>::max();
+ const int kIntMin = std::numeric_limits<int>::min();
+
+ // Check day arithmetic at the end of the year range.
+ const civil_day max_day(kIntMax, 12, 31);
+ EXPECT_EQ(1, max_day - (max_day - 1));
+ EXPECT_EQ(-1, (max_day - 1) - max_day);
+
+ // Check day arithmetic at the end of the year range.
+ const civil_day min_day(kIntMin, 1, 1);
+ EXPECT_EQ(1, (min_day + 1) - min_day);
+ EXPECT_EQ(-1, min_day - (min_day + 1));
+
+ // Check the limits of the return value.
+ const civil_day d1(1970, 1, 1);
+ const civil_day d2(5881580, 7, 11);
+ EXPECT_EQ(kIntMax, d2 - d1);
+ EXPECT_EQ(kIntMin, d1 - (d2 + 1));
+}
+
+TEST(CivilTime, Properties) {
+ civil_second ss(2015, 2, 3, 4, 5, 6);
+ EXPECT_EQ(2015, ss.year());
+ EXPECT_EQ(2, ss.month());
+ EXPECT_EQ(3, ss.day());
+ EXPECT_EQ(4, ss.hour());
+ EXPECT_EQ(5, ss.minute());
+ EXPECT_EQ(6, ss.second());
+
+ civil_minute mm(2015, 2, 3, 4, 5, 6);
+ EXPECT_EQ(2015, mm.year());
+ EXPECT_EQ(2, mm.month());
+ EXPECT_EQ(3, mm.day());
+ EXPECT_EQ(4, mm.hour());
+ EXPECT_EQ(5, mm.minute());
+ EXPECT_EQ(0, mm.second());
+
+ civil_hour hh(2015, 2, 3, 4, 5, 6);
+ EXPECT_EQ(2015, hh.year());
+ EXPECT_EQ(2, hh.month());
+ EXPECT_EQ(3, hh.day());
+ EXPECT_EQ(4, hh.hour());
+ EXPECT_EQ(0, hh.minute());
+ EXPECT_EQ(0, hh.second());
+
+ civil_day d(2015, 2, 3, 4, 5, 6);
+ EXPECT_EQ(2015, d.year());
+ EXPECT_EQ(2, d.month());
+ EXPECT_EQ(3, d.day());
+ EXPECT_EQ(0, d.hour());
+ EXPECT_EQ(0, d.minute());
+ EXPECT_EQ(0, d.second());
+ EXPECT_EQ(weekday::tuesday, get_weekday(d));
+ EXPECT_EQ(34, get_yearday(d));
+
+ civil_month m(2015, 2, 3, 4, 5, 6);
+ EXPECT_EQ(2015, m.year());
+ EXPECT_EQ(2, m.month());
+ EXPECT_EQ(1, m.day());
+ EXPECT_EQ(0, m.hour());
+ EXPECT_EQ(0, m.minute());
+ EXPECT_EQ(0, m.second());
+
+ civil_year y(2015, 2, 3, 4, 5, 6);
+ EXPECT_EQ(2015, y.year());
+ EXPECT_EQ(1, y.month());
+ EXPECT_EQ(1, y.day());
+ EXPECT_EQ(0, y.hour());
+ EXPECT_EQ(0, y.minute());
+ EXPECT_EQ(0, y.second());
+}
+
+TEST(CivilTime, OutputStream) {
+ // Tests formatting of civil_year, which does not pad.
+ EXPECT_EQ("2016", Format(civil_year(2016)));
+ EXPECT_EQ("123", Format(civil_year(123)));
+ EXPECT_EQ("0", Format(civil_year(0)));
+ EXPECT_EQ("-1", Format(civil_year(-1)));
+
+ // Tests formatting of sub-year types, which pad to 2 digits
+ EXPECT_EQ("2016-02", Format(civil_month(2016, 2)));
+ EXPECT_EQ("2016-02-03", Format(civil_day(2016, 2, 3)));
+ EXPECT_EQ("2016-02-03T04", Format(civil_hour(2016, 2, 3, 4)));
+ EXPECT_EQ("2016-02-03T04:05", Format(civil_minute(2016, 2, 3, 4, 5)));
+ EXPECT_EQ("2016-02-03T04:05:06", Format(civil_second(2016, 2, 3, 4, 5, 6)));
+
+ // Tests formatting of weekday.
+ EXPECT_EQ("Monday", Format(weekday::monday));
+ EXPECT_EQ("Tuesday", Format(weekday::tuesday));
+ EXPECT_EQ("Wednesday", Format(weekday::wednesday));
+ EXPECT_EQ("Thursday", Format(weekday::thursday));
+ EXPECT_EQ("Friday", Format(weekday::friday));
+ EXPECT_EQ("Saturday", Format(weekday::saturday));
+ EXPECT_EQ("Sunday", Format(weekday::sunday));
+}
+
+TEST(CivilTime, OutputStreamLeftFillWidth) {
+ civil_second cs(2016, 2, 3, 4, 5, 6);
+ {
+ std::stringstream ss;
+ ss << std::left << std::setfill('.');
+ ss << std::setw(3) << 'X';
+ ss << std::setw(21) << civil_year(cs);
+ ss << std::setw(3) << 'X';
+ EXPECT_EQ("X..2016.................X..", ss.str());
+ }
+ {
+ std::stringstream ss;
+ ss << std::left << std::setfill('.');
+ ss << std::setw(3) << 'X';
+ ss << std::setw(21) << civil_month(cs);
+ ss << std::setw(3) << 'X';
+ EXPECT_EQ("X..2016-02..............X..", ss.str());
+ }
+ {
+ std::stringstream ss;
+ ss << std::left << std::setfill('.');
+ ss << std::setw(3) << 'X';
+ ss << std::setw(21) << civil_day(cs);
+ ss << std::setw(3) << 'X';
+ EXPECT_EQ("X..2016-02-03...........X..", ss.str());
+ }
+ {
+ std::stringstream ss;
+ ss << std::left << std::setfill('.');
+ ss << std::setw(3) << 'X';
+ ss << std::setw(21) << civil_hour(cs);
+ ss << std::setw(3) << 'X';
+ EXPECT_EQ("X..2016-02-03T04........X..", ss.str());
+ }
+ {
+ std::stringstream ss;
+ ss << std::left << std::setfill('.');
+ ss << std::setw(3) << 'X';
+ ss << std::setw(21) << civil_minute(cs);
+ ss << std::setw(3) << 'X';
+ EXPECT_EQ("X..2016-02-03T04:05.....X..", ss.str());
+ }
+ {
+ std::stringstream ss;
+ ss << std::left << std::setfill('.');
+ ss << std::setw(3) << 'X';
+ ss << std::setw(21) << civil_second(cs);
+ ss << std::setw(3) << 'X';
+ EXPECT_EQ("X..2016-02-03T04:05:06..X..", ss.str());
+ }
+}
+
+TEST(CivilTime, NextPrevWeekday) {
+ // Jan 1, 1970 was a Thursday.
+ const civil_day thursday(1970, 1, 1);
+ EXPECT_EQ(weekday::thursday, get_weekday(thursday));
+
+ // Thursday -> Thursday
+ civil_day d = next_weekday(thursday, weekday::thursday);
+ EXPECT_EQ(7, d - thursday) << Format(d);
+ EXPECT_EQ(d - 14, prev_weekday(thursday, weekday::thursday));
+
+ // Thursday -> Friday
+ d = next_weekday(thursday, weekday::friday);
+ EXPECT_EQ(1, d - thursday) << Format(d);
+ EXPECT_EQ(d - 7, prev_weekday(thursday, weekday::friday));
+
+ // Thursday -> Saturday
+ d = next_weekday(thursday, weekday::saturday);
+ EXPECT_EQ(2, d - thursday) << Format(d);
+ EXPECT_EQ(d - 7, prev_weekday(thursday, weekday::saturday));
+
+ // Thursday -> Sunday
+ d = next_weekday(thursday, weekday::sunday);
+ EXPECT_EQ(3, d - thursday) << Format(d);
+ EXPECT_EQ(d - 7, prev_weekday(thursday, weekday::sunday));
+
+ // Thursday -> Monday
+ d = next_weekday(thursday, weekday::monday);
+ EXPECT_EQ(4, d - thursday) << Format(d);
+ EXPECT_EQ(d - 7, prev_weekday(thursday, weekday::monday));
+
+ // Thursday -> Tuesday
+ d = next_weekday(thursday, weekday::tuesday);
+ EXPECT_EQ(5, d - thursday) << Format(d);
+ EXPECT_EQ(d - 7, prev_weekday(thursday, weekday::tuesday));
+
+ // Thursday -> Wednesday
+ d = next_weekday(thursday, weekday::wednesday);
+ EXPECT_EQ(6, d - thursday) << Format(d);
+ EXPECT_EQ(d - 7, prev_weekday(thursday, weekday::wednesday));
+}
+
+TEST(CivilTime, NormalizeWithHugeYear) {
+ civil_month c(9223372036854775807, 1);
+ EXPECT_EQ("9223372036854775807-01", Format(c));
+ c = c - 1; // Causes normalization
+ EXPECT_EQ("9223372036854775806-12", Format(c));
+
+ c = civil_month(-9223372036854775807 - 1, 1);
+ EXPECT_EQ("-9223372036854775808-01", Format(c));
+ c = c + 12; // Causes normalization
+ EXPECT_EQ("-9223372036854775807-01", Format(c));
+}
+
+TEST(CivilTime, LeapYears) {
+ // Test data for leap years.
+ const struct {
+ int year;
+ int days;
+ struct {
+ int month;
+ int day;
+ } leap_day; // The date of the day after Feb 28.
+ } kLeapYearTable[]{
+ {1900, 365, {3, 1}},
+ {1999, 365, {3, 1}},
+ {2000, 366, {2, 29}}, // leap year
+ {2001, 365, {3, 1}},
+ {2002, 365, {3, 1}},
+ {2003, 365, {3, 1}},
+ {2004, 366, {2, 29}}, // leap year
+ {2005, 365, {3, 1}},
+ {2006, 365, {3, 1}},
+ {2007, 365, {3, 1}},
+ {2008, 366, {2, 29}}, // leap year
+ {2009, 365, {3, 1}},
+ {2100, 365, {3, 1}},
+ };
+
+ for (const auto& e : kLeapYearTable) {
+ // Tests incrementing through the leap day.
+ const civil_day feb28(e.year, 2, 28);
+ const civil_day next_day = feb28 + 1;
+ EXPECT_EQ(e.leap_day.month, next_day.month());
+ EXPECT_EQ(e.leap_day.day, next_day.day());
+
+ // Tests difference in days of leap years.
+ const civil_year year(feb28);
+ const civil_year next_year = year + 1;
+ EXPECT_EQ(e.days, civil_day(next_year) - civil_day(year));
+ }
+}
+
+TEST(CivilTime, FirstThursdayInMonth) {
+ const civil_day nov1(2014, 11, 1);
+ const civil_day thursday = prev_weekday(nov1, weekday::thursday) + 7;
+ EXPECT_EQ("2014-11-06", Format(thursday));
+
+ // Bonus: Date of Thanksgiving in the United States
+ // Rule: Fourth Thursday of November
+ const civil_day thanksgiving = thursday + 7 * 3;
+ EXPECT_EQ("2014-11-27", Format(thanksgiving));
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_fixed.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_fixed.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_fixed.cc
new file mode 100644
index 0000000..8d3b144
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_fixed.cc
@@ -0,0 +1,133 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "time_zone_fixed.h"
+
+#include <algorithm>
+#include <chrono>
+#include <cstdio>
+#include <cstring>
+#include <string>
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+namespace {
+
+// The prefix used for the internal names of fixed-offset zones.
+const char kFixedOffsetPrefix[] = "Fixed/";
+
+int Parse02d(const char* p) {
+ static const char kDigits[] = "0123456789";
+ if (const char* ap = std::strchr(kDigits, *p)) {
+ int v = static_cast<int>(ap - kDigits);
+ if (const char* bp = std::strchr(kDigits, *++p)) {
+ return (v * 10) + static_cast<int>(bp - kDigits);
+ }
+ }
+ return -1;
+}
+
+} // namespace
+
+bool FixedOffsetFromName(const std::string& name, sys_seconds* offset) {
+ if (name.compare(0, std::string::npos, "UTC", 3) == 0) {
+ *offset = sys_seconds::zero();
+ return true;
+ }
+
+ const std::size_t prefix_len = sizeof(kFixedOffsetPrefix) - 1;
+ const char* const ep = kFixedOffsetPrefix + prefix_len;
+ if (name.size() != prefix_len + 12) // "<prefix>UTC+99:99:99"
+ return false;
+ if (!std::equal(kFixedOffsetPrefix, ep, name.begin()))
+ return false;
+ const char* np = name.data() + prefix_len;
+ if (*np++ != 'U' || *np++ != 'T' || *np++ != 'C')
+ return false;
+ if (np[0] != '+' && np[0] != '-')
+ return false;
+ if (np[3] != ':' || np[6] != ':') // see note below about large offsets
+ return false;
+
+ int hours = Parse02d(np + 1);
+ if (hours == -1) return false;
+ int mins = Parse02d(np + 4);
+ if (mins == -1) return false;
+ int secs = Parse02d(np + 7);
+ if (secs == -1) return false;
+
+ secs += ((hours * 60) + mins) * 60;
+ if (secs > 24 * 60 * 60) return false; // outside supported offset range
+ *offset = sys_seconds(secs * (np[0] == '-' ? -1 : 1)); // "-" means west
+ return true;
+}
+
+std::string FixedOffsetToName(const sys_seconds& offset) {
+ if (offset == sys_seconds::zero()) return "UTC";
+ if (offset < std::chrono::hours(-24) || offset > std::chrono::hours(24)) {
+ // We don't support fixed-offset zones more than 24 hours
+ // away from UTC to avoid complications in rendering such
+ // offsets and to (somewhat) limit the total number of zones.
+ return "UTC";
+ }
+ int seconds = static_cast<int>(offset.count());
+ const char sign = (seconds < 0 ? '-' : '+');
+ int minutes = seconds / 60;
+ seconds %= 60;
+ if (sign == '-') {
+ if (seconds > 0) {
+ seconds -= 60;
+ minutes += 1;
+ }
+ seconds = -seconds;
+ minutes = -minutes;
+ }
+ int hours = minutes / 60;
+ minutes %= 60;
+ char buf[sizeof(kFixedOffsetPrefix) + sizeof("UTC-24:00:00")];
+ snprintf(buf, sizeof(buf), "%sUTC%c%02d:%02d:%02d",
+ kFixedOffsetPrefix, sign, hours, minutes, seconds);
+ return buf;
+}
+
+std::string FixedOffsetToAbbr(const sys_seconds& offset) {
+ std::string abbr = FixedOffsetToName(offset);
+ const std::size_t prefix_len = sizeof(kFixedOffsetPrefix) - 1;
+ const char* const ep = kFixedOffsetPrefix + prefix_len;
+ if (abbr.size() >= prefix_len) {
+ if (std::equal(kFixedOffsetPrefix, ep, abbr.begin())) {
+ abbr.erase(0, prefix_len);
+ if (abbr.size() == 12) { // UTC+99:99:99
+ abbr.erase(9, 1); // UTC+99:9999
+ abbr.erase(6, 1); // UTC+999999
+ if (abbr[8] == '0' && abbr[9] == '0') { // UTC+999900
+ abbr.erase(8, 2); // UTC+9999
+ if (abbr[6] == '0' && abbr[7] == '0') { // UTC+9900
+ abbr.erase(6, 2); // UTC+99
+ if (abbr[4] == '0') { // UTC+09
+ abbr.erase(4, 1); // UTC+9
+ }
+ }
+ }
+ }
+ }
+ }
+ return abbr;
+}
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_fixed.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_fixed.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_fixed.h
new file mode 100644
index 0000000..7c9d11d
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_fixed.h
@@ -0,0 +1,49 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
+#define ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
+
+#include <string>
+
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+
+// Helper functions for dealing with the names and abbreviations
+// of time zones that are a fixed offset (seconds east) from UTC.
+// FixedOffsetFromName() extracts the offset from a valid fixed-offset
+// name, while FixedOffsetToName() and FixedOffsetToAbbr() generate
+// the canonical zone name and abbreviation respectively for the given
+// offset.
+//
+// A fixed-offset name looks like "Fixed/UTC<+-><hours>:<mins>:<secs>".
+// Its abbreviation is of the form "UTC(<+->H?H(MM(SS)?)?)?" where the
+// optional pieces are omitted when their values are zero. (Note that
+// the sign is the opposite of that used in a POSIX TZ specification.)
+//
+// Note: FixedOffsetFromName() fails on syntax errors or when the parsed
+// offset exceeds 24 hours. FixedOffsetToName() and FixedOffsetToAbbr()
+// both produce "UTC" when the argument offset exceeds 24 hours.
+bool FixedOffsetFromName(const std::string& name, sys_seconds* offset);
+std::string FixedOffsetToName(const sys_seconds& offset);
+std::string FixedOffsetToAbbr(const sys_seconds& offset);
+
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
+
+#endif // ABSL_TIME_INTERNAL_CCTZ_TIME_ZONE_FIXED_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_format.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_format.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_format.cc
new file mode 100644
index 0000000..6d5ccba
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/src/time_zone_format.cc
@@ -0,0 +1,848 @@
+// Copyright 2016 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#if !defined(HAS_STRPTIME)
+# if !defined(_MSC_VER)
+# define HAS_STRPTIME 1 // assume everyone has strptime() except windows
+# endif
+#endif
+
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+
+#include <cctype>
+#include <chrono>
+#include <cstddef>
+#include <cstdint>
+#include <cstring>
+#include <ctime>
+#include <limits>
+#include <string>
+#include <vector>
+#if !HAS_STRPTIME
+#include <iomanip>
+#include <sstream>
+#endif
+
+#include "absl/time/internal/cctz/include/cctz/civil_time.h"
+#include "time_zone_if.h"
+
+namespace absl {
+namespace time_internal {
+namespace cctz {
+namespace detail {
+
+namespace {
+
+#if !HAS_STRPTIME
+// Build a strptime() using C++11's std::get_time().
+char* strptime(const char* s, const char* fmt, std::tm* tm) {
+ std::istringstream input(s);
+ input >> std::get_time(tm, fmt);
+ if (input.fail()) return nullptr;
+ return const_cast<char*>(s) +
+ (input.eof() ? strlen(s) : static_cast<std::size_t>(input.tellg()));
+}
+#endif
+
+std::tm ToTM(const time_zone::absolute_lookup& al) {
+ std::tm tm{};
+ tm.tm_sec = al.cs.second();
+ tm.tm_min = al.cs.minute();
+ tm.tm_hour = al.cs.hour();
+ tm.tm_mday = al.cs.day();
+ tm.tm_mon = al.cs.month() - 1;
+
+ // Saturate tm.tm_year is cases of over/underflow.
+ if (al.cs.year() < std::numeric_limits<int>::min() + 1900) {
+ tm.tm_year = std::numeric_limits<int>::min();
+ } else if (al.cs.year() - 1900 > std::numeric_limits<int>::max()) {
+ tm.tm_year = std::numeric_limits<int>::max();
+ } else {
+ tm.tm_year = static_cast<int>(al.cs.year() - 1900);
+ }
+
+ switch (get_weekday(civil_day(al.cs))) {
+ case weekday::sunday:
+ tm.tm_wday = 0;
+ break;
+ case weekday::monday:
+ tm.tm_wday = 1;
+ break;
+ case weekday::tuesday:
+ tm.tm_wday = 2;
+ break;
+ case weekday::wednesday:
+ tm.tm_wday = 3;
+ break;
+ case weekday::thursday:
+ tm.tm_wday = 4;
+ break;
+ case weekday::friday:
+ tm.tm_wday = 5;
+ break;
+ case weekday::saturday:
+ tm.tm_wday = 6;
+ break;
+ }
+ tm.tm_yday = get_yearday(civil_day(al.cs)) - 1;
+ tm.tm_isdst = al.is_dst ? 1 : 0;
+ return tm;
+}
+
+const char kDigits[] = "0123456789";
+
+// Formats a 64-bit integer in the given field width. Note that it is up
+// to the caller of Format64() [and Format02d()/FormatOffset()] to ensure
+// that there is sufficient space before ep to hold the conversion.
+char* Format64(char* ep, int width, std::int_fast64_t v) {
+ bool neg = false;
+ if (v < 0) {
+ --width;
+ neg = true;
+ if (v == std::numeric_limits<std::int_fast64_t>::min()) {
+ // Avoid negating minimum value.
+ std::int_fast64_t last_digit = -(v % 10);
+ v /= 10;
+ if (last_digit < 0) {
+ ++v;
+ last_digit += 10;
+ }
+ --width;
+ *--ep = kDigits[last_digit];
+ }
+ v = -v;
+ }
+ do {
+ --width;
+ *--ep = kDigits[v % 10];
+ } while (v /= 10);
+ while (--width >= 0) *--ep = '0'; // zero pad
+ if (neg) *--ep = '-';
+ return ep;
+}
+
+// Formats [0 .. 99] as %02d.
+char* Format02d(char* ep, int v) {
+ *--ep = kDigits[v % 10];
+ *--ep = kDigits[(v / 10) % 10];
+ return ep;
+}
+
+// Formats a UTC offset, like +00:00.
+char* FormatOffset(char* ep, int offset, const char* mode) {
+ char sign = '+';
+ if (offset < 0) {
+ offset = -offset; // bounded by 24h so no overflow
+ sign = '-';
+ }
+ char sep = mode[0];
+ if (sep != '\0' && mode[1] == '*') {
+ ep = Format02d(ep, offset % 60);
+ *--ep = sep;
+ }
+ int minutes = offset / 60;
+ ep = Format02d(ep, minutes % 60);
+ if (sep != '\0') *--ep = sep;
+ ep = Format02d(ep, minutes / 60);
+ *--ep = sign;
+ return ep;
+}
+
+// Formats a std::tm using strftime(3).
+void FormatTM(std::string* out, const std::string& fmt, const std::tm& tm) {
+ // strftime(3) returns the number of characters placed in the output
+ // array (which may be 0 characters). It also returns 0 to indicate
+ // an error, like the array wasn't large enough. To accommodate this,
+ // the following code grows the buffer size from 2x the format std::string
+ // length up to 32x.
+ for (std::size_t i = 2; i != 32; i *= 2) {
+ std::size_t buf_size = fmt.size() * i;
+ std::vector<char> buf(buf_size);
+ if (std::size_t len = strftime(&buf[0], buf_size, fmt.c_str(), &tm)) {
+ out->append(&buf[0], len);
+ return;
+ }
+ }
+}
+
+// Used for %E#S/%E#f specifiers and for data values in parse().
+template <typename T>
+const char* ParseInt(const char* dp, int width, T min, T max, T* vp) {
+ if (dp != nullptr) {
+ const T kmin = std::numeric_limits<T>::min();
+ bool erange = false;
+ bool neg = false;
+ T value = 0;
+ if (*dp == '-') {
+ neg = true;
+ if (width <= 0 || --width != 0) {
+ ++dp;
+ } else {
+ dp = nullptr; // width was 1
+ }
+ }
+ if (const char* const bp = dp) {
+ while (const char* cp = strchr(kDigits, *dp)) {
+ int d = static_cast<int>(cp - kDigits);
+ if (d >= 10) break;
+ if (value < kmin / 10) {
+ erange = true;
+ break;
+ }
+ value *= 10;
+ if (value < kmin + d) {
+ erange = true;
+ break;
+ }
+ value -= d;
+ dp += 1;
+ if (width > 0 && --width == 0) break;
+ }
+ if (dp != bp && !erange && (neg || value != kmin)) {
+ if (!neg || value != 0) {
+ if (!neg) value = -value; // make positive
+ if (min <= value && value <= max) {
+ *vp = value;
+ } else {
+ dp = nullptr;
+ }
+ } else {
+ dp = nullptr;
+ }
+ } else {
+ dp = nullptr;
+ }
+ }
+ }
+ return dp;
+}
+
+// The number of base-10 digits that can be represented by a signed 64-bit
+// integer. That is, 10^kDigits10_64 <= 2^63 - 1 < 10^(kDigits10_64 + 1).
+const int kDigits10_64 = 18;
+
+// 10^n for everything that can be represented by a signed 64-bit integer.
+const std::int_fast64_t kExp10[kDigits10_64 + 1] = {
+ 1,
+ 10,
+ 100,
+ 1000,
+ 10000,
+ 100000,
+ 1000000,
+ 10000000,
+ 100000000,
+ 1000000000,
+ 10000000000,
+ 100000000000,
+ 1000000000000,
+ 10000000000000,
+ 100000000000000,
+ 1000000000000000,
+ 10000000000000000,
+ 100000000000000000,
+ 1000000000000000000,
+};
+
+} // namespace
+
+// Uses strftime(3) to format the given Time. The following extended format
+// specifiers are also supported:
+//
+// - %Ez - RFC3339-compatible numeric UTC offset (+hh:mm or -hh:mm)
+// - %E*z - Full-resolution numeric UTC offset (+hh:mm:ss or -hh:mm:ss)
+// - %E#S - Seconds with # digits of fractional precision
+// - %E*S - Seconds with full fractional precision (a literal '*')
+// - %E4Y - Four-character years (-999 ... -001, 0000, 0001 ... 9999)
+//
+// The standard specifiers from RFC3339_* (%Y, %m, %d, %H, %M, and %S) are
+// handled internally for performance reasons. strftime(3) is slow due to
+// a POSIX requirement to respect changes to ${TZ}.
+//
+// The TZ/GNU %s extension is handled internally because strftime() has
+// to use mktime() to generate it, and that assumes the local time zone.
+//
+// We also handle the %z and %Z specifiers to accommodate platforms that do
+// not support the tm_gmtoff and tm_zone extensions to std::tm.
+//
+// Requires that zero() <= fs < seconds(1).
+std::string format(const std::string& format, const time_point<sys_seconds>& tp,
+ const detail::femtoseconds& fs, const time_zone& tz) {
+ std::string result;
+ result.reserve(format.size()); // A reasonable guess for the result size.
+ const time_zone::absolute_lookup al = tz.lookup(tp);
+ const std::tm tm = ToTM(al);
+
+ // Scratch buffer for internal conversions.
+ char buf[3 + kDigits10_64]; // enough for longest conversion
+ char* const ep = buf + sizeof(buf);
+ char* bp; // works back from ep
+
+ // Maintain three, disjoint subsequences that span format.
+ // [format.begin() ... pending) : already formatted into result
+ // [pending ... cur) : formatting pending, but no special cases
+ // [cur ... format.end()) : unexamined
+ // Initially, everything is in the unexamined part.
+ const char* pending = format.c_str(); // NUL terminated
+ const char* cur = pending;
+ const char* end = pending + format.length();
+
+ while (cur != end) { // while something is unexamined
+ // Moves cur to the next percent sign.
+ const char* start = cur;
+ while (cur != end && *cur != '%') ++cur;
+
+ // If the new pending text is all ordinary, copy it out.
+ if (cur != start && pending == start) {
+ result.append(pending, static_cast<std::size_t>(cur - pending));
+ pending = start = cur;
+ }
+
+ // Span the sequential percent signs.
+ const char* percent = cur;
+ while (cur != end && *cur == '%') ++cur;
+
+ // If the new pending text is all percents, copy out one
+ // percent for every matched pair, then skip those pairs.
+ if (cur != start && pending == start) {
+ std::size_t escaped = static_cast<std::size_t>(cur - pending) / 2;
+ result.append(pending, escaped);
+ pending += escaped * 2;
+ // Also copy out a single trailing percent.
+ if (pending != cur && cur == end) {
+ result.push_back(*pending++);
+ }
+ }
+
+ // Loop unless we have an unescaped percent.
+ if (cur == end || (cur - percent) % 2 == 0) continue;
+
+ // Simple specifiers that we handle ourselves.
+ if (strchr("YmdeHMSzZs%", *cur)) {
+ if (cur - 1 != pending) {
+ FormatTM(&result, std::string(pending, cur - 1), tm);
+ }
+ switch (*cur) {
+ case 'Y':
+ // This avoids the tm.tm_year overflow problem for %Y, however
+ // tm.tm_year will still be used by other specifiers like %D.
+ bp = Format64(ep, 0, al.cs.year());
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ break;
+ case 'm':
+ bp = Format02d(ep, al.cs.month());
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ break;
+ case 'd':
+ case 'e':
+ bp = Format02d(ep, al.cs.day());
+ if (*cur == 'e' && *bp == '0') *bp = ' '; // for Windows
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ break;
+ case 'H':
+ bp = Format02d(ep, al.cs.hour());
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ break;
+ case 'M':
+ bp = Format02d(ep, al.cs.minute());
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ break;
+ case 'S':
+ bp = Format02d(ep, al.cs.second());
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ break;
+ case 'z':
+ bp = FormatOffset(ep, al.offset, "");
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ break;
+ case 'Z':
+ result.append(al.abbr);
+ break;
+ case 's':
+ bp = Format64(ep, 0, ToUnixSeconds(tp));
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ break;
+ case '%':
+ result.push_back('%');
+ break;
+ }
+ pending = ++cur;
+ continue;
+ }
+
+ // Loop if there is no E modifier.
+ if (*cur != 'E' || ++cur == end) continue;
+
+ // Format our extensions.
+ if (*cur == 'z') {
+ // Formats %Ez.
+ if (cur - 2 != pending) {
+ FormatTM(&result, std::string(pending, cur - 2), tm);
+ }
+ bp = FormatOffset(ep, al.offset, ":");
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ pending = ++cur;
+ } else if (*cur == '*' && cur + 1 != end && *(cur + 1) == 'z') {
+ // Formats %E*z.
+ if (cur - 2 != pending) {
+ FormatTM(&result, std::string(pending, cur - 2), tm);
+ }
+ bp = FormatOffset(ep, al.offset, ":*");
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ pending = cur += 2;
+ } else if (*cur == '*' && cur + 1 != end &&
+ (*(cur + 1) == 'S' || *(cur + 1) == 'f')) {
+ // Formats %E*S or %E*F.
+ if (cur - 2 != pending) {
+ FormatTM(&result, std::string(pending, cur - 2), tm);
+ }
+ char* cp = ep;
+ bp = Format64(cp, 15, fs.count());
+ while (cp != bp && cp[-1] == '0') --cp;
+ switch (*(cur + 1)) {
+ case 'S':
+ if (cp != bp) *--bp = '.';
+ bp = Format02d(bp, al.cs.second());
+ break;
+ case 'f':
+ if (cp == bp) *--bp = '0';
+ break;
+ }
+ result.append(bp, static_cast<std::size_t>(cp - bp));
+ pending = cur += 2;
+ } else if (*cur == '4' && cur + 1 != end && *(cur + 1) == 'Y') {
+ // Formats %E4Y.
+ if (cur - 2 != pending) {
+ FormatTM(&result, std::string(pending, cur - 2), tm);
+ }
+ bp = Format64(ep, 4, al.cs.year());
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ pending = cur += 2;
+ } else if (std::isdigit(*cur)) {
+ // Possibly found %E#S or %E#f.
+ int n = 0;
+ if (const char* np = ParseInt(cur, 0, 0, 1024, &n)) {
+ if (*np == 'S' || *np == 'f') {
+ // Formats %E#S or %E#f.
+ if (cur - 2 != pending) {
+ FormatTM(&result, std::string(pending, cur - 2), tm);
+ }
+ bp = ep;
+ if (n > 0) {
+ if (n > kDigits10_64) n = kDigits10_64;
+ bp = Format64(bp, n, (n > 15) ? fs.count() * kExp10[n - 15]
+ : fs.count() / kExp10[15 - n]);
+ if (*np == 'S') *--bp = '.';
+ }
+ if (*np == 'S') bp = Format02d(bp, al.cs.second());
+ result.append(bp, static_cast<std::size_t>(ep - bp));
+ pending = cur = ++np;
+ }
+ }
+ }
+ }
+
+ // Formats any remaining data.
+ if (end != pending) {
+ FormatTM(&result, std::string(pending, end), tm);
+ }
+
+ return result;
+}
+
+namespace {
+
+const char* ParseOffset(const char* dp, const char* mode, int* offset) {
+ if (dp != nullptr) {
+ const char first = *dp++;
+ if (first == '+' || first == '-') {
+ char sep = mode[0];
+ int hours = 0;
+ int minutes = 0;
+ int seconds = 0;
+ const char* ap = ParseInt(dp, 2, 0, 23, &hours);
+ if (ap != nullptr && ap - dp == 2) {
+ dp = ap;
+ if (sep != '\0' && *ap == sep) ++ap;
+ const char* bp = ParseInt(ap, 2, 0, 59, &minutes);
+ if (bp != nullptr && bp - ap == 2) {
+ dp = bp;
+ if (sep != '\0' && *bp == sep) ++bp;
+ const char* cp = ParseInt(bp, 2, 0, 59, &seconds);
+ if (cp != nullptr && cp - bp == 2) dp = cp;
+ }
+ *offset = ((hours * 60 + minutes) * 60) + seconds;
+ if (first == '-') *offset = -*offset;
+ } else {
+ dp = nullptr;
+ }
+ } else if (first == 'Z') { // Zulu
+ *offset = 0;
+ } else {
+ dp = nullptr;
+ }
+ }
+ return dp;
+}
+
+const char* ParseZone(const char* dp, std::string* zone) {
+ zone->clear();
+ if (dp != nullptr) {
+ while (*dp != '\0' && !std::isspace(*dp)) zone->push_back(*dp++);
+ if (zone->empty()) dp = nullptr;
+ }
+ return dp;
+}
+
+const char* ParseSubSeconds(const char* dp, detail::femtoseconds* subseconds) {
+ if (dp != nullptr) {
+ std::int_fast64_t v = 0;
+ std::int_fast64_t exp = 0;
+ const char* const bp = dp;
+ while (const char* cp = strchr(kDigits, *dp)) {
+ int d = static_cast<int>(cp - kDigits);
+ if (d >= 10) break;
+ if (exp < 15) {
+ exp += 1;
+ v *= 10;
+ v += d;
+ }
+ ++dp;
+ }
+ if (dp != bp) {
+ v *= kExp10[15 - exp];
+ *subseconds = detail::femtoseconds(v);
+ } else {
+ dp = nullptr;
+ }
+ }
+ return dp;
+}
+
+// Parses a std::string into a std::tm using strptime(3).
+const char* ParseTM(const char* dp, const char* fmt, std::tm* tm) {
+ if (dp != nullptr) {
+ dp = strptime(dp, fmt, tm);
+ }
+ return dp;
+}
+
+} // namespace
+
+// Uses strptime(3) to parse the given input. Supports the same extended
+// format specifiers as format(), although %E#S and %E*S are treated
+// identically (and similarly for %E#f and %E*f). %Ez and %E*z also accept
+// the same inputs.
+//
+// The standard specifiers from RFC3339_* (%Y, %m, %d, %H, %M, and %S) are
+// handled internally so that we can normally avoid strptime() altogether
+// (which is particularly helpful when the native implementation is broken).
+//
+// The TZ/GNU %s extension is handled internally because strptime() has to
+// use localtime_r() to generate it, and that assumes the local time zone.
+//
+// We also handle the %z specifier to accommodate platforms that do not
+// support the tm_gmtoff extension to std::tm. %Z is parsed but ignored.
+bool parse(const std::string& format, const std::string& input,
+ const time_zone& tz, time_point<sys_seconds>* sec,
+ detail::femtoseconds* fs, std::string* err) {
+ // The unparsed input.
+ const char* data = input.c_str(); // NUL terminated
+
+ // Skips leading whitespace.
+ while (std::isspace(*data)) ++data;
+
+ const year_t kyearmax = std::numeric_limits<year_t>::max();
+ const year_t kyearmin = std::numeric_limits<year_t>::min();
+
+ // Sets default values for unspecified fields.
+ bool saw_year = false;
+ year_t year = 1970;
+ std::tm tm{};
+ tm.tm_year = 1970 - 1900;
+ tm.tm_mon = 1 - 1; // Jan
+ tm.tm_mday = 1;
+ tm.tm_hour = 0;
+ tm.tm_min = 0;
+ tm.tm_sec = 0;
+ tm.tm_wday = 4; // Thu
+ tm.tm_yday = 0;
+ tm.tm_isdst = 0;
+ auto subseconds = detail::femtoseconds::zero();
+ bool saw_offset = false;
+ int offset = 0; // No offset from passed tz.
+ std::string zone = "UTC";
+
+ const char* fmt = format.c_str(); // NUL terminated
+ bool twelve_hour = false;
+ bool afternoon = false;
+
+ bool saw_percent_s = false;
+ std::int_fast64_t percent_s = 0;
+
+ // Steps through format, one specifier at a time.
+ while (data != nullptr && *fmt != '\0') {
+ if (std::isspace(*fmt)) {
+ while (std::isspace(*data)) ++data;
+ while (std::isspace(*++fmt)) continue;
+ continue;
+ }
+
+ if (*fmt != '%') {
+ if (*data == *fmt) {
+ ++data;
+ ++fmt;
+ } else {
+ data = nullptr;
+ }
+ continue;
+ }
+
+ const char* percent = fmt;
+ if (*++fmt == '\0') {
+ data = nullptr;
+ continue;
+ }
+ switch (*fmt++) {
+ case 'Y':
+ // Symmetrically with FormatTime(), directly handing %Y avoids the
+ // tm.tm_year overflow problem. However, tm.tm_year will still be
+ // used by other specifiers like %D.
+ data = ParseInt(data, 0, kyearmin, kyearmax, &year);
+ if (data != nullptr) saw_year = true;
+ continue;
+ case 'm':
+ data = ParseInt(data, 2, 1, 12, &tm.tm_mon);
+ if (data != nullptr) tm.tm_mon -= 1;
+ continue;
+ case 'd':
+ case 'e':
+ data = ParseInt(data, 2, 1, 31, &tm.tm_mday);
+ continue;
+ case 'H':
+ data = ParseInt(data, 2, 0, 23, &tm.tm_hour);
+ twelve_hour = false;
+ continue;
+ case 'M':
+ data = ParseInt(data, 2, 0, 59, &tm.tm_min);
+ continue;
+ case 'S':
+ data = ParseInt(data, 2, 0, 60, &tm.tm_sec);
+ continue;
+ case 'I':
+ case 'l':
+ case 'r': // probably uses %I
+ twelve_hour = true;
+ break;
+ case 'R': // uses %H
+ case 'T': // uses %H
+ case 'c': // probably uses %H
+ case 'X': // probably uses %H
+ twelve_hour = false;
+ break;
+ case 'z':
+ data = ParseOffset(data, "", &offset);
+ if (data != nullptr) saw_offset = true;
+ continue;
+ case 'Z': // ignored; zone abbreviations are ambiguous
+ data = ParseZone(data, &zone);
+ continue;
+ case 's':
+ data = ParseInt(data, 0,
+ std::numeric_limits<std::int_fast64_t>::min(),
+ std::numeric_limits<std::int_fast64_t>::max(),
+ &percent_s);
+ if (data != nullptr) saw_percent_s = true;
+ continue;
+ case '%':
+ data = (*data == '%' ? data + 1 : nullptr);
+ continue;
+ case 'E':
+ if (*fmt == 'z' || (*fmt == '*' && *(fmt + 1) == 'z')) {
+ data = ParseOffset(data, ":", &offset);
+ if (data != nullptr) saw_offset = true;
+ fmt += (*fmt == 'z') ? 1 : 2;
+ continue;
+ }
+ if (*fmt == '*' && *(fmt + 1) == 'S') {
+ data = ParseInt(data, 2, 0, 60, &tm.tm_sec);
+ if (data != nullptr && *data == '.') {
+ data = ParseSubSeconds(data + 1, &subseconds);
+ }
+ fmt += 2;
+ continue;
+ }
+ if (*fmt == '*' && *(fmt + 1) == 'f') {
+ if (data != nullptr && std::isdigit(*data)) {
+ data = ParseSubSeconds(data, &subseconds);
+ }
+ fmt += 2;
+ continue;
+ }
+ if (*fmt == '4' && *(fmt + 1) == 'Y') {
+ const char* bp = data;
+ data = ParseInt(data, 4, year_t{-999}, year_t{9999}, &year);
+ if (data != nullptr) {
+ if (data - bp == 4) {
+ saw_year = true;
+ } else {
+ data = nullptr; // stopped too soon
+ }
+ }
+ fmt += 2;
+ continue;
+ }
+ if (std::isdigit(*fmt)) {
+ int n = 0; // value ignored
+ if (const char* np = ParseInt(fmt, 0, 0, 1024, &n)) {
+ if (*np == 'S') {
+ data = ParseInt(data, 2, 0, 60, &tm.tm_sec);
+ if (data != nullptr && *data == '.') {
+ data = ParseSubSeconds(data + 1, &subseconds);
+ }
+ fmt = ++np;
+ continue;
+ }
+ if (*np == 'f') {
+ if (data != nullptr && std::isdigit(*data)) {
+ data = ParseSubSeconds(data, &subseconds);
+ }
+ fmt = ++np;
+ continue;
+ }
+ }
+ }
+ if (*fmt == 'c') twelve_hour = false; // probably uses %H
+ if (*fmt == 'X') twelve_hour = false; // probably uses %H
+ if (*fmt != '\0') ++fmt;
+ break;
+ case 'O':
+ if (*fmt == 'H') twelve_hour = false;
+ if (*fmt == 'I') twelve_hour = true;
+ if (*fmt != '\0') ++fmt;
+ break;
+ }
+
+ // Parses the current specifier.
+ const char* orig_data = data;
+ std::string spec(percent, static_cast<std::size_t>(fmt - percent));
+ data = ParseTM(data, spec.c_str(), &tm);
+
+ // If we successfully parsed %p we need to remember whether the result
+ // was AM or PM so that we can adjust tm_hour before ConvertDateTime().
+ // So reparse the input with a known AM hour, and check if it is shifted
+ // to a PM hour.
+ if (spec == "%p" && data != nullptr) {
+ std::string test_input = "1";
+ test_input.append(orig_data, static_cast<std::size_t>(data - orig_data));
+ const char* test_data = test_input.c_str();
+ std::tm tmp{};
+ ParseTM(test_data, "%I%p", &tmp);
+ afternoon = (tmp.tm_hour == 13);
+ }
+ }
+
+ // Adjust a 12-hour tm_hour value if it should be in the afternoon.
+ if (twelve_hour && afternoon && tm.tm_hour < 12) {
+ tm.tm_hour += 12;
+ }
+
+ if (data == nullptr) {
+ if (err != nullptr) *err = "Failed to parse input";
+ return false;
+ }
+
+ // Skip any remaining whitespace.
+ while (std::isspace(*data)) ++data;
+
+ // parse() must consume the entire input std::string.
+ if (*data != '\0') {
+ if (err != nullptr) *err = "Illegal trailing data in input string";
+ return false;
+ }
+
+ // If we saw %s then we ignore anything else and return that time.
+ if (saw_percent_s) {
+ *sec = FromUnixSeconds(percent_s);
+ *fs = detail::femtoseconds::zero();
+ return true;
+ }
+
+ // If we saw %z, %Ez, or %E*z then we want to interpret the parsed fields
+ // in UTC and then shift by that offset. Otherwise we want to interpret
+ // the fields directly in the passed time_zone.
+ time_zone ptz = saw_offset ? utc_time_zone() : tz;
+
+ // Allows a leap second of 60 to normalize forward to the following ":00".
+ if (tm.tm_sec == 60) {
+ tm.tm_sec -= 1;
+ offset -= 1;
+ subseconds = detail::femtoseconds::zero();
+ }
+
+ if (!saw_year) {
+ year = year_t{tm.tm_year};
+ if (year > kyearmax - 1900) {
+ // Platform-dependent, maybe unreachable.
+ if (err != nullptr) *err = "Out-of-range year";
+ return false;
+ }
+ year += 1900;
+ }
+
+ const int month = tm.tm_mon + 1;
+ civil_second cs(year, month, tm.tm_mday, tm.tm_hour, tm.tm_min, tm.tm_sec);
+
+ // parse() should not allow normalization. Due to the restricted field
+ // ranges above (see ParseInt()), the only possibility is for days to roll
+ // into months. That is, parsing "Sep 31" should not produce "Oct 1".
+ if (cs.month() != month || cs.day() != tm.tm_mday) {
+ if (err != nullptr) *err = "Out-of-range field";
+ return false;
+ }
+
+ // Accounts for the offset adjustment before converting to absolute time.
+ if ((offset < 0 && cs > civil_second::max() + offset) ||
+ (offset > 0 && cs < civil_second::min() + offset)) {
+ if (err != nullptr) *err = "Out-of-range field";
+ return false;
+ }
+ cs -= offset;
+
+ const auto tp = ptz.lookup(cs).pre;
+ // Checks for overflow/underflow and returns an error as necessary.
+ if (tp == time_point<sys_seconds>::max()) {
+ const auto al = ptz.lookup(time_point<sys_seconds>::max());
+ if (cs > al.cs) {
+ if (err != nullptr) *err = "Out-of-range field";
+ return false;
+ }
+ }
+ if (tp == time_point<sys_seconds>::min()) {
+ const auto al = ptz.lookup(time_point<sys_seconds>::min());
+ if (cs < al.cs) {
+ if (err != nullptr) *err = "Out-of-range field";
+ return false;
+ }
+ }
+
+ *sec = tp;
+ *fs = subseconds;
+ return true;
+}
+
+} // namespace detail
+} // namespace cctz
+} // namespace time_internal
+} // namespace absl
[33/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_stream_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_stream_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_stream_test.cc
new file mode 100644
index 0000000..09efaad
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_stream_test.cc
@@ -0,0 +1,666 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/numeric/int128.h"
+
+#include <sstream>
+#include <string>
+
+#include "gtest/gtest.h"
+
+namespace {
+
+struct Uint128TestCase {
+ absl::uint128 value;
+ std::ios_base::fmtflags flags;
+ std::streamsize width;
+ const char* expected;
+};
+
+constexpr char kFill = '_';
+
+std::string StreamFormatToString(std::ios_base::fmtflags flags,
+ std::streamsize width) {
+ std::vector<const char*> flagstr;
+ switch (flags & std::ios::basefield) {
+ case std::ios::dec:
+ flagstr.push_back("std::ios::dec");
+ break;
+ case std::ios::oct:
+ flagstr.push_back("std::ios::oct");
+ break;
+ case std::ios::hex:
+ flagstr.push_back("std::ios::hex");
+ break;
+ default: // basefield not specified
+ break;
+ }
+ switch (flags & std::ios::adjustfield) {
+ case std::ios::left:
+ flagstr.push_back("std::ios::left");
+ break;
+ case std::ios::internal:
+ flagstr.push_back("std::ios::internal");
+ break;
+ case std::ios::right:
+ flagstr.push_back("std::ios::right");
+ break;
+ default: // adjustfield not specified
+ break;
+ }
+ if (flags & std::ios::uppercase) flagstr.push_back("std::ios::uppercase");
+ if (flags & std::ios::showbase) flagstr.push_back("std::ios::showbase");
+ if (flags & std::ios::showpos) flagstr.push_back("std::ios::showpos");
+
+ std::ostringstream msg;
+ msg << "\n StreamFormatToString(test_case.flags, test_case.width)\n "
+ "flags: ";
+ if (!flagstr.empty()) {
+ for (size_t i = 0; i < flagstr.size() - 1; ++i) msg << flagstr[i] << " | ";
+ msg << flagstr.back();
+ } else {
+ msg << "(default)";
+ }
+ msg << "\n width: " << width << "\n fill: '" << kFill << "'";
+ return msg.str();
+}
+
+void CheckUint128Case(const Uint128TestCase& test_case) {
+ std::ostringstream os;
+ os.flags(test_case.flags);
+ os.width(test_case.width);
+ os.fill(kFill);
+ os << test_case.value;
+ SCOPED_TRACE(StreamFormatToString(test_case.flags, test_case.width));
+ EXPECT_EQ(test_case.expected, os.str());
+}
+
+constexpr std::ios::fmtflags kDec = std::ios::dec;
+constexpr std::ios::fmtflags kOct = std::ios::oct;
+constexpr std::ios::fmtflags kHex = std::ios::hex;
+constexpr std::ios::fmtflags kLeft = std::ios::left;
+constexpr std::ios::fmtflags kInt = std::ios::internal;
+constexpr std::ios::fmtflags kRight = std::ios::right;
+constexpr std::ios::fmtflags kUpper = std::ios::uppercase;
+constexpr std::ios::fmtflags kBase = std::ios::showbase;
+constexpr std::ios::fmtflags kPos = std::ios::showpos;
+
+TEST(Uint128, OStreamValueTest) {
+ CheckUint128Case({1, kDec, /*width = */ 0, "1"});
+ CheckUint128Case({1, kOct, /*width = */ 0, "1"});
+ CheckUint128Case({1, kHex, /*width = */ 0, "1"});
+ CheckUint128Case({9, kDec, /*width = */ 0, "9"});
+ CheckUint128Case({9, kOct, /*width = */ 0, "11"});
+ CheckUint128Case({9, kHex, /*width = */ 0, "9"});
+ CheckUint128Case({12345, kDec, /*width = */ 0, "12345"});
+ CheckUint128Case({12345, kOct, /*width = */ 0, "30071"});
+ CheckUint128Case({12345, kHex, /*width = */ 0, "3039"});
+ CheckUint128Case(
+ {0x8000000000000000, kDec, /*width = */ 0, "9223372036854775808"});
+ CheckUint128Case(
+ {0x8000000000000000, kOct, /*width = */ 0, "1000000000000000000000"});
+ CheckUint128Case(
+ {0x8000000000000000, kHex, /*width = */ 0, "8000000000000000"});
+ CheckUint128Case({std::numeric_limits<uint64_t>::max(), kDec,
+ /*width = */ 0, "18446744073709551615"});
+ CheckUint128Case({std::numeric_limits<uint64_t>::max(), kOct,
+ /*width = */ 0, "1777777777777777777777"});
+ CheckUint128Case({std::numeric_limits<uint64_t>::max(), kHex,
+ /*width = */ 0, "ffffffffffffffff"});
+ CheckUint128Case(
+ {absl::MakeUint128(1, 0), kDec, /*width = */ 0, "18446744073709551616"});
+ CheckUint128Case({absl::MakeUint128(1, 0), kOct, /*width = */ 0,
+ "2000000000000000000000"});
+ CheckUint128Case(
+ {absl::MakeUint128(1, 0), kHex, /*width = */ 0, "10000000000000000"});
+ CheckUint128Case({absl::MakeUint128(0x8000000000000000, 0), kDec,
+ /*width = */ 0, "170141183460469231731687303715884105728"});
+ CheckUint128Case({absl::MakeUint128(0x8000000000000000, 0), kOct,
+ /*width = */ 0,
+ "2000000000000000000000000000000000000000000"});
+ CheckUint128Case({absl::MakeUint128(0x8000000000000000, 0), kHex,
+ /*width = */ 0, "80000000000000000000000000000000"});
+ CheckUint128Case({absl::kuint128max, kDec, /*width = */ 0,
+ "340282366920938463463374607431768211455"});
+ CheckUint128Case({absl::kuint128max, kOct, /*width = */ 0,
+ "3777777777777777777777777777777777777777777"});
+ CheckUint128Case({absl::kuint128max, kHex, /*width = */ 0,
+ "ffffffffffffffffffffffffffffffff"});
+}
+
+std::vector<Uint128TestCase> GetUint128FormatCases();
+
+TEST(Uint128, OStreamFormatTest) {
+ for (const Uint128TestCase& test_case : GetUint128FormatCases()) {
+ CheckUint128Case(test_case);
+ }
+}
+
+std::vector<Uint128TestCase> GetUint128FormatCases() {
+ return {
+ {0, std::ios_base::fmtflags(), /*width = */ 0, "0"},
+ {0, std::ios_base::fmtflags(), /*width = */ 6, "_____0"},
+ {0, kPos, /*width = */ 0, "0"},
+ {0, kPos, /*width = */ 6, "_____0"},
+ {0, kBase, /*width = */ 0, "0"},
+ {0, kBase, /*width = */ 6, "_____0"},
+ {0, kBase | kPos, /*width = */ 0, "0"},
+ {0, kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kUpper, /*width = */ 0, "0"},
+ {0, kUpper, /*width = */ 6, "_____0"},
+ {0, kUpper | kPos, /*width = */ 0, "0"},
+ {0, kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kUpper | kBase, /*width = */ 0, "0"},
+ {0, kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kLeft, /*width = */ 0, "0"},
+ {0, kLeft, /*width = */ 6, "0_____"},
+ {0, kLeft | kPos, /*width = */ 0, "0"},
+ {0, kLeft | kPos, /*width = */ 6, "0_____"},
+ {0, kLeft | kBase, /*width = */ 0, "0"},
+ {0, kLeft | kBase, /*width = */ 6, "0_____"},
+ {0, kLeft | kBase | kPos, /*width = */ 0, "0"},
+ {0, kLeft | kBase | kPos, /*width = */ 6, "0_____"},
+ {0, kLeft | kUpper, /*width = */ 0, "0"},
+ {0, kLeft | kUpper, /*width = */ 6, "0_____"},
+ {0, kLeft | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
+ {0, kLeft | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
+ {0, kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
+ {0, kInt, /*width = */ 0, "0"},
+ {0, kInt, /*width = */ 6, "_____0"},
+ {0, kInt | kPos, /*width = */ 0, "0"},
+ {0, kInt | kPos, /*width = */ 6, "_____0"},
+ {0, kInt | kBase, /*width = */ 0, "0"},
+ {0, kInt | kBase, /*width = */ 6, "_____0"},
+ {0, kInt | kBase | kPos, /*width = */ 0, "0"},
+ {0, kInt | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kInt | kUpper, /*width = */ 0, "0"},
+ {0, kInt | kUpper, /*width = */ 6, "_____0"},
+ {0, kInt | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kInt | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kInt | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kInt | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kRight, /*width = */ 0, "0"},
+ {0, kRight, /*width = */ 6, "_____0"},
+ {0, kRight | kPos, /*width = */ 0, "0"},
+ {0, kRight | kPos, /*width = */ 6, "_____0"},
+ {0, kRight | kBase, /*width = */ 0, "0"},
+ {0, kRight | kBase, /*width = */ 6, "_____0"},
+ {0, kRight | kBase | kPos, /*width = */ 0, "0"},
+ {0, kRight | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kRight | kUpper, /*width = */ 0, "0"},
+ {0, kRight | kUpper, /*width = */ 6, "_____0"},
+ {0, kRight | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kRight | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kRight | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kRight | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kDec, /*width = */ 0, "0"},
+ {0, kDec, /*width = */ 6, "_____0"},
+ {0, kDec | kPos, /*width = */ 0, "0"},
+ {0, kDec | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kBase, /*width = */ 0, "0"},
+ {0, kDec | kBase, /*width = */ 6, "_____0"},
+ {0, kDec | kBase | kPos, /*width = */ 0, "0"},
+ {0, kDec | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kUpper, /*width = */ 0, "0"},
+ {0, kDec | kUpper, /*width = */ 6, "_____0"},
+ {0, kDec | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kDec | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kDec | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kDec | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kDec | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kLeft, /*width = */ 0, "0"},
+ {0, kDec | kLeft, /*width = */ 6, "0_____"},
+ {0, kDec | kLeft | kPos, /*width = */ 0, "0"},
+ {0, kDec | kLeft | kPos, /*width = */ 6, "0_____"},
+ {0, kDec | kLeft | kBase, /*width = */ 0, "0"},
+ {0, kDec | kLeft | kBase, /*width = */ 6, "0_____"},
+ {0, kDec | kLeft | kBase | kPos, /*width = */ 0, "0"},
+ {0, kDec | kLeft | kBase | kPos, /*width = */ 6, "0_____"},
+ {0, kDec | kLeft | kUpper, /*width = */ 0, "0"},
+ {0, kDec | kLeft | kUpper, /*width = */ 6, "0_____"},
+ {0, kDec | kLeft | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kDec | kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
+ {0, kDec | kLeft | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kDec | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
+ {0, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
+ {0, kDec | kInt, /*width = */ 0, "0"},
+ {0, kDec | kInt, /*width = */ 6, "_____0"},
+ {0, kDec | kInt | kPos, /*width = */ 0, "0"},
+ {0, kDec | kInt | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kInt | kBase, /*width = */ 0, "0"},
+ {0, kDec | kInt | kBase, /*width = */ 6, "_____0"},
+ {0, kDec | kInt | kBase | kPos, /*width = */ 0, "0"},
+ {0, kDec | kInt | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kInt | kUpper, /*width = */ 0, "0"},
+ {0, kDec | kInt | kUpper, /*width = */ 6, "_____0"},
+ {0, kDec | kInt | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kDec | kInt | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kInt | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kDec | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kDec | kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kDec | kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kRight, /*width = */ 0, "0"},
+ {0, kDec | kRight, /*width = */ 6, "_____0"},
+ {0, kDec | kRight | kPos, /*width = */ 0, "0"},
+ {0, kDec | kRight | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kRight | kBase, /*width = */ 0, "0"},
+ {0, kDec | kRight | kBase, /*width = */ 6, "_____0"},
+ {0, kDec | kRight | kBase | kPos, /*width = */ 0, "0"},
+ {0, kDec | kRight | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kRight | kUpper, /*width = */ 0, "0"},
+ {0, kDec | kRight | kUpper, /*width = */ 6, "_____0"},
+ {0, kDec | kRight | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kDec | kRight | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kDec | kRight | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kDec | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kDec | kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kDec | kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kOct, /*width = */ 0, "0"},
+ {0, kOct, /*width = */ 6, "_____0"},
+ {0, kOct | kPos, /*width = */ 0, "0"},
+ {0, kOct | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kBase, /*width = */ 0, "0"},
+ {0, kOct | kBase, /*width = */ 6, "_____0"},
+ {0, kOct | kBase | kPos, /*width = */ 0, "0"},
+ {0, kOct | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kUpper, /*width = */ 0, "0"},
+ {0, kOct | kUpper, /*width = */ 6, "_____0"},
+ {0, kOct | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kOct | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kOct | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kOct | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kOct | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kLeft, /*width = */ 0, "0"},
+ {0, kOct | kLeft, /*width = */ 6, "0_____"},
+ {0, kOct | kLeft | kPos, /*width = */ 0, "0"},
+ {0, kOct | kLeft | kPos, /*width = */ 6, "0_____"},
+ {0, kOct | kLeft | kBase, /*width = */ 0, "0"},
+ {0, kOct | kLeft | kBase, /*width = */ 6, "0_____"},
+ {0, kOct | kLeft | kBase | kPos, /*width = */ 0, "0"},
+ {0, kOct | kLeft | kBase | kPos, /*width = */ 6, "0_____"},
+ {0, kOct | kLeft | kUpper, /*width = */ 0, "0"},
+ {0, kOct | kLeft | kUpper, /*width = */ 6, "0_____"},
+ {0, kOct | kLeft | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kOct | kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
+ {0, kOct | kLeft | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kOct | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
+ {0, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
+ {0, kOct | kInt, /*width = */ 0, "0"},
+ {0, kOct | kInt, /*width = */ 6, "_____0"},
+ {0, kOct | kInt | kPos, /*width = */ 0, "0"},
+ {0, kOct | kInt | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kInt | kBase, /*width = */ 0, "0"},
+ {0, kOct | kInt | kBase, /*width = */ 6, "_____0"},
+ {0, kOct | kInt | kBase | kPos, /*width = */ 0, "0"},
+ {0, kOct | kInt | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kInt | kUpper, /*width = */ 0, "0"},
+ {0, kOct | kInt | kUpper, /*width = */ 6, "_____0"},
+ {0, kOct | kInt | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kOct | kInt | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kInt | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kOct | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kOct | kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kOct | kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kRight, /*width = */ 0, "0"},
+ {0, kOct | kRight, /*width = */ 6, "_____0"},
+ {0, kOct | kRight | kPos, /*width = */ 0, "0"},
+ {0, kOct | kRight | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kRight | kBase, /*width = */ 0, "0"},
+ {0, kOct | kRight | kBase, /*width = */ 6, "_____0"},
+ {0, kOct | kRight | kBase | kPos, /*width = */ 0, "0"},
+ {0, kOct | kRight | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kRight | kUpper, /*width = */ 0, "0"},
+ {0, kOct | kRight | kUpper, /*width = */ 6, "_____0"},
+ {0, kOct | kRight | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kOct | kRight | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kOct | kRight | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kOct | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kOct | kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kOct | kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kHex, /*width = */ 0, "0"},
+ {0, kHex, /*width = */ 6, "_____0"},
+ {0, kHex | kPos, /*width = */ 0, "0"},
+ {0, kHex | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kBase, /*width = */ 0, "0"},
+ {0, kHex | kBase, /*width = */ 6, "_____0"},
+ {0, kHex | kBase | kPos, /*width = */ 0, "0"},
+ {0, kHex | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kUpper, /*width = */ 0, "0"},
+ {0, kHex | kUpper, /*width = */ 6, "_____0"},
+ {0, kHex | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kHex | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kHex | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kHex | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kHex | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kLeft, /*width = */ 0, "0"},
+ {0, kHex | kLeft, /*width = */ 6, "0_____"},
+ {0, kHex | kLeft | kPos, /*width = */ 0, "0"},
+ {0, kHex | kLeft | kPos, /*width = */ 6, "0_____"},
+ {0, kHex | kLeft | kBase, /*width = */ 0, "0"},
+ {0, kHex | kLeft | kBase, /*width = */ 6, "0_____"},
+ {0, kHex | kLeft | kBase | kPos, /*width = */ 0, "0"},
+ {0, kHex | kLeft | kBase | kPos, /*width = */ 6, "0_____"},
+ {0, kHex | kLeft | kUpper, /*width = */ 0, "0"},
+ {0, kHex | kLeft | kUpper, /*width = */ 6, "0_____"},
+ {0, kHex | kLeft | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kHex | kLeft | kUpper | kPos, /*width = */ 6, "0_____"},
+ {0, kHex | kLeft | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kHex | kLeft | kUpper | kBase, /*width = */ 6, "0_____"},
+ {0, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0_____"},
+ {0, kHex | kInt, /*width = */ 0, "0"},
+ {0, kHex | kInt, /*width = */ 6, "_____0"},
+ {0, kHex | kInt | kPos, /*width = */ 0, "0"},
+ {0, kHex | kInt | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kInt | kBase, /*width = */ 0, "0"},
+ {0, kHex | kInt | kBase, /*width = */ 6, "_____0"},
+ {0, kHex | kInt | kBase | kPos, /*width = */ 0, "0"},
+ {0, kHex | kInt | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kInt | kUpper, /*width = */ 0, "0"},
+ {0, kHex | kInt | kUpper, /*width = */ 6, "_____0"},
+ {0, kHex | kInt | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kHex | kInt | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kInt | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kHex | kInt | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kHex | kInt | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kHex | kInt | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kRight, /*width = */ 0, "0"},
+ {0, kHex | kRight, /*width = */ 6, "_____0"},
+ {0, kHex | kRight | kPos, /*width = */ 0, "0"},
+ {0, kHex | kRight | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kRight | kBase, /*width = */ 0, "0"},
+ {0, kHex | kRight | kBase, /*width = */ 6, "_____0"},
+ {0, kHex | kRight | kBase | kPos, /*width = */ 0, "0"},
+ {0, kHex | kRight | kBase | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kRight | kUpper, /*width = */ 0, "0"},
+ {0, kHex | kRight | kUpper, /*width = */ 6, "_____0"},
+ {0, kHex | kRight | kUpper | kPos, /*width = */ 0, "0"},
+ {0, kHex | kRight | kUpper | kPos, /*width = */ 6, "_____0"},
+ {0, kHex | kRight | kUpper | kBase, /*width = */ 0, "0"},
+ {0, kHex | kRight | kUpper | kBase, /*width = */ 6, "_____0"},
+ {0, kHex | kRight | kUpper | kBase | kPos, /*width = */ 0, "0"},
+ {0, kHex | kRight | kUpper | kBase | kPos, /*width = */ 6, "_____0"},
+ {37, std::ios_base::fmtflags(), /*width = */ 0, "37"},
+ {37, std::ios_base::fmtflags(), /*width = */ 6, "____37"},
+ {37, kPos, /*width = */ 0, "37"},
+ {37, kPos, /*width = */ 6, "____37"},
+ {37, kBase, /*width = */ 0, "37"},
+ {37, kBase, /*width = */ 6, "____37"},
+ {37, kBase | kPos, /*width = */ 0, "37"},
+ {37, kBase | kPos, /*width = */ 6, "____37"},
+ {37, kUpper, /*width = */ 0, "37"},
+ {37, kUpper, /*width = */ 6, "____37"},
+ {37, kUpper | kPos, /*width = */ 0, "37"},
+ {37, kUpper | kPos, /*width = */ 6, "____37"},
+ {37, kUpper | kBase, /*width = */ 0, "37"},
+ {37, kUpper | kBase, /*width = */ 6, "____37"},
+ {37, kUpper | kBase | kPos, /*width = */ 0, "37"},
+ {37, kUpper | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kLeft, /*width = */ 0, "37"},
+ {37, kLeft, /*width = */ 6, "37____"},
+ {37, kLeft | kPos, /*width = */ 0, "37"},
+ {37, kLeft | kPos, /*width = */ 6, "37____"},
+ {37, kLeft | kBase, /*width = */ 0, "37"},
+ {37, kLeft | kBase, /*width = */ 6, "37____"},
+ {37, kLeft | kBase | kPos, /*width = */ 0, "37"},
+ {37, kLeft | kBase | kPos, /*width = */ 6, "37____"},
+ {37, kLeft | kUpper, /*width = */ 0, "37"},
+ {37, kLeft | kUpper, /*width = */ 6, "37____"},
+ {37, kLeft | kUpper | kPos, /*width = */ 0, "37"},
+ {37, kLeft | kUpper | kPos, /*width = */ 6, "37____"},
+ {37, kLeft | kUpper | kBase, /*width = */ 0, "37"},
+ {37, kLeft | kUpper | kBase, /*width = */ 6, "37____"},
+ {37, kLeft | kUpper | kBase | kPos, /*width = */ 0, "37"},
+ {37, kLeft | kUpper | kBase | kPos, /*width = */ 6, "37____"},
+ {37, kInt, /*width = */ 0, "37"},
+ {37, kInt, /*width = */ 6, "____37"},
+ {37, kInt | kPos, /*width = */ 0, "37"},
+ {37, kInt | kPos, /*width = */ 6, "____37"},
+ {37, kInt | kBase, /*width = */ 0, "37"},
+ {37, kInt | kBase, /*width = */ 6, "____37"},
+ {37, kInt | kBase | kPos, /*width = */ 0, "37"},
+ {37, kInt | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kInt | kUpper, /*width = */ 0, "37"},
+ {37, kInt | kUpper, /*width = */ 6, "____37"},
+ {37, kInt | kUpper | kPos, /*width = */ 0, "37"},
+ {37, kInt | kUpper | kPos, /*width = */ 6, "____37"},
+ {37, kInt | kUpper | kBase, /*width = */ 0, "37"},
+ {37, kInt | kUpper | kBase, /*width = */ 6, "____37"},
+ {37, kInt | kUpper | kBase | kPos, /*width = */ 0, "37"},
+ {37, kInt | kUpper | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kRight, /*width = */ 0, "37"},
+ {37, kRight, /*width = */ 6, "____37"},
+ {37, kRight | kPos, /*width = */ 0, "37"},
+ {37, kRight | kPos, /*width = */ 6, "____37"},
+ {37, kRight | kBase, /*width = */ 0, "37"},
+ {37, kRight | kBase, /*width = */ 6, "____37"},
+ {37, kRight | kBase | kPos, /*width = */ 0, "37"},
+ {37, kRight | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kRight | kUpper, /*width = */ 0, "37"},
+ {37, kRight | kUpper, /*width = */ 6, "____37"},
+ {37, kRight | kUpper | kPos, /*width = */ 0, "37"},
+ {37, kRight | kUpper | kPos, /*width = */ 6, "____37"},
+ {37, kRight | kUpper | kBase, /*width = */ 0, "37"},
+ {37, kRight | kUpper | kBase, /*width = */ 6, "____37"},
+ {37, kRight | kUpper | kBase | kPos, /*width = */ 0, "37"},
+ {37, kRight | kUpper | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kDec, /*width = */ 0, "37"},
+ {37, kDec, /*width = */ 6, "____37"},
+ {37, kDec | kPos, /*width = */ 0, "37"},
+ {37, kDec | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kBase, /*width = */ 0, "37"},
+ {37, kDec | kBase, /*width = */ 6, "____37"},
+ {37, kDec | kBase | kPos, /*width = */ 0, "37"},
+ {37, kDec | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kUpper, /*width = */ 0, "37"},
+ {37, kDec | kUpper, /*width = */ 6, "____37"},
+ {37, kDec | kUpper | kPos, /*width = */ 0, "37"},
+ {37, kDec | kUpper | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kUpper | kBase, /*width = */ 0, "37"},
+ {37, kDec | kUpper | kBase, /*width = */ 6, "____37"},
+ {37, kDec | kUpper | kBase | kPos, /*width = */ 0, "37"},
+ {37, kDec | kUpper | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kLeft, /*width = */ 0, "37"},
+ {37, kDec | kLeft, /*width = */ 6, "37____"},
+ {37, kDec | kLeft | kPos, /*width = */ 0, "37"},
+ {37, kDec | kLeft | kPos, /*width = */ 6, "37____"},
+ {37, kDec | kLeft | kBase, /*width = */ 0, "37"},
+ {37, kDec | kLeft | kBase, /*width = */ 6, "37____"},
+ {37, kDec | kLeft | kBase | kPos, /*width = */ 0, "37"},
+ {37, kDec | kLeft | kBase | kPos, /*width = */ 6, "37____"},
+ {37, kDec | kLeft | kUpper, /*width = */ 0, "37"},
+ {37, kDec | kLeft | kUpper, /*width = */ 6, "37____"},
+ {37, kDec | kLeft | kUpper | kPos, /*width = */ 0, "37"},
+ {37, kDec | kLeft | kUpper | kPos, /*width = */ 6, "37____"},
+ {37, kDec | kLeft | kUpper | kBase, /*width = */ 0, "37"},
+ {37, kDec | kLeft | kUpper | kBase, /*width = */ 6, "37____"},
+ {37, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 0, "37"},
+ {37, kDec | kLeft | kUpper | kBase | kPos, /*width = */ 6, "37____"},
+ {37, kDec | kInt, /*width = */ 0, "37"},
+ {37, kDec | kInt, /*width = */ 6, "____37"},
+ {37, kDec | kInt | kPos, /*width = */ 0, "37"},
+ {37, kDec | kInt | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kInt | kBase, /*width = */ 0, "37"},
+ {37, kDec | kInt | kBase, /*width = */ 6, "____37"},
+ {37, kDec | kInt | kBase | kPos, /*width = */ 0, "37"},
+ {37, kDec | kInt | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kInt | kUpper, /*width = */ 0, "37"},
+ {37, kDec | kInt | kUpper, /*width = */ 6, "____37"},
+ {37, kDec | kInt | kUpper | kPos, /*width = */ 0, "37"},
+ {37, kDec | kInt | kUpper | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kInt | kUpper | kBase, /*width = */ 0, "37"},
+ {37, kDec | kInt | kUpper | kBase, /*width = */ 6, "____37"},
+ {37, kDec | kInt | kUpper | kBase | kPos, /*width = */ 0, "37"},
+ {37, kDec | kInt | kUpper | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kRight, /*width = */ 0, "37"},
+ {37, kDec | kRight, /*width = */ 6, "____37"},
+ {37, kDec | kRight | kPos, /*width = */ 0, "37"},
+ {37, kDec | kRight | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kRight | kBase, /*width = */ 0, "37"},
+ {37, kDec | kRight | kBase, /*width = */ 6, "____37"},
+ {37, kDec | kRight | kBase | kPos, /*width = */ 0, "37"},
+ {37, kDec | kRight | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kRight | kUpper, /*width = */ 0, "37"},
+ {37, kDec | kRight | kUpper, /*width = */ 6, "____37"},
+ {37, kDec | kRight | kUpper | kPos, /*width = */ 0, "37"},
+ {37, kDec | kRight | kUpper | kPos, /*width = */ 6, "____37"},
+ {37, kDec | kRight | kUpper | kBase, /*width = */ 0, "37"},
+ {37, kDec | kRight | kUpper | kBase, /*width = */ 6, "____37"},
+ {37, kDec | kRight | kUpper | kBase | kPos, /*width = */ 0, "37"},
+ {37, kDec | kRight | kUpper | kBase | kPos, /*width = */ 6, "____37"},
+ {37, kOct, /*width = */ 0, "45"},
+ {37, kOct, /*width = */ 6, "____45"},
+ {37, kOct | kPos, /*width = */ 0, "45"},
+ {37, kOct | kPos, /*width = */ 6, "____45"},
+ {37, kOct | kBase, /*width = */ 0, "045"},
+ {37, kOct | kBase, /*width = */ 6, "___045"},
+ {37, kOct | kBase | kPos, /*width = */ 0, "045"},
+ {37, kOct | kBase | kPos, /*width = */ 6, "___045"},
+ {37, kOct | kUpper, /*width = */ 0, "45"},
+ {37, kOct | kUpper, /*width = */ 6, "____45"},
+ {37, kOct | kUpper | kPos, /*width = */ 0, "45"},
+ {37, kOct | kUpper | kPos, /*width = */ 6, "____45"},
+ {37, kOct | kUpper | kBase, /*width = */ 0, "045"},
+ {37, kOct | kUpper | kBase, /*width = */ 6, "___045"},
+ {37, kOct | kUpper | kBase | kPos, /*width = */ 0, "045"},
+ {37, kOct | kUpper | kBase | kPos, /*width = */ 6, "___045"},
+ {37, kOct | kLeft, /*width = */ 0, "45"},
+ {37, kOct | kLeft, /*width = */ 6, "45____"},
+ {37, kOct | kLeft | kPos, /*width = */ 0, "45"},
+ {37, kOct | kLeft | kPos, /*width = */ 6, "45____"},
+ {37, kOct | kLeft | kBase, /*width = */ 0, "045"},
+ {37, kOct | kLeft | kBase, /*width = */ 6, "045___"},
+ {37, kOct | kLeft | kBase | kPos, /*width = */ 0, "045"},
+ {37, kOct | kLeft | kBase | kPos, /*width = */ 6, "045___"},
+ {37, kOct | kLeft | kUpper, /*width = */ 0, "45"},
+ {37, kOct | kLeft | kUpper, /*width = */ 6, "45____"},
+ {37, kOct | kLeft | kUpper | kPos, /*width = */ 0, "45"},
+ {37, kOct | kLeft | kUpper | kPos, /*width = */ 6, "45____"},
+ {37, kOct | kLeft | kUpper | kBase, /*width = */ 0, "045"},
+ {37, kOct | kLeft | kUpper | kBase, /*width = */ 6, "045___"},
+ {37, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 0, "045"},
+ {37, kOct | kLeft | kUpper | kBase | kPos, /*width = */ 6, "045___"},
+ {37, kOct | kInt, /*width = */ 0, "45"},
+ {37, kOct | kInt, /*width = */ 6, "____45"},
+ {37, kOct | kInt | kPos, /*width = */ 0, "45"},
+ {37, kOct | kInt | kPos, /*width = */ 6, "____45"},
+ {37, kOct | kInt | kBase, /*width = */ 0, "045"},
+ {37, kOct | kInt | kBase, /*width = */ 6, "___045"},
+ {37, kOct | kInt | kBase | kPos, /*width = */ 0, "045"},
+ {37, kOct | kInt | kBase | kPos, /*width = */ 6, "___045"},
+ {37, kOct | kInt | kUpper, /*width = */ 0, "45"},
+ {37, kOct | kInt | kUpper, /*width = */ 6, "____45"},
+ {37, kOct | kInt | kUpper | kPos, /*width = */ 0, "45"},
+ {37, kOct | kInt | kUpper | kPos, /*width = */ 6, "____45"},
+ {37, kOct | kInt | kUpper | kBase, /*width = */ 0, "045"},
+ {37, kOct | kInt | kUpper | kBase, /*width = */ 6, "___045"},
+ {37, kOct | kInt | kUpper | kBase | kPos, /*width = */ 0, "045"},
+ {37, kOct | kInt | kUpper | kBase | kPos, /*width = */ 6, "___045"},
+ {37, kOct | kRight, /*width = */ 0, "45"},
+ {37, kOct | kRight, /*width = */ 6, "____45"},
+ {37, kOct | kRight | kPos, /*width = */ 0, "45"},
+ {37, kOct | kRight | kPos, /*width = */ 6, "____45"},
+ {37, kOct | kRight | kBase, /*width = */ 0, "045"},
+ {37, kOct | kRight | kBase, /*width = */ 6, "___045"},
+ {37, kOct | kRight | kBase | kPos, /*width = */ 0, "045"},
+ {37, kOct | kRight | kBase | kPos, /*width = */ 6, "___045"},
+ {37, kOct | kRight | kUpper, /*width = */ 0, "45"},
+ {37, kOct | kRight | kUpper, /*width = */ 6, "____45"},
+ {37, kOct | kRight | kUpper | kPos, /*width = */ 0, "45"},
+ {37, kOct | kRight | kUpper | kPos, /*width = */ 6, "____45"},
+ {37, kOct | kRight | kUpper | kBase, /*width = */ 0, "045"},
+ {37, kOct | kRight | kUpper | kBase, /*width = */ 6, "___045"},
+ {37, kOct | kRight | kUpper | kBase | kPos, /*width = */ 0, "045"},
+ {37, kOct | kRight | kUpper | kBase | kPos, /*width = */ 6, "___045"},
+ {37, kHex, /*width = */ 0, "25"},
+ {37, kHex, /*width = */ 6, "____25"},
+ {37, kHex | kPos, /*width = */ 0, "25"},
+ {37, kHex | kPos, /*width = */ 6, "____25"},
+ {37, kHex | kBase, /*width = */ 0, "0x25"},
+ {37, kHex | kBase, /*width = */ 6, "__0x25"},
+ {37, kHex | kBase | kPos, /*width = */ 0, "0x25"},
+ {37, kHex | kBase | kPos, /*width = */ 6, "__0x25"},
+ {37, kHex | kUpper, /*width = */ 0, "25"},
+ {37, kHex | kUpper, /*width = */ 6, "____25"},
+ {37, kHex | kUpper | kPos, /*width = */ 0, "25"},
+ {37, kHex | kUpper | kPos, /*width = */ 6, "____25"},
+ {37, kHex | kUpper | kBase, /*width = */ 0, "0X25"},
+ {37, kHex | kUpper | kBase, /*width = */ 6, "__0X25"},
+ {37, kHex | kUpper | kBase | kPos, /*width = */ 0, "0X25"},
+ {37, kHex | kUpper | kBase | kPos, /*width = */ 6, "__0X25"},
+ {37, kHex | kLeft, /*width = */ 0, "25"},
+ {37, kHex | kLeft, /*width = */ 6, "25____"},
+ {37, kHex | kLeft | kPos, /*width = */ 0, "25"},
+ {37, kHex | kLeft | kPos, /*width = */ 6, "25____"},
+ {37, kHex | kLeft | kBase, /*width = */ 0, "0x25"},
+ {37, kHex | kLeft | kBase, /*width = */ 6, "0x25__"},
+ {37, kHex | kLeft | kBase | kPos, /*width = */ 0, "0x25"},
+ {37, kHex | kLeft | kBase | kPos, /*width = */ 6, "0x25__"},
+ {37, kHex | kLeft | kUpper, /*width = */ 0, "25"},
+ {37, kHex | kLeft | kUpper, /*width = */ 6, "25____"},
+ {37, kHex | kLeft | kUpper | kPos, /*width = */ 0, "25"},
+ {37, kHex | kLeft | kUpper | kPos, /*width = */ 6, "25____"},
+ {37, kHex | kLeft | kUpper | kBase, /*width = */ 0, "0X25"},
+ {37, kHex | kLeft | kUpper | kBase, /*width = */ 6, "0X25__"},
+ {37, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 0, "0X25"},
+ {37, kHex | kLeft | kUpper | kBase | kPos, /*width = */ 6, "0X25__"},
+ {37, kHex | kInt, /*width = */ 0, "25"},
+ {37, kHex | kInt, /*width = */ 6, "____25"},
+ {37, kHex | kInt | kPos, /*width = */ 0, "25"},
+ {37, kHex | kInt | kPos, /*width = */ 6, "____25"},
+ {37, kHex | kInt | kBase, /*width = */ 0, "0x25"},
+ {37, kHex | kInt | kBase, /*width = */ 6, "0x__25"},
+ {37, kHex | kInt | kBase | kPos, /*width = */ 0, "0x25"},
+ {37, kHex | kInt | kBase | kPos, /*width = */ 6, "0x__25"},
+ {37, kHex | kInt | kUpper, /*width = */ 0, "25"},
+ {37, kHex | kInt | kUpper, /*width = */ 6, "____25"},
+ {37, kHex | kInt | kUpper | kPos, /*width = */ 0, "25"},
+ {37, kHex | kInt | kUpper | kPos, /*width = */ 6, "____25"},
+ {37, kHex | kInt | kUpper | kBase, /*width = */ 0, "0X25"},
+ {37, kHex | kInt | kUpper | kBase, /*width = */ 6, "0X__25"},
+ {37, kHex | kInt | kUpper | kBase | kPos, /*width = */ 0, "0X25"},
+ {37, kHex | kInt | kUpper | kBase | kPos, /*width = */ 6, "0X__25"},
+ {37, kHex | kRight, /*width = */ 0, "25"},
+ {37, kHex | kRight, /*width = */ 6, "____25"},
+ {37, kHex | kRight | kPos, /*width = */ 0, "25"},
+ {37, kHex | kRight | kPos, /*width = */ 6, "____25"},
+ {37, kHex | kRight | kBase, /*width = */ 0, "0x25"},
+ {37, kHex | kRight | kBase, /*width = */ 6, "__0x25"},
+ {37, kHex | kRight | kBase | kPos, /*width = */ 0, "0x25"},
+ {37, kHex | kRight | kBase | kPos, /*width = */ 6, "__0x25"},
+ {37, kHex | kRight | kUpper, /*width = */ 0, "25"},
+ {37, kHex | kRight | kUpper, /*width = */ 6, "____25"},
+ {37, kHex | kRight | kUpper | kPos, /*width = */ 0, "25"},
+ {37, kHex | kRight | kUpper | kPos, /*width = */ 6, "____25"},
+ {37, kHex | kRight | kUpper | kBase, /*width = */ 0, "0X25"},
+ {37, kHex | kRight | kUpper | kBase, /*width = */ 6, "__0X25"},
+ {37, kHex | kRight | kUpper | kBase | kPos, /*width = */ 0, "0X25"},
+ {37, kHex | kRight | kUpper | kBase | kPos, /*width = */ 6, "__0X25"}};
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_test.cc
new file mode 100644
index 0000000..79bcca9
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/numeric/int128_test.cc
@@ -0,0 +1,431 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/numeric/int128.h"
+
+#include <algorithm>
+#include <limits>
+#include <random>
+#include <type_traits>
+#include <utility>
+#include <vector>
+
+#include "gtest/gtest.h"
+#include "absl/base/internal/cycleclock.h"
+#include "absl/meta/type_traits.h"
+
+#if defined(_MSC_VER) && _MSC_VER == 1900
+// Disable "unary minus operator applied to unsigned type" warnings in Microsoft
+// Visual C++ 14 (2015).
+#pragma warning(disable:4146)
+#endif
+
+namespace {
+
+template <typename T>
+class Uint128IntegerTraitsTest : public ::testing::Test {};
+typedef ::testing::Types<bool, char, signed char, unsigned char, char16_t,
+ char32_t, wchar_t,
+ short, // NOLINT(runtime/int)
+ unsigned short, // NOLINT(runtime/int)
+ int, unsigned int,
+ long, // NOLINT(runtime/int)
+ unsigned long, // NOLINT(runtime/int)
+ long long, // NOLINT(runtime/int)
+ unsigned long long> // NOLINT(runtime/int)
+ IntegerTypes;
+
+template <typename T>
+class Uint128FloatTraitsTest : public ::testing::Test {};
+typedef ::testing::Types<float, double, long double> FloatingPointTypes;
+
+TYPED_TEST_CASE(Uint128IntegerTraitsTest, IntegerTypes);
+
+TYPED_TEST(Uint128IntegerTraitsTest, ConstructAssignTest) {
+ static_assert(std::is_constructible<absl::uint128, TypeParam>::value,
+ "absl::uint128 must be constructible from TypeParam");
+ static_assert(std::is_assignable<absl::uint128&, TypeParam>::value,
+ "absl::uint128 must be assignable from TypeParam");
+ static_assert(!std::is_assignable<TypeParam&, absl::uint128>::value,
+ "TypeParam must not be assignable from absl::uint128");
+}
+
+TYPED_TEST_CASE(Uint128FloatTraitsTest, FloatingPointTypes);
+
+TYPED_TEST(Uint128FloatTraitsTest, ConstructAssignTest) {
+ static_assert(std::is_constructible<absl::uint128, TypeParam>::value,
+ "absl::uint128 must be constructible from TypeParam");
+ static_assert(!std::is_assignable<absl::uint128&, TypeParam>::value,
+ "absl::uint128 must not be assignable from TypeParam");
+ static_assert(!std::is_assignable<TypeParam&, absl::uint128>::value,
+ "TypeParam must not be assignable from absl::uint128");
+}
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+// These type traits done separately as TYPED_TEST requires typeinfo, and not
+// all platforms have this for __int128 even though they define the type.
+TEST(Uint128, IntrinsicTypeTraitsTest) {
+ static_assert(std::is_constructible<absl::uint128, __int128>::value,
+ "absl::uint128 must be constructible from __int128");
+ static_assert(std::is_assignable<absl::uint128&, __int128>::value,
+ "absl::uint128 must be assignable from __int128");
+ static_assert(!std::is_assignable<__int128&, absl::uint128>::value,
+ "__int128 must not be assignable from absl::uint128");
+
+ static_assert(std::is_constructible<absl::uint128, unsigned __int128>::value,
+ "absl::uint128 must be constructible from unsigned __int128");
+ static_assert(std::is_assignable<absl::uint128&, unsigned __int128>::value,
+ "absl::uint128 must be assignable from unsigned __int128");
+ static_assert(!std::is_assignable<unsigned __int128&, absl::uint128>::value,
+ "unsigned __int128 must not be assignable from absl::uint128");
+}
+#endif // ABSL_HAVE_INTRINSIC_INT128
+
+TEST(Uint128, TrivialTraitsTest) {
+ static_assert(absl::is_trivially_default_constructible<absl::uint128>::value,
+ "");
+ static_assert(absl::is_trivially_copy_constructible<absl::uint128>::value,
+ "");
+ static_assert(absl::is_trivially_copy_assignable<absl::uint128>::value, "");
+ static_assert(std::is_trivially_destructible<absl::uint128>::value, "");
+}
+
+TEST(Uint128, AllTests) {
+ absl::uint128 zero = 0;
+ absl::uint128 one = 1;
+ absl::uint128 one_2arg = absl::MakeUint128(0, 1);
+ absl::uint128 two = 2;
+ absl::uint128 three = 3;
+ absl::uint128 big = absl::MakeUint128(2000, 2);
+ absl::uint128 big_minus_one = absl::MakeUint128(2000, 1);
+ absl::uint128 bigger = absl::MakeUint128(2001, 1);
+ absl::uint128 biggest = absl::Uint128Max();
+ absl::uint128 high_low = absl::MakeUint128(1, 0);
+ absl::uint128 low_high =
+ absl::MakeUint128(0, std::numeric_limits<uint64_t>::max());
+ EXPECT_LT(one, two);
+ EXPECT_GT(two, one);
+ EXPECT_LT(one, big);
+ EXPECT_LT(one, big);
+ EXPECT_EQ(one, one_2arg);
+ EXPECT_NE(one, two);
+ EXPECT_GT(big, one);
+ EXPECT_GE(big, two);
+ EXPECT_GE(big, big_minus_one);
+ EXPECT_GT(big, big_minus_one);
+ EXPECT_LT(big_minus_one, big);
+ EXPECT_LE(big_minus_one, big);
+ EXPECT_NE(big_minus_one, big);
+ EXPECT_LT(big, biggest);
+ EXPECT_LE(big, biggest);
+ EXPECT_GT(biggest, big);
+ EXPECT_GE(biggest, big);
+ EXPECT_EQ(big, ~~big);
+ EXPECT_EQ(one, one | one);
+ EXPECT_EQ(big, big | big);
+ EXPECT_EQ(one, one | zero);
+ EXPECT_EQ(one, one & one);
+ EXPECT_EQ(big, big & big);
+ EXPECT_EQ(zero, one & zero);
+ EXPECT_EQ(zero, big & ~big);
+ EXPECT_EQ(zero, one ^ one);
+ EXPECT_EQ(zero, big ^ big);
+ EXPECT_EQ(one, one ^ zero);
+
+ // Shift operators.
+ EXPECT_EQ(big, big << 0);
+ EXPECT_EQ(big, big >> 0);
+ EXPECT_GT(big << 1, big);
+ EXPECT_LT(big >> 1, big);
+ EXPECT_EQ(big, (big << 10) >> 10);
+ EXPECT_EQ(big, (big >> 1) << 1);
+ EXPECT_EQ(one, (one << 80) >> 80);
+ EXPECT_EQ(zero, (one >> 80) << 80);
+
+ // Shift assignments.
+ absl::uint128 big_copy = big;
+ EXPECT_EQ(big << 0, big_copy <<= 0);
+ big_copy = big;
+ EXPECT_EQ(big >> 0, big_copy >>= 0);
+ big_copy = big;
+ EXPECT_EQ(big << 1, big_copy <<= 1);
+ big_copy = big;
+ EXPECT_EQ(big >> 1, big_copy >>= 1);
+ big_copy = big;
+ EXPECT_EQ(big << 10, big_copy <<= 10);
+ big_copy = big;
+ EXPECT_EQ(big >> 10, big_copy >>= 10);
+ big_copy = big;
+ EXPECT_EQ(big << 64, big_copy <<= 64);
+ big_copy = big;
+ EXPECT_EQ(big >> 64, big_copy >>= 64);
+ big_copy = big;
+ EXPECT_EQ(big << 73, big_copy <<= 73);
+ big_copy = big;
+ EXPECT_EQ(big >> 73, big_copy >>= 73);
+
+ EXPECT_EQ(absl::Uint128High64(biggest), std::numeric_limits<uint64_t>::max());
+ EXPECT_EQ(absl::Uint128Low64(biggest), std::numeric_limits<uint64_t>::max());
+ EXPECT_EQ(zero + one, one);
+ EXPECT_EQ(one + one, two);
+ EXPECT_EQ(big_minus_one + one, big);
+ EXPECT_EQ(one - one, zero);
+ EXPECT_EQ(one - zero, one);
+ EXPECT_EQ(zero - one, biggest);
+ EXPECT_EQ(big - big, zero);
+ EXPECT_EQ(big - one, big_minus_one);
+ EXPECT_EQ(big + std::numeric_limits<uint64_t>::max(), bigger);
+ EXPECT_EQ(biggest + 1, zero);
+ EXPECT_EQ(zero - 1, biggest);
+ EXPECT_EQ(high_low - one, low_high);
+ EXPECT_EQ(low_high + one, high_low);
+ EXPECT_EQ(absl::Uint128High64((absl::uint128(1) << 64) - 1), 0);
+ EXPECT_EQ(absl::Uint128Low64((absl::uint128(1) << 64) - 1),
+ std::numeric_limits<uint64_t>::max());
+ EXPECT_TRUE(!!one);
+ EXPECT_TRUE(!!high_low);
+ EXPECT_FALSE(!!zero);
+ EXPECT_FALSE(!one);
+ EXPECT_FALSE(!high_low);
+ EXPECT_TRUE(!zero);
+ EXPECT_TRUE(zero == 0); // NOLINT(readability/check)
+ EXPECT_FALSE(zero != 0); // NOLINT(readability/check)
+ EXPECT_FALSE(one == 0); // NOLINT(readability/check)
+ EXPECT_TRUE(one != 0); // NOLINT(readability/check)
+ EXPECT_FALSE(high_low == 0); // NOLINT(readability/check)
+ EXPECT_TRUE(high_low != 0); // NOLINT(readability/check)
+
+ absl::uint128 test = zero;
+ EXPECT_EQ(++test, one);
+ EXPECT_EQ(test, one);
+ EXPECT_EQ(test++, one);
+ EXPECT_EQ(test, two);
+ EXPECT_EQ(test -= 2, zero);
+ EXPECT_EQ(test, zero);
+ EXPECT_EQ(test += 2, two);
+ EXPECT_EQ(test, two);
+ EXPECT_EQ(--test, one);
+ EXPECT_EQ(test, one);
+ EXPECT_EQ(test--, one);
+ EXPECT_EQ(test, zero);
+ EXPECT_EQ(test |= three, three);
+ EXPECT_EQ(test &= one, one);
+ EXPECT_EQ(test ^= three, two);
+ EXPECT_EQ(test >>= 1, one);
+ EXPECT_EQ(test <<= 1, two);
+
+ EXPECT_EQ(big, -(-big));
+ EXPECT_EQ(two, -((-one) - 1));
+ EXPECT_EQ(absl::Uint128Max(), -one);
+ EXPECT_EQ(zero, -zero);
+
+ EXPECT_EQ(absl::Uint128Max(), absl::kuint128max);
+}
+
+TEST(Uint128, ConversionTests) {
+ EXPECT_TRUE(absl::MakeUint128(1, 0));
+
+#ifdef ABSL_HAVE_INTRINSIC_INT128
+ unsigned __int128 intrinsic =
+ (static_cast<unsigned __int128>(0x3a5b76c209de76f6) << 64) +
+ 0x1f25e1d63a2b46c5;
+ absl::uint128 custom =
+ absl::MakeUint128(0x3a5b76c209de76f6, 0x1f25e1d63a2b46c5);
+
+ EXPECT_EQ(custom, absl::uint128(intrinsic));
+ EXPECT_EQ(custom, absl::uint128(static_cast<__int128>(intrinsic)));
+ EXPECT_EQ(intrinsic, static_cast<unsigned __int128>(custom));
+ EXPECT_EQ(intrinsic, static_cast<__int128>(custom));
+#endif // ABSL_HAVE_INTRINSIC_INT128
+
+ // verify that an integer greater than 2**64 that can be stored precisely
+ // inside a double is converted to a absl::uint128 without loss of
+ // information.
+ double precise_double = 0x530e * std::pow(2.0, 64.0) + 0xda74000000000000;
+ absl::uint128 from_precise_double(precise_double);
+ absl::uint128 from_precise_ints =
+ absl::MakeUint128(0x530e, 0xda74000000000000);
+ EXPECT_EQ(from_precise_double, from_precise_ints);
+ EXPECT_DOUBLE_EQ(static_cast<double>(from_precise_ints), precise_double);
+
+ double approx_double = 0xffffeeeeddddcccc * std::pow(2.0, 64.0) +
+ 0xbbbbaaaa99998888;
+ absl::uint128 from_approx_double(approx_double);
+ EXPECT_DOUBLE_EQ(static_cast<double>(from_approx_double), approx_double);
+
+ double round_to_zero = 0.7;
+ double round_to_five = 5.8;
+ double round_to_nine = 9.3;
+ EXPECT_EQ(static_cast<absl::uint128>(round_to_zero), 0);
+ EXPECT_EQ(static_cast<absl::uint128>(round_to_five), 5);
+ EXPECT_EQ(static_cast<absl::uint128>(round_to_nine), 9);
+}
+
+TEST(Uint128, OperatorAssignReturnRef) {
+ absl::uint128 v(1);
+ (v += 4) -= 3;
+ EXPECT_EQ(2, v);
+}
+
+TEST(Uint128, Multiply) {
+ absl::uint128 a, b, c;
+
+ // Zero test.
+ a = 0;
+ b = 0;
+ c = a * b;
+ EXPECT_EQ(0, c);
+
+ // Max carries.
+ a = absl::uint128(0) - 1;
+ b = absl::uint128(0) - 1;
+ c = a * b;
+ EXPECT_EQ(1, c);
+
+ // Self-operation with max carries.
+ c = absl::uint128(0) - 1;
+ c *= c;
+ EXPECT_EQ(1, c);
+
+ // 1-bit x 1-bit.
+ for (int i = 0; i < 64; ++i) {
+ for (int j = 0; j < 64; ++j) {
+ a = absl::uint128(1) << i;
+ b = absl::uint128(1) << j;
+ c = a * b;
+ EXPECT_EQ(absl::uint128(1) << (i + j), c);
+ }
+ }
+
+ // Verified with dc.
+ a = absl::MakeUint128(0xffffeeeeddddcccc, 0xbbbbaaaa99998888);
+ b = absl::MakeUint128(0x7777666655554444, 0x3333222211110000);
+ c = a * b;
+ EXPECT_EQ(absl::MakeUint128(0x530EDA741C71D4C3, 0xBF25975319080000), c);
+ EXPECT_EQ(0, c - b * a);
+ EXPECT_EQ(a*a - b*b, (a+b) * (a-b));
+
+ // Verified with dc.
+ a = absl::MakeUint128(0x0123456789abcdef, 0xfedcba9876543210);
+ b = absl::MakeUint128(0x02468ace13579bdf, 0xfdb97531eca86420);
+ c = a * b;
+ EXPECT_EQ(absl::MakeUint128(0x97a87f4f261ba3f2, 0x342d0bbf48948200), c);
+ EXPECT_EQ(0, c - b * a);
+ EXPECT_EQ(a*a - b*b, (a+b) * (a-b));
+}
+
+TEST(Uint128, AliasTests) {
+ absl::uint128 x1 = absl::MakeUint128(1, 2);
+ absl::uint128 x2 = absl::MakeUint128(2, 4);
+ x1 += x1;
+ EXPECT_EQ(x2, x1);
+
+ absl::uint128 x3 = absl::MakeUint128(1, static_cast<uint64_t>(1) << 63);
+ absl::uint128 x4 = absl::MakeUint128(3, 0);
+ x3 += x3;
+ EXPECT_EQ(x4, x3);
+}
+
+TEST(Uint128, DivideAndMod) {
+ using std::swap;
+
+ // a := q * b + r
+ absl::uint128 a, b, q, r;
+
+ // Zero test.
+ a = 0;
+ b = 123;
+ q = a / b;
+ r = a % b;
+ EXPECT_EQ(0, q);
+ EXPECT_EQ(0, r);
+
+ a = absl::MakeUint128(0x530eda741c71d4c3, 0xbf25975319080000);
+ q = absl::MakeUint128(0x4de2cab081, 0x14c34ab4676e4bab);
+ b = absl::uint128(0x1110001);
+ r = absl::uint128(0x3eb455);
+ ASSERT_EQ(a, q * b + r); // Sanity-check.
+
+ absl::uint128 result_q, result_r;
+ result_q = a / b;
+ result_r = a % b;
+ EXPECT_EQ(q, result_q);
+ EXPECT_EQ(r, result_r);
+
+ // Try the other way around.
+ swap(q, b);
+ result_q = a / b;
+ result_r = a % b;
+ EXPECT_EQ(q, result_q);
+ EXPECT_EQ(r, result_r);
+ // Restore.
+ swap(b, q);
+
+ // Dividend < divisor; result should be q:0 r:<dividend>.
+ swap(a, b);
+ result_q = a / b;
+ result_r = a % b;
+ EXPECT_EQ(0, result_q);
+ EXPECT_EQ(a, result_r);
+ // Try the other way around.
+ swap(a, q);
+ result_q = a / b;
+ result_r = a % b;
+ EXPECT_EQ(0, result_q);
+ EXPECT_EQ(a, result_r);
+ // Restore.
+ swap(q, a);
+ swap(b, a);
+
+ // Try a large remainder.
+ b = a / 2 + 1;
+ absl::uint128 expected_r =
+ absl::MakeUint128(0x29876d3a0e38ea61, 0xdf92cba98c83ffff);
+ // Sanity checks.
+ ASSERT_EQ(a / 2 - 1, expected_r);
+ ASSERT_EQ(a, b + expected_r);
+ result_q = a / b;
+ result_r = a % b;
+ EXPECT_EQ(1, result_q);
+ EXPECT_EQ(expected_r, result_r);
+}
+
+TEST(Uint128, DivideAndModRandomInputs) {
+ const int kNumIters = 1 << 18;
+ std::minstd_rand random(testing::UnitTest::GetInstance()->random_seed());
+ std::uniform_int_distribution<uint64_t> uniform_uint64;
+ for (int i = 0; i < kNumIters; ++i) {
+ const absl::uint128 a =
+ absl::MakeUint128(uniform_uint64(random), uniform_uint64(random));
+ const absl::uint128 b =
+ absl::MakeUint128(uniform_uint64(random), uniform_uint64(random));
+ if (b == 0) {
+ continue; // Avoid a div-by-zero.
+ }
+ const absl::uint128 q = a / b;
+ const absl::uint128 r = a % b;
+ ASSERT_EQ(a, b * q + r);
+ }
+}
+
+TEST(Uint128, ConstexprTest) {
+ constexpr absl::uint128 zero = absl::uint128();
+ constexpr absl::uint128 one = 1;
+ constexpr absl::uint128 minus_two = -2;
+ EXPECT_EQ(zero, absl::uint128(0));
+ EXPECT_EQ(one, absl::uint128(1));
+ EXPECT_EQ(minus_two, absl::MakeUint128(-1, -2));
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/BUILD.bazel
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/BUILD.bazel b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/BUILD.bazel
new file mode 100644
index 0000000..13badb7
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/BUILD.bazel
@@ -0,0 +1,322 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+# -*- mode: python; -*-
+# Libraries in this low-level package may not depend on libraries in packages
+# that are not low level. For more information, including how to submit
+# changes to this file, see http://www/eng/howto/build-monitors.html
+
+load(
+ "//absl:copts.bzl",
+ "ABSL_DEFAULT_COPTS",
+ "ABSL_TEST_COPTS",
+ "ABSL_EXCEPTIONS_FLAG",
+)
+
+package(
+ default_visibility = ["//visibility:public"],
+ features = ["parse_headers"],
+)
+
+licenses(["notice"]) # Apache 2.0
+
+cc_library(
+ name = "strings",
+ srcs = [
+ "ascii.cc",
+ "escaping.cc",
+ "internal/memutil.cc",
+ "internal/memutil.h",
+ "internal/stl_type_traits.h",
+ "internal/str_join_internal.h",
+ "internal/str_split_internal.h",
+ "match.cc",
+ "numbers.cc",
+ "str_cat.cc",
+ "str_replace.cc",
+ "str_split.cc",
+ "string_view.cc",
+ "substitute.cc",
+ ],
+ hdrs = [
+ "ascii.h",
+ "escaping.h",
+ "match.h",
+ "numbers.h",
+ "str_cat.h",
+ "str_join.h",
+ "str_replace.h",
+ "str_split.h",
+ "string_view.h",
+ "strip.h",
+ "substitute.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ ":internal",
+ "//absl/base",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/base:endian",
+ "//absl/base:throw_delegate",
+ "//absl/memory",
+ "//absl/meta:type_traits",
+ "//absl/numeric:int128",
+ ],
+)
+
+cc_library(
+ name = "internal",
+ srcs = [
+ "internal/ostringstream.cc",
+ "internal/utf8.cc",
+ ],
+ hdrs = [
+ "internal/char_map.h",
+ "internal/ostringstream.h",
+ "internal/resize_uninitialized.h",
+ "internal/utf8.h",
+ ],
+ copts = ABSL_DEFAULT_COPTS,
+ deps = [
+ "//absl/base:core_headers",
+ "//absl/base:endian",
+ "//absl/meta:type_traits",
+ ],
+)
+
+cc_test(
+ name = "match_test",
+ size = "small",
+ srcs = ["match_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "escaping_test",
+ size = "small",
+ srcs = [
+ "escaping_test.cc",
+ "internal/escaping_test_common.inc",
+ ],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "//absl/base:core_headers",
+ "//absl/container:fixed_array",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "ascii_test",
+ size = "small",
+ srcs = ["ascii_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "memutil_test",
+ size = "small",
+ srcs = [
+ "internal/memutil.h",
+ "internal/memutil_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "utf8_test",
+ size = "small",
+ srcs = [
+ "internal/utf8_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":internal",
+ ":strings",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "string_view_test",
+ size = "small",
+ srcs = ["string_view_test.cc"],
+ copts = ABSL_TEST_COPTS + ABSL_EXCEPTIONS_FLAG,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "//absl/base:config",
+ "//absl/base:core_headers",
+ "//absl/base:dynamic_annotations",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "substitute_test",
+ size = "small",
+ srcs = ["substitute_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "str_replace_test",
+ size = "small",
+ srcs = ["str_replace_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "str_split_test",
+ srcs = ["str_split_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "//absl/base:core_headers",
+ "//absl/base:dynamic_annotations",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "ostringstream_test",
+ size = "small",
+ srcs = ["internal/ostringstream_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":internal",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "resize_uninitialized_test",
+ size = "small",
+ srcs = [
+ "internal/resize_uninitialized.h",
+ "internal/resize_uninitialized_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ "//absl/base:core_headers",
+ "//absl/meta:type_traits",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "str_join_test",
+ size = "small",
+ srcs = ["str_join_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "//absl/base:core_headers",
+ "//absl/memory",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "str_cat_test",
+ size = "small",
+ srcs = ["str_cat_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "numbers_test",
+ size = "small",
+ srcs = [
+ "internal/numbers_test_common.inc",
+ "numbers_test.cc",
+ ],
+ copts = ABSL_TEST_COPTS,
+ tags = [
+ "no_test_loonix",
+ ],
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "//absl/base",
+ "//absl/base:core_headers",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "strip_test",
+ size = "small",
+ srcs = ["strip_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ visibility = ["//visibility:private"],
+ deps = [
+ ":strings",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
+
+cc_test(
+ name = "char_map_test",
+ srcs = ["internal/char_map_test.cc"],
+ copts = ABSL_TEST_COPTS,
+ deps = [
+ ":internal",
+ "@com_google_googletest//:gtest_main",
+ ],
+)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/CMakeLists.txt b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/CMakeLists.txt
new file mode 100644
index 0000000..83cb934
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/CMakeLists.txt
@@ -0,0 +1,304 @@
+#
+# Copyright 2017 The Abseil Authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+
+list(APPEND STRINGS_PUBLIC_HEADERS
+ "ascii.h"
+ "escaping.h"
+ "match.h"
+ "numbers.h"
+ "str_cat.h"
+ "string_view.h"
+ "strip.h"
+ "str_join.h"
+ "str_replace.h"
+ "str_split.h"
+ "substitute.h"
+)
+
+
+list(APPEND STRINGS_INTERNAL_HEADERS
+ "internal/char_map.h"
+ "internal/memutil.h"
+ "internal/ostringstream.h"
+ "internal/resize_uninitialized.h"
+ "internal/stl_type_traits.h"
+ "internal/str_join_internal.h"
+ "internal/str_split_internal.h"
+ "internal/utf8.h"
+)
+
+
+
+# add string library
+list(APPEND STRINGS_SRC
+ "ascii.cc"
+ "escaping.cc"
+ "internal/memutil.cc"
+ "internal/memutil.h"
+ "internal/utf8.cc"
+ "internal/ostringstream.cc"
+ "match.cc"
+ "numbers.cc"
+ "str_cat.cc"
+ "str_replace.cc"
+ "str_split.cc"
+ "string_view.cc"
+ "substitute.cc"
+ ${STRINGS_PUBLIC_HEADERS}
+ ${STRINGS_INTERNAL_HEADERS}
+)
+set(STRINGS_PUBLIC_LIBRARIES absl::base absl_throw_delegate)
+
+absl_library(
+ TARGET
+ absl_strings
+ SOURCES
+ ${STRINGS_SRC}
+ PUBLIC_LIBRARIES
+ ${STRINGS_PUBLIC_LIBRARIES}
+ EXPORT_NAME
+ strings
+)
+
+
+#
+## TESTS
+#
+
+# test match_test
+set(MATCH_TEST_SRC "match_test.cc")
+set(MATCH_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+ TARGET
+ match_test
+ SOURCES
+ ${MATCH_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${MATCH_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test escaping_test
+set(ESCAPING_TEST_SRC "escaping_test.cc")
+set(ESCAPING_TEST_PUBLIC_LIBRARIES absl::strings absl::base)
+
+absl_test(
+ TARGET
+ escaping_test
+ SOURCES
+ ${ESCAPING_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${ESCAPING_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test ascii_test
+set(ASCII_TEST_SRC "ascii_test.cc")
+set(ASCII_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+ TARGET
+ ascii_test
+ SOURCES
+ ${ASCII_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${ASCII_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test memutil_test
+set(MEMUTIL_TEST_SRC "internal/memutil_test.cc")
+set(MEMUTIL_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+ TARGET
+ memutil_test
+ SOURCES
+ ${MEMUTIL_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${MEMUTIL_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test utf8_test
+set(UTF8_TEST_SRC "internal/utf8_test.cc")
+set(UTF8_TEST_PUBLIC_LIBRARIES absl::strings absl::base)
+
+absl_test(
+ TARGET
+ utf8_test
+ SOURCES
+ ${UTF8_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${UTF8_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test string_view_test
+set(STRING_VIEW_TEST_SRC "string_view_test.cc")
+set(STRING_VIEW_TEST_PUBLIC_LIBRARIES absl::strings absl_throw_delegate absl::base)
+
+absl_test(
+ TARGET
+ string_view_test
+ SOURCES
+ ${STRING_VIEW_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${STRING_VIEW_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test substitute_test
+set(SUBSTITUTE_TEST_SRC "substitute_test.cc")
+set(SUBSTITUTE_TEST_PUBLIC_LIBRARIES absl::strings absl::base)
+
+absl_test(
+ TARGET
+ substitute_test
+ SOURCES
+ ${SUBSTITUTE_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${SUBSTITUTE_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test str_replace_test
+set(STR_REPLACE_TEST_SRC "str_replace_test.cc")
+set(STR_REPLACE_TEST_PUBLIC_LIBRARIES absl::strings absl::base absl_throw_delegate)
+
+absl_test(
+ TARGET
+ str_replace_test
+ SOURCES
+ ${STR_REPLACE_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${STR_REPLACE_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test str_split_test
+set(STR_SPLIT_TEST_SRC "str_split_test.cc")
+set(STR_SPLIT_TEST_PUBLIC_LIBRARIES absl::strings absl::base absl_throw_delegate)
+
+absl_test(
+ TARGET
+ str_split_test
+ SOURCES
+ ${STR_SPLIT_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${STR_SPLIT_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test ostringstream_test
+set(OSTRINGSTREAM_TEST_SRC "internal/ostringstream_test.cc")
+set(OSTRINGSTREAM_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+ TARGET
+ ostringstream_test
+ SOURCES
+ ${OSTRINGSTREAM_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${OSTRINGSTREAM_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test resize_uninitialized_test
+set(RESIZE_UNINITIALIZED_TEST_SRC "internal/resize_uninitialized_test.cc")
+
+absl_test(
+ TARGET
+ resize_uninitialized_test
+ SOURCES
+ ${RESIZE_UNINITIALIZED_TEST_SRC}
+)
+
+
+# test str_join_test
+set(STR_JOIN_TEST_SRC "str_join_test.cc")
+set(STR_JOIN_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+ TARGET
+ str_join_test
+ SOURCES
+ ${STR_JOIN_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${STR_JOIN_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test str_cat_test
+set(STR_CAT_TEST_SRC "str_cat_test.cc")
+set(STR_CAT_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+ TARGET
+ str_cat_test
+ SOURCES
+ ${STR_CAT_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${STR_CAT_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test numbers_test
+set(NUMBERS_TEST_SRC "numbers_test.cc")
+set(NUMBERS_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+ TARGET
+ numbers_test
+ SOURCES
+ ${NUMBERS_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${NUMBERS_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test strip_test
+set(STRIP_TEST_SRC "strip_test.cc")
+set(STRIP_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+ TARGET
+ strip_test
+ SOURCES
+ ${STRIP_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${STRIP_TEST_PUBLIC_LIBRARIES}
+)
+
+
+# test char_map_test
+set(CHAR_MAP_TEST_SRC "internal/char_map_test.cc")
+set(CHAR_MAP_TEST_PUBLIC_LIBRARIES absl::strings)
+
+absl_test(
+ TARGET
+ char_map_test
+ SOURCES
+ ${CHAR_MAP_TEST_SRC}
+ PUBLIC_LIBRARIES
+ ${CHAR_MAP_TEST_PUBLIC_LIBRARIES}
+)
+
+
+
+
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii.cc
new file mode 100644
index 0000000..c9481e8
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii.cc
@@ -0,0 +1,198 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/strings/ascii.h"
+
+namespace absl {
+namespace ascii_internal {
+
+// # Table generated by this Python code (bit 0x02 is currently unused):
+// TODO(mbar) Move Python code for generation of table to BUILD and link here.
+
+// NOTE: The kAsciiPropertyBits table used within this code was generated by
+// Python code of the following form. (Bit 0x02 is currently unused and
+// available.)
+//
+// def Hex2(n):
+// return '0x' + hex(n/16)[2:] + hex(n%16)[2:]
+// def IsPunct(ch):
+// return (ord(ch) >= 32 and ord(ch) < 127 and
+// not ch.isspace() and not ch.isalnum())
+// def IsBlank(ch):
+// return ch in ' \t'
+// def IsCntrl(ch):
+// return ord(ch) < 32 or ord(ch) == 127
+// def IsXDigit(ch):
+// return ch.isdigit() or ch.lower() in 'abcdef'
+// for i in range(128):
+// ch = chr(i)
+// mask = ((ch.isalpha() and 0x01 or 0) |
+// (ch.isalnum() and 0x04 or 0) |
+// (ch.isspace() and 0x08 or 0) |
+// (IsPunct(ch) and 0x10 or 0) |
+// (IsBlank(ch) and 0x20 or 0) |
+// (IsCntrl(ch) and 0x40 or 0) |
+// (IsXDigit(ch) and 0x80 or 0))
+// print Hex2(mask) + ',',
+// if i % 16 == 7:
+// print ' //', Hex2(i & 0x78)
+// elif i % 16 == 15:
+// print
+
+// clang-format off
+// Array of bitfields holding character information. Each bit value corresponds
+// to a particular character feature. For readability, and because the value
+// of these bits is tightly coupled to this implementation, the individual bits
+// are not named. Note that bitfields for all characters above ASCII 127 are
+// zero-initialized.
+const unsigned char kPropertyBits[256] = {
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x00
+ 0x40, 0x68, 0x48, 0x48, 0x48, 0x48, 0x40, 0x40,
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x10
+ 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40,
+ 0x28, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // 0x20
+ 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, 0x84, // 0x30
+ 0x84, 0x84, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x05, // 0x40
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, // 0x50
+ 0x05, 0x05, 0x05, 0x10, 0x10, 0x10, 0x10, 0x10,
+ 0x10, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x05, // 0x60
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+ 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, // 0x70
+ 0x05, 0x05, 0x05, 0x10, 0x10, 0x10, 0x10, 0x40,
+};
+
+// Array of characters for the ascii_tolower() function. For values 'A'
+// through 'Z', return the lower-case character; otherwise, return the
+// identity of the passed character.
+const char kToLower[256] = {
+ '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
+ '\x08', '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f',
+ '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17',
+ '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f',
+ '\x20', '\x21', '\x22', '\x23', '\x24', '\x25', '\x26', '\x27',
+ '\x28', '\x29', '\x2a', '\x2b', '\x2c', '\x2d', '\x2e', '\x2f',
+ '\x30', '\x31', '\x32', '\x33', '\x34', '\x35', '\x36', '\x37',
+ '\x38', '\x39', '\x3a', '\x3b', '\x3c', '\x3d', '\x3e', '\x3f',
+ '\x40', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+ 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
+ 'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
+ 'x', 'y', 'z', '\x5b', '\x5c', '\x5d', '\x5e', '\x5f',
+ '\x60', '\x61', '\x62', '\x63', '\x64', '\x65', '\x66', '\x67',
+ '\x68', '\x69', '\x6a', '\x6b', '\x6c', '\x6d', '\x6e', '\x6f',
+ '\x70', '\x71', '\x72', '\x73', '\x74', '\x75', '\x76', '\x77',
+ '\x78', '\x79', '\x7a', '\x7b', '\x7c', '\x7d', '\x7e', '\x7f',
+ '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87',
+ '\x88', '\x89', '\x8a', '\x8b', '\x8c', '\x8d', '\x8e', '\x8f',
+ '\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97',
+ '\x98', '\x99', '\x9a', '\x9b', '\x9c', '\x9d', '\x9e', '\x9f',
+ '\xa0', '\xa1', '\xa2', '\xa3', '\xa4', '\xa5', '\xa6', '\xa7',
+ '\xa8', '\xa9', '\xaa', '\xab', '\xac', '\xad', '\xae', '\xaf',
+ '\xb0', '\xb1', '\xb2', '\xb3', '\xb4', '\xb5', '\xb6', '\xb7',
+ '\xb8', '\xb9', '\xba', '\xbb', '\xbc', '\xbd', '\xbe', '\xbf',
+ '\xc0', '\xc1', '\xc2', '\xc3', '\xc4', '\xc5', '\xc6', '\xc7',
+ '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce', '\xcf',
+ '\xd0', '\xd1', '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd7',
+ '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde', '\xdf',
+ '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7',
+ '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\xed', '\xee', '\xef',
+ '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf7',
+ '\xf8', '\xf9', '\xfa', '\xfb', '\xfc', '\xfd', '\xfe', '\xff',
+};
+
+// Array of characters for the ascii_toupper() function. For values 'a'
+// through 'z', return the upper-case character; otherwise, return the
+// identity of the passed character.
+const char kToUpper[256] = {
+ '\x00', '\x01', '\x02', '\x03', '\x04', '\x05', '\x06', '\x07',
+ '\x08', '\x09', '\x0a', '\x0b', '\x0c', '\x0d', '\x0e', '\x0f',
+ '\x10', '\x11', '\x12', '\x13', '\x14', '\x15', '\x16', '\x17',
+ '\x18', '\x19', '\x1a', '\x1b', '\x1c', '\x1d', '\x1e', '\x1f',
+ '\x20', '\x21', '\x22', '\x23', '\x24', '\x25', '\x26', '\x27',
+ '\x28', '\x29', '\x2a', '\x2b', '\x2c', '\x2d', '\x2e', '\x2f',
+ '\x30', '\x31', '\x32', '\x33', '\x34', '\x35', '\x36', '\x37',
+ '\x38', '\x39', '\x3a', '\x3b', '\x3c', '\x3d', '\x3e', '\x3f',
+ '\x40', '\x41', '\x42', '\x43', '\x44', '\x45', '\x46', '\x47',
+ '\x48', '\x49', '\x4a', '\x4b', '\x4c', '\x4d', '\x4e', '\x4f',
+ '\x50', '\x51', '\x52', '\x53', '\x54', '\x55', '\x56', '\x57',
+ '\x58', '\x59', '\x5a', '\x5b', '\x5c', '\x5d', '\x5e', '\x5f',
+ '\x60', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
+ 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
+ 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
+ 'X', 'Y', 'Z', '\x7b', '\x7c', '\x7d', '\x7e', '\x7f',
+ '\x80', '\x81', '\x82', '\x83', '\x84', '\x85', '\x86', '\x87',
+ '\x88', '\x89', '\x8a', '\x8b', '\x8c', '\x8d', '\x8e', '\x8f',
+ '\x90', '\x91', '\x92', '\x93', '\x94', '\x95', '\x96', '\x97',
+ '\x98', '\x99', '\x9a', '\x9b', '\x9c', '\x9d', '\x9e', '\x9f',
+ '\xa0', '\xa1', '\xa2', '\xa3', '\xa4', '\xa5', '\xa6', '\xa7',
+ '\xa8', '\xa9', '\xaa', '\xab', '\xac', '\xad', '\xae', '\xaf',
+ '\xb0', '\xb1', '\xb2', '\xb3', '\xb4', '\xb5', '\xb6', '\xb7',
+ '\xb8', '\xb9', '\xba', '\xbb', '\xbc', '\xbd', '\xbe', '\xbf',
+ '\xc0', '\xc1', '\xc2', '\xc3', '\xc4', '\xc5', '\xc6', '\xc7',
+ '\xc8', '\xc9', '\xca', '\xcb', '\xcc', '\xcd', '\xce', '\xcf',
+ '\xd0', '\xd1', '\xd2', '\xd3', '\xd4', '\xd5', '\xd6', '\xd7',
+ '\xd8', '\xd9', '\xda', '\xdb', '\xdc', '\xdd', '\xde', '\xdf',
+ '\xe0', '\xe1', '\xe2', '\xe3', '\xe4', '\xe5', '\xe6', '\xe7',
+ '\xe8', '\xe9', '\xea', '\xeb', '\xec', '\xed', '\xee', '\xef',
+ '\xf0', '\xf1', '\xf2', '\xf3', '\xf4', '\xf5', '\xf6', '\xf7',
+ '\xf8', '\xf9', '\xfa', '\xfb', '\xfc', '\xfd', '\xfe', '\xff',
+};
+// clang-format on
+
+} // namespace ascii_internal
+
+void AsciiStrToLower(std::string* s) {
+ for (auto& ch : *s) {
+ ch = absl::ascii_tolower(ch);
+ }
+}
+
+void AsciiStrToUpper(std::string* s) {
+ for (auto& ch : *s) {
+ ch = absl::ascii_toupper(ch);
+ }
+}
+
+void RemoveExtraAsciiWhitespace(std::string* str) {
+ auto stripped = StripAsciiWhitespace(*str);
+
+ if (stripped.empty()) {
+ str->clear();
+ return;
+ }
+
+ auto input_it = stripped.begin();
+ auto input_end = stripped.end();
+ auto output_it = &(*str)[0];
+ bool is_ws = false;
+
+ for (; input_it < input_end; ++input_it) {
+ if (is_ws) {
+ // Consecutive whitespace? Keep only the last.
+ is_ws = absl::ascii_isspace(*input_it);
+ if (is_ws) --output_it;
+ } else {
+ is_ws = absl::ascii_isspace(*input_it);
+ }
+
+ *output_it = *input_it;
+ ++output_it;
+ }
+
+ str->erase(output_it - &(*str)[0]);
+}
+
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii.h b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii.h
new file mode 100644
index 0000000..96a6454
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/strings/ascii.h
@@ -0,0 +1,239 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: ascii.h
+// -----------------------------------------------------------------------------
+//
+// This package contains functions operating on characters and strings
+// restricted to standard ASCII. These include character classification
+// functions analogous to those found in the ANSI C Standard Library <ctype.h>
+// header file.
+//
+// C++ implementations provide <ctype.h> functionality based on their
+// C environment locale. In general, reliance on such a locale is not ideal, as
+// the locale standard is problematic (and may not return invariant information
+// for the same character set, for example). These `ascii_*()` functions are
+// hard-wired for standard ASCII, much faster, and guaranteed to behave
+// consistently. They will never be overloaded, nor will their function
+// signature change.
+//
+// `ascii_isalnum()`, `ascii_isalpha()`, `ascii_isascii()`, `ascii_isblank()`,
+// `ascii_iscntrl()`, `ascii_isdigit()`, `ascii_isgraph()`, `ascii_islower()`,
+// `ascii_isprint()`, `ascii_ispunct()`, `ascii_isspace()`, `ascii_isupper()`,
+// `ascii_isxdigit()`
+// Analogous to the <ctype.h> functions with similar names, these
+// functions take an unsigned char and return a bool, based on whether the
+// character matches the condition specified.
+//
+// If the input character has a numerical value greater than 127, these
+// functions return `false`.
+//
+// `ascii_tolower()`, `ascii_toupper()`
+// Analogous to the <ctype.h> functions with similar names, these functions
+// take an unsigned char and return a char.
+//
+// If the input character is not an ASCII {lower,upper}-case letter (including
+// numerical values greater than 127) then the functions return the same value
+// as the input character.
+
+#ifndef ABSL_STRINGS_ASCII_H_
+#define ABSL_STRINGS_ASCII_H_
+
+#include <algorithm>
+#include <string>
+
+#include "absl/base/attributes.h"
+#include "absl/strings/string_view.h"
+
+namespace absl {
+namespace ascii_internal {
+
+// Declaration for an array of bitfields holding character information.
+extern const unsigned char kPropertyBits[256];
+
+// Declaration for the array of characters to upper-case characters.
+extern const char kToUpper[256];
+
+// Declaration for the array of characters to lower-case characters.
+extern const char kToLower[256];
+
+} // namespace ascii_internal
+
+// ascii_isalpha()
+//
+// Determines whether the given character is an alphabetic character.
+inline bool ascii_isalpha(unsigned char c) {
+ return (ascii_internal::kPropertyBits[c] & 0x01) != 0;
+}
+
+// ascii_isalnum()
+//
+// Determines whether the given character is an alphanumeric character.
+inline bool ascii_isalnum(unsigned char c) {
+ return (ascii_internal::kPropertyBits[c] & 0x04) != 0;
+}
+
+// ascii_isspace()
+//
+// Determines whether the given character is a whitespace character (space,
+// tab, vertical tab, formfeed, linefeed, or carriage return).
+inline bool ascii_isspace(unsigned char c) {
+ return (ascii_internal::kPropertyBits[c] & 0x08) != 0;
+}
+
+// ascii_ispunct()
+//
+// Determines whether the given character is a punctuation character.
+inline bool ascii_ispunct(unsigned char c) {
+ return (ascii_internal::kPropertyBits[c] & 0x10) != 0;
+}
+
+// ascii_isblank()
+//
+// Determines whether the given character is a blank character (tab or space).
+inline bool ascii_isblank(unsigned char c) {
+ return (ascii_internal::kPropertyBits[c] & 0x20) != 0;
+}
+
+// ascii_iscntrl()
+//
+// Determines whether the given character is a control character.
+inline bool ascii_iscntrl(unsigned char c) {
+ return (ascii_internal::kPropertyBits[c] & 0x40) != 0;
+}
+
+// ascii_isxdigit()
+//
+// Determines whether the given character can be represented as a hexadecimal
+// digit character (i.e. {0-9} or {A-F}).
+inline bool ascii_isxdigit(unsigned char c) {
+ return (ascii_internal::kPropertyBits[c] & 0x80) != 0;
+}
+
+// ascii_isdigit()
+//
+// Determines whether the given character can be represented as a decimal
+// digit character (i.e. {0-9}).
+inline bool ascii_isdigit(unsigned char c) { return c >= '0' && c <= '9'; }
+
+// ascii_isprint()
+//
+// Determines whether the given character is printable, including whitespace.
+inline bool ascii_isprint(unsigned char c) { return c >= 32 && c < 127; }
+
+// ascii_isgraph()
+//
+// Determines whether the given character has a graphical representation.
+inline bool ascii_isgraph(unsigned char c) { return c > 32 && c < 127; }
+
+// ascii_isupper()
+//
+// Determines whether the given character is uppercase.
+inline bool ascii_isupper(unsigned char c) { return c >= 'A' && c <= 'Z'; }
+
+// ascii_islower()
+//
+// Determines whether the given character is lowercase.
+inline bool ascii_islower(unsigned char c) { return c >= 'a' && c <= 'z'; }
+
+// ascii_isascii()
+//
+// Determines whether the given character is ASCII.
+inline bool ascii_isascii(unsigned char c) { return c < 128; }
+
+// ascii_tolower()
+//
+// Returns an ASCII character, converting to lowercase if uppercase is
+// passed. Note that character values > 127 are simply returned.
+inline char ascii_tolower(unsigned char c) {
+ return ascii_internal::kToLower[c];
+}
+
+// Converts the characters in `s` to lowercase, changing the contents of `s`.
+void AsciiStrToLower(std::string* s);
+
+// Creates a lowercase std::string from a given absl::string_view.
+ABSL_MUST_USE_RESULT inline std::string AsciiStrToLower(absl::string_view s) {
+ std::string result(s);
+ absl::AsciiStrToLower(&result);
+ return result;
+}
+
+// ascii_toupper()
+//
+// Returns the ASCII character, converting to upper-case if lower-case is
+// passed. Note that characters values > 127 are simply returned.
+inline char ascii_toupper(unsigned char c) {
+ return ascii_internal::kToUpper[c];
+}
+
+// Converts the characters in `s` to uppercase, changing the contents of `s`.
+void AsciiStrToUpper(std::string* s);
+
+// Creates an uppercase std::string from a given absl::string_view.
+ABSL_MUST_USE_RESULT inline std::string AsciiStrToUpper(absl::string_view s) {
+ std::string result(s);
+ absl::AsciiStrToUpper(&result);
+ return result;
+}
+
+// Returns absl::string_view with whitespace stripped from the beginning of the
+// given string_view.
+ABSL_MUST_USE_RESULT inline absl::string_view StripLeadingAsciiWhitespace(
+ absl::string_view str) {
+ auto it = std::find_if_not(str.begin(), str.end(), absl::ascii_isspace);
+ return absl::string_view(it, str.end() - it);
+}
+
+// Strips in place whitespace from the beginning of the given std::string.
+inline void StripLeadingAsciiWhitespace(std::string* str) {
+ auto it = std::find_if_not(str->begin(), str->end(), absl::ascii_isspace);
+ str->erase(str->begin(), it);
+}
+
+// Returns absl::string_view with whitespace stripped from the end of the given
+// string_view.
+ABSL_MUST_USE_RESULT inline absl::string_view StripTrailingAsciiWhitespace(
+ absl::string_view str) {
+ auto it = std::find_if_not(str.rbegin(), str.rend(), absl::ascii_isspace);
+ return absl::string_view(str.begin(), str.rend() - it);
+}
+
+// Strips in place whitespace from the end of the given std::string
+inline void StripTrailingAsciiWhitespace(std::string* str) {
+ auto it = std::find_if_not(str->rbegin(), str->rend(), absl::ascii_isspace);
+ str->erase(str->rend() - it);
+}
+
+// Returns absl::string_view with whitespace stripped from both ends of the
+// given string_view.
+ABSL_MUST_USE_RESULT inline absl::string_view StripAsciiWhitespace(
+ absl::string_view str) {
+ return StripTrailingAsciiWhitespace(StripLeadingAsciiWhitespace(str));
+}
+
+// Strips in place whitespace from both ends of the given std::string
+inline void StripAsciiWhitespace(std::string* str) {
+ StripTrailingAsciiWhitespace(str);
+ StripLeadingAsciiWhitespace(str);
+}
+
+// Removes leading, trailing, and consecutive internal whitespace.
+void RemoveExtraAsciiWhitespace(std::string*);
+
+} // namespace absl
+
+#endif // ABSL_STRINGS_ASCII_H_
[19/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/duration_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/duration_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/duration_test.cc
new file mode 100644
index 0000000..7918e16
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/duration_test.cc
@@ -0,0 +1,1688 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <chrono> // NOLINT(build/c++11)
+#include <cmath>
+#include <cstdint>
+#include <ctime>
+#include <limits>
+#include <string>
+
+#include "gmock/gmock.h"
+#include "gtest/gtest.h"
+#include "absl/time/time.h"
+
+namespace {
+
+constexpr int64_t kint64max = std::numeric_limits<int64_t>::max();
+constexpr int64_t kint64min = std::numeric_limits<int64_t>::min();
+
+// Approximates the given number of years. This is only used to make some test
+// code more readable.
+absl::Duration ApproxYears(int64_t n) { return absl::Hours(n) * 365 * 24; }
+
+// A gMock matcher to match timespec values. Use this matcher like:
+// timespec ts1, ts2;
+// EXPECT_THAT(ts1, TimespecMatcher(ts2));
+MATCHER_P(TimespecMatcher, ts, "") {
+ if (ts.tv_sec == arg.tv_sec && ts.tv_nsec == arg.tv_nsec)
+ return true;
+ *result_listener << "expected: {" << ts.tv_sec << ", " << ts.tv_nsec << "} ";
+ *result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_nsec << "}";
+ return false;
+}
+
+// A gMock matcher to match timeval values. Use this matcher like:
+// timeval tv1, tv2;
+// EXPECT_THAT(tv1, TimevalMatcher(tv2));
+MATCHER_P(TimevalMatcher, tv, "") {
+ if (tv.tv_sec == arg.tv_sec && tv.tv_usec == arg.tv_usec)
+ return true;
+ *result_listener << "expected: {" << tv.tv_sec << ", " << tv.tv_usec << "} ";
+ *result_listener << "actual: {" << arg.tv_sec << ", " << arg.tv_usec << "}";
+ return false;
+}
+
+TEST(Duration, ValueSemantics) {
+ // If this compiles, the test passes.
+ constexpr absl::Duration a; // Default construction
+ constexpr absl::Duration b = a; // Copy construction
+ constexpr absl::Duration c(b); // Copy construction (again)
+
+ absl::Duration d;
+ d = c; // Assignment
+}
+
+TEST(Duration, Factories) {
+ constexpr absl::Duration zero = absl::ZeroDuration();
+ constexpr absl::Duration nano = absl::Nanoseconds(1);
+ constexpr absl::Duration micro = absl::Microseconds(1);
+ constexpr absl::Duration milli = absl::Milliseconds(1);
+ constexpr absl::Duration sec = absl::Seconds(1);
+ constexpr absl::Duration min = absl::Minutes(1);
+ constexpr absl::Duration hour = absl::Hours(1);
+
+ EXPECT_EQ(zero, absl::Duration());
+ EXPECT_EQ(zero, absl::Seconds(0));
+ EXPECT_EQ(nano, absl::Nanoseconds(1));
+ EXPECT_EQ(micro, absl::Nanoseconds(1000));
+ EXPECT_EQ(milli, absl::Microseconds(1000));
+ EXPECT_EQ(sec, absl::Milliseconds(1000));
+ EXPECT_EQ(min, absl::Seconds(60));
+ EXPECT_EQ(hour, absl::Minutes(60));
+
+ // Tests factory limits
+ const absl::Duration inf = absl::InfiniteDuration();
+
+ EXPECT_GT(inf, absl::Seconds(kint64max));
+ EXPECT_LT(-inf, absl::Seconds(kint64min));
+ EXPECT_LT(-inf, absl::Seconds(-kint64max));
+
+ EXPECT_EQ(inf, absl::Minutes(kint64max));
+ EXPECT_EQ(-inf, absl::Minutes(kint64min));
+ EXPECT_EQ(-inf, absl::Minutes(-kint64max));
+ EXPECT_GT(inf, absl::Minutes(kint64max / 60));
+ EXPECT_LT(-inf, absl::Minutes(kint64min / 60));
+ EXPECT_LT(-inf, absl::Minutes(-kint64max / 60));
+
+ EXPECT_EQ(inf, absl::Hours(kint64max));
+ EXPECT_EQ(-inf, absl::Hours(kint64min));
+ EXPECT_EQ(-inf, absl::Hours(-kint64max));
+ EXPECT_GT(inf, absl::Hours(kint64max / 3600));
+ EXPECT_LT(-inf, absl::Hours(kint64min / 3600));
+ EXPECT_LT(-inf, absl::Hours(-kint64max / 3600));
+}
+
+TEST(Duration, ToConversion) {
+#define TEST_DURATION_CONVERSION(UNIT) \
+ do { \
+ const absl::Duration d = absl::UNIT(1.5); \
+ const absl::Duration z = absl::ZeroDuration(); \
+ const absl::Duration inf = absl::InfiniteDuration(); \
+ const double dbl_inf = std::numeric_limits<double>::infinity(); \
+ EXPECT_EQ(kint64min, absl::ToInt64##UNIT(-inf)); \
+ EXPECT_EQ(-1, absl::ToInt64##UNIT(-d)); \
+ EXPECT_EQ(0, absl::ToInt64##UNIT(z)); \
+ EXPECT_EQ(1, absl::ToInt64##UNIT(d)); \
+ EXPECT_EQ(kint64max, absl::ToInt64##UNIT(inf)); \
+ EXPECT_EQ(-dbl_inf, absl::ToDouble##UNIT(-inf)); \
+ EXPECT_EQ(-1.5, absl::ToDouble##UNIT(-d)); \
+ EXPECT_EQ(0, absl::ToDouble##UNIT(z)); \
+ EXPECT_EQ(1.5, absl::ToDouble##UNIT(d)); \
+ EXPECT_EQ(dbl_inf, absl::ToDouble##UNIT(inf)); \
+ } while (0)
+
+ TEST_DURATION_CONVERSION(Nanoseconds);
+ TEST_DURATION_CONVERSION(Microseconds);
+ TEST_DURATION_CONVERSION(Milliseconds);
+ TEST_DURATION_CONVERSION(Seconds);
+ TEST_DURATION_CONVERSION(Minutes);
+ TEST_DURATION_CONVERSION(Hours);
+
+#undef TEST_DURATION_CONVERSION
+}
+
+template <int64_t N>
+void TestToConversion() {
+ constexpr absl::Duration nano = absl::Nanoseconds(N);
+ EXPECT_EQ(N, absl::ToInt64Nanoseconds(nano));
+ EXPECT_EQ(0, absl::ToInt64Microseconds(nano));
+ EXPECT_EQ(0, absl::ToInt64Milliseconds(nano));
+ EXPECT_EQ(0, absl::ToInt64Seconds(nano));
+ EXPECT_EQ(0, absl::ToInt64Minutes(nano));
+ EXPECT_EQ(0, absl::ToInt64Hours(nano));
+ const absl::Duration micro = absl::Microseconds(N);
+ EXPECT_EQ(N * 1000, absl::ToInt64Nanoseconds(micro));
+ EXPECT_EQ(N, absl::ToInt64Microseconds(micro));
+ EXPECT_EQ(0, absl::ToInt64Milliseconds(micro));
+ EXPECT_EQ(0, absl::ToInt64Seconds(micro));
+ EXPECT_EQ(0, absl::ToInt64Minutes(micro));
+ EXPECT_EQ(0, absl::ToInt64Hours(micro));
+ const absl::Duration milli = absl::Milliseconds(N);
+ EXPECT_EQ(N * 1000 * 1000, absl::ToInt64Nanoseconds(milli));
+ EXPECT_EQ(N * 1000, absl::ToInt64Microseconds(milli));
+ EXPECT_EQ(N, absl::ToInt64Milliseconds(milli));
+ EXPECT_EQ(0, absl::ToInt64Seconds(milli));
+ EXPECT_EQ(0, absl::ToInt64Minutes(milli));
+ EXPECT_EQ(0, absl::ToInt64Hours(milli));
+ const absl::Duration sec = absl::Seconds(N);
+ EXPECT_EQ(N * 1000 * 1000 * 1000, absl::ToInt64Nanoseconds(sec));
+ EXPECT_EQ(N * 1000 * 1000, absl::ToInt64Microseconds(sec));
+ EXPECT_EQ(N * 1000, absl::ToInt64Milliseconds(sec));
+ EXPECT_EQ(N, absl::ToInt64Seconds(sec));
+ EXPECT_EQ(0, absl::ToInt64Minutes(sec));
+ EXPECT_EQ(0, absl::ToInt64Hours(sec));
+ const absl::Duration min = absl::Minutes(N);
+ EXPECT_EQ(N * 60 * 1000 * 1000 * 1000, absl::ToInt64Nanoseconds(min));
+ EXPECT_EQ(N * 60 * 1000 * 1000, absl::ToInt64Microseconds(min));
+ EXPECT_EQ(N * 60 * 1000, absl::ToInt64Milliseconds(min));
+ EXPECT_EQ(N * 60, absl::ToInt64Seconds(min));
+ EXPECT_EQ(N, absl::ToInt64Minutes(min));
+ EXPECT_EQ(0, absl::ToInt64Hours(min));
+ const absl::Duration hour = absl::Hours(N);
+ EXPECT_EQ(N * 60 * 60 * 1000 * 1000 * 1000, absl::ToInt64Nanoseconds(hour));
+ EXPECT_EQ(N * 60 * 60 * 1000 * 1000, absl::ToInt64Microseconds(hour));
+ EXPECT_EQ(N * 60 * 60 * 1000, absl::ToInt64Milliseconds(hour));
+ EXPECT_EQ(N * 60 * 60, absl::ToInt64Seconds(hour));
+ EXPECT_EQ(N * 60, absl::ToInt64Minutes(hour));
+ EXPECT_EQ(N, absl::ToInt64Hours(hour));
+}
+
+TEST(Duration, ToConversionDeprecated) {
+ TestToConversion<43>();
+ TestToConversion<1>();
+ TestToConversion<0>();
+ TestToConversion<-1>();
+ TestToConversion<-43>();
+}
+
+template <int64_t N>
+void TestFromChronoBasicEquality() {
+ using std::chrono::nanoseconds;
+ using std::chrono::microseconds;
+ using std::chrono::milliseconds;
+ using std::chrono::seconds;
+ using std::chrono::minutes;
+ using std::chrono::hours;
+
+ static_assert(absl::Nanoseconds(N) == absl::FromChrono(nanoseconds(N)), "");
+ static_assert(absl::Microseconds(N) == absl::FromChrono(microseconds(N)), "");
+ static_assert(absl::Milliseconds(N) == absl::FromChrono(milliseconds(N)), "");
+ static_assert(absl::Seconds(N) == absl::FromChrono(seconds(N)), "");
+ static_assert(absl::Minutes(N) == absl::FromChrono(minutes(N)), "");
+ static_assert(absl::Hours(N) == absl::FromChrono(hours(N)), "");
+}
+
+TEST(Duration, FromChrono) {
+ TestFromChronoBasicEquality<-123>();
+ TestFromChronoBasicEquality<-1>();
+ TestFromChronoBasicEquality<0>();
+ TestFromChronoBasicEquality<1>();
+ TestFromChronoBasicEquality<123>();
+
+ // Minutes (might, depending on the platform) saturate at +inf.
+ const auto chrono_minutes_max = std::chrono::minutes::max();
+ const auto minutes_max = absl::FromChrono(chrono_minutes_max);
+ const int64_t minutes_max_count = chrono_minutes_max.count();
+ if (minutes_max_count > kint64max / 60) {
+ EXPECT_EQ(absl::InfiniteDuration(), minutes_max);
+ } else {
+ EXPECT_EQ(absl::Minutes(minutes_max_count), minutes_max);
+ }
+
+ // Minutes (might, depending on the platform) saturate at -inf.
+ const auto chrono_minutes_min = std::chrono::minutes::min();
+ const auto minutes_min = absl::FromChrono(chrono_minutes_min);
+ const int64_t minutes_min_count = chrono_minutes_min.count();
+ if (minutes_min_count < kint64min / 60) {
+ EXPECT_EQ(-absl::InfiniteDuration(), minutes_min);
+ } else {
+ EXPECT_EQ(absl::Minutes(minutes_min_count), minutes_min);
+ }
+
+ // Hours (might, depending on the platform) saturate at +inf.
+ const auto chrono_hours_max = std::chrono::hours::max();
+ const auto hours_max = absl::FromChrono(chrono_hours_max);
+ const int64_t hours_max_count = chrono_hours_max.count();
+ if (hours_max_count > kint64max / 3600) {
+ EXPECT_EQ(absl::InfiniteDuration(), hours_max);
+ } else {
+ EXPECT_EQ(absl::Hours(hours_max_count), hours_max);
+ }
+
+ // Hours (might, depending on the platform) saturate at -inf.
+ const auto chrono_hours_min = std::chrono::hours::min();
+ const auto hours_min = absl::FromChrono(chrono_hours_min);
+ const int64_t hours_min_count = chrono_hours_min.count();
+ if (hours_min_count < kint64min / 3600) {
+ EXPECT_EQ(-absl::InfiniteDuration(), hours_min);
+ } else {
+ EXPECT_EQ(absl::Hours(hours_min_count), hours_min);
+ }
+}
+
+template <int64_t N>
+void TestToChrono() {
+ using std::chrono::nanoseconds;
+ using std::chrono::microseconds;
+ using std::chrono::milliseconds;
+ using std::chrono::seconds;
+ using std::chrono::minutes;
+ using std::chrono::hours;
+
+ EXPECT_EQ(nanoseconds(N), absl::ToChronoNanoseconds(absl::Nanoseconds(N)));
+ EXPECT_EQ(microseconds(N), absl::ToChronoMicroseconds(absl::Microseconds(N)));
+ EXPECT_EQ(milliseconds(N), absl::ToChronoMilliseconds(absl::Milliseconds(N)));
+ EXPECT_EQ(seconds(N), absl::ToChronoSeconds(absl::Seconds(N)));
+
+ constexpr auto absl_minutes = absl::Minutes(N);
+ auto chrono_minutes = minutes(N);
+ if (absl_minutes == -absl::InfiniteDuration()) {
+ chrono_minutes = minutes::min();
+ } else if (absl_minutes == absl::InfiniteDuration()) {
+ chrono_minutes = minutes::max();
+ }
+ EXPECT_EQ(chrono_minutes, absl::ToChronoMinutes(absl_minutes));
+
+ constexpr auto absl_hours = absl::Hours(N);
+ auto chrono_hours = hours(N);
+ if (absl_hours == -absl::InfiniteDuration()) {
+ chrono_hours = hours::min();
+ } else if (absl_hours == absl::InfiniteDuration()) {
+ chrono_hours = hours::max();
+ }
+ EXPECT_EQ(chrono_hours, absl::ToChronoHours(absl_hours));
+}
+
+TEST(Duration, ToChrono) {
+ using std::chrono::nanoseconds;
+ using std::chrono::microseconds;
+ using std::chrono::milliseconds;
+ using std::chrono::seconds;
+ using std::chrono::minutes;
+ using std::chrono::hours;
+
+ TestToChrono<kint64min>();
+ TestToChrono<-1>();
+ TestToChrono<0>();
+ TestToChrono<1>();
+ TestToChrono<kint64max>();
+
+ // Verify truncation toward zero.
+ const auto tick = absl::Nanoseconds(1) / 4;
+ EXPECT_EQ(nanoseconds(0), absl::ToChronoNanoseconds(tick));
+ EXPECT_EQ(nanoseconds(0), absl::ToChronoNanoseconds(-tick));
+ EXPECT_EQ(microseconds(0), absl::ToChronoMicroseconds(tick));
+ EXPECT_EQ(microseconds(0), absl::ToChronoMicroseconds(-tick));
+ EXPECT_EQ(milliseconds(0), absl::ToChronoMilliseconds(tick));
+ EXPECT_EQ(milliseconds(0), absl::ToChronoMilliseconds(-tick));
+ EXPECT_EQ(seconds(0), absl::ToChronoSeconds(tick));
+ EXPECT_EQ(seconds(0), absl::ToChronoSeconds(-tick));
+ EXPECT_EQ(minutes(0), absl::ToChronoMinutes(tick));
+ EXPECT_EQ(minutes(0), absl::ToChronoMinutes(-tick));
+ EXPECT_EQ(hours(0), absl::ToChronoHours(tick));
+ EXPECT_EQ(hours(0), absl::ToChronoHours(-tick));
+
+ // Verifies +/- infinity saturation at max/min.
+ constexpr auto inf = absl::InfiniteDuration();
+ EXPECT_EQ(nanoseconds::min(), absl::ToChronoNanoseconds(-inf));
+ EXPECT_EQ(nanoseconds::max(), absl::ToChronoNanoseconds(inf));
+ EXPECT_EQ(microseconds::min(), absl::ToChronoMicroseconds(-inf));
+ EXPECT_EQ(microseconds::max(), absl::ToChronoMicroseconds(inf));
+ EXPECT_EQ(milliseconds::min(), absl::ToChronoMilliseconds(-inf));
+ EXPECT_EQ(milliseconds::max(), absl::ToChronoMilliseconds(inf));
+ EXPECT_EQ(seconds::min(), absl::ToChronoSeconds(-inf));
+ EXPECT_EQ(seconds::max(), absl::ToChronoSeconds(inf));
+ EXPECT_EQ(minutes::min(), absl::ToChronoMinutes(-inf));
+ EXPECT_EQ(minutes::max(), absl::ToChronoMinutes(inf));
+ EXPECT_EQ(hours::min(), absl::ToChronoHours(-inf));
+ EXPECT_EQ(hours::max(), absl::ToChronoHours(inf));
+}
+
+// Used for testing the factory overloads.
+template <typename T>
+struct ImplicitlyConvertible {
+ T n_;
+ explicit ImplicitlyConvertible(T n) : n_(n) {}
+ // Marking this conversion operator with 'explicit' will cause the test to
+ // fail (as desired).
+ operator T() { return n_; }
+};
+
+TEST(Duration, FactoryOverloads) {
+#define TEST_FACTORY_OVERLOADS(NAME) \
+ EXPECT_EQ(1, NAME(static_cast<int8_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(static_cast<int16_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(static_cast<int32_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(static_cast<int64_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(static_cast<uint8_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(static_cast<uint16_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(static_cast<uint32_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(static_cast<uint64_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(ImplicitlyConvertible<int8_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(ImplicitlyConvertible<int16_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(ImplicitlyConvertible<int32_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(ImplicitlyConvertible<int64_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(ImplicitlyConvertible<uint8_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(ImplicitlyConvertible<uint16_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(ImplicitlyConvertible<uint32_t>(1)) / NAME(1)); \
+ EXPECT_EQ(1, NAME(ImplicitlyConvertible<uint64_t>(1)) / NAME(1)); \
+ EXPECT_EQ(NAME(1) / 2, NAME(static_cast<float>(0.5))); \
+ EXPECT_EQ(NAME(1) / 2, NAME(static_cast<double>(0.5))); \
+ EXPECT_EQ(1.5, absl::FDivDuration(NAME(static_cast<float>(1.5)), NAME(1))); \
+ EXPECT_EQ(1.5, absl::FDivDuration(NAME(static_cast<double>(1.5)), NAME(1)));
+
+ TEST_FACTORY_OVERLOADS(absl::Nanoseconds);
+ TEST_FACTORY_OVERLOADS(absl::Microseconds);
+ TEST_FACTORY_OVERLOADS(absl::Milliseconds);
+ TEST_FACTORY_OVERLOADS(absl::Seconds);
+ TEST_FACTORY_OVERLOADS(absl::Minutes);
+ TEST_FACTORY_OVERLOADS(absl::Hours);
+
+#undef TEST_FACTORY_OVERLOADS
+
+ EXPECT_EQ(absl::Milliseconds(1500), absl::Seconds(1.5));
+ EXPECT_LT(absl::Nanoseconds(1), absl::Nanoseconds(1.5));
+ EXPECT_GT(absl::Nanoseconds(2), absl::Nanoseconds(1.5));
+
+ const double dbl_inf = std::numeric_limits<double>::infinity();
+ EXPECT_EQ(absl::InfiniteDuration(), absl::Nanoseconds(dbl_inf));
+ EXPECT_EQ(absl::InfiniteDuration(), absl::Microseconds(dbl_inf));
+ EXPECT_EQ(absl::InfiniteDuration(), absl::Milliseconds(dbl_inf));
+ EXPECT_EQ(absl::InfiniteDuration(), absl::Seconds(dbl_inf));
+ EXPECT_EQ(absl::InfiniteDuration(), absl::Minutes(dbl_inf));
+ EXPECT_EQ(absl::InfiniteDuration(), absl::Hours(dbl_inf));
+ EXPECT_EQ(-absl::InfiniteDuration(), absl::Nanoseconds(-dbl_inf));
+ EXPECT_EQ(-absl::InfiniteDuration(), absl::Microseconds(-dbl_inf));
+ EXPECT_EQ(-absl::InfiniteDuration(), absl::Milliseconds(-dbl_inf));
+ EXPECT_EQ(-absl::InfiniteDuration(), absl::Seconds(-dbl_inf));
+ EXPECT_EQ(-absl::InfiniteDuration(), absl::Minutes(-dbl_inf));
+ EXPECT_EQ(-absl::InfiniteDuration(), absl::Hours(-dbl_inf));
+}
+
+TEST(Duration, InfinityExamples) {
+ // These examples are used in the documentation in time.h. They are
+ // written so that they can be copy-n-pasted easily.
+
+ constexpr absl::Duration inf = absl::InfiniteDuration();
+ constexpr absl::Duration d = absl::Seconds(1); // Any finite duration
+
+ EXPECT_TRUE(inf == inf + inf);
+ EXPECT_TRUE(inf == inf + d);
+ EXPECT_TRUE(inf == inf - inf);
+ EXPECT_TRUE(-inf == d - inf);
+
+ EXPECT_TRUE(inf == d * 1e100);
+ EXPECT_TRUE(0 == d / inf); // NOLINT(readability/check)
+
+ // Division by zero returns infinity, or kint64min/MAX where necessary.
+ EXPECT_TRUE(inf == d / 0);
+ EXPECT_TRUE(kint64max == d / absl::ZeroDuration());
+}
+
+TEST(Duration, InfinityComparison) {
+ const absl::Duration inf = absl::InfiniteDuration();
+ const absl::Duration any_dur = absl::Seconds(1);
+
+ // Equality
+ EXPECT_EQ(inf, inf);
+ EXPECT_EQ(-inf, -inf);
+ EXPECT_NE(inf, -inf);
+ EXPECT_NE(any_dur, inf);
+ EXPECT_NE(any_dur, -inf);
+
+ // Relational
+ EXPECT_GT(inf, any_dur);
+ EXPECT_LT(-inf, any_dur);
+ EXPECT_LT(-inf, inf);
+ EXPECT_GT(inf, -inf);
+}
+
+TEST(Duration, InfinityAddition) {
+ const absl::Duration sec_max = absl::Seconds(kint64max);
+ const absl::Duration sec_min = absl::Seconds(kint64min);
+ const absl::Duration any_dur = absl::Seconds(1);
+ const absl::Duration inf = absl::InfiniteDuration();
+
+ // Addition
+ EXPECT_EQ(inf, inf + inf);
+ EXPECT_EQ(inf, inf + -inf);
+ EXPECT_EQ(-inf, -inf + inf);
+ EXPECT_EQ(-inf, -inf + -inf);
+
+ EXPECT_EQ(inf, inf + any_dur);
+ EXPECT_EQ(inf, any_dur + inf);
+ EXPECT_EQ(-inf, -inf + any_dur);
+ EXPECT_EQ(-inf, any_dur + -inf);
+
+ // Interesting case
+ absl::Duration almost_inf = sec_max + absl::Nanoseconds(999999999);
+ EXPECT_GT(inf, almost_inf);
+ almost_inf += -absl::Nanoseconds(999999999);
+ EXPECT_GT(inf, almost_inf);
+
+ // Addition overflow/underflow
+ EXPECT_EQ(inf, sec_max + absl::Seconds(1));
+ EXPECT_EQ(inf, sec_max + sec_max);
+ EXPECT_EQ(-inf, sec_min + -absl::Seconds(1));
+ EXPECT_EQ(-inf, sec_min + -sec_max);
+
+ // For reference: IEEE 754 behavior
+ const double dbl_inf = std::numeric_limits<double>::infinity();
+ EXPECT_TRUE(std::isinf(dbl_inf + dbl_inf));
+ EXPECT_TRUE(std::isnan(dbl_inf + -dbl_inf)); // We return inf
+ EXPECT_TRUE(std::isnan(-dbl_inf + dbl_inf)); // We return inf
+ EXPECT_TRUE(std::isinf(-dbl_inf + -dbl_inf));
+}
+
+TEST(Duration, InfinitySubtraction) {
+ const absl::Duration sec_max = absl::Seconds(kint64max);
+ const absl::Duration sec_min = absl::Seconds(kint64min);
+ const absl::Duration any_dur = absl::Seconds(1);
+ const absl::Duration inf = absl::InfiniteDuration();
+
+ // Subtraction
+ EXPECT_EQ(inf, inf - inf);
+ EXPECT_EQ(inf, inf - -inf);
+ EXPECT_EQ(-inf, -inf - inf);
+ EXPECT_EQ(-inf, -inf - -inf);
+
+ EXPECT_EQ(inf, inf - any_dur);
+ EXPECT_EQ(-inf, any_dur - inf);
+ EXPECT_EQ(-inf, -inf - any_dur);
+ EXPECT_EQ(inf, any_dur - -inf);
+
+ // Subtraction overflow/underflow
+ EXPECT_EQ(inf, sec_max - -absl::Seconds(1));
+ EXPECT_EQ(inf, sec_max - -sec_max);
+ EXPECT_EQ(-inf, sec_min - absl::Seconds(1));
+ EXPECT_EQ(-inf, sec_min - sec_max);
+
+ // Interesting case
+ absl::Duration almost_neg_inf = sec_min;
+ EXPECT_LT(-inf, almost_neg_inf);
+ almost_neg_inf -= -absl::Nanoseconds(1);
+ EXPECT_LT(-inf, almost_neg_inf);
+
+ // For reference: IEEE 754 behavior
+ const double dbl_inf = std::numeric_limits<double>::infinity();
+ EXPECT_TRUE(std::isnan(dbl_inf - dbl_inf)); // We return inf
+ EXPECT_TRUE(std::isinf(dbl_inf - -dbl_inf));
+ EXPECT_TRUE(std::isinf(-dbl_inf - dbl_inf));
+ EXPECT_TRUE(std::isnan(-dbl_inf - -dbl_inf)); // We return inf
+}
+
+TEST(Duration, InfinityMultiplication) {
+ const absl::Duration sec_max = absl::Seconds(kint64max);
+ const absl::Duration sec_min = absl::Seconds(kint64min);
+ const absl::Duration inf = absl::InfiniteDuration();
+
+#define TEST_INF_MUL_WITH_TYPE(T) \
+ EXPECT_EQ(inf, inf * static_cast<T>(2)); \
+ EXPECT_EQ(-inf, inf * static_cast<T>(-2)); \
+ EXPECT_EQ(-inf, -inf * static_cast<T>(2)); \
+ EXPECT_EQ(inf, -inf * static_cast<T>(-2)); \
+ EXPECT_EQ(inf, inf * static_cast<T>(0)); \
+ EXPECT_EQ(-inf, -inf * static_cast<T>(0)); \
+ EXPECT_EQ(inf, sec_max * static_cast<T>(2)); \
+ EXPECT_EQ(inf, sec_min * static_cast<T>(-2)); \
+ EXPECT_EQ(inf, (sec_max / static_cast<T>(2)) * static_cast<T>(3)); \
+ EXPECT_EQ(-inf, sec_max * static_cast<T>(-2)); \
+ EXPECT_EQ(-inf, sec_min * static_cast<T>(2)); \
+ EXPECT_EQ(-inf, (sec_min / static_cast<T>(2)) * static_cast<T>(3));
+
+ TEST_INF_MUL_WITH_TYPE(int64_t); // NOLINT(readability/function)
+ TEST_INF_MUL_WITH_TYPE(double); // NOLINT(readability/function)
+
+#undef TEST_INF_MUL_WITH_TYPE
+
+ const double dbl_inf = std::numeric_limits<double>::infinity();
+ EXPECT_EQ(inf, inf * dbl_inf);
+ EXPECT_EQ(-inf, -inf * dbl_inf);
+ EXPECT_EQ(-inf, inf * -dbl_inf);
+ EXPECT_EQ(inf, -inf * -dbl_inf);
+
+ const absl::Duration any_dur = absl::Seconds(1);
+ EXPECT_EQ(inf, any_dur * dbl_inf);
+ EXPECT_EQ(-inf, -any_dur * dbl_inf);
+ EXPECT_EQ(-inf, any_dur * -dbl_inf);
+ EXPECT_EQ(inf, -any_dur * -dbl_inf);
+
+ // Fixed-point multiplication will produce a finite value, whereas floating
+ // point fuzziness will overflow to inf.
+ EXPECT_NE(absl::InfiniteDuration(), absl::Seconds(1) * kint64max);
+ EXPECT_EQ(inf, absl::Seconds(1) * static_cast<double>(kint64max));
+ EXPECT_NE(-absl::InfiniteDuration(), absl::Seconds(1) * kint64min);
+ EXPECT_EQ(-inf, absl::Seconds(1) * static_cast<double>(kint64min));
+
+ // Note that sec_max * or / by 1.0 overflows to inf due to the 53-bit
+ // limitations of double.
+ EXPECT_NE(inf, sec_max);
+ EXPECT_NE(inf, sec_max / 1);
+ EXPECT_EQ(inf, sec_max / 1.0);
+ EXPECT_NE(inf, sec_max * 1);
+ EXPECT_EQ(inf, sec_max * 1.0);
+}
+
+TEST(Duration, InfinityDivision) {
+ const absl::Duration sec_max = absl::Seconds(kint64max);
+ const absl::Duration sec_min = absl::Seconds(kint64min);
+ const absl::Duration inf = absl::InfiniteDuration();
+
+ // Division of Duration by a double
+#define TEST_INF_DIV_WITH_TYPE(T) \
+ EXPECT_EQ(inf, inf / static_cast<T>(2)); \
+ EXPECT_EQ(-inf, inf / static_cast<T>(-2)); \
+ EXPECT_EQ(-inf, -inf / static_cast<T>(2)); \
+ EXPECT_EQ(inf, -inf / static_cast<T>(-2));
+
+ TEST_INF_DIV_WITH_TYPE(int64_t); // NOLINT(readability/function)
+ TEST_INF_DIV_WITH_TYPE(double); // NOLINT(readability/function)
+
+#undef TEST_INF_DIV_WITH_TYPE
+
+ // Division of Duration by a double overflow/underflow
+ EXPECT_EQ(inf, sec_max / 0.5);
+ EXPECT_EQ(inf, sec_min / -0.5);
+ EXPECT_EQ(inf, ((sec_max / 0.5) + absl::Seconds(1)) / 0.5);
+ EXPECT_EQ(-inf, sec_max / -0.5);
+ EXPECT_EQ(-inf, sec_min / 0.5);
+ EXPECT_EQ(-inf, ((sec_min / 0.5) - absl::Seconds(1)) / 0.5);
+
+ const double dbl_inf = std::numeric_limits<double>::infinity();
+ EXPECT_EQ(inf, inf / dbl_inf);
+ EXPECT_EQ(-inf, inf / -dbl_inf);
+ EXPECT_EQ(-inf, -inf / dbl_inf);
+ EXPECT_EQ(inf, -inf / -dbl_inf);
+
+ const absl::Duration any_dur = absl::Seconds(1);
+ EXPECT_EQ(absl::ZeroDuration(), any_dur / dbl_inf);
+ EXPECT_EQ(absl::ZeroDuration(), any_dur / -dbl_inf);
+ EXPECT_EQ(absl::ZeroDuration(), -any_dur / dbl_inf);
+ EXPECT_EQ(absl::ZeroDuration(), -any_dur / -dbl_inf);
+}
+
+TEST(Duration, InfinityModulus) {
+ const absl::Duration sec_max = absl::Seconds(kint64max);
+ const absl::Duration any_dur = absl::Seconds(1);
+ const absl::Duration inf = absl::InfiniteDuration();
+
+ EXPECT_EQ(inf, inf % inf);
+ EXPECT_EQ(inf, inf % -inf);
+ EXPECT_EQ(-inf, -inf % -inf);
+ EXPECT_EQ(-inf, -inf % inf);
+
+ EXPECT_EQ(any_dur, any_dur % inf);
+ EXPECT_EQ(any_dur, any_dur % -inf);
+ EXPECT_EQ(-any_dur, -any_dur % inf);
+ EXPECT_EQ(-any_dur, -any_dur % -inf);
+
+ EXPECT_EQ(inf, inf % -any_dur);
+ EXPECT_EQ(inf, inf % any_dur);
+ EXPECT_EQ(-inf, -inf % -any_dur);
+ EXPECT_EQ(-inf, -inf % any_dur);
+
+ // Remainder isn't affected by overflow.
+ EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Seconds(1));
+ EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Milliseconds(1));
+ EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Microseconds(1));
+ EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Nanoseconds(1));
+ EXPECT_EQ(absl::ZeroDuration(), sec_max % absl::Nanoseconds(1) / 4);
+}
+
+TEST(Duration, InfinityIDiv) {
+ const absl::Duration sec_max = absl::Seconds(kint64max);
+ const absl::Duration any_dur = absl::Seconds(1);
+ const absl::Duration inf = absl::InfiniteDuration();
+ const double dbl_inf = std::numeric_limits<double>::infinity();
+
+ // IDivDuration (int64_t return value + a remainer)
+ absl::Duration rem = absl::ZeroDuration();
+ EXPECT_EQ(kint64max, absl::IDivDuration(inf, inf, &rem));
+ EXPECT_EQ(inf, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(kint64max, absl::IDivDuration(-inf, -inf, &rem));
+ EXPECT_EQ(-inf, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(kint64max, absl::IDivDuration(inf, any_dur, &rem));
+ EXPECT_EQ(inf, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(0, absl::IDivDuration(any_dur, inf, &rem));
+ EXPECT_EQ(any_dur, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(kint64max, absl::IDivDuration(-inf, -any_dur, &rem));
+ EXPECT_EQ(-inf, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(0, absl::IDivDuration(-any_dur, -inf, &rem));
+ EXPECT_EQ(-any_dur, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(kint64min, absl::IDivDuration(-inf, inf, &rem));
+ EXPECT_EQ(-inf, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(kint64min, absl::IDivDuration(inf, -inf, &rem));
+ EXPECT_EQ(inf, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(kint64min, absl::IDivDuration(-inf, any_dur, &rem));
+ EXPECT_EQ(-inf, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(0, absl::IDivDuration(-any_dur, inf, &rem));
+ EXPECT_EQ(-any_dur, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(kint64min, absl::IDivDuration(inf, -any_dur, &rem));
+ EXPECT_EQ(inf, rem);
+
+ rem = absl::ZeroDuration();
+ EXPECT_EQ(0, absl::IDivDuration(any_dur, -inf, &rem));
+ EXPECT_EQ(any_dur, rem);
+
+ // IDivDuration overflow/underflow
+ rem = any_dur;
+ EXPECT_EQ(kint64max,
+ absl::IDivDuration(sec_max, absl::Nanoseconds(1) / 4, &rem));
+ EXPECT_EQ(sec_max - absl::Nanoseconds(kint64max) / 4, rem);
+
+ rem = any_dur;
+ EXPECT_EQ(kint64max,
+ absl::IDivDuration(sec_max, absl::Milliseconds(1), &rem));
+ EXPECT_EQ(sec_max - absl::Milliseconds(kint64max), rem);
+
+ rem = any_dur;
+ EXPECT_EQ(kint64max,
+ absl::IDivDuration(-sec_max, -absl::Milliseconds(1), &rem));
+ EXPECT_EQ(-sec_max + absl::Milliseconds(kint64max), rem);
+
+ rem = any_dur;
+ EXPECT_EQ(kint64min,
+ absl::IDivDuration(-sec_max, absl::Milliseconds(1), &rem));
+ EXPECT_EQ(-sec_max - absl::Milliseconds(kint64min), rem);
+
+ rem = any_dur;
+ EXPECT_EQ(kint64min,
+ absl::IDivDuration(sec_max, -absl::Milliseconds(1), &rem));
+ EXPECT_EQ(sec_max + absl::Milliseconds(kint64min), rem);
+
+ //
+ // operator/(Duration, Duration) is a wrapper for IDivDuration().
+ //
+
+ // IEEE 754 says inf / inf should be nan, but int64_t doesn't have
+ // nan so we'll return kint64max/kint64min instead.
+ EXPECT_TRUE(std::isnan(dbl_inf / dbl_inf));
+ EXPECT_EQ(kint64max, inf / inf);
+ EXPECT_EQ(kint64max, -inf / -inf);
+ EXPECT_EQ(kint64min, -inf / inf);
+ EXPECT_EQ(kint64min, inf / -inf);
+
+ EXPECT_TRUE(std::isinf(dbl_inf / 2.0));
+ EXPECT_EQ(kint64max, inf / any_dur);
+ EXPECT_EQ(kint64max, -inf / -any_dur);
+ EXPECT_EQ(kint64min, -inf / any_dur);
+ EXPECT_EQ(kint64min, inf / -any_dur);
+
+ EXPECT_EQ(0.0, 2.0 / dbl_inf);
+ EXPECT_EQ(0, any_dur / inf);
+ EXPECT_EQ(0, any_dur / -inf);
+ EXPECT_EQ(0, -any_dur / inf);
+ EXPECT_EQ(0, -any_dur / -inf);
+ EXPECT_EQ(0, absl::ZeroDuration() / inf);
+
+ // Division of Duration by a Duration overflow/underflow
+ EXPECT_EQ(kint64max, sec_max / absl::Milliseconds(1));
+ EXPECT_EQ(kint64max, -sec_max / -absl::Milliseconds(1));
+ EXPECT_EQ(kint64min, -sec_max / absl::Milliseconds(1));
+ EXPECT_EQ(kint64min, sec_max / -absl::Milliseconds(1));
+}
+
+TEST(Duration, InfinityFDiv) {
+ const absl::Duration any_dur = absl::Seconds(1);
+ const absl::Duration inf = absl::InfiniteDuration();
+ const double dbl_inf = std::numeric_limits<double>::infinity();
+
+ EXPECT_EQ(dbl_inf, absl::FDivDuration(inf, inf));
+ EXPECT_EQ(dbl_inf, absl::FDivDuration(-inf, -inf));
+ EXPECT_EQ(dbl_inf, absl::FDivDuration(inf, any_dur));
+ EXPECT_EQ(0.0, absl::FDivDuration(any_dur, inf));
+ EXPECT_EQ(dbl_inf, absl::FDivDuration(-inf, -any_dur));
+ EXPECT_EQ(0.0, absl::FDivDuration(-any_dur, -inf));
+
+ EXPECT_EQ(-dbl_inf, absl::FDivDuration(-inf, inf));
+ EXPECT_EQ(-dbl_inf, absl::FDivDuration(inf, -inf));
+ EXPECT_EQ(-dbl_inf, absl::FDivDuration(-inf, any_dur));
+ EXPECT_EQ(0.0, absl::FDivDuration(-any_dur, inf));
+ EXPECT_EQ(-dbl_inf, absl::FDivDuration(inf, -any_dur));
+ EXPECT_EQ(0.0, absl::FDivDuration(any_dur, -inf));
+}
+
+TEST(Duration, DivisionByZero) {
+ const absl::Duration zero = absl::ZeroDuration();
+ const absl::Duration inf = absl::InfiniteDuration();
+ const absl::Duration any_dur = absl::Seconds(1);
+ const double dbl_inf = std::numeric_limits<double>::infinity();
+ const double dbl_denorm = std::numeric_limits<double>::denorm_min();
+
+ // IEEE 754 behavior
+ double z = 0.0, two = 2.0;
+ EXPECT_TRUE(std::isinf(two / z));
+ EXPECT_TRUE(std::isnan(z / z)); // We'll return inf
+
+ // Operator/(Duration, double)
+ EXPECT_EQ(inf, zero / 0.0);
+ EXPECT_EQ(-inf, zero / -0.0);
+ EXPECT_EQ(inf, any_dur / 0.0);
+ EXPECT_EQ(-inf, any_dur / -0.0);
+ EXPECT_EQ(-inf, -any_dur / 0.0);
+ EXPECT_EQ(inf, -any_dur / -0.0);
+
+ // Tests dividing by a number very close to, but not quite zero.
+ EXPECT_EQ(zero, zero / dbl_denorm);
+ EXPECT_EQ(zero, zero / -dbl_denorm);
+ EXPECT_EQ(inf, any_dur / dbl_denorm);
+ EXPECT_EQ(-inf, any_dur / -dbl_denorm);
+ EXPECT_EQ(-inf, -any_dur / dbl_denorm);
+ EXPECT_EQ(inf, -any_dur / -dbl_denorm);
+
+ // IDiv
+ absl::Duration rem = zero;
+ EXPECT_EQ(kint64max, absl::IDivDuration(zero, zero, &rem));
+ EXPECT_EQ(inf, rem);
+
+ rem = zero;
+ EXPECT_EQ(kint64max, absl::IDivDuration(any_dur, zero, &rem));
+ EXPECT_EQ(inf, rem);
+
+ rem = zero;
+ EXPECT_EQ(kint64min, absl::IDivDuration(-any_dur, zero, &rem));
+ EXPECT_EQ(-inf, rem);
+
+ // Operator/(Duration, Duration)
+ EXPECT_EQ(kint64max, zero / zero);
+ EXPECT_EQ(kint64max, any_dur / zero);
+ EXPECT_EQ(kint64min, -any_dur / zero);
+
+ // FDiv
+ EXPECT_EQ(dbl_inf, absl::FDivDuration(zero, zero));
+ EXPECT_EQ(dbl_inf, absl::FDivDuration(any_dur, zero));
+ EXPECT_EQ(-dbl_inf, absl::FDivDuration(-any_dur, zero));
+}
+
+TEST(Duration, Range) {
+ const absl::Duration range = ApproxYears(100 * 1e9);
+ const absl::Duration range_future = range;
+ const absl::Duration range_past = -range;
+
+ EXPECT_LT(range_future, absl::InfiniteDuration());
+ EXPECT_GT(range_past, -absl::InfiniteDuration());
+
+ const absl::Duration full_range = range_future - range_past;
+ EXPECT_GT(full_range, absl::ZeroDuration());
+ EXPECT_LT(full_range, absl::InfiniteDuration());
+
+ const absl::Duration neg_full_range = range_past - range_future;
+ EXPECT_LT(neg_full_range, absl::ZeroDuration());
+ EXPECT_GT(neg_full_range, -absl::InfiniteDuration());
+
+ EXPECT_LT(neg_full_range, full_range);
+ EXPECT_EQ(neg_full_range, -full_range);
+}
+
+TEST(Duration, RelationalOperators) {
+#define TEST_REL_OPS(UNIT) \
+ static_assert(UNIT(2) == UNIT(2), ""); \
+ static_assert(UNIT(1) != UNIT(2), ""); \
+ static_assert(UNIT(1) < UNIT(2), ""); \
+ static_assert(UNIT(3) > UNIT(2), ""); \
+ static_assert(UNIT(1) <= UNIT(2), ""); \
+ static_assert(UNIT(2) <= UNIT(2), ""); \
+ static_assert(UNIT(3) >= UNIT(2), ""); \
+ static_assert(UNIT(2) >= UNIT(2), "");
+
+ TEST_REL_OPS(absl::Nanoseconds);
+ TEST_REL_OPS(absl::Microseconds);
+ TEST_REL_OPS(absl::Milliseconds);
+ TEST_REL_OPS(absl::Seconds);
+ TEST_REL_OPS(absl::Minutes);
+ TEST_REL_OPS(absl::Hours);
+
+#undef TEST_REL_OPS
+}
+
+TEST(Duration, Addition) {
+#define TEST_ADD_OPS(UNIT) \
+ do { \
+ EXPECT_EQ(UNIT(2), UNIT(1) + UNIT(1)); \
+ EXPECT_EQ(UNIT(1), UNIT(2) - UNIT(1)); \
+ EXPECT_EQ(UNIT(0), UNIT(2) - UNIT(2)); \
+ EXPECT_EQ(UNIT(-1), UNIT(1) - UNIT(2)); \
+ EXPECT_EQ(UNIT(-2), UNIT(0) - UNIT(2)); \
+ EXPECT_EQ(UNIT(-2), UNIT(1) - UNIT(3)); \
+ absl::Duration a = UNIT(1); \
+ a += UNIT(1); \
+ EXPECT_EQ(UNIT(2), a); \
+ a -= UNIT(1); \
+ EXPECT_EQ(UNIT(1), a); \
+ } while (0)
+
+ TEST_ADD_OPS(absl::Nanoseconds);
+ TEST_ADD_OPS(absl::Microseconds);
+ TEST_ADD_OPS(absl::Milliseconds);
+ TEST_ADD_OPS(absl::Seconds);
+ TEST_ADD_OPS(absl::Minutes);
+ TEST_ADD_OPS(absl::Hours);
+
+#undef TEST_ADD_OPS
+
+ EXPECT_EQ(absl::Seconds(2), absl::Seconds(3) - 2 * absl::Milliseconds(500));
+ EXPECT_EQ(absl::Seconds(2) + absl::Milliseconds(500),
+ absl::Seconds(3) - absl::Milliseconds(500));
+
+ EXPECT_EQ(absl::Seconds(1) + absl::Milliseconds(998),
+ absl::Milliseconds(999) + absl::Milliseconds(999));
+
+ EXPECT_EQ(absl::Milliseconds(-1),
+ absl::Milliseconds(998) - absl::Milliseconds(999));
+
+ // Tests fractions of a nanoseconds. These are implementation details only.
+ EXPECT_GT(absl::Nanoseconds(1), absl::Nanoseconds(1) / 2);
+ EXPECT_EQ(absl::Nanoseconds(1),
+ absl::Nanoseconds(1) / 2 + absl::Nanoseconds(1) / 2);
+ EXPECT_GT(absl::Nanoseconds(1) / 4, absl::Nanoseconds(0));
+ EXPECT_EQ(absl::Nanoseconds(1) / 8, absl::Nanoseconds(0));
+
+ // Tests subtraction that will cause wrap around of the rep_lo_ bits.
+ absl::Duration d_7_5 = absl::Seconds(7) + absl::Milliseconds(500);
+ absl::Duration d_3_7 = absl::Seconds(3) + absl::Milliseconds(700);
+ absl::Duration ans_3_8 = absl::Seconds(3) + absl::Milliseconds(800);
+ EXPECT_EQ(ans_3_8, d_7_5 - d_3_7);
+
+ // Subtracting min_duration
+ absl::Duration min_dur = absl::Seconds(kint64min);
+ EXPECT_EQ(absl::Seconds(0), min_dur - min_dur);
+ EXPECT_EQ(absl::Seconds(kint64max), absl::Seconds(-1) - min_dur);
+}
+
+TEST(Duration, Negation) {
+ // By storing negations of various values in constexpr variables we
+ // verify that the initializers are constant expressions.
+ constexpr absl::Duration negated_zero_duration = -absl::ZeroDuration();
+ EXPECT_EQ(negated_zero_duration, absl::ZeroDuration());
+
+ constexpr absl::Duration negated_infinite_duration =
+ -absl::InfiniteDuration();
+ EXPECT_NE(negated_infinite_duration, absl::InfiniteDuration());
+ EXPECT_EQ(-negated_infinite_duration, absl::InfiniteDuration());
+
+ // The public APIs to check if a duration is infinite depend on using
+ // -InfiniteDuration(), but we're trying to test operator- here, so we
+ // need to use the lower-level internal query IsInfiniteDuration.
+ EXPECT_TRUE(
+ absl::time_internal::IsInfiniteDuration(negated_infinite_duration));
+
+ // The largest Duration is kint64max seconds and kTicksPerSecond - 1 ticks.
+ // Using the absl::time_internal::MakeDuration API is the cleanest way to
+ // construct that Duration.
+ constexpr absl::Duration max_duration = absl::time_internal::MakeDuration(
+ kint64max, absl::time_internal::kTicksPerSecond - 1);
+ constexpr absl::Duration negated_max_duration = -max_duration;
+ // The largest negatable value is one tick above the minimum representable;
+ // it's the negation of max_duration.
+ constexpr absl::Duration nearly_min_duration =
+ absl::time_internal::MakeDuration(kint64min, int64_t{1});
+ constexpr absl::Duration negated_nearly_min_duration = -nearly_min_duration;
+
+ EXPECT_EQ(negated_max_duration, nearly_min_duration);
+ EXPECT_EQ(negated_nearly_min_duration, max_duration);
+ EXPECT_EQ(-(-max_duration), max_duration);
+
+ constexpr absl::Duration min_duration =
+ absl::time_internal::MakeDuration(kint64min);
+ constexpr absl::Duration negated_min_duration = -min_duration;
+ EXPECT_EQ(negated_min_duration, absl::InfiniteDuration());
+}
+
+TEST(Duration, AbsoluteValue) {
+ EXPECT_EQ(absl::ZeroDuration(), AbsDuration(absl::ZeroDuration()));
+ EXPECT_EQ(absl::Seconds(1), AbsDuration(absl::Seconds(1)));
+ EXPECT_EQ(absl::Seconds(1), AbsDuration(absl::Seconds(-1)));
+
+ EXPECT_EQ(absl::InfiniteDuration(), AbsDuration(absl::InfiniteDuration()));
+ EXPECT_EQ(absl::InfiniteDuration(), AbsDuration(-absl::InfiniteDuration()));
+
+ absl::Duration max_dur =
+ absl::Seconds(kint64max) + (absl::Seconds(1) - absl::Nanoseconds(1) / 4);
+ EXPECT_EQ(max_dur, AbsDuration(max_dur));
+
+ absl::Duration min_dur = absl::Seconds(kint64min);
+ EXPECT_EQ(absl::InfiniteDuration(), AbsDuration(min_dur));
+ EXPECT_EQ(max_dur, AbsDuration(min_dur + absl::Nanoseconds(1) / 4));
+}
+
+TEST(Duration, Multiplication) {
+#define TEST_MUL_OPS(UNIT) \
+ do { \
+ EXPECT_EQ(UNIT(5), UNIT(2) * 2.5); \
+ EXPECT_EQ(UNIT(2), UNIT(5) / 2.5); \
+ EXPECT_EQ(UNIT(-5), UNIT(-2) * 2.5); \
+ EXPECT_EQ(UNIT(-5), -UNIT(2) * 2.5); \
+ EXPECT_EQ(UNIT(-5), UNIT(2) * -2.5); \
+ EXPECT_EQ(UNIT(-2), UNIT(-5) / 2.5); \
+ EXPECT_EQ(UNIT(-2), -UNIT(5) / 2.5); \
+ EXPECT_EQ(UNIT(-2), UNIT(5) / -2.5); \
+ EXPECT_EQ(UNIT(2), UNIT(11) % UNIT(3)); \
+ absl::Duration a = UNIT(2); \
+ a *= 2.5; \
+ EXPECT_EQ(UNIT(5), a); \
+ a /= 2.5; \
+ EXPECT_EQ(UNIT(2), a); \
+ a %= UNIT(1); \
+ EXPECT_EQ(UNIT(0), a); \
+ absl::Duration big = UNIT(1000000000); \
+ big *= 3; \
+ big /= 3; \
+ EXPECT_EQ(UNIT(1000000000), big); \
+ EXPECT_EQ(-UNIT(2), -UNIT(2)); \
+ EXPECT_EQ(-UNIT(2), UNIT(2) * -1); \
+ EXPECT_EQ(-UNIT(2), -1 * UNIT(2)); \
+ EXPECT_EQ(-UNIT(-2), UNIT(2)); \
+ EXPECT_EQ(2, UNIT(2) / UNIT(1)); \
+ absl::Duration rem; \
+ EXPECT_EQ(2, absl::IDivDuration(UNIT(2), UNIT(1), &rem)); \
+ EXPECT_EQ(2.0, absl::FDivDuration(UNIT(2), UNIT(1))); \
+ } while (0)
+
+ TEST_MUL_OPS(absl::Nanoseconds);
+ TEST_MUL_OPS(absl::Microseconds);
+ TEST_MUL_OPS(absl::Milliseconds);
+ TEST_MUL_OPS(absl::Seconds);
+ TEST_MUL_OPS(absl::Minutes);
+ TEST_MUL_OPS(absl::Hours);
+
+#undef TEST_MUL_OPS
+
+ // Ensures that multiplication and division by 1 with a maxed-out durations
+ // doesn't lose precision.
+ absl::Duration max_dur =
+ absl::Seconds(kint64max) + (absl::Seconds(1) - absl::Nanoseconds(1) / 4);
+ absl::Duration min_dur = absl::Seconds(kint64min);
+ EXPECT_EQ(max_dur, max_dur * 1);
+ EXPECT_EQ(max_dur, max_dur / 1);
+ EXPECT_EQ(min_dur, min_dur * 1);
+ EXPECT_EQ(min_dur, min_dur / 1);
+
+ // Tests division on a Duration with a large number of significant digits.
+ // Tests when the digits span hi and lo as well as only in hi.
+ absl::Duration sigfigs = absl::Seconds(2000000000) + absl::Nanoseconds(3);
+ EXPECT_EQ(absl::Seconds(666666666) + absl::Nanoseconds(666666667) +
+ absl::Nanoseconds(1) / 2,
+ sigfigs / 3);
+ sigfigs = absl::Seconds(7000000000LL);
+ EXPECT_EQ(absl::Seconds(2333333333) + absl::Nanoseconds(333333333) +
+ absl::Nanoseconds(1) / 4,
+ sigfigs / 3);
+
+ EXPECT_EQ(absl::Seconds(7) + absl::Milliseconds(500), absl::Seconds(3) * 2.5);
+ EXPECT_EQ(absl::Seconds(8) * -1 + absl::Milliseconds(300),
+ (absl::Seconds(2) + absl::Milliseconds(200)) * -3.5);
+ EXPECT_EQ(-absl::Seconds(8) + absl::Milliseconds(300),
+ (absl::Seconds(2) + absl::Milliseconds(200)) * -3.5);
+ EXPECT_EQ(absl::Seconds(1) + absl::Milliseconds(875),
+ (absl::Seconds(7) + absl::Milliseconds(500)) / 4);
+ EXPECT_EQ(absl::Seconds(30),
+ (absl::Seconds(7) + absl::Milliseconds(500)) / 0.25);
+ EXPECT_EQ(absl::Seconds(3),
+ (absl::Seconds(7) + absl::Milliseconds(500)) / 2.5);
+
+ // Tests division remainder.
+ EXPECT_EQ(absl::Nanoseconds(0), absl::Nanoseconds(7) % absl::Nanoseconds(1));
+ EXPECT_EQ(absl::Nanoseconds(0), absl::Nanoseconds(0) % absl::Nanoseconds(10));
+ EXPECT_EQ(absl::Nanoseconds(2), absl::Nanoseconds(7) % absl::Nanoseconds(5));
+ EXPECT_EQ(absl::Nanoseconds(2), absl::Nanoseconds(2) % absl::Nanoseconds(5));
+
+ EXPECT_EQ(absl::Nanoseconds(1), absl::Nanoseconds(10) % absl::Nanoseconds(3));
+ EXPECT_EQ(absl::Nanoseconds(1),
+ absl::Nanoseconds(10) % absl::Nanoseconds(-3));
+ EXPECT_EQ(absl::Nanoseconds(-1),
+ absl::Nanoseconds(-10) % absl::Nanoseconds(3));
+ EXPECT_EQ(absl::Nanoseconds(-1),
+ absl::Nanoseconds(-10) % absl::Nanoseconds(-3));
+
+ EXPECT_EQ(absl::Milliseconds(100),
+ absl::Seconds(1) % absl::Milliseconds(300));
+ EXPECT_EQ(
+ absl::Milliseconds(300),
+ (absl::Seconds(3) + absl::Milliseconds(800)) % absl::Milliseconds(500));
+
+ EXPECT_EQ(absl::Nanoseconds(1), absl::Nanoseconds(1) % absl::Seconds(1));
+ EXPECT_EQ(absl::Nanoseconds(-1), absl::Nanoseconds(-1) % absl::Seconds(1));
+ EXPECT_EQ(0, absl::Nanoseconds(-1) / absl::Seconds(1)); // Actual -1e-9
+
+ // Tests identity a = (a/b)*b + a%b
+#define TEST_MOD_IDENTITY(a, b) \
+ EXPECT_EQ((a), ((a) / (b))*(b) + ((a)%(b)))
+
+ TEST_MOD_IDENTITY(absl::Seconds(0), absl::Seconds(2));
+ TEST_MOD_IDENTITY(absl::Seconds(1), absl::Seconds(1));
+ TEST_MOD_IDENTITY(absl::Seconds(1), absl::Seconds(2));
+ TEST_MOD_IDENTITY(absl::Seconds(2), absl::Seconds(1));
+
+ TEST_MOD_IDENTITY(absl::Seconds(-2), absl::Seconds(1));
+ TEST_MOD_IDENTITY(absl::Seconds(2), absl::Seconds(-1));
+ TEST_MOD_IDENTITY(absl::Seconds(-2), absl::Seconds(-1));
+
+ TEST_MOD_IDENTITY(absl::Nanoseconds(0), absl::Nanoseconds(2));
+ TEST_MOD_IDENTITY(absl::Nanoseconds(1), absl::Nanoseconds(1));
+ TEST_MOD_IDENTITY(absl::Nanoseconds(1), absl::Nanoseconds(2));
+ TEST_MOD_IDENTITY(absl::Nanoseconds(2), absl::Nanoseconds(1));
+
+ TEST_MOD_IDENTITY(absl::Nanoseconds(-2), absl::Nanoseconds(1));
+ TEST_MOD_IDENTITY(absl::Nanoseconds(2), absl::Nanoseconds(-1));
+ TEST_MOD_IDENTITY(absl::Nanoseconds(-2), absl::Nanoseconds(-1));
+
+ // Mixed seconds + subseconds
+ absl::Duration mixed_a = absl::Seconds(1) + absl::Nanoseconds(2);
+ absl::Duration mixed_b = absl::Seconds(1) + absl::Nanoseconds(3);
+
+ TEST_MOD_IDENTITY(absl::Seconds(0), mixed_a);
+ TEST_MOD_IDENTITY(mixed_a, mixed_a);
+ TEST_MOD_IDENTITY(mixed_a, mixed_b);
+ TEST_MOD_IDENTITY(mixed_b, mixed_a);
+
+ TEST_MOD_IDENTITY(-mixed_a, mixed_b);
+ TEST_MOD_IDENTITY(mixed_a, -mixed_b);
+ TEST_MOD_IDENTITY(-mixed_a, -mixed_b);
+
+#undef TEST_MOD_IDENTITY
+}
+
+TEST(Duration, Truncation) {
+ const absl::Duration d = absl::Nanoseconds(1234567890);
+ const absl::Duration inf = absl::InfiniteDuration();
+ for (int unit_sign : {1, -1}) { // sign shouldn't matter
+ EXPECT_EQ(absl::Nanoseconds(1234567890),
+ Trunc(d, unit_sign * absl::Nanoseconds(1)));
+ EXPECT_EQ(absl::Microseconds(1234567),
+ Trunc(d, unit_sign * absl::Microseconds(1)));
+ EXPECT_EQ(absl::Milliseconds(1234),
+ Trunc(d, unit_sign * absl::Milliseconds(1)));
+ EXPECT_EQ(absl::Seconds(1), Trunc(d, unit_sign * absl::Seconds(1)));
+ EXPECT_EQ(inf, Trunc(inf, unit_sign * absl::Seconds(1)));
+
+ EXPECT_EQ(absl::Nanoseconds(-1234567890),
+ Trunc(-d, unit_sign * absl::Nanoseconds(1)));
+ EXPECT_EQ(absl::Microseconds(-1234567),
+ Trunc(-d, unit_sign * absl::Microseconds(1)));
+ EXPECT_EQ(absl::Milliseconds(-1234),
+ Trunc(-d, unit_sign * absl::Milliseconds(1)));
+ EXPECT_EQ(absl::Seconds(-1), Trunc(-d, unit_sign * absl::Seconds(1)));
+ EXPECT_EQ(-inf, Trunc(-inf, unit_sign * absl::Seconds(1)));
+ }
+}
+
+TEST(Duration, Flooring) {
+ const absl::Duration d = absl::Nanoseconds(1234567890);
+ const absl::Duration inf = absl::InfiniteDuration();
+ for (int unit_sign : {1, -1}) { // sign shouldn't matter
+ EXPECT_EQ(absl::Nanoseconds(1234567890),
+ absl::Floor(d, unit_sign * absl::Nanoseconds(1)));
+ EXPECT_EQ(absl::Microseconds(1234567),
+ absl::Floor(d, unit_sign * absl::Microseconds(1)));
+ EXPECT_EQ(absl::Milliseconds(1234),
+ absl::Floor(d, unit_sign * absl::Milliseconds(1)));
+ EXPECT_EQ(absl::Seconds(1), absl::Floor(d, unit_sign * absl::Seconds(1)));
+ EXPECT_EQ(inf, absl::Floor(inf, unit_sign * absl::Seconds(1)));
+
+ EXPECT_EQ(absl::Nanoseconds(-1234567890),
+ absl::Floor(-d, unit_sign * absl::Nanoseconds(1)));
+ EXPECT_EQ(absl::Microseconds(-1234568),
+ absl::Floor(-d, unit_sign * absl::Microseconds(1)));
+ EXPECT_EQ(absl::Milliseconds(-1235),
+ absl::Floor(-d, unit_sign * absl::Milliseconds(1)));
+ EXPECT_EQ(absl::Seconds(-2), absl::Floor(-d, unit_sign * absl::Seconds(1)));
+ EXPECT_EQ(-inf, absl::Floor(-inf, unit_sign * absl::Seconds(1)));
+ }
+}
+
+TEST(Duration, Ceiling) {
+ const absl::Duration d = absl::Nanoseconds(1234567890);
+ const absl::Duration inf = absl::InfiniteDuration();
+ for (int unit_sign : {1, -1}) { // // sign shouldn't matter
+ EXPECT_EQ(absl::Nanoseconds(1234567890),
+ absl::Ceil(d, unit_sign * absl::Nanoseconds(1)));
+ EXPECT_EQ(absl::Microseconds(1234568),
+ absl::Ceil(d, unit_sign * absl::Microseconds(1)));
+ EXPECT_EQ(absl::Milliseconds(1235),
+ absl::Ceil(d, unit_sign * absl::Milliseconds(1)));
+ EXPECT_EQ(absl::Seconds(2), absl::Ceil(d, unit_sign * absl::Seconds(1)));
+ EXPECT_EQ(inf, absl::Ceil(inf, unit_sign * absl::Seconds(1)));
+
+ EXPECT_EQ(absl::Nanoseconds(-1234567890),
+ absl::Ceil(-d, unit_sign * absl::Nanoseconds(1)));
+ EXPECT_EQ(absl::Microseconds(-1234567),
+ absl::Ceil(-d, unit_sign * absl::Microseconds(1)));
+ EXPECT_EQ(absl::Milliseconds(-1234),
+ absl::Ceil(-d, unit_sign * absl::Milliseconds(1)));
+ EXPECT_EQ(absl::Seconds(-1), absl::Ceil(-d, unit_sign * absl::Seconds(1)));
+ EXPECT_EQ(-inf, absl::Ceil(-inf, unit_sign * absl::Seconds(1)));
+ }
+}
+
+TEST(Duration, RoundTripUnits) {
+ const int kRange = 100000;
+
+#define ROUND_TRIP_UNIT(U, LOW, HIGH) \
+ do { \
+ for (int64_t i = LOW; i < HIGH; ++i) { \
+ absl::Duration d = absl::U(i); \
+ if (d == absl::InfiniteDuration()) \
+ EXPECT_EQ(kint64max, d / absl::U(1)); \
+ else if (d == -absl::InfiniteDuration()) \
+ EXPECT_EQ(kint64min, d / absl::U(1)); \
+ else \
+ EXPECT_EQ(i, absl::U(i) / absl::U(1)); \
+ } \
+ } while (0)
+
+ ROUND_TRIP_UNIT(Nanoseconds, kint64min, kint64min + kRange);
+ ROUND_TRIP_UNIT(Nanoseconds, -kRange, kRange);
+ ROUND_TRIP_UNIT(Nanoseconds, kint64max - kRange, kint64max);
+
+ ROUND_TRIP_UNIT(Microseconds, kint64min, kint64min + kRange);
+ ROUND_TRIP_UNIT(Microseconds, -kRange, kRange);
+ ROUND_TRIP_UNIT(Microseconds, kint64max - kRange, kint64max);
+
+ ROUND_TRIP_UNIT(Milliseconds, kint64min, kint64min + kRange);
+ ROUND_TRIP_UNIT(Milliseconds, -kRange, kRange);
+ ROUND_TRIP_UNIT(Milliseconds, kint64max - kRange, kint64max);
+
+ ROUND_TRIP_UNIT(Seconds, kint64min, kint64min + kRange);
+ ROUND_TRIP_UNIT(Seconds, -kRange, kRange);
+ ROUND_TRIP_UNIT(Seconds, kint64max - kRange, kint64max);
+
+ ROUND_TRIP_UNIT(Minutes, kint64min / 60, kint64min / 60 + kRange);
+ ROUND_TRIP_UNIT(Minutes, -kRange, kRange);
+ ROUND_TRIP_UNIT(Minutes, kint64max / 60 - kRange, kint64max / 60);
+
+ ROUND_TRIP_UNIT(Hours, kint64min / 3600, kint64min / 3600 + kRange);
+ ROUND_TRIP_UNIT(Hours, -kRange, kRange);
+ ROUND_TRIP_UNIT(Hours, kint64max / 3600 - kRange, kint64max / 3600);
+
+#undef ROUND_TRIP_UNIT
+}
+
+TEST(Duration, TruncConversions) {
+ // Tests ToTimespec()/DurationFromTimespec()
+ const struct {
+ absl::Duration d;
+ timespec ts;
+ } to_ts[] = {
+ {absl::Seconds(1) + absl::Nanoseconds(1), {1, 1}},
+ {absl::Seconds(1) + absl::Nanoseconds(1) / 2, {1, 0}},
+ {absl::Seconds(1) + absl::Nanoseconds(0), {1, 0}},
+ {absl::Seconds(0) + absl::Nanoseconds(0), {0, 0}},
+ {absl::Seconds(0) - absl::Nanoseconds(1) / 2, {0, 0}},
+ {absl::Seconds(0) - absl::Nanoseconds(1), {-1, 999999999}},
+ {absl::Seconds(-1) + absl::Nanoseconds(1), {-1, 1}},
+ {absl::Seconds(-1) + absl::Nanoseconds(1) / 2, {-1, 1}},
+ {absl::Seconds(-1) + absl::Nanoseconds(0), {-1, 0}},
+ {absl::Seconds(-1) - absl::Nanoseconds(1) / 2, {-1, 0}},
+ };
+ for (const auto& test : to_ts) {
+ EXPECT_THAT(absl::ToTimespec(test.d), TimespecMatcher(test.ts));
+ }
+ const struct {
+ timespec ts;
+ absl::Duration d;
+ } from_ts[] = {
+ {{1, 1}, absl::Seconds(1) + absl::Nanoseconds(1)},
+ {{1, 0}, absl::Seconds(1) + absl::Nanoseconds(0)},
+ {{0, 0}, absl::Seconds(0) + absl::Nanoseconds(0)},
+ {{0, -1}, absl::Seconds(0) - absl::Nanoseconds(1)},
+ {{-1, 999999999}, absl::Seconds(0) - absl::Nanoseconds(1)},
+ {{-1, 1}, absl::Seconds(-1) + absl::Nanoseconds(1)},
+ {{-1, 0}, absl::Seconds(-1) + absl::Nanoseconds(0)},
+ {{-1, -1}, absl::Seconds(-1) - absl::Nanoseconds(1)},
+ {{-2, 999999999}, absl::Seconds(-1) - absl::Nanoseconds(1)},
+ };
+ for (const auto& test : from_ts) {
+ EXPECT_EQ(test.d, absl::DurationFromTimespec(test.ts));
+ }
+
+ // Tests ToTimeval()/DurationFromTimeval() (same as timespec above)
+ const struct {
+ absl::Duration d;
+ timeval tv;
+ } to_tv[] = {
+ {absl::Seconds(1) + absl::Microseconds(1), {1, 1}},
+ {absl::Seconds(1) + absl::Microseconds(1) / 2, {1, 0}},
+ {absl::Seconds(1) + absl::Microseconds(0), {1, 0}},
+ {absl::Seconds(0) + absl::Microseconds(0), {0, 0}},
+ {absl::Seconds(0) - absl::Microseconds(1) / 2, {0, 0}},
+ {absl::Seconds(0) - absl::Microseconds(1), {-1, 999999}},
+ {absl::Seconds(-1) + absl::Microseconds(1), {-1, 1}},
+ {absl::Seconds(-1) + absl::Microseconds(1) / 2, {-1, 1}},
+ {absl::Seconds(-1) + absl::Microseconds(0), {-1, 0}},
+ {absl::Seconds(-1) - absl::Microseconds(1) / 2, {-1, 0}},
+ };
+ for (const auto& test : to_tv) {
+ EXPECT_THAT(absl::ToTimeval(test.d), TimevalMatcher(test.tv));
+ }
+ const struct {
+ timeval tv;
+ absl::Duration d;
+ } from_tv[] = {
+ {{1, 1}, absl::Seconds(1) + absl::Microseconds(1)},
+ {{1, 0}, absl::Seconds(1) + absl::Microseconds(0)},
+ {{0, 0}, absl::Seconds(0) + absl::Microseconds(0)},
+ {{0, -1}, absl::Seconds(0) - absl::Microseconds(1)},
+ {{-1, 999999}, absl::Seconds(0) - absl::Microseconds(1)},
+ {{-1, 1}, absl::Seconds(-1) + absl::Microseconds(1)},
+ {{-1, 0}, absl::Seconds(-1) + absl::Microseconds(0)},
+ {{-1, -1}, absl::Seconds(-1) - absl::Microseconds(1)},
+ {{-2, 999999}, absl::Seconds(-1) - absl::Microseconds(1)},
+ };
+ for (const auto& test : from_tv) {
+ EXPECT_EQ(test.d, absl::DurationFromTimeval(test.tv));
+ }
+}
+
+TEST(Duration, SmallConversions) {
+ // Special tests for conversions of small durations.
+
+ EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(0));
+ // TODO(bww): Is the next one OK?
+ EXPECT_EQ(absl::ZeroDuration(), absl::Seconds(0.124999999e-9));
+ EXPECT_EQ(absl::Nanoseconds(1) / 4, absl::Seconds(0.125e-9));
+ EXPECT_EQ(absl::Nanoseconds(1) / 4, absl::Seconds(0.250e-9));
+ EXPECT_EQ(absl::Nanoseconds(1) / 2, absl::Seconds(0.375e-9));
+ EXPECT_EQ(absl::Nanoseconds(1) / 2, absl::Seconds(0.500e-9));
+ EXPECT_EQ(absl::Nanoseconds(3) / 4, absl::Seconds(0.625e-9));
+ EXPECT_EQ(absl::Nanoseconds(3) / 4, absl::Seconds(0.750e-9));
+ EXPECT_EQ(absl::Nanoseconds(1), absl::Seconds(0.875e-9));
+ EXPECT_EQ(absl::Nanoseconds(1), absl::Seconds(1.000e-9));
+
+ timespec ts;
+ ts.tv_sec = 0;
+ ts.tv_nsec = 0;
+ EXPECT_THAT(ToTimespec(absl::Nanoseconds(0)), TimespecMatcher(ts));
+ // TODO(bww): Are the next three OK?
+ EXPECT_THAT(ToTimespec(absl::Nanoseconds(1) / 4), TimespecMatcher(ts));
+ EXPECT_THAT(ToTimespec(absl::Nanoseconds(2) / 4), TimespecMatcher(ts));
+ EXPECT_THAT(ToTimespec(absl::Nanoseconds(3) / 4), TimespecMatcher(ts));
+ ts.tv_nsec = 1;
+ EXPECT_THAT(ToTimespec(absl::Nanoseconds(4) / 4), TimespecMatcher(ts));
+ EXPECT_THAT(ToTimespec(absl::Nanoseconds(5) / 4), TimespecMatcher(ts));
+ EXPECT_THAT(ToTimespec(absl::Nanoseconds(6) / 4), TimespecMatcher(ts));
+ EXPECT_THAT(ToTimespec(absl::Nanoseconds(7) / 4), TimespecMatcher(ts));
+ ts.tv_nsec = 2;
+ EXPECT_THAT(ToTimespec(absl::Nanoseconds(8) / 4), TimespecMatcher(ts));
+
+ timeval tv;
+ tv.tv_sec = 0;
+ tv.tv_usec = 0;
+ EXPECT_THAT(ToTimeval(absl::Nanoseconds(0)), TimevalMatcher(tv));
+ // TODO(bww): Is the next one OK?
+ EXPECT_THAT(ToTimeval(absl::Nanoseconds(999)), TimevalMatcher(tv));
+ tv.tv_usec = 1;
+ EXPECT_THAT(ToTimeval(absl::Nanoseconds(1000)), TimevalMatcher(tv));
+ EXPECT_THAT(ToTimeval(absl::Nanoseconds(1999)), TimevalMatcher(tv));
+ tv.tv_usec = 2;
+ EXPECT_THAT(ToTimeval(absl::Nanoseconds(2000)), TimevalMatcher(tv));
+}
+
+TEST(Duration, ConversionSaturation) {
+ absl::Duration d;
+
+ const auto max_timeval_sec =
+ std::numeric_limits<decltype(timeval::tv_sec)>::max();
+ const auto min_timeval_sec =
+ std::numeric_limits<decltype(timeval::tv_sec)>::min();
+ timeval tv;
+ tv.tv_sec = max_timeval_sec;
+ tv.tv_usec = 999998;
+ d = absl::DurationFromTimeval(tv);
+ tv = ToTimeval(d);
+ EXPECT_EQ(max_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(999998, tv.tv_usec);
+ d += absl::Microseconds(1);
+ tv = ToTimeval(d);
+ EXPECT_EQ(max_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(999999, tv.tv_usec);
+ d += absl::Microseconds(1); // no effect
+ tv = ToTimeval(d);
+ EXPECT_EQ(max_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(999999, tv.tv_usec);
+
+ tv.tv_sec = min_timeval_sec;
+ tv.tv_usec = 1;
+ d = absl::DurationFromTimeval(tv);
+ tv = ToTimeval(d);
+ EXPECT_EQ(min_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(1, tv.tv_usec);
+ d -= absl::Microseconds(1);
+ tv = ToTimeval(d);
+ EXPECT_EQ(min_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(0, tv.tv_usec);
+ d -= absl::Microseconds(1); // no effect
+ tv = ToTimeval(d);
+ EXPECT_EQ(min_timeval_sec, tv.tv_sec);
+ EXPECT_EQ(0, tv.tv_usec);
+
+ const auto max_timespec_sec =
+ std::numeric_limits<decltype(timespec::tv_sec)>::max();
+ const auto min_timespec_sec =
+ std::numeric_limits<decltype(timespec::tv_sec)>::min();
+ timespec ts;
+ ts.tv_sec = max_timespec_sec;
+ ts.tv_nsec = 999999998;
+ d = absl::DurationFromTimespec(ts);
+ ts = absl::ToTimespec(d);
+ EXPECT_EQ(max_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(999999998, ts.tv_nsec);
+ d += absl::Nanoseconds(1);
+ ts = absl::ToTimespec(d);
+ EXPECT_EQ(max_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(999999999, ts.tv_nsec);
+ d += absl::Nanoseconds(1); // no effect
+ ts = absl::ToTimespec(d);
+ EXPECT_EQ(max_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(999999999, ts.tv_nsec);
+
+ ts.tv_sec = min_timespec_sec;
+ ts.tv_nsec = 1;
+ d = absl::DurationFromTimespec(ts);
+ ts = absl::ToTimespec(d);
+ EXPECT_EQ(min_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(1, ts.tv_nsec);
+ d -= absl::Nanoseconds(1);
+ ts = absl::ToTimespec(d);
+ EXPECT_EQ(min_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(0, ts.tv_nsec);
+ d -= absl::Nanoseconds(1); // no effect
+ ts = absl::ToTimespec(d);
+ EXPECT_EQ(min_timespec_sec, ts.tv_sec);
+ EXPECT_EQ(0, ts.tv_nsec);
+}
+
+TEST(Duration, FormatDuration) {
+ // Example from Go's docs.
+ EXPECT_EQ("72h3m0.5s",
+ absl::FormatDuration(absl::Hours(72) + absl::Minutes(3) +
+ absl::Milliseconds(500)));
+ // Go's largest time: 2540400h10m10.000000000s
+ EXPECT_EQ("2540400h10m10s",
+ absl::FormatDuration(absl::Hours(2540400) + absl::Minutes(10) +
+ absl::Seconds(10)));
+
+ EXPECT_EQ("0", absl::FormatDuration(absl::ZeroDuration()));
+ EXPECT_EQ("0", absl::FormatDuration(absl::Seconds(0)));
+ EXPECT_EQ("0", absl::FormatDuration(absl::Nanoseconds(0)));
+
+ EXPECT_EQ("1ns", absl::FormatDuration(absl::Nanoseconds(1)));
+ EXPECT_EQ("1us", absl::FormatDuration(absl::Microseconds(1)));
+ EXPECT_EQ("1ms", absl::FormatDuration(absl::Milliseconds(1)));
+ EXPECT_EQ("1s", absl::FormatDuration(absl::Seconds(1)));
+ EXPECT_EQ("1m", absl::FormatDuration(absl::Minutes(1)));
+ EXPECT_EQ("1h", absl::FormatDuration(absl::Hours(1)));
+
+ EXPECT_EQ("1h1m", absl::FormatDuration(absl::Hours(1) + absl::Minutes(1)));
+ EXPECT_EQ("1h1s", absl::FormatDuration(absl::Hours(1) + absl::Seconds(1)));
+ EXPECT_EQ("1m1s", absl::FormatDuration(absl::Minutes(1) + absl::Seconds(1)));
+
+ EXPECT_EQ("1h0.25s",
+ absl::FormatDuration(absl::Hours(1) + absl::Milliseconds(250)));
+ EXPECT_EQ("1m0.25s",
+ absl::FormatDuration(absl::Minutes(1) + absl::Milliseconds(250)));
+ EXPECT_EQ("1h1m0.25s",
+ absl::FormatDuration(absl::Hours(1) + absl::Minutes(1) +
+ absl::Milliseconds(250)));
+ EXPECT_EQ("1h0.0005s",
+ absl::FormatDuration(absl::Hours(1) + absl::Microseconds(500)));
+ EXPECT_EQ("1h0.0000005s",
+ absl::FormatDuration(absl::Hours(1) + absl::Nanoseconds(500)));
+
+ // Subsecond special case.
+ EXPECT_EQ("1.5ns", absl::FormatDuration(absl::Nanoseconds(1) +
+ absl::Nanoseconds(1) / 2));
+ EXPECT_EQ("1.25ns", absl::FormatDuration(absl::Nanoseconds(1) +
+ absl::Nanoseconds(1) / 4));
+ EXPECT_EQ("1ns", absl::FormatDuration(absl::Nanoseconds(1) +
+ absl::Nanoseconds(1) / 9));
+ EXPECT_EQ("1.2us", absl::FormatDuration(absl::Microseconds(1) +
+ absl::Nanoseconds(200)));
+ EXPECT_EQ("1.2ms", absl::FormatDuration(absl::Milliseconds(1) +
+ absl::Microseconds(200)));
+ EXPECT_EQ("1.0002ms", absl::FormatDuration(absl::Milliseconds(1) +
+ absl::Nanoseconds(200)));
+ EXPECT_EQ("1.00001ms", absl::FormatDuration(absl::Milliseconds(1) +
+ absl::Nanoseconds(10)));
+ EXPECT_EQ("1.000001ms",
+ absl::FormatDuration(absl::Milliseconds(1) + absl::Nanoseconds(1)));
+
+ // Negative durations.
+ EXPECT_EQ("-1ns", absl::FormatDuration(absl::Nanoseconds(-1)));
+ EXPECT_EQ("-1us", absl::FormatDuration(absl::Microseconds(-1)));
+ EXPECT_EQ("-1ms", absl::FormatDuration(absl::Milliseconds(-1)));
+ EXPECT_EQ("-1s", absl::FormatDuration(absl::Seconds(-1)));
+ EXPECT_EQ("-1m", absl::FormatDuration(absl::Minutes(-1)));
+ EXPECT_EQ("-1h", absl::FormatDuration(absl::Hours(-1)));
+
+ EXPECT_EQ("-1h1m",
+ absl::FormatDuration(-(absl::Hours(1) + absl::Minutes(1))));
+ EXPECT_EQ("-1h1s",
+ absl::FormatDuration(-(absl::Hours(1) + absl::Seconds(1))));
+ EXPECT_EQ("-1m1s",
+ absl::FormatDuration(-(absl::Minutes(1) + absl::Seconds(1))));
+
+ EXPECT_EQ("-1ns", absl::FormatDuration(absl::Nanoseconds(-1)));
+ EXPECT_EQ("-1.2us", absl::FormatDuration(
+ -(absl::Microseconds(1) + absl::Nanoseconds(200))));
+ EXPECT_EQ("-1.2ms", absl::FormatDuration(
+ -(absl::Milliseconds(1) + absl::Microseconds(200))));
+ EXPECT_EQ("-1.0002ms", absl::FormatDuration(-(absl::Milliseconds(1) +
+ absl::Nanoseconds(200))));
+ EXPECT_EQ("-1.00001ms", absl::FormatDuration(-(absl::Milliseconds(1) +
+ absl::Nanoseconds(10))));
+ EXPECT_EQ("-1.000001ms", absl::FormatDuration(-(absl::Milliseconds(1) +
+ absl::Nanoseconds(1))));
+
+ //
+ // Interesting corner cases.
+ //
+
+ const absl::Duration qns = absl::Nanoseconds(1) / 4;
+ const absl::Duration max_dur =
+ absl::Seconds(kint64max) + (absl::Seconds(1) - qns);
+ const absl::Duration min_dur = absl::Seconds(kint64min);
+
+ EXPECT_EQ("0.25ns", absl::FormatDuration(qns));
+ EXPECT_EQ("-0.25ns", absl::FormatDuration(-qns));
+ EXPECT_EQ("2562047788015215h30m7.99999999975s",
+ absl::FormatDuration(max_dur));
+ EXPECT_EQ("-2562047788015215h30m8s", absl::FormatDuration(min_dur));
+
+ // Tests printing full precision from units that print using FDivDuration
+ EXPECT_EQ("55.00000000025s", absl::FormatDuration(absl::Seconds(55) + qns));
+ EXPECT_EQ("55.00000025ms",
+ absl::FormatDuration(absl::Milliseconds(55) + qns));
+ EXPECT_EQ("55.00025us", absl::FormatDuration(absl::Microseconds(55) + qns));
+ EXPECT_EQ("55.25ns", absl::FormatDuration(absl::Nanoseconds(55) + qns));
+
+ // Formatting infinity
+ EXPECT_EQ("inf", absl::FormatDuration(absl::InfiniteDuration()));
+ EXPECT_EQ("-inf", absl::FormatDuration(-absl::InfiniteDuration()));
+
+ // Formatting approximately +/- 100 billion years
+ const absl::Duration huge_range = ApproxYears(100000000000);
+ EXPECT_EQ("876000000000000h", absl::FormatDuration(huge_range));
+ EXPECT_EQ("-876000000000000h", absl::FormatDuration(-huge_range));
+
+ EXPECT_EQ("876000000000000h0.999999999s",
+ absl::FormatDuration(huge_range +
+ (absl::Seconds(1) - absl::Nanoseconds(1))));
+ EXPECT_EQ("876000000000000h0.9999999995s",
+ absl::FormatDuration(
+ huge_range + (absl::Seconds(1) - absl::Nanoseconds(1) / 2)));
+ EXPECT_EQ("876000000000000h0.99999999975s",
+ absl::FormatDuration(
+ huge_range + (absl::Seconds(1) - absl::Nanoseconds(1) / 4)));
+
+ EXPECT_EQ("-876000000000000h0.999999999s",
+ absl::FormatDuration(-huge_range -
+ (absl::Seconds(1) - absl::Nanoseconds(1))));
+ EXPECT_EQ("-876000000000000h0.9999999995s",
+ absl::FormatDuration(
+ -huge_range - (absl::Seconds(1) - absl::Nanoseconds(1) / 2)));
+ EXPECT_EQ("-876000000000000h0.99999999975s",
+ absl::FormatDuration(
+ -huge_range - (absl::Seconds(1) - absl::Nanoseconds(1) / 4)));
+}
+
+TEST(Duration, ParseDuration) {
+ absl::Duration d;
+
+ // No specified unit. Should only work for zero and infinity.
+ EXPECT_TRUE(absl::ParseDuration("0", &d));
+ EXPECT_EQ(absl::ZeroDuration(), d);
+ EXPECT_TRUE(absl::ParseDuration("+0", &d));
+ EXPECT_EQ(absl::ZeroDuration(), d);
+ EXPECT_TRUE(absl::ParseDuration("-0", &d));
+ EXPECT_EQ(absl::ZeroDuration(), d);
+
+ EXPECT_TRUE(absl::ParseDuration("inf", &d));
+ EXPECT_EQ(absl::InfiniteDuration(), d);
+ EXPECT_TRUE(absl::ParseDuration("+inf", &d));
+ EXPECT_EQ(absl::InfiniteDuration(), d);
+ EXPECT_TRUE(absl::ParseDuration("-inf", &d));
+ EXPECT_EQ(-absl::InfiniteDuration(), d);
+ EXPECT_FALSE(absl::ParseDuration("infBlah", &d));
+
+ // Illegal input forms.
+ EXPECT_FALSE(absl::ParseDuration("", &d));
+ EXPECT_FALSE(absl::ParseDuration("0.0", &d));
+ EXPECT_FALSE(absl::ParseDuration(".0", &d));
+ EXPECT_FALSE(absl::ParseDuration(".", &d));
+ EXPECT_FALSE(absl::ParseDuration("01", &d));
+ EXPECT_FALSE(absl::ParseDuration("1", &d));
+ EXPECT_FALSE(absl::ParseDuration("-1", &d));
+ EXPECT_FALSE(absl::ParseDuration("2", &d));
+ EXPECT_FALSE(absl::ParseDuration("2 s", &d));
+ EXPECT_FALSE(absl::ParseDuration(".s", &d));
+ EXPECT_FALSE(absl::ParseDuration("-.s", &d));
+ EXPECT_FALSE(absl::ParseDuration("s", &d));
+ EXPECT_FALSE(absl::ParseDuration(" 2s", &d));
+ EXPECT_FALSE(absl::ParseDuration("2s ", &d));
+ EXPECT_FALSE(absl::ParseDuration(" 2s ", &d));
+ EXPECT_FALSE(absl::ParseDuration("2mt", &d));
+ EXPECT_FALSE(absl::ParseDuration("1e3s", &d));
+
+ // One unit type.
+ EXPECT_TRUE(absl::ParseDuration("1ns", &d));
+ EXPECT_EQ(absl::Nanoseconds(1), d);
+ EXPECT_TRUE(absl::ParseDuration("1us", &d));
+ EXPECT_EQ(absl::Microseconds(1), d);
+ EXPECT_TRUE(absl::ParseDuration("1ms", &d));
+ EXPECT_EQ(absl::Milliseconds(1), d);
+ EXPECT_TRUE(absl::ParseDuration("1s", &d));
+ EXPECT_EQ(absl::Seconds(1), d);
+ EXPECT_TRUE(absl::ParseDuration("2m", &d));
+ EXPECT_EQ(absl::Minutes(2), d);
+ EXPECT_TRUE(absl::ParseDuration("2h", &d));
+ EXPECT_EQ(absl::Hours(2), d);
+
+ // Huge counts of a unit.
+ EXPECT_TRUE(absl::ParseDuration("9223372036854775807us", &d));
+ EXPECT_EQ(absl::Microseconds(9223372036854775807), d);
+ EXPECT_TRUE(absl::ParseDuration("-9223372036854775807us", &d));
+ EXPECT_EQ(absl::Microseconds(-9223372036854775807), d);
+
+ // Multiple units.
+ EXPECT_TRUE(absl::ParseDuration("2h3m4s", &d));
+ EXPECT_EQ(absl::Hours(2) + absl::Minutes(3) + absl::Seconds(4), d);
+ EXPECT_TRUE(absl::ParseDuration("3m4s5us", &d));
+ EXPECT_EQ(absl::Minutes(3) + absl::Seconds(4) + absl::Microseconds(5), d);
+ EXPECT_TRUE(absl::ParseDuration("2h3m4s5ms6us7ns", &d));
+ EXPECT_EQ(absl::Hours(2) + absl::Minutes(3) + absl::Seconds(4) +
+ absl::Milliseconds(5) + absl::Microseconds(6) +
+ absl::Nanoseconds(7),
+ d);
+
+ // Multiple units out of order.
+ EXPECT_TRUE(absl::ParseDuration("2us3m4s5h", &d));
+ EXPECT_EQ(absl::Hours(5) + absl::Minutes(3) + absl::Seconds(4) +
+ absl::Microseconds(2),
+ d);
+
+ // Fractional values of units.
+ EXPECT_TRUE(absl::ParseDuration("1.5ns", &d));
+ EXPECT_EQ(1.5 * absl::Nanoseconds(1), d);
+ EXPECT_TRUE(absl::ParseDuration("1.5us", &d));
+ EXPECT_EQ(1.5 * absl::Microseconds(1), d);
+ EXPECT_TRUE(absl::ParseDuration("1.5ms", &d));
+ EXPECT_EQ(1.5 * absl::Milliseconds(1), d);
+ EXPECT_TRUE(absl::ParseDuration("1.5s", &d));
+ EXPECT_EQ(1.5 * absl::Seconds(1), d);
+ EXPECT_TRUE(absl::ParseDuration("1.5m", &d));
+ EXPECT_EQ(1.5 * absl::Minutes(1), d);
+ EXPECT_TRUE(absl::ParseDuration("1.5h", &d));
+ EXPECT_EQ(1.5 * absl::Hours(1), d);
+
+ // Huge fractional counts of a unit.
+ EXPECT_TRUE(absl::ParseDuration("0.4294967295s", &d));
+ EXPECT_EQ(absl::Nanoseconds(429496729) + absl::Nanoseconds(1) / 2, d);
+ EXPECT_TRUE(absl::ParseDuration("0.429496729501234567890123456789s", &d));
+ EXPECT_EQ(absl::Nanoseconds(429496729) + absl::Nanoseconds(1) / 2, d);
+
+ // Negative durations.
+ EXPECT_TRUE(absl::ParseDuration("-1s", &d));
+ EXPECT_EQ(absl::Seconds(-1), d);
+ EXPECT_TRUE(absl::ParseDuration("-1m", &d));
+ EXPECT_EQ(absl::Minutes(-1), d);
+ EXPECT_TRUE(absl::ParseDuration("-1h", &d));
+ EXPECT_EQ(absl::Hours(-1), d);
+
+ EXPECT_TRUE(absl::ParseDuration("-1h2s", &d));
+ EXPECT_EQ(-(absl::Hours(1) + absl::Seconds(2)), d);
+ EXPECT_FALSE(absl::ParseDuration("1h-2s", &d));
+ EXPECT_FALSE(absl::ParseDuration("-1h-2s", &d));
+ EXPECT_FALSE(absl::ParseDuration("-1h -2s", &d));
+}
+
+TEST(Duration, FormatParseRoundTrip) {
+#define TEST_PARSE_ROUNDTRIP(d) \
+ do { \
+ std::string s = absl::FormatDuration(d); \
+ absl::Duration dur; \
+ EXPECT_TRUE(absl::ParseDuration(s, &dur)); \
+ EXPECT_EQ(d, dur); \
+ } while (0)
+
+ TEST_PARSE_ROUNDTRIP(absl::Nanoseconds(1));
+ TEST_PARSE_ROUNDTRIP(absl::Microseconds(1));
+ TEST_PARSE_ROUNDTRIP(absl::Milliseconds(1));
+ TEST_PARSE_ROUNDTRIP(absl::Seconds(1));
+ TEST_PARSE_ROUNDTRIP(absl::Minutes(1));
+ TEST_PARSE_ROUNDTRIP(absl::Hours(1));
+ TEST_PARSE_ROUNDTRIP(absl::Hours(1) + absl::Nanoseconds(2));
+
+ TEST_PARSE_ROUNDTRIP(absl::Nanoseconds(-1));
+ TEST_PARSE_ROUNDTRIP(absl::Microseconds(-1));
+ TEST_PARSE_ROUNDTRIP(absl::Milliseconds(-1));
+ TEST_PARSE_ROUNDTRIP(absl::Seconds(-1));
+ TEST_PARSE_ROUNDTRIP(absl::Minutes(-1));
+ TEST_PARSE_ROUNDTRIP(absl::Hours(-1));
+
+ TEST_PARSE_ROUNDTRIP(absl::Hours(-1) + absl::Nanoseconds(2));
+ TEST_PARSE_ROUNDTRIP(absl::Hours(1) + absl::Nanoseconds(-2));
+ TEST_PARSE_ROUNDTRIP(absl::Hours(-1) + absl::Nanoseconds(-2));
+
+ TEST_PARSE_ROUNDTRIP(absl::Nanoseconds(1) +
+ absl::Nanoseconds(1) / 4); // 1.25ns
+
+ const absl::Duration huge_range = ApproxYears(100000000000);
+ TEST_PARSE_ROUNDTRIP(huge_range);
+ TEST_PARSE_ROUNDTRIP(huge_range + (absl::Seconds(1) - absl::Nanoseconds(1)));
+
+#undef TEST_PARSE_ROUNDTRIP
+}
+
+} // namespace
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/format.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/format.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/format.cc
new file mode 100644
index 0000000..5dc01bd
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/format.cc
@@ -0,0 +1,142 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include <string.h>
+#include <cctype>
+#include <cstdint>
+
+#include "absl/time/internal/cctz/include/cctz/time_zone.h"
+#include "absl/time/time.h"
+
+namespace cctz = absl::time_internal::cctz;
+
+namespace absl {
+
+extern const char RFC3339_full[] = "%Y-%m-%dT%H:%M:%E*S%Ez";
+extern const char RFC3339_sec[] = "%Y-%m-%dT%H:%M:%S%Ez";
+
+extern const char RFC1123_full[] = "%a, %d %b %E4Y %H:%M:%S %z";
+extern const char RFC1123_no_wday[] = "%d %b %E4Y %H:%M:%S %z";
+
+namespace {
+
+const char kInfiniteFutureStr[] = "infinite-future";
+const char kInfinitePastStr[] = "infinite-past";
+
+using cctz_sec = cctz::time_point<cctz::sys_seconds>;
+using cctz_fem = cctz::detail::femtoseconds;
+struct cctz_parts {
+ cctz_sec sec;
+ cctz_fem fem;
+};
+
+inline cctz_sec unix_epoch() {
+ return std::chrono::time_point_cast<cctz::sys_seconds>(
+ std::chrono::system_clock::from_time_t(0));
+}
+
+// Splits a Time into seconds and femtoseconds, which can be used with CCTZ.
+// Requires that 't' is finite. See duration.cc for details about rep_hi and
+// rep_lo.
+cctz_parts Split(absl::Time t) {
+ const auto d = time_internal::ToUnixDuration(t);
+ const int64_t rep_hi = time_internal::GetRepHi(d);
+ const int64_t rep_lo = time_internal::GetRepLo(d);
+ const auto sec = unix_epoch() + cctz::sys_seconds(rep_hi);
+ const auto fem = cctz_fem(rep_lo * (1000 * 1000 / 4));
+ return {sec, fem};
+}
+
+// Joins the given seconds and femtoseconds into a Time. See duration.cc for
+// details about rep_hi and rep_lo.
+absl::Time Join(const cctz_parts& parts) {
+ const int64_t rep_hi = (parts.sec - unix_epoch()).count();
+ const uint32_t rep_lo = parts.fem.count() / (1000 * 1000 / 4);
+ const auto d = time_internal::MakeDuration(rep_hi, rep_lo);
+ return time_internal::FromUnixDuration(d);
+}
+
+} // namespace
+
+std::string FormatTime(const std::string& format, absl::Time t, absl::TimeZone tz) {
+ if (t == absl::InfiniteFuture()) return kInfiniteFutureStr;
+ if (t == absl::InfinitePast()) return kInfinitePastStr;
+ const auto parts = Split(t);
+ return cctz::detail::format(format, parts.sec, parts.fem,
+ cctz::time_zone(tz));
+}
+
+std::string FormatTime(absl::Time t, absl::TimeZone tz) {
+ return FormatTime(RFC3339_full, t, tz);
+}
+
+std::string FormatTime(absl::Time t) {
+ return absl::FormatTime(RFC3339_full, t, absl::LocalTimeZone());
+}
+
+bool ParseTime(const std::string& format, const std::string& input, absl::Time* time,
+ std::string* err) {
+ return absl::ParseTime(format, input, absl::UTCTimeZone(), time, err);
+}
+
+// If the input std::string does not contain an explicit UTC offset, interpret
+// the fields with respect to the given TimeZone.
+bool ParseTime(const std::string& format, const std::string& input, absl::TimeZone tz,
+ absl::Time* time, std::string* err) {
+ const char* data = input.c_str();
+ while (std::isspace(*data)) ++data;
+
+ size_t inf_size = strlen(kInfiniteFutureStr);
+ if (strncmp(data, kInfiniteFutureStr, inf_size) == 0) {
+ const char* new_data = data + inf_size;
+ while (std::isspace(*new_data)) ++new_data;
+ if (*new_data == '\0') {
+ *time = InfiniteFuture();
+ return true;
+ }
+ }
+
+ inf_size = strlen(kInfinitePastStr);
+ if (strncmp(data, kInfinitePastStr, inf_size) == 0) {
+ const char* new_data = data + inf_size;
+ while (std::isspace(*new_data)) ++new_data;
+ if (*new_data == '\0') {
+ *time = InfinitePast();
+ return true;
+ }
+ }
+
+ std::string error;
+ cctz_parts parts;
+ const bool b = cctz::detail::parse(format, input, cctz::time_zone(tz),
+ &parts.sec, &parts.fem, &error);
+ if (b) {
+ *time = Join(parts);
+ } else if (err != nullptr) {
+ *err = error;
+ }
+ return b;
+}
+
+// TODO(absl-team): Remove once dependencies are removed.
+// Functions required to support absl::Time flags.
+bool ParseFlag(const std::string& text, absl::Time* t, std::string* error) {
+ return absl::ParseTime(RFC3339_full, text, absl::UTCTimeZone(), t, error);
+}
+
+std::string UnparseFlag(absl::Time t) {
+ return absl::FormatTime(RFC3339_full, t, absl::UTCTimeZone());
+}
+
+} // namespace absl
[45/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc.cc
new file mode 100644
index 0000000..0a6f307
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc.cc
@@ -0,0 +1,604 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// A low-level allocator that can be used by other low-level
+// modules without introducing dependency cycles.
+// This allocator is slow and wasteful of memory;
+// it should not be used when performance is key.
+
+#include "absl/base/internal/low_level_alloc.h"
+
+#include <type_traits>
+
+#include "absl/base/call_once.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/direct_mmap.h"
+#include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/macros.h"
+#include "absl/base/thread_annotations.h"
+
+// LowLevelAlloc requires that the platform support low-level
+// allocation of virtual memory. Platforms lacking this cannot use
+// LowLevelAlloc.
+#ifndef ABSL_LOW_LEVEL_ALLOC_MISSING
+
+#ifndef _WIN32
+#include <pthread.h>
+#include <signal.h>
+#include <sys/mman.h>
+#include <unistd.h>
+#else
+#include <windows.h>
+#endif
+
+#include <string.h>
+#include <algorithm>
+#include <atomic>
+#include <cerrno>
+#include <cstddef>
+#include <new> // for placement-new
+
+#include "absl/base/dynamic_annotations.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/spinlock.h"
+
+// MAP_ANONYMOUS
+#if defined(__APPLE__)
+// For mmap, Linux defines both MAP_ANONYMOUS and MAP_ANON and says MAP_ANON is
+// deprecated. In Darwin, MAP_ANON is all there is.
+#if !defined MAP_ANONYMOUS
+#define MAP_ANONYMOUS MAP_ANON
+#endif // !MAP_ANONYMOUS
+#endif // __APPLE__
+
+namespace absl {
+namespace base_internal {
+
+// A first-fit allocator with amortized logarithmic free() time.
+
+// ---------------------------------------------------------------------------
+static const int kMaxLevel = 30;
+
+namespace {
+// This struct describes one allocated block, or one free block.
+struct AllocList {
+ struct Header {
+ // Size of entire region, including this field. Must be
+ // first. Valid in both allocated and unallocated blocks.
+ uintptr_t size;
+
+ // kMagicAllocated or kMagicUnallocated xor this.
+ uintptr_t magic;
+
+ // Pointer to parent arena.
+ LowLevelAlloc::Arena *arena;
+
+ // Aligns regions to 0 mod 2*sizeof(void*).
+ void *dummy_for_alignment;
+ } header;
+
+ // Next two fields: in unallocated blocks: freelist skiplist data
+ // in allocated blocks: overlaps with client data
+
+ // Levels in skiplist used.
+ int levels;
+
+ // Actually has levels elements. The AllocList node may not have room
+ // for all kMaxLevel entries. See max_fit in LLA_SkiplistLevels().
+ AllocList *next[kMaxLevel];
+};
+} // namespace
+
+// ---------------------------------------------------------------------------
+// A trivial skiplist implementation. This is used to keep the freelist
+// in address order while taking only logarithmic time per insert and delete.
+
+// An integer approximation of log2(size/base)
+// Requires size >= base.
+static int IntLog2(size_t size, size_t base) {
+ int result = 0;
+ for (size_t i = size; i > base; i >>= 1) { // i == floor(size/2**result)
+ result++;
+ }
+ // floor(size / 2**result) <= base < floor(size / 2**(result-1))
+ // => log2(size/(base+1)) <= result < 1+log2(size/base)
+ // => result ~= log2(size/base)
+ return result;
+}
+
+// Return a random integer n: p(n)=1/(2**n) if 1 <= n; p(n)=0 if n < 1.
+static int Random(uint32_t *state) {
+ uint32_t r = *state;
+ int result = 1;
+ while ((((r = r*1103515245 + 12345) >> 30) & 1) == 0) {
+ result++;
+ }
+ *state = r;
+ return result;
+}
+
+// Return a number of skiplist levels for a node of size bytes, where
+// base is the minimum node size. Compute level=log2(size / base)+n
+// where n is 1 if random is false and otherwise a random number generated with
+// the standard distribution for a skiplist: See Random() above.
+// Bigger nodes tend to have more skiplist levels due to the log2(size / base)
+// term, so first-fit searches touch fewer nodes. "level" is clipped so
+// level<kMaxLevel and next[level-1] will fit in the node.
+// 0 < LLA_SkiplistLevels(x,y,false) <= LLA_SkiplistLevels(x,y,true) < kMaxLevel
+static int LLA_SkiplistLevels(size_t size, size_t base, uint32_t *random) {
+ // max_fit is the maximum number of levels that will fit in a node for the
+ // given size. We can't return more than max_fit, no matter what the
+ // random number generator says.
+ size_t max_fit = (size - offsetof(AllocList, next)) / sizeof(AllocList *);
+ int level = IntLog2(size, base) + (random != nullptr ? Random(random) : 1);
+ if (static_cast<size_t>(level) > max_fit) level = static_cast<int>(max_fit);
+ if (level > kMaxLevel-1) level = kMaxLevel - 1;
+ ABSL_RAW_CHECK(level >= 1, "block not big enough for even one level");
+ return level;
+}
+
+// Return "atleast", the first element of AllocList *head s.t. *atleast >= *e.
+// For 0 <= i < head->levels, set prev[i] to "no_greater", where no_greater
+// points to the last element at level i in the AllocList less than *e, or is
+// head if no such element exists.
+static AllocList *LLA_SkiplistSearch(AllocList *head,
+ AllocList *e, AllocList **prev) {
+ AllocList *p = head;
+ for (int level = head->levels - 1; level >= 0; level--) {
+ for (AllocList *n; (n = p->next[level]) != nullptr && n < e; p = n) {
+ }
+ prev[level] = p;
+ }
+ return (head->levels == 0) ? nullptr : prev[0]->next[0];
+}
+
+// Insert element *e into AllocList *head. Set prev[] as LLA_SkiplistSearch.
+// Requires that e->levels be previously set by the caller (using
+// LLA_SkiplistLevels())
+static void LLA_SkiplistInsert(AllocList *head, AllocList *e,
+ AllocList **prev) {
+ LLA_SkiplistSearch(head, e, prev);
+ for (; head->levels < e->levels; head->levels++) { // extend prev pointers
+ prev[head->levels] = head; // to all *e's levels
+ }
+ for (int i = 0; i != e->levels; i++) { // add element to list
+ e->next[i] = prev[i]->next[i];
+ prev[i]->next[i] = e;
+ }
+}
+
+// Remove element *e from AllocList *head. Set prev[] as LLA_SkiplistSearch().
+// Requires that e->levels be previous set by the caller (using
+// LLA_SkiplistLevels())
+static void LLA_SkiplistDelete(AllocList *head, AllocList *e,
+ AllocList **prev) {
+ AllocList *found = LLA_SkiplistSearch(head, e, prev);
+ ABSL_RAW_CHECK(e == found, "element not in freelist");
+ for (int i = 0; i != e->levels && prev[i]->next[i] == e; i++) {
+ prev[i]->next[i] = e->next[i];
+ }
+ while (head->levels > 0 && head->next[head->levels - 1] == nullptr) {
+ head->levels--; // reduce head->levels if level unused
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Arena implementation
+
+// Metadata for an LowLevelAlloc arena instance.
+struct LowLevelAlloc::Arena {
+ // Constructs an arena with the given LowLevelAlloc flags.
+ explicit Arena(uint32_t flags_value);
+
+ base_internal::SpinLock mu;
+ // Head of free list, sorted by address
+ AllocList freelist GUARDED_BY(mu);
+ // Count of allocated blocks
+ int32_t allocation_count GUARDED_BY(mu);
+ // flags passed to NewArena
+ const uint32_t flags;
+ // Result of getpagesize()
+ const size_t pagesize;
+ // Lowest power of two >= max(16, sizeof(AllocList))
+ const size_t roundup;
+ // Smallest allocation block size
+ const size_t min_size;
+ // PRNG state
+ uint32_t random GUARDED_BY(mu);
+};
+
+namespace {
+using ArenaStorage = std::aligned_storage<sizeof(LowLevelAlloc::Arena),
+ alignof(LowLevelAlloc::Arena)>::type;
+
+// Static storage space for the lazily-constructed, default global arena
+// instances. We require this space because the whole point of LowLevelAlloc
+// is to avoid relying on malloc/new.
+ArenaStorage default_arena_storage;
+ArenaStorage unhooked_arena_storage;
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+ArenaStorage unhooked_async_sig_safe_arena_storage;
+#endif
+
+// We must use LowLevelCallOnce here to construct the global arenas, rather than
+// using function-level statics, to avoid recursively invoking the scheduler.
+absl::once_flag create_globals_once;
+
+void CreateGlobalArenas() {
+ new (&default_arena_storage)
+ LowLevelAlloc::Arena(LowLevelAlloc::kCallMallocHook);
+ new (&unhooked_arena_storage) LowLevelAlloc::Arena(0);
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+ new (&unhooked_async_sig_safe_arena_storage)
+ LowLevelAlloc::Arena(LowLevelAlloc::kAsyncSignalSafe);
+#endif
+}
+
+// Returns a global arena that does not call into hooks. Used by NewArena()
+// when kCallMallocHook is not set.
+LowLevelAlloc::Arena* UnhookedArena() {
+ base_internal::LowLevelCallOnce(&create_globals_once, CreateGlobalArenas);
+ return reinterpret_cast<LowLevelAlloc::Arena*>(&unhooked_arena_storage);
+}
+
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+// Returns a global arena that is async-signal safe. Used by NewArena() when
+// kAsyncSignalSafe is set.
+LowLevelAlloc::Arena *UnhookedAsyncSigSafeArena() {
+ base_internal::LowLevelCallOnce(&create_globals_once, CreateGlobalArenas);
+ return reinterpret_cast<LowLevelAlloc::Arena *>(
+ &unhooked_async_sig_safe_arena_storage);
+}
+#endif
+
+} // namespace
+
+// Returns the default arena, as used by LowLevelAlloc::Alloc() and friends.
+LowLevelAlloc::Arena *LowLevelAlloc::DefaultArena() {
+ base_internal::LowLevelCallOnce(&create_globals_once, CreateGlobalArenas);
+ return reinterpret_cast<LowLevelAlloc::Arena*>(&default_arena_storage);
+}
+
+// magic numbers to identify allocated and unallocated blocks
+static const uintptr_t kMagicAllocated = 0x4c833e95U;
+static const uintptr_t kMagicUnallocated = ~kMagicAllocated;
+
+namespace {
+class SCOPED_LOCKABLE ArenaLock {
+ public:
+ explicit ArenaLock(LowLevelAlloc::Arena *arena)
+ EXCLUSIVE_LOCK_FUNCTION(arena->mu)
+ : arena_(arena) {
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+ if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
+ sigset_t all;
+ sigfillset(&all);
+ mask_valid_ = pthread_sigmask(SIG_BLOCK, &all, &mask_) == 0;
+ }
+#endif
+ arena_->mu.Lock();
+ }
+ ~ArenaLock() { ABSL_RAW_CHECK(left_, "haven't left Arena region"); }
+ void Leave() UNLOCK_FUNCTION() {
+ arena_->mu.Unlock();
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+ if (mask_valid_) {
+ pthread_sigmask(SIG_SETMASK, &mask_, nullptr);
+ }
+#endif
+ left_ = true;
+ }
+
+ private:
+ bool left_ = false; // whether left region
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+ bool mask_valid_ = false;
+ sigset_t mask_; // old mask of blocked signals
+#endif
+ LowLevelAlloc::Arena *arena_;
+ ArenaLock(const ArenaLock &) = delete;
+ ArenaLock &operator=(const ArenaLock &) = delete;
+};
+} // namespace
+
+// create an appropriate magic number for an object at "ptr"
+// "magic" should be kMagicAllocated or kMagicUnallocated
+inline static uintptr_t Magic(uintptr_t magic, AllocList::Header *ptr) {
+ return magic ^ reinterpret_cast<uintptr_t>(ptr);
+}
+
+namespace {
+size_t GetPageSize() {
+#ifdef _WIN32
+ SYSTEM_INFO system_info;
+ GetSystemInfo(&system_info);
+ return std::max(system_info.dwPageSize, system_info.dwAllocationGranularity);
+#else
+ return getpagesize();
+#endif
+}
+
+size_t RoundedUpBlockSize() {
+ // Round up block sizes to a power of two close to the header size.
+ size_t roundup = 16;
+ while (roundup < sizeof(AllocList::Header)) {
+ roundup += roundup;
+ }
+ return roundup;
+}
+
+} // namespace
+
+LowLevelAlloc::Arena::Arena(uint32_t flags_value)
+ : mu(base_internal::SCHEDULE_KERNEL_ONLY),
+ allocation_count(0),
+ flags(flags_value),
+ pagesize(GetPageSize()),
+ roundup(RoundedUpBlockSize()),
+ min_size(2 * roundup),
+ random(0) {
+ freelist.header.size = 0;
+ freelist.header.magic =
+ Magic(kMagicUnallocated, &freelist.header);
+ freelist.header.arena = this;
+ freelist.levels = 0;
+ memset(freelist.next, 0, sizeof(freelist.next));
+}
+
+// L < meta_data_arena->mu
+LowLevelAlloc::Arena *LowLevelAlloc::NewArena(int32_t flags) {
+ Arena *meta_data_arena = DefaultArena();
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+ if ((flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
+ meta_data_arena = UnhookedAsyncSigSafeArena();
+ } else // NOLINT(readability/braces)
+#endif
+ if ((flags & LowLevelAlloc::kCallMallocHook) == 0) {
+ meta_data_arena = UnhookedArena();
+ }
+ Arena *result =
+ new (AllocWithArena(sizeof (*result), meta_data_arena)) Arena(flags);
+ return result;
+}
+
+// L < arena->mu, L < arena->arena->mu
+bool LowLevelAlloc::DeleteArena(Arena *arena) {
+ ABSL_RAW_CHECK(
+ arena != nullptr && arena != DefaultArena() && arena != UnhookedArena(),
+ "may not delete default arena");
+ ArenaLock section(arena);
+ if (arena->allocation_count != 0) {
+ section.Leave();
+ return false;
+ }
+ while (arena->freelist.next[0] != nullptr) {
+ AllocList *region = arena->freelist.next[0];
+ size_t size = region->header.size;
+ arena->freelist.next[0] = region->next[0];
+ ABSL_RAW_CHECK(
+ region->header.magic == Magic(kMagicUnallocated, ®ion->header),
+ "bad magic number in DeleteArena()");
+ ABSL_RAW_CHECK(region->header.arena == arena,
+ "bad arena pointer in DeleteArena()");
+ ABSL_RAW_CHECK(size % arena->pagesize == 0,
+ "empty arena has non-page-aligned block size");
+ ABSL_RAW_CHECK(reinterpret_cast<uintptr_t>(region) % arena->pagesize == 0,
+ "empty arena has non-page-aligned block");
+ int munmap_result;
+#ifdef _WIN32
+ munmap_result = VirtualFree(region, 0, MEM_RELEASE);
+ ABSL_RAW_CHECK(munmap_result != 0,
+ "LowLevelAlloc::DeleteArena: VitualFree failed");
+#else
+ if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) == 0) {
+ munmap_result = munmap(region, size);
+ } else {
+ munmap_result = base_internal::DirectMunmap(region, size);
+ }
+ if (munmap_result != 0) {
+ ABSL_RAW_LOG(FATAL, "LowLevelAlloc::DeleteArena: munmap failed: %d",
+ errno);
+ }
+#endif
+ }
+ section.Leave();
+ arena->~Arena();
+ Free(arena);
+ return true;
+}
+
+// ---------------------------------------------------------------------------
+
+// Addition, checking for overflow. The intent is to die if an external client
+// manages to push through a request that would cause arithmetic to fail.
+static inline uintptr_t CheckedAdd(uintptr_t a, uintptr_t b) {
+ uintptr_t sum = a + b;
+ ABSL_RAW_CHECK(sum >= a, "LowLevelAlloc arithmetic overflow");
+ return sum;
+}
+
+// Return value rounded up to next multiple of align.
+// align must be a power of two.
+static inline uintptr_t RoundUp(uintptr_t addr, uintptr_t align) {
+ return CheckedAdd(addr, align - 1) & ~(align - 1);
+}
+
+// Equivalent to "return prev->next[i]" but with sanity checking
+// that the freelist is in the correct order, that it
+// consists of regions marked "unallocated", and that no two regions
+// are adjacent in memory (they should have been coalesced).
+// L < arena->mu
+static AllocList *Next(int i, AllocList *prev, LowLevelAlloc::Arena *arena) {
+ ABSL_RAW_CHECK(i < prev->levels, "too few levels in Next()");
+ AllocList *next = prev->next[i];
+ if (next != nullptr) {
+ ABSL_RAW_CHECK(
+ next->header.magic == Magic(kMagicUnallocated, &next->header),
+ "bad magic number in Next()");
+ ABSL_RAW_CHECK(next->header.arena == arena, "bad arena pointer in Next()");
+ if (prev != &arena->freelist) {
+ ABSL_RAW_CHECK(prev < next, "unordered freelist");
+ ABSL_RAW_CHECK(reinterpret_cast<char *>(prev) + prev->header.size <
+ reinterpret_cast<char *>(next),
+ "malformed freelist");
+ }
+ }
+ return next;
+}
+
+// Coalesce list item "a" with its successor if they are adjacent.
+static void Coalesce(AllocList *a) {
+ AllocList *n = a->next[0];
+ if (n != nullptr && reinterpret_cast<char *>(a) + a->header.size ==
+ reinterpret_cast<char *>(n)) {
+ LowLevelAlloc::Arena *arena = a->header.arena;
+ a->header.size += n->header.size;
+ n->header.magic = 0;
+ n->header.arena = nullptr;
+ AllocList *prev[kMaxLevel];
+ LLA_SkiplistDelete(&arena->freelist, n, prev);
+ LLA_SkiplistDelete(&arena->freelist, a, prev);
+ a->levels = LLA_SkiplistLevels(a->header.size, arena->min_size,
+ &arena->random);
+ LLA_SkiplistInsert(&arena->freelist, a, prev);
+ }
+}
+
+// Adds block at location "v" to the free list
+// L >= arena->mu
+static void AddToFreelist(void *v, LowLevelAlloc::Arena *arena) {
+ AllocList *f = reinterpret_cast<AllocList *>(
+ reinterpret_cast<char *>(v) - sizeof (f->header));
+ ABSL_RAW_CHECK(f->header.magic == Magic(kMagicAllocated, &f->header),
+ "bad magic number in AddToFreelist()");
+ ABSL_RAW_CHECK(f->header.arena == arena,
+ "bad arena pointer in AddToFreelist()");
+ f->levels = LLA_SkiplistLevels(f->header.size, arena->min_size,
+ &arena->random);
+ AllocList *prev[kMaxLevel];
+ LLA_SkiplistInsert(&arena->freelist, f, prev);
+ f->header.magic = Magic(kMagicUnallocated, &f->header);
+ Coalesce(f); // maybe coalesce with successor
+ Coalesce(prev[0]); // maybe coalesce with predecessor
+}
+
+// Frees storage allocated by LowLevelAlloc::Alloc().
+// L < arena->mu
+void LowLevelAlloc::Free(void *v) {
+ if (v != nullptr) {
+ AllocList *f = reinterpret_cast<AllocList *>(
+ reinterpret_cast<char *>(v) - sizeof (f->header));
+ ABSL_RAW_CHECK(f->header.magic == Magic(kMagicAllocated, &f->header),
+ "bad magic number in Free()");
+ LowLevelAlloc::Arena *arena = f->header.arena;
+ ArenaLock section(arena);
+ AddToFreelist(v, arena);
+ ABSL_RAW_CHECK(arena->allocation_count > 0, "nothing in arena to free");
+ arena->allocation_count--;
+ section.Leave();
+ }
+}
+
+// allocates and returns a block of size bytes, to be freed with Free()
+// L < arena->mu
+static void *DoAllocWithArena(size_t request, LowLevelAlloc::Arena *arena) {
+ void *result = nullptr;
+ if (request != 0) {
+ AllocList *s; // will point to region that satisfies request
+ ArenaLock section(arena);
+ // round up with header
+ size_t req_rnd = RoundUp(CheckedAdd(request, sizeof (s->header)),
+ arena->roundup);
+ for (;;) { // loop until we find a suitable region
+ // find the minimum levels that a block of this size must have
+ int i = LLA_SkiplistLevels(req_rnd, arena->min_size, nullptr) - 1;
+ if (i < arena->freelist.levels) { // potential blocks exist
+ AllocList *before = &arena->freelist; // predecessor of s
+ while ((s = Next(i, before, arena)) != nullptr &&
+ s->header.size < req_rnd) {
+ before = s;
+ }
+ if (s != nullptr) { // we found a region
+ break;
+ }
+ }
+ // we unlock before mmap() both because mmap() may call a callback hook,
+ // and because it may be slow.
+ arena->mu.Unlock();
+ // mmap generous 64K chunks to decrease
+ // the chances/impact of fragmentation:
+ size_t new_pages_size = RoundUp(req_rnd, arena->pagesize * 16);
+ void *new_pages;
+#ifdef _WIN32
+ new_pages = VirtualAlloc(0, new_pages_size,
+ MEM_RESERVE | MEM_COMMIT, PAGE_READWRITE);
+ ABSL_RAW_CHECK(new_pages != nullptr, "VirtualAlloc failed");
+#else
+ if ((arena->flags & LowLevelAlloc::kAsyncSignalSafe) != 0) {
+ new_pages = base_internal::DirectMmap(nullptr, new_pages_size,
+ PROT_WRITE|PROT_READ, MAP_ANONYMOUS|MAP_PRIVATE, -1, 0);
+ } else {
+ new_pages = mmap(nullptr, new_pages_size, PROT_WRITE | PROT_READ,
+ MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
+ }
+ if (new_pages == MAP_FAILED) {
+ ABSL_RAW_LOG(FATAL, "mmap error: %d", errno);
+ }
+#endif
+ arena->mu.Lock();
+ s = reinterpret_cast<AllocList *>(new_pages);
+ s->header.size = new_pages_size;
+ // Pretend the block is allocated; call AddToFreelist() to free it.
+ s->header.magic = Magic(kMagicAllocated, &s->header);
+ s->header.arena = arena;
+ AddToFreelist(&s->levels, arena); // insert new region into free list
+ }
+ AllocList *prev[kMaxLevel];
+ LLA_SkiplistDelete(&arena->freelist, s, prev); // remove from free list
+ // s points to the first free region that's big enough
+ if (CheckedAdd(req_rnd, arena->min_size) <= s->header.size) {
+ // big enough to split
+ AllocList *n = reinterpret_cast<AllocList *>
+ (req_rnd + reinterpret_cast<char *>(s));
+ n->header.size = s->header.size - req_rnd;
+ n->header.magic = Magic(kMagicAllocated, &n->header);
+ n->header.arena = arena;
+ s->header.size = req_rnd;
+ AddToFreelist(&n->levels, arena);
+ }
+ s->header.magic = Magic(kMagicAllocated, &s->header);
+ ABSL_RAW_CHECK(s->header.arena == arena, "");
+ arena->allocation_count++;
+ section.Leave();
+ result = &s->levels;
+ }
+ ANNOTATE_MEMORY_IS_UNINITIALIZED(result, request);
+ return result;
+}
+
+void *LowLevelAlloc::Alloc(size_t request) {
+ void *result = DoAllocWithArena(request, DefaultArena());
+ return result;
+}
+
+void *LowLevelAlloc::AllocWithArena(size_t request, Arena *arena) {
+ ABSL_RAW_CHECK(arena != nullptr, "must pass a valid arena");
+ void *result = DoAllocWithArena(request, arena);
+ return result;
+}
+
+} // namespace base_internal
+} // namespace absl
+
+#endif // ABSL_LOW_LEVEL_ALLOC_MISSING
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc.h
new file mode 100644
index 0000000..3c15605
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc.h
@@ -0,0 +1,119 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
+#define ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
+
+// A simple thread-safe memory allocator that does not depend on
+// mutexes or thread-specific data. It is intended to be used
+// sparingly, and only when malloc() would introduce an unwanted
+// dependency, such as inside the heap-checker, or the Mutex
+// implementation.
+
+// IWYU pragma: private, include "base/low_level_alloc.h"
+
+#include <sys/types.h>
+#include <cstdint>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+
+// LowLevelAlloc requires that the platform support low-level
+// allocation of virtual memory. Platforms lacking this cannot use
+// LowLevelAlloc.
+#ifdef ABSL_LOW_LEVEL_ALLOC_MISSING
+#error ABSL_LOW_LEVEL_ALLOC_MISSING cannot be directly set
+#elif !defined(ABSL_HAVE_MMAP) && !defined(_WIN32)
+#define ABSL_LOW_LEVEL_ALLOC_MISSING 1
+#endif
+
+// Using LowLevelAlloc with kAsyncSignalSafe isn't supported on Windows.
+#ifdef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+#error ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING cannot be directly set
+#elif defined(_WIN32)
+#define ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING 1
+#endif
+
+#include <cstddef>
+
+#include "absl/base/port.h"
+
+namespace absl {
+namespace base_internal {
+
+class LowLevelAlloc {
+ public:
+ struct Arena; // an arena from which memory may be allocated
+
+ // Returns a pointer to a block of at least "request" bytes
+ // that have been newly allocated from the specific arena.
+ // for Alloc() call the DefaultArena() is used.
+ // Returns 0 if passed request==0.
+ // Does not return 0 under other circumstances; it crashes if memory
+ // is not available.
+ static void *Alloc(size_t request) ABSL_ATTRIBUTE_SECTION(malloc_hook);
+ static void *AllocWithArena(size_t request, Arena *arena)
+ ABSL_ATTRIBUTE_SECTION(malloc_hook);
+
+ // Deallocates a region of memory that was previously allocated with
+ // Alloc(). Does nothing if passed 0. "s" must be either 0,
+ // or must have been returned from a call to Alloc() and not yet passed to
+ // Free() since that call to Alloc(). The space is returned to the arena
+ // from which it was allocated.
+ static void Free(void *s) ABSL_ATTRIBUTE_SECTION(malloc_hook);
+
+ // ABSL_ATTRIBUTE_SECTION(malloc_hook) for Alloc* and Free
+ // are to put all callers of MallocHook::Invoke* in this module
+ // into special section,
+ // so that MallocHook::GetCallerStackTrace can function accurately.
+
+ // Create a new arena.
+ // The root metadata for the new arena is allocated in the
+ // meta_data_arena; the DefaultArena() can be passed for meta_data_arena.
+ // These values may be ored into flags:
+ enum {
+ // Report calls to Alloc() and Free() via the MallocHook interface.
+ // Set in the DefaultArena.
+ kCallMallocHook = 0x0001,
+
+#ifndef ABSL_LOW_LEVEL_ALLOC_ASYNC_SIGNAL_SAFE_MISSING
+ // Make calls to Alloc(), Free() be async-signal-safe. Not set in
+ // DefaultArena(). Not supported on all platforms.
+ kAsyncSignalSafe = 0x0002,
+#endif
+ };
+ // Construct a new arena. The allocation of the underlying metadata honors
+ // the provided flags. For example, the call NewArena(kAsyncSignalSafe)
+ // is itself async-signal-safe, as well as generatating an arena that provides
+ // async-signal-safe Alloc/Free.
+ static Arena *NewArena(int32_t flags);
+
+ // Destroys an arena allocated by NewArena and returns true,
+ // provided no allocated blocks remain in the arena.
+ // If allocated blocks remain in the arena, does nothing and
+ // returns false.
+ // It is illegal to attempt to destroy the DefaultArena().
+ static bool DeleteArena(Arena *arena);
+
+ // The default arena that always exists.
+ static Arena *DefaultArena();
+
+ private:
+ LowLevelAlloc(); // no instances
+};
+
+} // namespace base_internal
+} // namespace absl
+#endif // ABSL_BASE_INTERNAL_LOW_LEVEL_ALLOC_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc_test.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc_test.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc_test.cc
new file mode 100644
index 0000000..cf2b363
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_alloc_test.cc
@@ -0,0 +1,157 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/low_level_alloc.h"
+
+#include <stdint.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <thread> // NOLINT(build/c++11)
+#include <unordered_map>
+#include <utility>
+
+namespace absl {
+namespace base_internal {
+namespace {
+
+// This test doesn't use gtest since it needs to test that everything
+// works before main().
+#define TEST_ASSERT(x) \
+ if (!(x)) { \
+ printf("TEST_ASSERT(%s) FAILED ON LINE %d\n", #x, __LINE__); \
+ abort(); \
+ }
+
+// a block of memory obtained from the allocator
+struct BlockDesc {
+ char *ptr; // pointer to memory
+ int len; // number of bytes
+ int fill; // filled with data starting with this
+};
+
+// Check that the pattern placed in the block d
+// by RandomizeBlockDesc is still there.
+static void CheckBlockDesc(const BlockDesc &d) {
+ for (int i = 0; i != d.len; i++) {
+ TEST_ASSERT((d.ptr[i] & 0xff) == ((d.fill + i) & 0xff));
+ }
+}
+
+// Fill the block "*d" with a pattern
+// starting with a random byte.
+static void RandomizeBlockDesc(BlockDesc *d) {
+ d->fill = rand() & 0xff;
+ for (int i = 0; i != d->len; i++) {
+ d->ptr[i] = (d->fill + i) & 0xff;
+ }
+}
+
+// Use to indicate to the malloc hooks that
+// this calls is from LowLevelAlloc.
+static bool using_low_level_alloc = false;
+
+// n times, toss a coin, and based on the outcome
+// either allocate a new block or deallocate an old block.
+// New blocks are placed in a std::unordered_map with a random key
+// and initialized with RandomizeBlockDesc().
+// If keys conflict, the older block is freed.
+// Old blocks are always checked with CheckBlockDesc()
+// before being freed. At the end of the run,
+// all remaining allocated blocks are freed.
+// If use_new_arena is true, use a fresh arena, and then delete it.
+// If call_malloc_hook is true and user_arena is true,
+// allocations and deallocations are reported via the MallocHook
+// interface.
+static void Test(bool use_new_arena, bool call_malloc_hook, int n) {
+ typedef std::unordered_map<int, BlockDesc> AllocMap;
+ AllocMap allocated;
+ AllocMap::iterator it;
+ BlockDesc block_desc;
+ int rnd;
+ LowLevelAlloc::Arena *arena = 0;
+ if (use_new_arena) {
+ int32_t flags = call_malloc_hook ? LowLevelAlloc::kCallMallocHook : 0;
+ arena = LowLevelAlloc::NewArena(flags);
+ }
+ for (int i = 0; i != n; i++) {
+ if (i != 0 && i % 10000 == 0) {
+ printf(".");
+ fflush(stdout);
+ }
+
+ switch (rand() & 1) { // toss a coin
+ case 0: // coin came up heads: add a block
+ using_low_level_alloc = true;
+ block_desc.len = rand() & 0x3fff;
+ block_desc.ptr =
+ reinterpret_cast<char *>(
+ arena == 0
+ ? LowLevelAlloc::Alloc(block_desc.len)
+ : LowLevelAlloc::AllocWithArena(block_desc.len, arena));
+ using_low_level_alloc = false;
+ RandomizeBlockDesc(&block_desc);
+ rnd = rand();
+ it = allocated.find(rnd);
+ if (it != allocated.end()) {
+ CheckBlockDesc(it->second);
+ using_low_level_alloc = true;
+ LowLevelAlloc::Free(it->second.ptr);
+ using_low_level_alloc = false;
+ it->second = block_desc;
+ } else {
+ allocated[rnd] = block_desc;
+ }
+ break;
+ case 1: // coin came up tails: remove a block
+ it = allocated.begin();
+ if (it != allocated.end()) {
+ CheckBlockDesc(it->second);
+ using_low_level_alloc = true;
+ LowLevelAlloc::Free(it->second.ptr);
+ using_low_level_alloc = false;
+ allocated.erase(it);
+ }
+ break;
+ }
+ }
+ // remove all remaining blocks
+ while ((it = allocated.begin()) != allocated.end()) {
+ CheckBlockDesc(it->second);
+ using_low_level_alloc = true;
+ LowLevelAlloc::Free(it->second.ptr);
+ using_low_level_alloc = false;
+ allocated.erase(it);
+ }
+ if (use_new_arena) {
+ TEST_ASSERT(LowLevelAlloc::DeleteArena(arena));
+ }
+}
+// LowLevelAlloc is designed to be safe to call before main().
+static struct BeforeMain {
+ BeforeMain() {
+ Test(false, false, 50000);
+ Test(true, false, 50000);
+ Test(true, true, 50000);
+ }
+} before_main;
+
+} // namespace
+} // namespace base_internal
+} // namespace absl
+
+int main(int argc, char *argv[]) {
+ // The actual test runs in the global constructor of `before_main`.
+ printf("PASS\n");
+ return 0;
+}
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_scheduling.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_scheduling.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_scheduling.h
new file mode 100644
index 0000000..e716f2b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/low_level_scheduling.h
@@ -0,0 +1,104 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Core interfaces and definitions used by by low-level interfaces such as
+// SpinLock.
+
+#ifndef ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
+#define ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
+
+#include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/macros.h"
+
+// The following two declarations exist so SchedulingGuard may friend them with
+// the appropriate language linkage. These callbacks allow libc internals, such
+// as function level statics, to schedule cooperatively when locking.
+extern "C" bool __google_disable_rescheduling(void);
+extern "C" void __google_enable_rescheduling(bool disable_result);
+
+namespace absl {
+namespace base_internal {
+
+class SchedulingHelper; // To allow use of SchedulingGuard.
+class SpinLock; // To allow use of SchedulingGuard.
+
+// SchedulingGuard
+// Provides guard semantics that may be used to disable cooperative rescheduling
+// of the calling thread within specific program blocks. This is used to
+// protect resources (e.g. low-level SpinLocks or Domain code) that cooperative
+// scheduling depends on.
+//
+// Domain implementations capable of rescheduling in reaction to involuntary
+// kernel thread actions (e.g blocking due to a pagefault or syscall) must
+// guarantee that an annotated thread is not allowed to (cooperatively)
+// reschedule until the annotated region is complete.
+//
+// It is an error to attempt to use a cooperatively scheduled resource (e.g.
+// Mutex) within a rescheduling-disabled region.
+//
+// All methods are async-signal safe.
+class SchedulingGuard {
+ public:
+ // Returns true iff the calling thread may be cooperatively rescheduled.
+ static bool ReschedulingIsAllowed();
+
+ private:
+ // Disable cooperative rescheduling of the calling thread. It may still
+ // initiate scheduling operations (e.g. wake-ups), however, it may not itself
+ // reschedule. Nestable. The returned result is opaque, clients should not
+ // attempt to interpret it.
+ // REQUIRES: Result must be passed to a pairing EnableScheduling().
+ static bool DisableRescheduling();
+
+ // Marks the end of a rescheduling disabled region, previously started by
+ // DisableRescheduling().
+ // REQUIRES: Pairs with innermost call (and result) of DisableRescheduling().
+ static void EnableRescheduling(bool disable_result);
+
+ // A scoped helper for {Disable, Enable}Rescheduling().
+ // REQUIRES: destructor must run in same thread as constructor.
+ struct ScopedDisable {
+ ScopedDisable() { disabled = SchedulingGuard::DisableRescheduling(); }
+ ~ScopedDisable() { SchedulingGuard::EnableRescheduling(disabled); }
+
+ bool disabled;
+ };
+
+ // Access to SchedulingGuard is explicitly white-listed.
+ friend class SchedulingHelper;
+ friend class SpinLock;
+
+ SchedulingGuard(const SchedulingGuard&) = delete;
+ SchedulingGuard& operator=(const SchedulingGuard&) = delete;
+};
+
+//------------------------------------------------------------------------------
+// End of public interfaces.
+//------------------------------------------------------------------------------
+inline bool SchedulingGuard::ReschedulingIsAllowed() {
+ return false;
+}
+
+inline bool SchedulingGuard::DisableRescheduling() {
+ return false;
+}
+
+inline void SchedulingGuard::EnableRescheduling(bool /* disable_result */) {
+ return;
+}
+
+
+} // namespace base_internal
+} // namespace absl
+#endif // ABSL_BASE_INTERNAL_LOW_LEVEL_SCHEDULING_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/per_thread_tls.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/per_thread_tls.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/per_thread_tls.h
new file mode 100644
index 0000000..2428bdc
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/per_thread_tls.h
@@ -0,0 +1,48 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
+#define ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
+
+// This header defines two macros:
+// If the platform supports thread-local storage:
+// ABSL_PER_THREAD_TLS_KEYWORD is the C keyword needed to declare a
+// thread-local variable ABSL_PER_THREAD_TLS is 1
+//
+// Otherwise:
+// ABSL_PER_THREAD_TLS_KEYWORD is empty
+// ABSL_PER_THREAD_TLS is 0
+//
+// Microsoft C supports thread-local storage.
+// GCC supports it if the appropriate version of glibc is available,
+// which the programmer can indicate by defining ABSL_HAVE_TLS
+
+#include "absl/base/port.h" // For ABSL_HAVE_TLS
+
+#if defined(ABSL_PER_THREAD_TLS)
+#error ABSL_PER_THREAD_TLS cannot be directly set
+#elif defined(ABSL_PER_THREAD_TLS_KEYWORD)
+#error ABSL_PER_THREAD_TLS_KEYWORD cannot be directly set
+#elif defined(ABSL_HAVE_TLS)
+#define ABSL_PER_THREAD_TLS_KEYWORD __thread
+#define ABSL_PER_THREAD_TLS 1
+#elif defined(_MSC_VER)
+#define ABSL_PER_THREAD_TLS_KEYWORD __declspec(thread)
+#define ABSL_PER_THREAD_TLS 1
+#else
+#define ABSL_PER_THREAD_TLS_KEYWORD
+#define ABSL_PER_THREAD_TLS 0
+#endif
+
+#endif // ABSL_BASE_INTERNAL_PER_THREAD_TLS_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/pretty_function.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/pretty_function.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/pretty_function.h
new file mode 100644
index 0000000..01b0547
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/pretty_function.h
@@ -0,0 +1,33 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
+#define ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
+
+// ABSL_PRETTY_FUNCTION
+//
+// In C++11, __func__ gives the undecorated name of the current function. That
+// is, "main", not "int main()". Various compilers give extra macros to get the
+// decorated function name, including return type and arguments, to
+// differentiate between overload sets. ABSL_PRETTY_FUNCTION is a portable
+// version of these macros which forwards to the correct macro on each compiler.
+#if defined(_MSC_VER)
+#define ABSL_PRETTY_FUNCTION __FUNCSIG__
+#elif defined(__GNUC__)
+#define ABSL_PRETTY_FUNCTION __PRETTY_FUNCTION__
+#else
+#error "Unsupported compiler"
+#endif
+
+#endif // ABSL_BASE_INTERNAL_PRETTY_FUNCTION_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/raw_logging.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/raw_logging.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/raw_logging.cc
new file mode 100644
index 0000000..1ce1388
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/raw_logging.cc
@@ -0,0 +1,218 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/raw_logging.h"
+
+#include <stddef.h>
+#include <cstdarg>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include "absl/base/attributes.h"
+#include "absl/base/config.h"
+#include "absl/base/internal/atomic_hook.h"
+#include "absl/base/log_severity.h"
+
+// We know how to perform low-level writes to stderr in POSIX and Windows. For
+// these platforms, we define the token ABSL_LOW_LEVEL_WRITE_SUPPORTED.
+// Much of raw_logging.cc becomes a no-op when we can't output messages,
+// although a FATAL ABSL_RAW_LOG message will still abort the process.
+
+// ABSL_HAVE_POSIX_WRITE is defined when the platform provides posix write()
+// (as from unistd.h)
+//
+// This preprocessor token is also defined in raw_io.cc. If you need to copy
+// this, consider moving both to config.h instead.
+#if defined(__linux__) || defined(__APPLE__) || defined(__FreeBSD__) || \
+ defined(__Fuchsia__) || defined(__native_client__)
+#include <unistd.h>
+
+
+#define ABSL_HAVE_POSIX_WRITE 1
+#define ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
+#else
+#undef ABSL_HAVE_POSIX_WRITE
+#endif
+
+// ABSL_HAVE_SYSCALL_WRITE is defined when the platform provides the syscall
+// syscall(SYS_write, /*int*/ fd, /*char* */ buf, /*size_t*/ len);
+// for low level operations that want to avoid libc.
+#if (defined(__linux__) || defined(__FreeBSD__)) && !defined(__ANDROID__)
+#include <sys/syscall.h>
+#define ABSL_HAVE_SYSCALL_WRITE 1
+#define ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
+#else
+#undef ABSL_HAVE_SYSCALL_WRITE
+#endif
+
+#ifdef _WIN32
+#include <io.h>
+
+#define ABSL_HAVE_RAW_IO 1
+#define ABSL_LOW_LEVEL_WRITE_SUPPORTED 1
+#else
+#undef ABSL_HAVE_RAW_IO
+#endif
+
+// TODO(gfalcon): We want raw-logging to work on as many platforms as possible.
+// Explicitly #error out when not ABSL_LOW_LEVEL_WRITE_SUPPORTED, except for a
+// whitelisted set of platforms for which we expect not to be able to raw log.
+
+ABSL_CONST_INIT static absl::base_internal::AtomicHook<
+ absl::raw_logging_internal::LogPrefixHook> log_prefix_hook;
+ABSL_CONST_INIT static absl::base_internal::AtomicHook<
+ absl::raw_logging_internal::AbortHook> abort_hook;
+
+#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
+static const char kTruncated[] = " ... (message truncated)\n";
+
+// sprintf the format to the buffer, adjusting *buf and *size to reflect the
+// consumed bytes, and return whether the message fit without truncation. If
+// truncation occurred, if possible leave room in the buffer for the message
+// kTruncated[].
+inline static bool VADoRawLog(char** buf, int* size, const char* format,
+ va_list ap) ABSL_PRINTF_ATTRIBUTE(3, 0);
+inline static bool VADoRawLog(char** buf, int* size,
+ const char* format, va_list ap) {
+ int n = vsnprintf(*buf, *size, format, ap);
+ bool result = true;
+ if (n < 0 || n > *size) {
+ result = false;
+ if (static_cast<size_t>(*size) > sizeof(kTruncated)) {
+ n = *size - sizeof(kTruncated); // room for truncation message
+ } else {
+ n = 0; // no room for truncation message
+ }
+ }
+ *size -= n;
+ *buf += n;
+ return result;
+}
+#endif // ABSL_LOW_LEVEL_WRITE_SUPPORTED
+
+static constexpr int kLogBufSize = 3000;
+
+namespace {
+
+// CAVEAT: vsnprintf called from *DoRawLog below has some (exotic) code paths
+// that invoke malloc() and getenv() that might acquire some locks.
+
+// Helper for RawLog below.
+// *DoRawLog writes to *buf of *size and move them past the written portion.
+// It returns true iff there was no overflow or error.
+bool DoRawLog(char** buf, int* size, const char* format, ...)
+ ABSL_PRINTF_ATTRIBUTE(3, 4);
+bool DoRawLog(char** buf, int* size, const char* format, ...) {
+ va_list ap;
+ va_start(ap, format);
+ int n = vsnprintf(*buf, *size, format, ap);
+ va_end(ap);
+ if (n < 0 || n > *size) return false;
+ *size -= n;
+ *buf += n;
+ return true;
+}
+
+void RawLogVA(absl::LogSeverity severity, const char* file, int line,
+ const char* format, va_list ap) ABSL_PRINTF_ATTRIBUTE(4, 0);
+void RawLogVA(absl::LogSeverity severity, const char* file, int line,
+ const char* format, va_list ap) {
+ char buffer[kLogBufSize];
+ char* buf = buffer;
+ int size = sizeof(buffer);
+#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
+ bool enabled = true;
+#else
+ bool enabled = false;
+#endif
+
+#ifdef ABSL_MIN_LOG_LEVEL
+ if (static_cast<int>(severity) < ABSL_MIN_LOG_LEVEL &&
+ severity < absl::LogSeverity::kFatal) {
+ enabled = false;
+ }
+#endif
+
+ auto log_prefix_hook_ptr = log_prefix_hook.Load();
+ if (log_prefix_hook_ptr) {
+ enabled = log_prefix_hook_ptr(severity, file, line, &buf, &size);
+ } else {
+ if (enabled) {
+ DoRawLog(&buf, &size, "[%s : %d] RAW: ", file, line);
+ }
+ }
+ const char* const prefix_end = buf;
+
+#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
+ if (enabled) {
+ bool no_chop = VADoRawLog(&buf, &size, format, ap);
+ if (no_chop) {
+ DoRawLog(&buf, &size, "\n");
+ } else {
+ DoRawLog(&buf, &size, "%s", kTruncated);
+ }
+ absl::raw_logging_internal::SafeWriteToStderr(buffer, strlen(buffer));
+ }
+#else
+ static_cast<void>(format);
+ static_cast<void>(ap);
+#endif
+
+ // Abort the process after logging a FATAL message, even if the output itself
+ // was suppressed.
+ if (severity == absl::LogSeverity::kFatal) {
+ abort_hook(file, line, buffer, prefix_end, buffer + kLogBufSize);
+ abort();
+ }
+}
+
+} // namespace
+
+namespace absl {
+namespace raw_logging_internal {
+void SafeWriteToStderr(const char *s, size_t len) {
+#if defined(ABSL_HAVE_SYSCALL_WRITE)
+ syscall(SYS_write, STDERR_FILENO, s, len);
+#elif defined(ABSL_HAVE_POSIX_WRITE)
+ write(STDERR_FILENO, s, len);
+#elif defined(ABSL_HAVE_RAW_IO)
+ _write(/* stderr */ 2, s, len);
+#else
+ // stderr logging unsupported on this platform
+ (void) s;
+ (void) len;
+#endif
+}
+
+void RawLog(absl::LogSeverity severity, const char* file, int line,
+ const char* format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5);
+void RawLog(absl::LogSeverity severity, const char* file, int line,
+ const char* format, ...) {
+ va_list ap;
+ va_start(ap, format);
+ RawLogVA(severity, file, line, format, ap);
+ va_end(ap);
+}
+
+bool RawLoggingFullySupported() {
+#ifdef ABSL_LOW_LEVEL_WRITE_SUPPORTED
+ return true;
+#else // !ABSL_LOW_LEVEL_WRITE_SUPPORTED
+ return false;
+#endif // !ABSL_LOW_LEVEL_WRITE_SUPPORTED
+}
+
+} // namespace raw_logging_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/raw_logging.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/raw_logging.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/raw_logging.h
new file mode 100644
index 0000000..a2b7207
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/raw_logging.h
@@ -0,0 +1,137 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Thread-safe logging routines that do not allocate any memory or
+// acquire any locks, and can therefore be used by low-level memory
+// allocation, synchronization, and signal-handling code.
+
+#ifndef ABSL_BASE_INTERNAL_RAW_LOGGING_H_
+#define ABSL_BASE_INTERNAL_RAW_LOGGING_H_
+
+#include "absl/base/attributes.h"
+#include "absl/base/log_severity.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+
+// This is similar to LOG(severity) << format..., but
+// * it is to be used ONLY by low-level modules that can't use normal LOG()
+// * it is designed to be a low-level logger that does not allocate any
+// memory and does not need any locks, hence:
+// * it logs straight and ONLY to STDERR w/o buffering
+// * it uses an explicit printf-format and arguments list
+// * it will silently chop off really long message strings
+// Usage example:
+// ABSL_RAW_LOG(ERROR, "Failed foo with %i: %s", status, error);
+// This will print an almost standard log line like this to stderr only:
+// E0821 211317 file.cc:123] RAW: Failed foo with 22: bad_file
+#define ABSL_RAW_LOG(severity, ...) \
+ do { \
+ constexpr const char* absl_raw_logging_internal_basename = \
+ ::absl::raw_logging_internal::Basename(__FILE__, \
+ sizeof(__FILE__) - 1); \
+ ::absl::raw_logging_internal::RawLog(ABSL_RAW_LOGGING_INTERNAL_##severity, \
+ absl_raw_logging_internal_basename, \
+ __LINE__, __VA_ARGS__); \
+ } while (0)
+
+// Similar to CHECK(condition) << message, but for low-level modules:
+// we use only ABSL_RAW_LOG that does not allocate memory.
+// We do not want to provide args list here to encourage this usage:
+// if (!cond) ABSL_RAW_LOG(FATAL, "foo ...", hard_to_compute_args);
+// so that the args are not computed when not needed.
+#define ABSL_RAW_CHECK(condition, message) \
+ do { \
+ if (ABSL_PREDICT_FALSE(!(condition))) { \
+ ABSL_RAW_LOG(FATAL, "Check %s failed: %s", #condition, message); \
+ } \
+ } while (0)
+
+#define ABSL_RAW_LOGGING_INTERNAL_INFO ::absl::LogSeverity::kInfo
+#define ABSL_RAW_LOGGING_INTERNAL_WARNING ::absl::LogSeverity::kWarning
+#define ABSL_RAW_LOGGING_INTERNAL_ERROR ::absl::LogSeverity::kError
+#define ABSL_RAW_LOGGING_INTERNAL_FATAL ::absl::LogSeverity::kFatal
+#define ABSL_RAW_LOGGING_INTERNAL_LEVEL(severity) \
+ ::absl::NormalizeLogSeverity(severity)
+
+namespace absl {
+namespace raw_logging_internal {
+
+// Helper function to implement ABSL_RAW_LOG
+// Logs format... at "severity" level, reporting it
+// as called from file:line.
+// This does not allocate memory or acquire locks.
+void RawLog(absl::LogSeverity severity, const char* file, int line,
+ const char* format, ...) ABSL_PRINTF_ATTRIBUTE(4, 5);
+
+// Writes the provided buffer directly to stderr, in a safe, low-level manner.
+//
+// In POSIX this means calling write(), which is async-signal safe and does
+// not malloc. If the platform supports the SYS_write syscall, we invoke that
+// directly to side-step any libc interception.
+void SafeWriteToStderr(const char *s, size_t len);
+
+// compile-time function to get the "base" filename, that is, the part of
+// a filename after the last "/" or "\" path separator. The search starts at
+// the end of the std::string; the second parameter is the length of the std::string.
+constexpr const char* Basename(const char* fname, int offset) {
+ return offset == 0 || fname[offset - 1] == '/' || fname[offset - 1] == '\\'
+ ? fname + offset
+ : Basename(fname, offset - 1);
+}
+
+// For testing only.
+// Returns true if raw logging is fully supported. When it is not
+// fully supported, no messages will be emitted, but a log at FATAL
+// severity will cause an abort.
+//
+// TODO(gfalcon): Come up with a better name for this method.
+bool RawLoggingFullySupported();
+
+// Function type for a raw_logging customization hook for suppressing messages
+// by severity, and for writing custom prefixes on non-suppressed messages.
+//
+// The installed hook is called for every raw log invocation. The message will
+// be logged to stderr only if the hook returns true. FATAL errors will cause
+// the process to abort, even if writing to stderr is suppressed. The hook is
+// also provided with an output buffer, where it can write a custom log message
+// prefix.
+//
+// The raw_logging system does not allocate memory or grab locks. User-provided
+// hooks must avoid these operations, and must not throw exceptions.
+//
+// 'severity' is the severity level of the message being written.
+// 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
+// was located.
+// 'buffer' and 'buf_size' are pointers to the buffer and buffer size. If the
+// hook writes a prefix, it must increment *buffer and decrement *buf_size
+// accordingly.
+using LogPrefixHook = bool (*)(absl::LogSeverity severity, const char* file,
+ int line, char** buffer, int* buf_size);
+
+// Function type for a raw_logging customization hook called to abort a process
+// when a FATAL message is logged. If the provided AbortHook() returns, the
+// logging system will call abort().
+//
+// 'file' and 'line' are the file and line number where the ABSL_RAW_LOG macro
+// was located.
+// The null-terminated logged message lives in the buffer between 'buf_start'
+// and 'buf_end'. 'prefix_end' points to the first non-prefix character of the
+// buffer (as written by the LogPrefixHook.)
+using AbortHook = void (*)(const char* file, int line, const char* buf_start,
+ const char* prefix_end, const char* buf_end);
+
+} // namespace raw_logging_internal
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_RAW_LOGGING_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/scheduling_mode.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/scheduling_mode.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/scheduling_mode.h
new file mode 100644
index 0000000..1b6497a
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/scheduling_mode.h
@@ -0,0 +1,54 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// Core interfaces and definitions used by by low-level interfaces such as
+// SpinLock.
+
+#ifndef ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
+#define ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
+
+namespace absl {
+namespace base_internal {
+
+// Used to describe how a thread may be scheduled. Typically associated with
+// the declaration of a resource supporting synchronized access.
+//
+// SCHEDULE_COOPERATIVE_AND_KERNEL:
+// Specifies that when waiting, a cooperative thread (e.g. a Fiber) may
+// reschedule (using base::scheduling semantics); allowing other cooperative
+// threads to proceed.
+//
+// SCHEDULE_KERNEL_ONLY: (Also described as "non-cooperative")
+// Specifies that no cooperative scheduling semantics may be used, even if the
+// current thread is itself cooperatively scheduled. This means that
+// cooperative threads will NOT allow other cooperative threads to execute in
+// their place while waiting for a resource of this type. Host operating system
+// semantics (e.g. a futex) may still be used.
+//
+// When optional, clients should strongly prefer SCHEDULE_COOPERATIVE_AND_KERNEL
+// by default. SCHEDULE_KERNEL_ONLY should only be used for resources on which
+// base::scheduling (e.g. the implementation of a Scheduler) may depend.
+//
+// NOTE: Cooperative resources may not be nested below non-cooperative ones.
+// This means that it is invalid to to acquire a SCHEDULE_COOPERATIVE_AND_KERNEL
+// resource if a SCHEDULE_KERNEL_ONLY resource is already held.
+enum SchedulingMode {
+ SCHEDULE_KERNEL_ONLY = 0, // Allow scheduling only the host OS.
+ SCHEDULE_COOPERATIVE_AND_KERNEL, // Also allow cooperative scheduling.
+};
+
+} // namespace base_internal
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_SCHEDULING_MODE_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock.cc
new file mode 100644
index 0000000..28a2059
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock.cc
@@ -0,0 +1,238 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/base/internal/spinlock.h"
+
+#include <algorithm>
+#include <atomic>
+#include <limits>
+
+#include "absl/base/internal/atomic_hook.h"
+#include "absl/base/internal/cycleclock.h"
+#include "absl/base/internal/spinlock_wait.h"
+#include "absl/base/internal/sysinfo.h" /* For NumCPUs() */
+
+// Description of lock-word:
+// 31..00: [............................3][2][1][0]
+//
+// [0]: kSpinLockHeld
+// [1]: kSpinLockCooperative
+// [2]: kSpinLockDisabledScheduling
+// [31..3]: ONLY kSpinLockSleeper OR
+// Wait time in cycles >> PROFILE_TIMESTAMP_SHIFT
+//
+// Detailed descriptions:
+//
+// Bit [0]: The lock is considered held iff kSpinLockHeld is set.
+//
+// Bit [1]: Eligible waiters (e.g. Fibers) may co-operatively reschedule when
+// contended iff kSpinLockCooperative is set.
+//
+// Bit [2]: This bit is exclusive from bit [1]. It is used only by a
+// non-cooperative lock. When set, indicates that scheduling was
+// successfully disabled when the lock was acquired. May be unset,
+// even if non-cooperative, if a ThreadIdentity did not yet exist at
+// time of acquisition.
+//
+// Bit [3]: If this is the only upper bit ([31..3]) set then this lock was
+// acquired without contention, however, at least one waiter exists.
+//
+// Otherwise, bits [31..3] represent the time spent by the current lock
+// holder to acquire the lock. There may be outstanding waiter(s).
+
+namespace absl {
+namespace base_internal {
+
+static int adaptive_spin_count = 0;
+
+namespace {
+struct SpinLock_InitHelper {
+ SpinLock_InitHelper() {
+ // On multi-cpu machines, spin for longer before yielding
+ // the processor or sleeping. Reduces idle time significantly.
+ if (base_internal::NumCPUs() > 1) {
+ adaptive_spin_count = 1000;
+ }
+ }
+};
+
+// Hook into global constructor execution:
+// We do not do adaptive spinning before that,
+// but nothing lock-intensive should be going on at that time.
+static SpinLock_InitHelper init_helper;
+
+ABSL_CONST_INIT static base_internal::AtomicHook<void (*)(const void *lock,
+ int64_t wait_cycles)>
+ submit_profile_data;
+
+} // namespace
+
+void RegisterSpinLockProfiler(void (*fn)(const void *contendedlock,
+ int64_t wait_cycles)) {
+ submit_profile_data.Store(fn);
+}
+
+// Uncommon constructors.
+SpinLock::SpinLock(base_internal::SchedulingMode mode)
+ : lockword_(IsCooperative(mode) ? kSpinLockCooperative : 0) {
+ ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
+}
+
+SpinLock::SpinLock(base_internal::LinkerInitialized,
+ base_internal::SchedulingMode mode) {
+ ABSL_TSAN_MUTEX_CREATE(this, 0);
+ if (IsCooperative(mode)) {
+ InitLinkerInitializedAndCooperative();
+ }
+ // Otherwise, lockword_ is already initialized.
+}
+
+// Static (linker initialized) spinlocks always start life as functional
+// non-cooperative locks. When their static constructor does run, it will call
+// this initializer to augment the lockword with the cooperative bit. By
+// actually taking the lock when we do this we avoid the need for an atomic
+// operation in the regular unlock path.
+//
+// SlowLock() must be careful to re-test for this bit so that any outstanding
+// waiters may be upgraded to cooperative status.
+void SpinLock::InitLinkerInitializedAndCooperative() {
+ Lock();
+ lockword_.fetch_or(kSpinLockCooperative, std::memory_order_relaxed);
+ Unlock();
+}
+
+// Monitor the lock to see if its value changes within some time period
+// (adaptive_spin_count loop iterations). A timestamp indicating
+// when the thread initially started waiting for the lock is passed in via
+// the initial_wait_timestamp value. The total wait time in cycles for the
+// lock is returned in the wait_cycles parameter. The last value read
+// from the lock is returned from the method.
+uint32_t SpinLock::SpinLoop(int64_t initial_wait_timestamp,
+ uint32_t *wait_cycles) {
+ int c = adaptive_spin_count;
+ uint32_t lock_value;
+ do {
+ lock_value = lockword_.load(std::memory_order_relaxed);
+ } while ((lock_value & kSpinLockHeld) != 0 && --c > 0);
+ uint32_t spin_loop_wait_cycles =
+ EncodeWaitCycles(initial_wait_timestamp, CycleClock::Now());
+ *wait_cycles = spin_loop_wait_cycles;
+
+ return TryLockInternal(lock_value, spin_loop_wait_cycles);
+}
+
+void SpinLock::SlowLock() {
+ // The lock was not obtained initially, so this thread needs to wait for
+ // it. Record the current timestamp in the local variable wait_start_time
+ // so the total wait time can be stored in the lockword once this thread
+ // obtains the lock.
+ int64_t wait_start_time = CycleClock::Now();
+ uint32_t wait_cycles;
+ uint32_t lock_value = SpinLoop(wait_start_time, &wait_cycles);
+
+ int lock_wait_call_count = 0;
+ while ((lock_value & kSpinLockHeld) != 0) {
+ // If the lock is currently held, but not marked as having a sleeper, mark
+ // it as having a sleeper.
+ if ((lock_value & kWaitTimeMask) == 0) {
+ // Here, just "mark" that the thread is going to sleep. Don't store the
+ // lock wait time in the lock as that will cause the current lock
+ // owner to think it experienced contention.
+ if (lockword_.compare_exchange_strong(
+ lock_value, lock_value | kSpinLockSleeper,
+ std::memory_order_acquire, std::memory_order_relaxed)) {
+ // Successfully transitioned to kSpinLockSleeper. Pass
+ // kSpinLockSleeper to the SpinLockWait routine to properly indicate
+ // the last lock_value observed.
+ lock_value |= kSpinLockSleeper;
+ } else if ((lock_value & kSpinLockHeld) == 0) {
+ // Lock is free again, so try and acquire it before sleeping. The
+ // new lock state will be the number of cycles this thread waited if
+ // this thread obtains the lock.
+ lock_value = TryLockInternal(lock_value, wait_cycles);
+ continue; // Skip the delay at the end of the loop.
+ }
+ }
+
+ base_internal::SchedulingMode scheduling_mode;
+ if ((lock_value & kSpinLockCooperative) != 0) {
+ scheduling_mode = base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
+ } else {
+ scheduling_mode = base_internal::SCHEDULE_KERNEL_ONLY;
+ }
+ // SpinLockDelay() calls into fiber scheduler, we need to see
+ // synchronization there to avoid false positives.
+ ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
+ // Wait for an OS specific delay.
+ base_internal::SpinLockDelay(&lockword_, lock_value, ++lock_wait_call_count,
+ scheduling_mode);
+ ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
+ // Spin again after returning from the wait routine to give this thread
+ // some chance of obtaining the lock.
+ lock_value = SpinLoop(wait_start_time, &wait_cycles);
+ }
+}
+
+void SpinLock::SlowUnlock(uint32_t lock_value) {
+ base_internal::SpinLockWake(&lockword_,
+ false); // wake waiter if necessary
+
+ // If our acquisition was contended, collect contentionz profile info. We
+ // reserve a unitary wait time to represent that a waiter exists without our
+ // own acquisition having been contended.
+ if ((lock_value & kWaitTimeMask) != kSpinLockSleeper) {
+ const uint64_t wait_cycles = DecodeWaitCycles(lock_value);
+ ABSL_TSAN_MUTEX_PRE_DIVERT(this, 0);
+ submit_profile_data(this, wait_cycles);
+ ABSL_TSAN_MUTEX_POST_DIVERT(this, 0);
+ }
+}
+
+// We use the upper 29 bits of the lock word to store the time spent waiting to
+// acquire this lock. This is reported by contentionz profiling. Since the
+// lower bits of the cycle counter wrap very quickly on high-frequency
+// processors we divide to reduce the granularity to 2^PROFILE_TIMESTAMP_SHIFT
+// sized units. On a 4Ghz machine this will lose track of wait times greater
+// than (2^29/4 Ghz)*128 =~ 17.2 seconds. Such waits should be extremely rare.
+enum { PROFILE_TIMESTAMP_SHIFT = 7 };
+enum { LOCKWORD_RESERVED_SHIFT = 3 }; // We currently reserve the lower 3 bits.
+
+uint32_t SpinLock::EncodeWaitCycles(int64_t wait_start_time,
+ int64_t wait_end_time) {
+ static const int64_t kMaxWaitTime =
+ std::numeric_limits<uint32_t>::max() >> LOCKWORD_RESERVED_SHIFT;
+ int64_t scaled_wait_time =
+ (wait_end_time - wait_start_time) >> PROFILE_TIMESTAMP_SHIFT;
+
+ // Return a representation of the time spent waiting that can be stored in
+ // the lock word's upper bits. bit_cast is required as Atomic32 is signed.
+ const uint32_t clamped = static_cast<uint32_t>(
+ std::min(scaled_wait_time, kMaxWaitTime) << LOCKWORD_RESERVED_SHIFT);
+
+ // bump up value if necessary to avoid returning kSpinLockSleeper.
+ const uint32_t after_spinlock_sleeper =
+ kSpinLockSleeper + (1 << LOCKWORD_RESERVED_SHIFT);
+ return clamped == kSpinLockSleeper ? after_spinlock_sleeper : clamped;
+}
+
+uint64_t SpinLock::DecodeWaitCycles(uint32_t lock_value) {
+ // Cast to uint32_t first to ensure bits [63:32] are cleared.
+ const uint64_t scaled_wait_time =
+ static_cast<uint32_t>(lock_value & kWaitTimeMask);
+ return scaled_wait_time
+ << (PROFILE_TIMESTAMP_SHIFT - LOCKWORD_RESERVED_SHIFT);
+}
+
+} // namespace base_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock.h b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock.h
new file mode 100644
index 0000000..212abc6
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock.h
@@ -0,0 +1,239 @@
+//
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Most users requiring mutual exclusion should use Mutex.
+// SpinLock is provided for use in three situations:
+// - for use in code that Mutex itself depends on
+// - to get a faster fast-path release under low contention (without an
+// atomic read-modify-write) In return, SpinLock has worse behaviour under
+// contention, which is why Mutex is preferred in most situations.
+// - for async signal safety (see below)
+
+// SpinLock is async signal safe. If a spinlock is used within a signal
+// handler, all code that acquires the lock must ensure that the signal cannot
+// arrive while they are holding the lock. Typically, this is done by blocking
+// the signal.
+
+#ifndef ABSL_BASE_INTERNAL_SPINLOCK_H_
+#define ABSL_BASE_INTERNAL_SPINLOCK_H_
+
+#include <stdint.h>
+#include <sys/types.h>
+#include <atomic>
+
+#include "absl/base/attributes.h"
+#include "absl/base/dynamic_annotations.h"
+#include "absl/base/internal/low_level_scheduling.h"
+#include "absl/base/internal/raw_logging.h"
+#include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/internal/tsan_mutex_interface.h"
+#include "absl/base/macros.h"
+#include "absl/base/port.h"
+#include "absl/base/thread_annotations.h"
+
+namespace absl {
+namespace base_internal {
+
+class LOCKABLE SpinLock {
+ public:
+ SpinLock() : lockword_(kSpinLockCooperative) {
+ ABSL_TSAN_MUTEX_CREATE(this, __tsan_mutex_not_static);
+ }
+
+ // Special constructor for use with static SpinLock objects. E.g.,
+ //
+ // static SpinLock lock(base_internal::kLinkerInitialized);
+ //
+ // When intialized using this constructor, we depend on the fact
+ // that the linker has already initialized the memory appropriately.
+ // A SpinLock constructed like this can be freely used from global
+ // initializers without worrying about the order in which global
+ // initializers run.
+ explicit SpinLock(base_internal::LinkerInitialized) {
+ // Does nothing; lockword_ is already initialized
+ ABSL_TSAN_MUTEX_CREATE(this, 0);
+ }
+
+ // Constructors that allow non-cooperative spinlocks to be created for use
+ // inside thread schedulers. Normal clients should not use these.
+ explicit SpinLock(base_internal::SchedulingMode mode);
+ SpinLock(base_internal::LinkerInitialized,
+ base_internal::SchedulingMode mode);
+
+ ~SpinLock() { ABSL_TSAN_MUTEX_DESTROY(this, __tsan_mutex_not_static); }
+
+ // Acquire this SpinLock.
+ inline void Lock() EXCLUSIVE_LOCK_FUNCTION() {
+ ABSL_TSAN_MUTEX_PRE_LOCK(this, 0);
+ if (!TryLockImpl()) {
+ SlowLock();
+ }
+ ABSL_TSAN_MUTEX_POST_LOCK(this, 0, 0);
+ }
+
+ // Try to acquire this SpinLock without blocking and return true if the
+ // acquisition was successful. If the lock was not acquired, false is
+ // returned. If this SpinLock is free at the time of the call, TryLock
+ // will return true with high probability.
+ inline bool TryLock() EXCLUSIVE_TRYLOCK_FUNCTION(true) {
+ ABSL_TSAN_MUTEX_PRE_LOCK(this, __tsan_mutex_try_lock);
+ bool res = TryLockImpl();
+ ABSL_TSAN_MUTEX_POST_LOCK(
+ this, __tsan_mutex_try_lock | (res ? 0 : __tsan_mutex_try_lock_failed),
+ 0);
+ return res;
+ }
+
+ // Release this SpinLock, which must be held by the calling thread.
+ inline void Unlock() UNLOCK_FUNCTION() {
+ ABSL_TSAN_MUTEX_PRE_UNLOCK(this, 0);
+ uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
+ lockword_.store(lock_value & kSpinLockCooperative,
+ std::memory_order_release);
+
+ if ((lock_value & kSpinLockDisabledScheduling) != 0) {
+ base_internal::SchedulingGuard::EnableRescheduling(true);
+ }
+ if ((lock_value & kWaitTimeMask) != 0) {
+ // Collect contentionz profile info, and speed the wakeup of any waiter.
+ // The wait_cycles value indicates how long this thread spent waiting
+ // for the lock.
+ SlowUnlock(lock_value);
+ }
+ ABSL_TSAN_MUTEX_POST_UNLOCK(this, 0);
+ }
+
+ // Determine if the lock is held. When the lock is held by the invoking
+ // thread, true will always be returned. Intended to be used as
+ // CHECK(lock.IsHeld()).
+ inline bool IsHeld() const {
+ return (lockword_.load(std::memory_order_relaxed) & kSpinLockHeld) != 0;
+ }
+
+ protected:
+ // These should not be exported except for testing.
+
+ // Store number of cycles between wait_start_time and wait_end_time in a
+ // lock value.
+ static uint32_t EncodeWaitCycles(int64_t wait_start_time,
+ int64_t wait_end_time);
+
+ // Extract number of wait cycles in a lock value.
+ static uint64_t DecodeWaitCycles(uint32_t lock_value);
+
+ // Provide access to protected method above. Use for testing only.
+ friend struct SpinLockTest;
+
+ private:
+ // lockword_ is used to store the following:
+ //
+ // bit[0] encodes whether a lock is being held.
+ // bit[1] encodes whether a lock uses cooperative scheduling.
+ // bit[2] encodes whether a lock disables scheduling.
+ // bit[3:31] encodes time a lock spent on waiting as a 29-bit unsigned int.
+ enum { kSpinLockHeld = 1 };
+ enum { kSpinLockCooperative = 2 };
+ enum { kSpinLockDisabledScheduling = 4 };
+ enum { kSpinLockSleeper = 8 };
+ enum { kWaitTimeMask = // Includes kSpinLockSleeper.
+ ~(kSpinLockHeld | kSpinLockCooperative | kSpinLockDisabledScheduling) };
+
+ // Returns true if the provided scheduling mode is cooperative.
+ static constexpr bool IsCooperative(
+ base_internal::SchedulingMode scheduling_mode) {
+ return scheduling_mode == base_internal::SCHEDULE_COOPERATIVE_AND_KERNEL;
+ }
+
+ uint32_t TryLockInternal(uint32_t lock_value, uint32_t wait_cycles);
+ void InitLinkerInitializedAndCooperative();
+ void SlowLock() ABSL_ATTRIBUTE_COLD;
+ void SlowUnlock(uint32_t lock_value) ABSL_ATTRIBUTE_COLD;
+ uint32_t SpinLoop(int64_t initial_wait_timestamp, uint32_t* wait_cycles);
+
+ inline bool TryLockImpl() {
+ uint32_t lock_value = lockword_.load(std::memory_order_relaxed);
+ return (TryLockInternal(lock_value, 0) & kSpinLockHeld) == 0;
+ }
+
+ std::atomic<uint32_t> lockword_;
+
+ SpinLock(const SpinLock&) = delete;
+ SpinLock& operator=(const SpinLock&) = delete;
+};
+
+// Corresponding locker object that arranges to acquire a spinlock for
+// the duration of a C++ scope.
+class SCOPED_LOCKABLE SpinLockHolder {
+ public:
+ inline explicit SpinLockHolder(SpinLock* l) EXCLUSIVE_LOCK_FUNCTION(l)
+ : lock_(l) {
+ l->Lock();
+ }
+ inline ~SpinLockHolder() UNLOCK_FUNCTION() { lock_->Unlock(); }
+
+ SpinLockHolder(const SpinLockHolder&) = delete;
+ SpinLockHolder& operator=(const SpinLockHolder&) = delete;
+
+ private:
+ SpinLock* lock_;
+};
+
+// Register a hook for profiling support.
+//
+// The function pointer registered here will be called whenever a spinlock is
+// contended. The callback is given an opaque handle to the contended spinlock
+// and the number of wait cycles. This is thread-safe, but only a single
+// profiler can be registered. It is an error to call this function multiple
+// times with different arguments.
+void RegisterSpinLockProfiler(void (*fn)(const void* lock,
+ int64_t wait_cycles));
+
+//------------------------------------------------------------------------------
+// Public interface ends here.
+//------------------------------------------------------------------------------
+
+// If (result & kSpinLockHeld) == 0, then *this was successfully locked.
+// Otherwise, returns last observed value for lockword_.
+inline uint32_t SpinLock::TryLockInternal(uint32_t lock_value,
+ uint32_t wait_cycles) {
+ if ((lock_value & kSpinLockHeld) != 0) {
+ return lock_value;
+ }
+
+ uint32_t sched_disabled_bit = 0;
+ if ((lock_value & kSpinLockCooperative) == 0) {
+ // For non-cooperative locks we must make sure we mark ourselves as
+ // non-reschedulable before we attempt to CompareAndSwap.
+ if (base_internal::SchedulingGuard::DisableRescheduling()) {
+ sched_disabled_bit = kSpinLockDisabledScheduling;
+ }
+ }
+
+ if (lockword_.compare_exchange_strong(
+ lock_value,
+ kSpinLockHeld | lock_value | wait_cycles | sched_disabled_bit,
+ std::memory_order_acquire, std::memory_order_relaxed)) {
+ } else {
+ base_internal::SchedulingGuard::EnableRescheduling(sched_disabled_bit != 0);
+ }
+
+ return lock_value;
+}
+
+} // namespace base_internal
+} // namespace absl
+
+#endif // ABSL_BASE_INTERNAL_SPINLOCK_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_akaros.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_akaros.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_akaros.inc
new file mode 100644
index 0000000..051c8cf
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_akaros.inc
@@ -0,0 +1,35 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is an Akaros-specific part of spinlock_wait.cc
+
+#include <atomic>
+
+#include "absl/base/internal/scheduling_mode.h"
+
+extern "C" {
+
+ABSL_ATTRIBUTE_WEAK void AbslInternalSpinLockDelay(
+ std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */,
+ int /* loop */, absl::base_internal::SchedulingMode /* mode */) {
+ // In Akaros, one must take care not to call anything that could cause a
+ // malloc(), a blocking system call, or a uthread_yield() while holding a
+ // spinlock. Our callers assume will not call into libraries or other
+ // arbitrary code.
+}
+
+ABSL_ATTRIBUTE_WEAK void AbslInternalSpinLockWake(
+ std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
+
+} // extern "C"
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_posix.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_posix.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_posix.inc
new file mode 100644
index 0000000..0098c1c
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_posix.inc
@@ -0,0 +1,46 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// This file is a Posix-specific part of spinlock_wait.cc
+
+#include <sched.h>
+#include <atomic>
+#include <ctime>
+#include <cerrno>
+
+#include "absl/base/internal/scheduling_mode.h"
+#include "absl/base/port.h"
+
+extern "C" {
+
+ABSL_ATTRIBUTE_WEAK void AbslInternalSpinLockDelay(
+ std::atomic<uint32_t>* /* lock_word */, uint32_t /* value */, int loop,
+ absl::base_internal::SchedulingMode /* mode */) {
+ int save_errno = errno;
+ if (loop == 0) {
+ } else if (loop == 1) {
+ sched_yield();
+ } else {
+ struct timespec tm;
+ tm.tv_sec = 0;
+ tm.tv_nsec = absl::base_internal::SpinLockSuggestedDelayNS(loop);
+ nanosleep(&tm, nullptr);
+ }
+ errno = save_errno;
+}
+
+ABSL_ATTRIBUTE_WEAK void AbslInternalSpinLockWake(
+ std::atomic<uint32_t>* /* lock_word */, bool /* all */) {}
+
+} // extern "C"
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_wait.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_wait.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_wait.cc
new file mode 100644
index 0000000..9f6e991
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/base/internal/spinlock_wait.cc
@@ -0,0 +1,79 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// The OS-specific header included below must provide two calls:
+// base::subtle::SpinLockDelay() and base::subtle::SpinLockWake().
+// See spinlock_wait.h for the specs.
+
+#include <atomic>
+#include <cstdint>
+
+#include "absl/base/internal/spinlock_wait.h"
+
+#if defined(_WIN32)
+#include "absl/base/internal/spinlock_win32.inc"
+#elif defined(__akaros__)
+#include "absl/base/internal/spinlock_akaros.inc"
+#else
+#include "absl/base/internal/spinlock_posix.inc"
+#endif
+
+namespace absl {
+namespace base_internal {
+
+// See spinlock_wait.h for spec.
+uint32_t SpinLockWait(std::atomic<uint32_t> *w, int n,
+ const SpinLockWaitTransition trans[],
+ base_internal::SchedulingMode scheduling_mode) {
+ for (int loop = 0; ; loop++) {
+ uint32_t v = w->load(std::memory_order_acquire);
+ int i;
+ for (i = 0; i != n && v != trans[i].from; i++) {
+ }
+ if (i == n) {
+ SpinLockDelay(w, v, loop, scheduling_mode); // no matching transition
+ } else if (trans[i].to == v || // null transition
+ w->compare_exchange_strong(v, trans[i].to,
+ std::memory_order_acquire,
+ std::memory_order_relaxed)) {
+ if (trans[i].done) return v;
+ }
+ }
+}
+
+static std::atomic<uint64_t> delay_rand;
+
+// Return a suggested delay in nanoseconds for iteration number "loop"
+int SpinLockSuggestedDelayNS(int loop) {
+ // Weak pseudo-random number generator to get some spread between threads
+ // when many are spinning.
+ uint64_t r = delay_rand.load(std::memory_order_relaxed);
+ r = 0x5deece66dLL * r + 0xb; // numbers from nrand48()
+ delay_rand.store(r, std::memory_order_relaxed);
+
+ r <<= 16; // 48-bit random number now in top 48-bits.
+ if (loop < 0 || loop > 32) { // limit loop to 0..32
+ loop = 32;
+ }
+ // loop>>3 cannot exceed 4 because loop cannot exceed 32.
+ // Select top 20..24 bits of lower 48 bits,
+ // giving approximately 0ms to 16ms.
+ // Mean is exponential in loop for first 32 iterations, then 8ms.
+ // The futex path multiplies this by 16, since we expect explicit wakeups
+ // almost always on that path.
+ return static_cast<int>(r >> (44 - (loop >> 3)));
+}
+
+} // namespace base_internal
+} // namespace absl
[52/62] [abbrv] marmotta git commit: Remove some more unnecessary code
Posted by ja...@apache.org.
Remove some more unnecessary code
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/1e9b2b15
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/1e9b2b15
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/1e9b2b15
Branch: refs/heads/master
Commit: 1e9b2b151fe3cd738ad14270f251a1836de394e7
Parents: 0eb556d
Author: Sebastian Schaffert <ss...@apache.org>
Authored: Sun Apr 29 21:55:27 2018 +0200
Committer: Sebastian Schaffert <ss...@apache.org>
Committed: Sun Apr 29 21:55:27 2018 +0200
----------------------------------------------------------------------
libraries/ostrich/backend/test/CMakeLists.txt | 8 +++----
libraries/ostrich/backend/test/main.cc | 25 ----------------------
2 files changed, 4 insertions(+), 29 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/marmotta/blob/1e9b2b15/libraries/ostrich/backend/test/CMakeLists.txt
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/test/CMakeLists.txt b/libraries/ostrich/backend/test/CMakeLists.txt
index e195e91..a79a33c 100644
--- a/libraries/ostrich/backend/test/CMakeLists.txt
+++ b/libraries/ostrich/backend/test/CMakeLists.txt
@@ -7,16 +7,16 @@ include_directories(
"${RAPTOR_INCLUDE_DIR}/raptor2"
)
-add_executable(model_tests NamespaceTest.cc StatementTest.cc main.cc)
+add_executable(model_tests NamespaceTest.cc StatementTest.cc)
target_link_libraries(model_tests gtest_main marmotta_model ${GLOG_LIBRARY})
-add_executable(sparql_tests SparqlTest.cc main.cc)
+add_executable(sparql_tests SparqlTest.cc)
target_link_libraries(sparql_tests gtest_main marmotta_model marmotta_sparql ${GLOG_LIBRARY})
-add_executable(leveldb_tests main.cc LevelDBTest.cc)
+add_executable(leveldb_tests LevelDBTest.cc)
target_link_libraries(leveldb_tests gtest_main marmotta_leveldb ${GLOG_LIBRARY} ${Boost_LIBRARIES})
-add_executable(persistence_tests main.cc PersistenceTest.cc)
+add_executable(persistence_tests PersistenceTest.cc)
target_link_libraries(persistence_tests gtest_main marmotta_persistence ${GLOG_LIBRARY} ${Boost_LIBRARIES})
add_test(NAME ModelTest COMMAND model_tests)
http://git-wip-us.apache.org/repos/asf/marmotta/blob/1e9b2b15/libraries/ostrich/backend/test/main.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/test/main.cc b/libraries/ostrich/backend/test/main.cc
deleted file mode 100644
index f659381..0000000
--- a/libraries/ostrich/backend/test/main.cc
+++ /dev/null
@@ -1,25 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */#include <glog/logging.h>
-#include "gtest/gtest.h"
-
-// run all tests in the current binary
-int main(int argc, char **argv) {
- ::google::InitGoogleLogging(argv[0]);
- ::testing::InitGoogleTest(&argc, argv);
- return RUN_ALL_TESTS();
-}
[61/62] [abbrv] marmotta git commit: Merge tag '3.4.0'
Posted by ja...@apache.org.
Merge tag '3.4.0'
[maven-release-plugin] copy for tag 3.4.0
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/28c9b8b0
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/28c9b8b0
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/28c9b8b0
Branch: refs/heads/develop
Commit: 28c9b8b0791ea1693578af302981a1358e56933d
Parents: 6a10c48 b0e5b93
Author: Jakob Frank <ja...@apache.org>
Authored: Mon Jun 18 20:31:12 2018 +0200
Committer: Jakob Frank <ja...@apache.org>
Committed: Mon Jun 18 20:31:12 2018 +0200
----------------------------------------------------------------------
.dockerignore | 2 +
.github/PULL_REQUEST_TEMPLATE.md | 12 +
.travis.yml | 35 +
Dockerfile | 98 +
KEYS | 250 +-
LICENSE.txt | 100 +-
NOTICE.txt | 17 +-
README.md | 132 +
README.txt | 119 -
.../marmotta-archetype-module/pom.xml | 2 +-
.../main/java/exceptions/DoThisException.java | 2 +-
.../marmotta-archetype-webapp/pom.xml | 2 +-
.../src/main/webapp/WEB-INF/web.xml | 2 +-
.../src/test/resources/test-config.properties | 2 +-
build/archetypes/pom.xml | 2 +-
build/checkstyle-resources/pom.xml | 2 +-
build/dependency-resource-supplement/pom.xml | 2 +-
build/plugins/buildinfo-maven-plugin/pom.xml | 2 +-
.../plugins/buildinfo/AbstractInfoProvider.java | 2 +-
.../maven/plugins/buildinfo/BuildInfoMojo.java | 2 +-
.../plugins/buildinfo/GitInfoProvider.java | 2 +-
.../maven/plugins/buildinfo/InfoProvider.java | 2 +-
.../buildinfo/MercurialInfoProvider.java | 2 +-
.../plugins/buildinfo/ProjectInfoProvider.java | 2 +-
build/plugins/marmotta-maven-plugin/pom.xml | 2 +-
build/plugins/pom.xml | 17 +-
build/plugins/refpack-maven-plugin/pom.xml | 31 +-
.../maven/plugins/refpack/RefPackMojo.java | 26 +-
build/plugins/repocheck-maven-plugin/pom.xml | 8 +-
.../plugins/repochecker/LogMatrixPrinter.java | 2 +-
.../plugins/repochecker/MatrixPrinter.java | 12 +-
.../repochecker/RepositoryCheckerMojo.java | 2 +-
.../repochecker/SilentMatrixPrinter.java | 2 +-
build/pom.xml | 2 +-
client/marmotta-client-java/pom.xml | 11 +-
.../marmotta/client/ClientConfiguration.java | 2 +-
.../apache/marmotta/client/MarmottaClient.java | 2 +-
.../client/clients/ConfigurationClient.java | 2 +-
.../marmotta/client/clients/ContextClient.java | 2 +-
.../marmotta/client/clients/ImportClient.java | 2 +-
.../marmotta/client/clients/LDPathClient.java | 2 +-
.../marmotta/client/clients/ResourceClient.java | 2 +-
.../marmotta/client/clients/SPARQLClient.java | 2 +-
.../exception/ContentFormatException.java | 2 +-
.../exception/MarmottaClientException.java | 2 +-
.../client/exception/NotFoundException.java | 2 +-
.../client/exception/ParseException.java | 2 +-
.../model/classification/Classification.java | 2 +-
.../client/model/config/Configuration.java | 2 +-
.../client/model/content/ByteContent.java | 2 +-
.../marmotta/client/model/content/Content.java | 2 +-
.../client/model/content/StreamContent.java | 2 +-
.../client/model/content/StringContent.java | 2 +-
.../marmotta/client/model/meta/Metadata.java | 2 +-
.../apache/marmotta/client/model/rdf/BNode.java | 5 +-
.../marmotta/client/model/rdf/Literal.java | 5 +-
.../marmotta/client/model/rdf/RDFNode.java | 2 +-
.../apache/marmotta/client/model/rdf/URI.java | 5 +-
.../client/model/sparql/SPARQLResult.java | 2 +-
.../marmotta/client/util/CollectionUtils.java | 11 +-
.../apache/marmotta/client/util/HTTPUtil.java | 7 +-
.../apache/marmotta/client/util/MetaUtil.java | 2 +-
.../marmotta/client/util/RDFJSONParser.java | 2 +-
.../marmotta/client/test/AbstractClientIT.java | 2 +-
.../client/test/config/ConfigurationIT.java | 2 +-
.../marmotta/client/test/io/ImportIT.java | 2 +-
.../marmotta/client/test/ldpath/LDPathIT.java | 2 +-
.../marmotta/client/test/sparql/SPARQLIT.java | 2 +-
client/marmotta-client-js-sample-webapp/pom.xml | 2 +-
client/marmotta-client-js/pom.xml | 2 +-
.../marmotta-client-js/src/main/js/marmotta.js | 34 +
client/marmotta-client-php/pom.xml | 2 +-
client/pom.xml | 4 +-
commons/marmotta-commons/pom.xml | 3 +-
.../src/ext/java/javolution/lang/Immutable.java | 2 +-
.../src/ext/java/javolution/lang/Realtime.java | 2 +-
.../src/ext/java/javolution/lang/ValueType.java | 2 +-
.../java/javolution/util/FastCollection.java | 2 +-
.../src/ext/java/javolution/util/FastSet.java | 2 +-
.../ext/java/javolution/util/FastSortedSet.java | 2 +-
.../java/javolution/util/FastSortedTable.java | 2 +-
.../src/ext/java/javolution/util/FastTable.java | 2 +-
.../java/javolution/util/function/Consumer.java | 2 +-
.../javolution/util/function/Equalities.java | 2 +-
.../java/javolution/util/function/Function.java | 2 +-
.../javolution/util/function/Iteration.java | 6 +-
.../javolution/util/function/MultiVariable.java | 2 +-
.../javolution/util/function/Predicate.java | 2 +-
.../java/javolution/util/function/Reducer.java | 2 +-
.../java/javolution/util/function/Reducers.java | 2 +-
.../javolution/util/function/Splittable.java | 2 +-
.../java/javolution/util/function/Supplier.java | 2 +-
.../collection/AtomicCollectionImpl.java | 16 +-
.../internal/collection/CollectionView.java | 3 +-
.../util/internal/map/AtomicMapImpl.java | 20 +-
.../util/internal/table/AtomicTableImpl.java | 28 +-
.../util/internal/table/FractalTableImpl.java | 2 +-
.../util/internal/table/SharedTableImpl.java | 2 +-
.../table/sorted/AtomicSortedTableImpl.java | 2 +-
.../table/sorted/SharedSortedTableImpl.java | 2 +-
.../util/service/CollectionService.java | 2 +-
.../javolution/util/service/MapService.java | 2 +-
.../util/service/SortedTableService.java | 2 +-
.../marmotta/commons/http/ContentType.java | 2 +-
.../marmotta/commons/http/ETagGenerator.java | 2 +-
.../commons/http/MarmottaHttpUtils.java | 28 +-
.../apache/marmotta/commons/http/UriUtil.java | 31 +-
.../commons/nio/watch/AbstractTreeWatcher.java | 20 +-
.../commons/sesame/model/BNodeCommons.java | 2 +-
.../commons/sesame/model/LiteralKey.java | 3 +-
.../commons/sesame/model/Namespaces.java | 7 +-
.../commons/sesame/model/URICommons.java | 2 +-
.../sesame/repository/ExceptionUtils.java | 2 +-
.../sesame/repository/ResourceConnection.java | 2 +-
.../sesame/repository/ResourceUtils.java | 5 +-
.../commons/sesame/repository/ResultUtils.java | 2 +-
.../apache/marmotta/commons/util/DateUtils.java | 2 +-
.../apache/marmotta/commons/util/JSONUtils.java | 2 +-
.../src/main/resources/META-INF/NOTICE | 2 +-
.../commons/http/ContentTypeMatchingTest.java | 2 +-
.../commons/http/ETagGeneratorTest.java | 2 +-
.../commons/http/MarmottaHttpUtilsTest.java | 29 +-
.../marmotta/commons/http/UriUtilTest.java | 2 +-
.../sesame/model/LiteralCommonsTest.java | 2 +-
.../commons/sesame/model/ResourceUtilsTest.java | 2 +-
.../commons/sesame/model/URICommonsTest.java | 2 +-
.../marmotta/commons/util/DateUtilsTest.java | 2 +-
.../marmotta-model-vocabs/pom.xml | 18 +-
.../marmotta-rio-api/pom.xml | 2 +-
.../commons/sesame/rio/ical/ICalFormat.java | 3 +-
.../commons/sesame/rio/rss/RSSFormat.java | 3 +-
.../commons/sesame/rio/vcard/VCardFormat.java | 3 +-
.../marmotta-rio-ical/pom.xml | 2 +-
.../commons/sesame/rio/ical/ICalParser.java | 36 +-
.../sesame/rio/ical/ICalParserFactory.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../marmotta-rio-rss/pom.xml | 2 +-
.../java/com/sun/syndication/feed/CopyFrom.java | 4 +-
.../java/com/sun/syndication/feed/WireFeed.java | 8 +-
.../com/sun/syndication/feed/atom/Content.java | 2 +-
.../com/sun/syndication/feed/atom/Entry.java | 12 +-
.../com/sun/syndication/feed/atom/Feed.java | 10 +-
.../syndication/feed/impl/BeanIntrospector.java | 54 +-
.../syndication/feed/impl/CloneableBean.java | 32 +-
.../syndication/feed/impl/CopyFromHelper.java | 39 +-
.../sun/syndication/feed/impl/ToStringBean.java | 20 +-
.../sun/syndication/feed/module/DCSubject.java | 2 +-
.../sun/syndication/feed/module/Extendable.java | 2 +-
.../com/sun/syndication/feed/module/Module.java | 3 +-
.../sun/syndication/feed/module/SyModule.java | 12 +-
.../syndication/feed/module/SyModuleImpl.java | 2 +-
.../feed/module/impl/ModuleUtils.java | 2 +-
.../com/sun/syndication/feed/rss/Channel.java | 23 +-
.../java/com/sun/syndication/feed/rss/Item.java | 10 +-
.../sun/syndication/feed/synd/Converter.java | 7 +-
.../sun/syndication/feed/synd/SyndCategory.java | 2 +-
.../syndication/feed/synd/SyndCategoryImpl.java | 12 +-
.../sun/syndication/feed/synd/SyndContent.java | 2 +-
.../syndication/feed/synd/SyndEnclosure.java | 12 +-
.../sun/syndication/feed/synd/SyndEntry.java | 20 +-
.../syndication/feed/synd/SyndEntryImpl.java | 12 +-
.../com/sun/syndication/feed/synd/SyndFeed.java | 14 +-
.../sun/syndication/feed/synd/SyndImage.java | 2 +-
.../com/sun/syndication/feed/synd/SyndLink.java | 34 +-
.../sun/syndication/feed/synd/SyndPerson.java | 14 +-
.../feed/synd/impl/ConverterForAtom03.java | 66 +-
.../feed/synd/impl/ConverterForAtom10.java | 83 +-
.../feed/synd/impl/ConverterForRSS090.java | 8 +-
.../feed/synd/impl/ConverterForRSS092.java | 30 +-
.../com/sun/syndication/io/ModuleGenerator.java | 7 +-
.../com/sun/syndication/io/ModuleParser.java | 4 +-
.../sun/syndication/io/WireFeedGenerator.java | 5 +-
.../com/sun/syndication/io/WireFeedInput.java | 48 +-
.../com/sun/syndication/io/WireFeedParser.java | 7 +-
.../syndication/io/impl/Atom03Generator.java | 47 +-
.../sun/syndication/io/impl/Atom03Parser.java | 63 +-
.../syndication/io/impl/Atom10Generator.java | 69 +-
.../sun/syndication/io/impl/Atom10Parser.java | 72 +-
.../com/sun/syndication/io/impl/Base64.java | 6 +-
.../io/impl/BaseWireFeedGenerator.java | 12 +-
.../syndication/io/impl/BaseWireFeedParser.java | 34 +-
.../syndication/io/impl/DCModuleGenerator.java | 28 +-
.../sun/syndication/io/impl/DCModuleParser.java | 30 +-
.../sun/syndication/io/impl/FeedGenerators.java | 2 +-
.../syndication/io/impl/ModuleGenerators.java | 10 +-
.../sun/syndication/io/impl/ModuleParsers.java | 4 +-
.../sun/syndication/io/impl/NumberParser.java | 10 +-
.../sun/syndication/io/impl/PluginManager.java | 16 +-
.../syndication/io/impl/PropertiesLoader.java | 14 +-
.../sun/syndication/io/impl/RSS090Parser.java | 6 +-
.../io/impl/RSS091UserlandGenerator.java | 13 +-
.../io/impl/RSS091UserlandParser.java | 22 +-
.../syndication/io/impl/RSS092Generator.java | 4 +-
.../sun/syndication/io/impl/RSS092Parser.java | 24 +-
.../sun/syndication/io/impl/RSS094Parser.java | 6 +-
.../sun/syndication/io/impl/RSS10Generator.java | 12 +-
.../sun/syndication/io/impl/RSS20Generator.java | 4 +-
.../sun/syndication/io/impl/XmlFixerReader.java | 4 +-
.../activitystreams/ActivityStreamModule.java | 16 +-
.../activitystreams/types/HasLocation.java | 8 +-
.../org/rometools/feed/module/base/Article.java | 16 +-
.../org/rometools/feed/module/base/Course.java | 24 +-
.../rometools/feed/module/base/CustomTag.java | 4 +-
.../feed/module/base/CustomTagImpl.java | 4 +-
.../rometools/feed/module/base/CustomTags.java | 7 +-
.../org/rometools/feed/module/base/Event.java | 59 +-
.../feed/module/base/GlobalInterface.java | 20 +-
.../rometools/feed/module/base/GoogleBase.java | 2 +-
.../feed/module/base/GoogleBaseImpl.java | 20 +-
.../org/rometools/feed/module/base/Housing.java | 75 +-
.../org/rometools/feed/module/base/Job.java | 40 +-
.../org/rometools/feed/module/base/Person.java | 40 +-
.../org/rometools/feed/module/base/Product.java | 135 +-
.../org/rometools/feed/module/base/Review.java | 38 +-
.../feed/module/base/ScholarlyArticle.java | 20 +-
.../org/rometools/feed/module/base/Service.java | 58 +-
.../org/rometools/feed/module/base/Travel.java | 63 +-
.../org/rometools/feed/module/base/Unknown.java | 28 +-
.../org/rometools/feed/module/base/Vehicle.java | 87 +-
.../org/rometools/feed/module/base/Wanted.java | 12 +-
.../feed/module/base/io/CustomTagGenerator.java | 90 +-
.../feed/module/base/io/CustomTagParser.java | 114 +-
.../module/base/io/GoogleBaseGenerator.java | 76 +-
.../feed/module/base/io/GoogleBaseParser.java | 58 +-
.../feed/module/base/types/CloneableType.java | 2 +-
.../feed/module/base/types/DateTimeRange.java | 4 +-
.../feed/module/base/types/FloatUnit.java | 9 +-
.../feed/module/base/types/IntUnit.java | 4 +-
.../feed/module/cc/CreativeCommons.java | 10 +-
.../feed/module/cc/CreativeCommonsImpl.java | 5 +-
.../feed/module/cc/io/CCModuleGenerator.java | 51 +-
.../feed/module/cc/io/ModuleParserRSS1.java | 72 +-
.../feed/module/cc/io/ModuleParserRSS2.java | 38 +-
.../rometools/feed/module/cc/types/License.java | 5 +-
.../feed/module/content/ContentItem.java | 8 +-
.../feed/module/content/ContentModule.java | 21 +-
.../content/io/ContentModuleGenerator.java | 28 +-
.../module/content/io/ContentModuleParser.java | 21 +-
.../feed/module/feedburner/FeedBurner.java | 18 +-
.../feed/module/georss/GMLGenerator.java | 20 +-
.../rometools/feed/module/georss/GMLParser.java | 23 +-
.../feed/module/georss/GeoRSSUtils.java | 2 +-
.../feed/module/georss/SimpleGenerator.java | 13 +-
.../feed/module/georss/SimpleParser.java | 7 +-
.../feed/module/georss/W3CGeoParser.java | 9 +-
.../feed/module/georss/geometries/Polygon.java | 9 +-
.../module/itunes/AbstractITunesObject.java | 4 +-
.../feed/module/itunes/EntryInformation.java | 4 +-
.../module/itunes/EntryInformationImpl.java | 2 +-
.../feed/module/itunes/FeedInformation.java | 16 +-
.../feed/module/itunes/FeedInformationImpl.java | 4 +-
.../rometools/feed/module/itunes/ITunes.java | 27 +-
.../feed/module/itunes/io/ITunesGenerator.java | 14 +-
.../feed/module/itunes/io/ITunesParser.java | 26 +-
.../feed/module/itunes/types/Category.java | 4 +-
.../feed/module/mediarss/MediaEntryModule.java | 4 +-
.../feed/module/mediarss/MediaModule.java | 6 +-
.../mediarss/io/MediaModuleGenerator.java | 99 +-
.../module/mediarss/io/MediaModuleParser.java | 46 +-
.../feed/module/mediarss/types/MediaGroup.java | 6 +-
.../module/opensearch/OpenSearchModule.java | 2 +-
.../module/opensearch/OpenSearchResponse.java | 26 +-
.../impl/OpenSearchModuleGenerator.java | 32 +-
.../opensearch/impl/OpenSearchModuleParser.java | 45 +-
.../feed/module/photocast/PhotocastModule.java | 23 +-
.../feed/module/photocast/io/Parser.java | 71 +-
.../feed/module/photocast/types/PhotoDate.java | 5 +-
.../org/rometools/feed/module/slash/Slash.java | 19 +-
.../rometools/feed/module/slash/SlashImpl.java | 4 +-
.../module/slash/io/SlashModuleGenerator.java | 7 +-
.../feed/module/sle/SimpleListExtension.java | 14 +-
.../org/rometools/feed/module/sle/SleEntry.java | 12 +-
.../rometools/feed/module/sle/SleEntryImpl.java | 16 +-
.../rometools/feed/module/sle/SleUtility.java | 14 +-
.../feed/module/sle/io/ItemParser.java | 16 +-
.../module/sle/io/LabelNamespaceElement.java | 2 +-
.../feed/module/sle/io/ModuleGenerator.java | 19 +-
.../feed/module/sle/io/ModuleParser.java | 55 +-
.../feed/module/sle/types/EntryValue.java | 11 +-
.../feed/module/sse/SSE091Generator.java | 11 +-
.../rometools/feed/module/sse/SSE091Parser.java | 30 +-
.../feed/module/sse/modules/SSEModule.java | 5 +-
.../yahooweather/YWeatherEntryModule.java | 8 +-
.../module/yahooweather/YWeatherFeedModule.java | 26 +-
.../module/yahooweather/YWeatherModule.java | 2 +-
.../module/yahooweather/YWeatherModuleImpl.java | 10 +-
.../yahooweather/types/ConditionCode.java | 9 +-
.../commons/sesame/rio/rss/AtomParser.java | 2 +-
.../sesame/rio/rss/AtomParserFactory.java | 2 +-
.../commons/sesame/rio/rss/FeedParserBase.java | 2 +-
.../commons/sesame/rio/rss/RSSParser.java | 2 +-
.../sesame/rio/rss/RSSParserFactory.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../marmotta-rio-vcard/pom.xml | 2 +-
.../commons/sesame/rio/vcard/VCardParser.java | 6 +-
.../sesame/rio/vcard/VCardParserFactory.java | 2 +-
.../sesame/rio/vcard/TestVCardParser.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../marmotta-sail-contextaware/pom.xml | 2 +-
.../sesame/contextaware/ContextAwareSail.java | 2 +-
.../ContextAwareSailConnection.java | 4 +-
.../marmotta-sail-transactions/pom.xml | 2 +-
.../transactions/api/TransactionListener.java | 8 +-
.../transactions/api/TransactionalSail.java | 10 +-
.../api/TransactionalSailConnection.java | 6 +-
.../transactions/model/TransactionData.java | 6 +-
.../sail/KiWiTransactionalConnection.java | 2 +-
.../sail/KiWiTransactionalSail.java | 4 +-
.../TransactionalSailConnectionWrapper.java | 2 +-
.../wrapper/TransactionalSailWrapper.java | 2 +-
.../marmotta/kiwi/test/TransactionTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../marmotta-sesame-matchers/pom.xml | 2 +-
.../sesame/test/base/RdfStringMatcher.java | 4 +-
.../sesame/test/base/RepositoryMatcher.java | 6 +-
.../test/connection/HasStatementMatcher.java | 2 +-
.../sesame/test/sparql/SparqlAskMatcher.java | 2 +-
.../test/sparql/SparqlGraphQueryMatcher.java | 4 +-
.../test/sparql/SparqlTupleQueryMatcher.java | 4 +-
.../marmotta-util-facading/pom.xml | 2 +-
.../commons/sesame/facading/api/Facading.java | 12 +-
.../facading/api/FacadingPredicateBuilder.java | 6 +-
.../sesame/facading/impl/FacadingImpl.java | 12 +-
.../impl/FacadingInvocationHandler.java | 21 +-
.../facading/impl/FacadingInvocationHelper.java | 10 +-
.../commons/sesame/facading/model/Facade.java | 2 +-
.../sesame/facading/util/FacadeUtils.java | 15 +-
.../src/test/resources/logback.xml | 4 +-
.../marmotta-util-filter/pom.xml | 2 +-
.../commons/sesame/filter/AllOfFilter.java | 5 +-
.../sesame/filter/AlwaysFalseFilter.java | 2 +-
.../commons/sesame/filter/AlwaysTrueFilter.java | 2 +-
.../commons/sesame/filter/NotFilter.java | 2 +-
.../commons/sesame/filter/OneOfFilter.java | 5 +-
.../commons/sesame/filter/SesameFilter.java | 4 +-
.../sesame/filter/resource/ResourceFilter.java | 2 +-
.../sesame/filter/resource/UriPrefixFilter.java | 4 +-
.../sesame/filter/resource/UriRegexFilter.java | 4 +-
.../filter/statement/StatementFilter.java | 2 +-
.../marmotta-util-rdfpatch/pom.xml | 2 +-
.../platform/ldp/patch/model/PatchLine.java | 3 +-
.../ldp/patch/parser/RdfPatchParser.java | 6 +-
.../marmotta-util-tripletable/pom.xml | 2 +-
.../commons/sesame/tripletable/ByteArray.java | 2 +-
.../commons/sesame/tripletable/IntArray.java | 2 +-
.../commons/sesame/tripletable/TripleTable.java | 13 +-
commons/marmotta-sesame-tools/pom.xml | 2 +-
commons/pom.xml | 2 +-
extras/pom.xml | 2 +-
extras/webjars/codemirror/pom.xml | 2 +-
extras/webjars/pom.xml | 2 +-
extras/webjars/strftime/pom.xml | 2 +-
launchers/marmotta-installer/assembly.xml | 4 -
launchers/marmotta-installer/pom.xml | 6 +-
.../src/main/resources/images/splashscreen.png | Bin 69972 -> 89064 bytes
.../src/main/resources/installer/NOTICE.txt | 2 +-
launchers/marmotta-splash/pom.xml | 2 +-
.../splash/systray/SystrayListener.java | 35 +-
launchers/marmotta-webapp/README.md | 50 +
launchers/marmotta-webapp/assembly.xml | 4 -
launchers/marmotta-webapp/pom.xml | 108 +-
.../marmotta-webapp/src/deb/control/control | 4 +-
launchers/marmotta-webapp/src/deb/pkg/copyright | 2 +-
.../marmotta-webapp/src/docker/entrypoint.sh | 38 +
.../src/main/webapp/META-INF/NOTICE | 2 +-
.../src/main/webapp/WEB-INF/web.xml | 6 +-
.../src/test/resources/test-config.properties | 2 +-
launchers/pom.xml | 2 +-
libraries/kiwi/README.txt | 2 -
libraries/kiwi/kiwi-caching-ehcache/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-hazelcast/pom.xml | 2 +-
.../caching/HazelcastCacheManager.java | 2 +-
libraries/kiwi/kiwi-caching-infinispan/pom.xml | 2 +-
.../InfinispanEmbeddedCacheManager.java | 9 +-
.../remote/CustomClassExternalizerFactory.java | 4 +-
.../infinispan/remote/CustomClassTable.java | 6 +-
.../marmotta/kiwi/infinispan/util/AsyncMap.java | 2 +-
.../kiwi/test/embedded/EmbeddedClusterTest.java | 7 +-
.../EmbeddedRepositoryConnectionTest.java | 6 +
libraries/kiwi/kiwi-loader/pom.xml | 4 +-
.../kiwi/loader/csv/SQLBooleanProcessor.java | 2 +-
.../kiwi/loader/csv/SQLDateTimeProcessor.java | 6 +-
.../kiwi/loader/generic/KiWiBatchHandler.java | 6 +-
.../kiwi/loader/generic/KiWiHandler.java | 4 +-
.../marmotta/kiwi/loader/pgsql/PGCopyUtil.java | 6 +-
.../kiwi-loader/src/main/resources/logback.xml | 4 +-
.../src/test/resources/logback-test.xml | 4 +-
libraries/kiwi/kiwi-reasoner/pom.xml | 2 +-
.../reasoner/engine/ReasoningConfiguration.java | 2 +-
.../kiwi/reasoner/engine/ReasoningEngine.java | 45 +-
.../kiwi/reasoner/model/program/Field.java | 10 +-
.../kiwi/reasoner/model/program/Filter.java | 2 +-
.../reasoner/model/program/Justification.java | 8 +-
.../reasoner/model/program/LiteralField.java | 5 +-
.../kiwi/reasoner/model/program/Pattern.java | 5 +-
.../kiwi/reasoner/model/program/Program.java | 9 +-
.../reasoner/model/program/ResourceField.java | 5 +-
.../kiwi/reasoner/model/program/Rule.java | 6 +-
.../reasoner/model/program/VariableField.java | 5 +-
.../kiwi/reasoner/model/query/QueryResult.java | 5 +-
.../model/query/QueryResultIterator.java | 4 +-
.../reasoner/parser/KWRLProgramParserBase.java | 8 +-
.../persistence/KiWiReasoningConnection.java | 100 +-
.../persistence/KiWiReasoningPersistence.java | 2 +-
.../kiwi/reasoner/sail/KiWiReasoningSail.java | 37 +-
.../kiwi/reasoner/parser/KWRLProgramParser.jj | 26 +-
.../engine/JustificationResolutionTest.java | 19 +-
.../test/engine/ReasoningEngineTest.java | 2 +-
.../reasoner/test/model/JustificationTest.java | 9 -
.../test/parser/KWRLProgramParserTest.java | 2 +-
.../test/parser/KWRLRuleParserTest.java | 43 +-
.../JustificationPersistenceTest.java | 2 +-
.../persistence/KWRLProgramPersistenceTest.java | 4 +-
.../test/persistence/PatternQueryTest.java | 2 +-
.../reasoner/test/sail/ReasoningLargeTest.java | 2 +-
.../reasoner/test/sail/ReasoningSailTest.java | 2 +-
libraries/kiwi/kiwi-sparql/pom.xml | 4 +-
.../kiwi/sparql/builder/SQLBuilder.java | 206 +-
.../kiwi/sparql/builder/ValueConverter.java | 2 +-
.../sparql/builder/collect/ConditionFinder.java | 10 +-
.../sparql/builder/collect/DistinctFinder.java | 10 +-
.../sparql/builder/collect/ExtensionFinder.java | 9 +-
.../sparql/builder/collect/GroupFinder.java | 9 +-
.../sparql/builder/collect/OrderFinder.java | 8 +-
.../builder/collect/PatternCollector.java | 9 +-
.../sparql/builder/collect/VariableFinder.java | 7 +-
.../builder/eval/ValueExpressionEvaluator.java | 22 +-
.../builder/model/SQLAbstractSubquery.java | 3 +-
.../kiwi/sparql/builder/model/SQLClause.java | 15 +-
.../kiwi/sparql/builder/model/SQLFragment.java | 14 +-
.../kiwi/sparql/builder/model/SQLPattern.java | 10 +-
.../kiwi/sparql/builder/model/SQLUnion.java | 14 +-
.../kiwi/sparql/builder/model/SQLVariable.java | 11 +-
.../evaluation/KiWiEvaluationStrategy.java | 43 +-
.../kiwi/sparql/function/NativeFunction.java | 12 +-
.../optimizer/DistinctLimitOptimizer.java | 21 +-
.../sparql/optimizer/NativeFilterOptimizer.java | 215 +
.../kiwi/sparql/sail/KiWiSparqlSail.java | 35 +-
.../sparql/sail/KiWiSparqlSailConnection.java | 7 +-
.../sparql/test/ComplexKiWiSparqlQueryTest.java | 17 +-
.../kiwi/sparql/test/ContextAwareTest.java | 2 -
.../kiwi/sparql/test/KiWiSparqlTest.java | 399 +
.../kiwi/sparql/test/KiWiSparqlUpdateTest.java | 3 +-
.../testsuite/KiWiSparqlComplianceTest.java | 1 -
.../kiwi/sparql/test/MARMOTTA-578.sparql | 27 +
.../kiwi/sparql/test/MARMOTTA-617.sparql | 28 +
.../marmotta/kiwi/sparql/test/MARMOTTA-617.ttl | 41 +
.../kiwi/sparql/test/MARMOTTA-640_1.sparql | 33 +
.../kiwi/sparql/test/MARMOTTA-640_2.sparql | 51 +
.../kiwi/sparql/test/MARMOTTA-651_1.sparql | 26 +
.../kiwi/sparql/test/MARMOTTA-657.sparql | 25 +
libraries/kiwi/kiwi-triplestore/pom.xml | 23 +-
.../kiwi/persistence/util/ScriptRunner.java | 289 +
.../marmotta/kiwi/caching/CacheManager.java | 40 +-
.../kiwi/caching/CacheManagerFactory.java | 2 +-
.../kiwi/caching/GuavaCacheManager.java | 2 +-
.../marmotta/kiwi/config/KiWiConfiguration.java | 4 +-
.../kiwi/exception/DriverNotFoundException.java | 2 +-
.../marmotta/kiwi/generator/IDGenerator.java | 4 +-
.../kiwi/generator/SnowflakeIDGenerator.java | 8 +-
.../kiwi/generator/UUIDRandomIDGenerator.java | 4 +-
.../marmotta/kiwi/hashing/TripleFunnel.java | 2 +-
.../org/apache/marmotta/kiwi/io/KiWiIO.java | 176 +-
.../kiwi/model/rdf/KiWiAnonResource.java | 2 +-
.../kiwi/model/rdf/KiWiBooleanLiteral.java | 2 +-
.../kiwi/model/rdf/KiWiDateLiteral.java | 3 +-
.../kiwi/model/rdf/KiWiDoubleLiteral.java | 8 +-
.../marmotta/kiwi/model/rdf/KiWiIntLiteral.java | 4 +-
.../marmotta/kiwi/model/rdf/KiWiLiteral.java | 8 +-
.../marmotta/kiwi/model/rdf/KiWiNamespace.java | 5 +-
.../marmotta/kiwi/model/rdf/KiWiNode.java | 2 +-
.../marmotta/kiwi/model/rdf/KiWiResource.java | 2 +-
.../kiwi/model/rdf/KiWiStringLiteral.java | 2 +-
.../marmotta/kiwi/model/rdf/KiWiTriple.java | 14 +-
.../kiwi/model/rdf/KiWiUriResource.java | 2 +-
.../kiwi/persistence/KiWiConnection.java | 629 +-
.../marmotta/kiwi/persistence/KiWiDialect.java | 42 +-
.../kiwi/persistence/KiWiGarbageCollector.java | 25 +-
.../kiwi/persistence/KiWiPersistence.java | 91 +-
.../marmotta/kiwi/persistence/h2/H2Dialect.java | 7 +-
.../kiwi/persistence/mysql/MySQLDialect.java | 7 +-
.../persistence/pgsql/PostgreSQLDialect.java | 9 +-
.../registry/LocalTripleRegistry.java | 7 +-
.../persistence/util/ResultSetIteration.java | 4 +-
.../util/ResultTransformerFunction.java | 4 +-
.../kiwi/persistence/util/ScriptRunner.java | 302 -
.../marmotta/kiwi/sail/KiWiSailConnection.java | 49 +-
.../apache/marmotta/kiwi/sail/KiWiStore.java | 2 +-
.../marmotta/kiwi/sail/KiWiValueFactory.java | 58 +-
.../kiwi/test/cluster/BaseClusterTest.java | 4 +
.../kiwi/test/junit/KiWiDatabaseRunner.java | 4 +-
.../src/test/resources/logback.xml | 4 +-
libraries/kiwi/kiwi-versioning/pom.xml | 2 +-
.../kiwi/versioning/api/VersioningSail.java | 8 +-
.../marmotta/kiwi/versioning/model/Version.java | 2 +-
.../persistence/KiWiVersioningConnection.java | 4 +-
.../persistence/KiWiVersioningPersistence.java | 2 +-
.../repository/SnapshotRepository.java | 2 +-
.../SnapshotRepositoryConnection.java | 2 +-
.../versioning/sail/KiWiSnapshotConnection.java | 27 +-
.../versioning/sail/KiWiVersionListener.java | 2 +-
.../versioning/sail/KiWiVersioningSail.java | 24 +-
.../versioning/test/SnapshotRepositoryTest.java | 2 +-
.../test/VersioningPersistenceTest.java | 2 +-
.../test/VersioningRepositoryTest.java | 2 +-
libraries/kiwi/pom.xml | 2 +-
libraries/ldcache/ldcache-api/pom.xml | 2 +-
.../marmotta/ldcache/api/LDCachingBackend.java | 12 +-
.../ldcache/api/LDCachingConnection.java | 8 +-
.../marmotta/ldcache/api/LDCachingService.java | 14 +-
.../ldcache/model/CacheConfiguration.java | 2 +-
.../marmotta/ldcache/model/CacheEntry.java | 2 +-
libraries/ldcache/ldcache-backend-file/pom.xml | 19 +-
.../backend/file/LDCachingFileBackend.java | 2 +-
.../backend/file/util/FileBackendUtils.java | 17 +-
.../backend/file/test/LDCacheFileTest.java | 31 +-
.../src/test/resources/logback.xml | 7 +-
.../ldcache/ldcache-backend-infinispan/pom.xml | 23 +-
.../infinispan/io/ModelExternalizer.java | 2 +-
.../infinispan/io/ValueExternalizer.java | 2 +-
libraries/ldcache/ldcache-backend-kiwi/pom.xml | 15 +-
.../backend/kiwi/model/KiWiCacheEntry.java | 2 +-
.../persistence/LDCachingKiWiPersistence.java | 2 +-
.../LDCachingKiWiPersistenceConnection.java | 15 +-
.../kiwi/test/LDCachePersistenceTest.java | 2 +-
.../src/test/resources/logback.xml | 7 +-
libraries/ldcache/ldcache-core/pom.xml | 15 +-
.../services/test/dummy/DummyEndpoint.java | 2 +-
.../ldcache/services/test/dummy/DummyTest.java | 2 +-
.../services/test/ng/BaseLDCacheTest.java | 20 +-
.../ldcache-core/src/test/resources/logback.xml | 7 +-
libraries/ldcache/ldcache-sail-generic/pom.xml | 2 +-
.../sail/GenericLinkedDataSailConnection.java | 4 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldcache/ldcache-sail-kiwi/pom.xml | 2 +-
.../ldcache/sail/KiWiLinkedDataSail.java | 2 +-
.../sail/KiWiLinkedDataSailConnection.java | 2 +-
.../test/KiWiLinkedDataSailOfflineTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldcache/pom.xml | 2 +-
libraries/ldclient/ldclient-api/pom.xml | 8 +-
.../ldclient/api/endpoint/Endpoint.java | 2 +-
.../ldclient/api/ldclient/LDClientService.java | 2 +-
.../ldclient/api/provider/DataProvider.java | 2 +-
.../ldclient/api/provider/ValueMapper.java | 2 +-
.../exception/DataRetrievalException.java | 2 +-
.../ldclient/model/ClientConfiguration.java | 2 +-
.../marmotta/ldclient/model/ClientResponse.java | 2 +-
libraries/ldclient/ldclient-core/pom.xml | 16 +-
.../ldclient/services/ldclient/LDClient.java | 8 +-
.../services/provider/AbstractHttpProvider.java | 2 +-
.../services/provider/BlockingProvider.java | 2 +-
.../marmotta/ldclient/dummy/DummyEndpoint.java | 2 +-
.../marmotta/ldclient/dummy/DummyProvider.java | 2 +-
.../ldclient/test/TestLDClientTest.java | 2 +-
.../ldclient/test/helper/TestLDClient.java | 2 +-
.../test/provider/ProviderTestBase.java | 20 +-
.../src/test/resources/logback.xml | 4 +-
.../ldclient/ldclient-provider-facebook/pom.xml | 21 +-
.../src/test/resources/logback.xml | 4 +-
.../ldclient/ldclient-provider-freebase/pom.xml | 78 -
.../endpoint/freebase/FreebaseEndpoint.java | 39 -
.../provider/freebase/FreebaseProvider.java | 227 -
...ache.marmotta.ldclient.api.endpoint.Endpoint | 1 -
....marmotta.ldclient.api.provider.DataProvider | 1 -
.../test/freebase/TestFreebaseProvider.java | 142 -
.../src/test/resources/logback.xml | 27 -
.../ldclient/test/freebase/m.07zqbwz.sparql | 26 -
.../ldclient/test/freebase/m.0h21k1c.sparql | 26 -
.../ldclient/test/freebase/m.0nzm.sparql | 27 -
.../ldclient/test/freebase/m.0wqhskn.sparql | 27 -
.../ldclient/ldclient-provider-html/pom.xml | 20 +-
.../provider/html/AbstractHTMLDataProvider.java | 2 +-
.../html/mapping/CssDateLiteralMapper.java | 2 +-
.../html/mapping/CssLiteralAttrMapper.java | 2 +-
.../html/mapping/CssSelectorMapper.java | 2 +-
.../html/mapping/CssTextLiteralMapper.java | 2 +-
.../CssUriAttrBlacklistQueryParamsMapper.java | 2 +-
.../provider/html/mapping/CssUriAttrMapper.java | 2 +-
.../CssUriAttrWhitelistQueryParamsMapper.java | 2 +-
.../provider/html/mapping/JSoupMapper.java | 2 +-
.../ldclient/ldclient-provider-ldap/pom.xml | 20 +-
.../ldclient/provider/ldap/LdapEndpoint.java | 2 +-
.../provider/ldap/LdapFoafProvider.java | 2 +-
.../ldap/mapping/LiteralPredicateFactory.java | 2 +-
.../ldap/mapping/PredicateObjectFactory.java | 2 +-
.../ldap/mapping/UriPredicateFactory.java | 2 +-
.../provider/ldap/TestLdapFoafProvider.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../ldclient-provider-mediawiki/pom.xml | 22 +-
.../mediawiki/WikipediaIndexEndpoint.java | 4 +-
.../mediawiki/WikipediaPageEndpoint.java | 4 +-
.../provider/mediawiki/MediawikiProvider.java | 2 +-
.../test/mediawiki/TestMediawikiProvider.java | 10 +-
.../src/test/resources/logback.xml | 4 +-
.../test/mediawiki/wikipedia-marmot-http.sparql | 29 +
.../test/mediawiki/wikipedia-marmot.sparql | 4 +-
.../ldclient/ldclient-provider-phpbb/pom.xml | 21 +-
.../ldclient/endpoint/phpbb/PHPBBEndpoints.java | 2 +-
.../endpoint/phpbb/PHPBBForumEndpoint.java | 2 +-
.../endpoint/phpbb/PHPBBPostEndpoint.java | 2 +-
.../endpoint/phpbb/PHPBBTopicEndpoint.java | 2 +-
.../provider/phpbb/PHPBBForumProvider.java | 2 +-
.../provider/phpbb/PHPBBPostProvider.java | 2 +-
.../provider/phpbb/PHPBBTopicProvider.java | 2 +-
.../provider/phpbb/mapping/PHPBBDateMapper.java | 2 +-
.../phpbb/mapping/PHPBBForumHrefMapper.java | 2 +-
.../phpbb/mapping/PHPBBPostIdMapper.java | 2 +-
.../phpbb/mapping/PHPBBTopicHrefMapper.java | 2 +-
.../ldclient/ldclient-provider-rdf/pom.xml | 16 +-
.../endpoint/rdf/LinkedDataEndpoint.java | 2 +-
.../ldclient/endpoint/rdf/SPARQLEndpoint.java | 2 +-
.../ldclient/endpoint/rdf/StanbolEndpoint.java | 2 +-
.../provider/rdf/AbstractRDFProvider.java | 2 +-
.../ldclient/provider/rdf/CacheProvider.java | 2 +-
.../provider/rdf/LinkedDataProvider.java | 2 +-
.../ldclient/provider/rdf/RegexUriProvider.java | 2 +-
.../ldclient/provider/rdf/SPARQLProvider.java | 2 +-
.../test/rdf/TestLinkedDataProvider.java | 3 +-
.../ldclient/test/rdf/TestSPARQLProvider.java | 2 +-
.../ldclient/test/rdf/TestStanbolProvider.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../ldclient/ldclient-provider-rdfa/pom.xml | 2 +-
.../ldclient/ldclient-provider-vimeo/pom.xml | 21 +-
.../endpoint/vimeo/VimeoChannelEndpoint.java | 2 +-
.../endpoint/vimeo/VimeoGroupEndpoint.java | 2 +-
.../endpoint/vimeo/VimeoVideoEndpoint.java | 2 +-
.../provider/vimeo/VimeoChannelProvider.java | 2 +-
.../provider/vimeo/VimeoVideoProvider.java | 2 +-
.../provider/vimeo/mapping/VimeoDateMapper.java | 2 +-
.../ldclient/test/vimeo/TestVimeoProvider.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
.../ldclient/test/vimeo/vimeo-channel.sparql | 2 +-
.../ldclient/ldclient-provider-xml/pom.xml | 19 +-
.../provider/xml/AbstractXMLDataProvider.java | 2 +-
.../xml/mapping/CommaSeparatedMapper.java | 2 +-
.../xml/mapping/XPathLiteralMapper.java | 2 +-
.../provider/xml/mapping/XPathURIMapper.java | 2 +-
.../provider/xml/mapping/XPathValueMapper.java | 2 +-
.../ldclient/ldclient-provider-youtube/pom.xml | 22 +-
.../youtube/YoutubeChannelEndpointGData.java | 2 +-
.../youtube/YoutubeChannelEndpointWeb.java | 2 +-
.../youtube/YoutubePlaylistEndpointGData.java | 2 +-
.../youtube/YoutubePlaylistEndpointWeb.java | 2 +-
.../youtube/YoutubePlaylistEndpointWebLong.java | 2 +-
.../endpoint/youtube/YoutubeVideoEndpoint.java | 2 +-
.../youtube/YoutubeVideoPageEndpointGData.java | 2 +-
.../youtube/YoutubeVideoPageEndpointWatch.java | 2 +-
.../youtube/YoutubeVideoPageEndpointWeb.java | 2 +-
.../youtube/YoutubeChannelProvider.java | 2 +-
.../youtube/YoutubePlaylistProvider.java | 2 +-
.../youtube/YoutubeVideoPagesProvider.java | 2 +-
.../provider/youtube/YoutubeVideoProvider.java | 2 +-
.../youtube/mapping/YoutubeCategoryMapper.java | 2 +-
.../youtube/mapping/YoutubeLatitudeMapper.java | 2 +-
.../youtube/mapping/YoutubeLongitudeMapper.java | 2 +-
.../youtube/mapping/YoutubeUriMapper.java | 2 +-
.../test/youtube/TestYoutubeProvider.java | 4 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldclient/pom.xml | 3 +-
libraries/ldpath/ldpath-api/pom.xml | 2 +-
.../marmotta/ldpath/api/LDPathConstruct.java | 4 +-
.../ldpath/api/backend/NodeBackend.java | 42 +-
.../marmotta/ldpath/api/backend/RDFBackend.java | 10 +-
.../ldpath/api/functions/NodeFunction.java | 12 +-
.../ldpath/api/functions/SelectorFunction.java | 2 +-
.../ldpath/api/functions/TestFunction.java | 2 +-
.../ldpath/api/selectors/NodeSelector.java | 14 +-
.../marmotta/ldpath/api/tests/NodeTest.java | 2 +-
.../api/transformers/NodeTransformer.java | 8 +-
libraries/ldpath/ldpath-backend-file/pom.xml | 2 +-
.../ldpath/backend/file/FileBackend.java | 2 +-
.../marmotta/ldpath/backend/file/FileQuery.java | 31 +-
.../ldpath/backend/file/ParserTest.java | 2 +-
.../marmotta/ldpath/backend/file/PathTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-backend-jena/pom.xml | 4 +-
.../ldpath/backend/jena/GenericJenaBackend.java | 16 +-
.../ldpath/ldpath-backend-linkeddata/pom.xml | 2 +-
.../backend/linkeddata/LDCacheBackend.java | 12 +-
libraries/ldpath/ldpath-backend-sesame/pom.xml | 2 +-
.../backend/sesame/AbstractSesameBackend.java | 21 +-
.../backend/sesame/SesameRepositoryBackend.java | 2 +-
.../backend/sesame/SesameValueBackend.java | 23 +-
.../backend/sesame/ThreadingSesameBackend.java | 2 +-
libraries/ldpath/ldpath-core-bundle/pom.xml | 3 +-
libraries/ldpath/ldpath-core/pom.xml | 2 +-
.../java/org/apache/marmotta/ldpath/LDPath.java | 38 +-
.../ldpath/exception/LDPathParseException.java | 2 +-
.../apache/marmotta/ldpath/model/Constants.java | 2 +-
.../ldpath/model/backend/AbstractBackend.java | 42 +-
.../ldpath/model/fields/FieldMapping.java | 13 +-
.../functions/AbstractTextFilterFunction.java | 19 +-
.../model/functions/ConcatenateFunction.java | 12 +-
.../ldpath/model/functions/CountFunction.java | 4 +-
.../ldpath/model/functions/FirstFunction.java | 9 +-
.../ldpath/model/functions/LastFunction.java | 9 +-
.../ldpath/model/functions/SortFunction.java | 24 +-
.../marmotta/ldpath/model/programs/Program.java | 22 +-
.../model/selectors/FunctionSelector.java | 40 +-
.../ldpath/model/selectors/GroupedSelector.java | 20 +-
.../model/selectors/IntersectionSelector.java | 29 +-
.../ldpath/model/selectors/PathSelector.java | 38 +-
.../model/selectors/PropertySelector.java | 22 +-
.../model/selectors/RecursivePathSelector.java | 49 +-
.../selectors/ReversePropertySelector.java | 21 +-
.../ldpath/model/selectors/SelfSelector.java | 2 +-
.../model/selectors/StringConstantSelector.java | 23 +-
.../ldpath/model/selectors/TestingSelector.java | 36 +-
.../ldpath/model/selectors/UnionSelector.java | 32 +-
.../model/selectors/WildcardSelector.java | 5 +-
.../marmotta/ldpath/model/tests/AndTest.java | 29 +-
.../ldpath/model/tests/ComplexTest.java | 2 +-
.../ldpath/model/tests/FunctionTest.java | 28 +-
.../marmotta/ldpath/model/tests/IsATest.java | 6 +-
.../ldpath/model/tests/LiteralLanguageTest.java | 22 +-
.../ldpath/model/tests/LiteralTypeTest.java | 26 +-
.../marmotta/ldpath/model/tests/NotTest.java | 15 +-
.../marmotta/ldpath/model/tests/OrTest.java | 25 +-
.../ldpath/model/tests/PathEqualityTest.java | 24 +-
.../marmotta/ldpath/model/tests/PathTest.java | 20 +-
.../tests/functions/BinaryNumericTest.java | 4 +-
.../ldpath/model/tests/functions/EqualTest.java | 2 +-
.../model/tests/functions/GreaterEqualTest.java | 2 +-
.../model/tests/functions/GreaterThanTest.java | 2 +-
.../model/tests/functions/LessEqualTest.java | 2 +-
.../model/tests/functions/LessThanTest.java | 2 +-
.../model/tests/functions/NotEqualTest.java | 2 +-
.../transformers/BigDecimalTransformer.java | 2 +-
.../transformers/BigIntegerTransformer.java | 2 +-
.../model/transformers/BooleanTransformer.java | 2 +-
.../model/transformers/ByteTransformer.java | 2 +-
.../model/transformers/DateTimeTransformer.java | 2 +-
.../model/transformers/DateTransformer.java | 2 +-
.../model/transformers/DoubleTransformer.java | 2 +-
.../model/transformers/DurationTransformer.java | 2 +-
.../model/transformers/FloatTransformer.java | 2 +-
.../model/transformers/IdentityTransformer.java | 2 +-
.../model/transformers/IntTransformer.java | 2 +-
.../model/transformers/LongTransformer.java | 2 +-
.../model/transformers/ShortTransformer.java | 2 +-
.../model/transformers/StringTransformer.java | 2 +-
.../model/transformers/TimeTransformer.java | 2 +-
.../marmotta/ldpath/parser/Configuration.java | 10 +-
.../ldpath/parser/DefaultConfiguration.java | 31 +-
.../marmotta/ldpath/util/Collections.java | 4 +-
.../marmotta/ldpath/util/FormatUtils.java | 2 +-
.../org/apache/marmotta/ldpath/parser/ldpath.jj | 140 +-
.../BinaryNumericTestFunctionsTest.java | 2 +-
.../ldpath/model/functions/FunctionsTest.java | 2 +-
.../ldpath/parser/EmptyTestingBackend.java | 2 +-
.../marmotta/ldpath/parser/ProgramTest.java | 3 +-
.../marmotta/ldpath/test/AbstractTestBase.java | 2 +-
.../ldpath-core/src/test/resources/logback.xml | 4 +-
.../ldpath/ldpath-functions-collections/pom.xml | 2 +-
.../functions/coll/AbstractCollFunction.java | 2 +-
.../model/functions/coll/FlattenFunction.java | 15 +-
.../model/functions/coll/GetFunction.java | 13 +-
.../model/functions/coll/SubListFunction.java | 13 +-
.../model/functions/coll/CollectionsTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-date/pom.xml | 2 +-
.../model/functions/date/DateFunction.java | 2 +-
.../functions/date/EarliestDateFunction.java | 15 +-
.../functions/date/LatestDateFunction.java | 15 +-
.../model/functions/date/DateFunctionsTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-html/pom.xml | 2 +-
.../model/functions/html/CleanHtmlFunction.java | 2 +-
.../model/functions/html/CssSelectFunction.java | 43 +-
.../model/functions/html/HtmlFunctionsTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-json/pom.xml | 2 +-
.../model/functions/json/JsonPathFunction.java | 30 +-
.../functions/json/JsonPathFunctionTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-math/pom.xml | 2 +-
.../model/functions/math/MathFunction.java | 4 +-
.../model/functions/math/MaxFunction.java | 20 +-
.../model/functions/math/MinFunction.java | 18 +-
.../model/functions/math/RoundFunction.java | 20 +-
.../model/functions/math/SumFunction.java | 22 +-
.../model/functions/math/MathFunctionTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-text/pom.xml | 2 +-
.../model/functions/text/ReplaceFunction.java | 17 +-
.../model/functions/text/StrJoinFunction.java | 13 +-
.../model/functions/text/StrLeftFunction.java | 17 +-
.../model/functions/text/StrLenFunction.java | 12 +-
.../model/functions/text/StrRightFunction.java | 17 +-
.../model/functions/text/SubstringFunction.java | 17 +-
.../model/functions/text/WordCountFunction.java | 12 +-
.../text/AbstractBinaryStringTest.java | 9 +-
.../functions/text/AbstractStringTest.java | 16 +-
.../functions/text/StringContainsTest.java | 2 +-
.../functions/text/StringEndsWithTest.java | 2 +-
.../tests/functions/text/StringEqualsIC.java | 2 +-
.../tests/functions/text/StringEqualsTest.java | 2 +-
.../tests/functions/text/StringIsEmptyTest.java | 9 +-
.../functions/text/StringStartsWithTest.java | 2 +-
.../model/functions/text/TextFunctionsTest.java | 2 +-
.../tests/functions/text/StringTestTest.java | 2 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-functions-xml/pom.xml | 2 +-
.../model/functions/xml/XPathFunction.java | 28 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-ldquery-cli/pom.xml | 4 +-
.../ldpath-ldquery-cli/src/main/doc/NOTICE.txt | 2 +-
.../apache/marmotta/ldpath/ldquery/LDQuery.java | 4 +-
.../ldpath/ldpath-template-linkeddata/pom.xml | 2 +-
.../marmotta/ldpath/template/LDTemplate.java | 4 +-
.../src/test/resources/logback.xml | 4 +-
libraries/ldpath/ldpath-template/pom.xml | 2 +-
.../ldpath/template/engine/LDPathDirective.java | 21 +-
.../ldpath/template/engine/LDPathMethod.java | 20 +-
.../template/engine/NamespaceDirective.java | 30 +-
.../ldpath/template/engine/TemplateEngine.java | 2 +-
.../model/freemarker/TemplateNodeModel.java | 2 +-
.../model/freemarker/TemplateStackModel.java | 4 +-
.../model/freemarker/TemplateWrapperModel.java | 2 +-
.../TemplateBooleanTransformer.java | 9 +-
.../transformers/TemplateDateTransformer.java | 11 +-
.../transformers/TemplateDoubleTransformer.java | 9 +-
.../transformers/TemplateFloatTransformer.java | 9 +-
.../TemplateIntegerTransformer.java | 9 +-
.../transformers/TemplateLongTransformer.java | 2 +-
.../transformers/TemplateScalarTransformer.java | 9 +-
.../ldpath/template/util/FormatUtil.java | 2 +-
libraries/ldpath/pom.xml | 2 +-
libraries/ostrich/Dockerfile | 94 +
libraries/ostrich/README.md | 116 +
libraries/ostrich/backend/.dockerignore | 1 +
.../backend/3rdparty/abseil/.clang-format | 4 +
.../ostrich/backend/3rdparty/abseil/.gitignore | 2 +
.../3rdparty/abseil/ABSEIL_ISSUE_TEMPLATE.md | 22 +
.../ostrich/backend/3rdparty/abseil/AUTHORS | 6 +
.../3rdparty/abseil/CMake/AbseilHelpers.cmake | 157 +
.../backend/3rdparty/abseil/CMake/README.md | 79 +
.../backend/3rdparty/abseil/CMakeLists.txt | 86 +
.../backend/3rdparty/abseil/CONTRIBUTING.md | 91 +
.../ostrich/backend/3rdparty/abseil/LICENSE | 204 +
.../ostrich/backend/3rdparty/abseil/README.md | 108 +
.../ostrich/backend/3rdparty/abseil/WORKSPACE | 25 +
.../backend/3rdparty/abseil/absl/BUILD.bazel | 52 +
.../backend/3rdparty/abseil/absl/CMakeLists.txt | 30 +
.../3rdparty/abseil/absl/algorithm/BUILD.bazel | 69 +
.../abseil/absl/algorithm/CMakeLists.txt | 63 +
.../3rdparty/abseil/absl/algorithm/algorithm.h | 150 +
.../abseil/absl/algorithm/algorithm_test.cc | 182 +
.../3rdparty/abseil/absl/algorithm/container.h | 1642 ++++
.../abseil/absl/algorithm/container_test.cc | 997 +++
.../3rdparty/abseil/absl/base/BUILD.bazel | 395 +
.../3rdparty/abseil/absl/base/CMakeLists.txt | 358 +
.../3rdparty/abseil/absl/base/attributes.h | 567 ++
.../3rdparty/abseil/absl/base/bit_cast_test.cc | 107 +
.../3rdparty/abseil/absl/base/call_once.h | 216 +
.../3rdparty/abseil/absl/base/call_once_test.cc | 102 +
.../backend/3rdparty/abseil/absl/base/casts.h | 140 +
.../backend/3rdparty/abseil/absl/base/config.h | 427 +
.../3rdparty/abseil/absl/base/config_test.cc | 60 +
.../abseil/absl/base/dynamic_annotations.cc | 129 +
.../abseil/absl/base/dynamic_annotations.h | 409 +
.../absl/base/exception_safety_testing_test.cc | 842 ++
.../abseil/absl/base/inline_variable_test.cc | 62 +
.../abseil/absl/base/inline_variable_test_a.cc | 25 +
.../abseil/absl/base/inline_variable_test_b.cc | 25 +
.../abseil/absl/base/internal/atomic_hook.h | 150 +
.../abseil/absl/base/internal/cycleclock.cc | 81 +
.../abseil/absl/base/internal/cycleclock.h | 77 +
.../abseil/absl/base/internal/direct_mmap.h | 151 +
.../3rdparty/abseil/absl/base/internal/endian.h | 269 +
.../abseil/absl/base/internal/endian_test.cc | 279 +
.../base/internal/exception_safety_testing.cc | 41 +
.../base/internal/exception_safety_testing.h | 997 +++
.../absl/base/internal/exception_testing.h | 38 +
.../abseil/absl/base/internal/identity.h | 33 +
.../abseil/absl/base/internal/inline_variable.h | 107 +
.../base/internal/inline_variable_testing.h | 44 +
.../3rdparty/abseil/absl/base/internal/invoke.h | 188 +
.../absl/base/internal/low_level_alloc.cc | 604 ++
.../abseil/absl/base/internal/low_level_alloc.h | 119 +
.../absl/base/internal/low_level_alloc_test.cc | 157 +
.../absl/base/internal/low_level_scheduling.h | 104 +
.../abseil/absl/base/internal/per_thread_tls.h | 48 +
.../abseil/absl/base/internal/pretty_function.h | 33 +
.../abseil/absl/base/internal/raw_logging.cc | 218 +
.../abseil/absl/base/internal/raw_logging.h | 137 +
.../abseil/absl/base/internal/scheduling_mode.h | 54 +
.../abseil/absl/base/internal/spinlock.cc | 238 +
.../abseil/absl/base/internal/spinlock.h | 239 +
.../absl/base/internal/spinlock_akaros.inc | 35 +
.../absl/base/internal/spinlock_posix.inc | 46 +
.../abseil/absl/base/internal/spinlock_wait.cc | 79 +
.../abseil/absl/base/internal/spinlock_wait.h | 91 +
.../absl/base/internal/spinlock_win32.inc | 37 +
.../abseil/absl/base/internal/sysinfo.cc | 404 +
.../abseil/absl/base/internal/sysinfo.h | 63 +
.../abseil/absl/base/internal/sysinfo_test.cc | 98 +
.../absl/base/internal/thread_identity.cc | 123 +
.../abseil/absl/base/internal/thread_identity.h | 240 +
.../absl/base/internal/thread_identity_test.cc | 126 +
.../abseil/absl/base/internal/throw_delegate.cc | 106 +
.../abseil/absl/base/internal/throw_delegate.h | 71 +
.../absl/base/internal/tsan_mutex_interface.h | 66 +
.../absl/base/internal/unaligned_access.h | 256 +
.../absl/base/internal/unscaledcycleclock.cc | 101 +
.../absl/base/internal/unscaledcycleclock.h | 119 +
.../3rdparty/abseil/absl/base/invoke_test.cc | 200 +
.../3rdparty/abseil/absl/base/log_severity.h | 67 +
.../backend/3rdparty/abseil/absl/base/macros.h | 202 +
.../3rdparty/abseil/absl/base/optimization.h | 165 +
.../3rdparty/abseil/absl/base/policy_checks.h | 121 +
.../backend/3rdparty/abseil/absl/base/port.h | 26 +
.../abseil/absl/base/raw_logging_test.cc | 50 +
.../abseil/absl/base/spinlock_test_common.cc | 266 +
.../abseil/absl/base/thread_annotations.h | 258 +
.../abseil/absl/base/throw_delegate_test.cc | 94 +
.../3rdparty/abseil/absl/container/BUILD.bazel | 128 +
.../abseil/absl/container/CMakeLists.txt | 126 +
.../abseil/absl/container/fixed_array.h | 498 ++
.../abseil/absl/container/fixed_array_test.cc | 659 ++
.../abseil/absl/container/inlined_vector.h | 1384 ++++
.../absl/container/inlined_vector_test.cc | 1766 ++++
.../container/internal/test_instance_tracker.cc | 26 +
.../container/internal/test_instance_tracker.h | 220 +
.../internal/test_instance_tracker_test.cc | 160 +
.../backend/3rdparty/abseil/absl/copts.bzl | 155 +
.../3rdparty/abseil/absl/debugging/BUILD.bazel | 305 +
.../abseil/absl/debugging/CMakeLists.txt | 193 +
.../absl/debugging/failure_signal_handler.cc | 351 +
.../absl/debugging/failure_signal_handler.h | 103 +
.../debugging/failure_signal_handler_test.cc | 146 +
.../debugging/internal/address_is_readable.cc | 133 +
.../debugging/internal/address_is_readable.h | 29 +
.../abseil/absl/debugging/internal/demangle.cc | 1862 +++++
.../abseil/absl/debugging/internal/demangle.h | 67 +
.../absl/debugging/internal/demangle_test.cc | 191 +
.../absl/debugging/internal/elf_mem_image.cc | 398 +
.../absl/debugging/internal/elf_mem_image.h | 130 +
.../absl/debugging/internal/examine_stack.cc | 147 +
.../absl/debugging/internal/examine_stack.h | 38 +
.../debugging/internal/stack_consumption.cc | 172 +
.../absl/debugging/internal/stack_consumption.h | 45 +
.../internal/stack_consumption_test.cc | 48 +
.../internal/stacktrace_aarch64-inl.inc | 189 +
.../debugging/internal/stacktrace_arm-inl.inc | 123 +
.../absl/debugging/internal/stacktrace_config.h | 74 +
.../internal/stacktrace_generic-inl.inc | 59 +
.../internal/stacktrace_powerpc-inl.inc | 243 +
.../internal/stacktrace_unimplemented-inl.inc | 22 +
.../debugging/internal/stacktrace_win32-inl.inc | 83 +
.../debugging/internal/stacktrace_x86-inl.inc | 337 +
.../abseil/absl/debugging/internal/symbolize.h | 122 +
.../absl/debugging/internal/vdso_support.cc | 192 +
.../absl/debugging/internal/vdso_support.h | 155 +
.../abseil/absl/debugging/leak_check.cc | 48 +
.../3rdparty/abseil/absl/debugging/leak_check.h | 111 +
.../abseil/absl/debugging/leak_check_disable.cc | 20 +
.../absl/debugging/leak_check_fail_test.cc | 41 +
.../abseil/absl/debugging/leak_check_test.cc | 42 +
.../abseil/absl/debugging/stacktrace.cc | 133 +
.../3rdparty/abseil/absl/debugging/stacktrace.h | 167 +
.../3rdparty/abseil/absl/debugging/symbolize.cc | 28 +
.../3rdparty/abseil/absl/debugging/symbolize.h | 35 +
.../abseil/absl/debugging/symbolize_elf.inc | 1473 ++++
.../abseil/absl/debugging/symbolize_test.cc | 517 ++
.../absl/debugging/symbolize_unimplemented.inc | 35 +
.../abseil/absl/debugging/symbolize_win32.inc | 74 +
.../3rdparty/abseil/absl/memory/BUILD.bazel | 47 +
.../3rdparty/abseil/absl/memory/CMakeLists.txt | 52 +
.../3rdparty/abseil/absl/memory/memory.h | 640 ++
.../3rdparty/abseil/absl/memory/memory_test.cc | 614 ++
.../3rdparty/abseil/absl/meta/BUILD.bazel | 29 +
.../3rdparty/abseil/absl/meta/CMakeLists.txt | 49 +
.../3rdparty/abseil/absl/meta/type_traits.h | 372 +
.../abseil/absl/meta/type_traits_test.cc | 799 ++
.../3rdparty/abseil/absl/numeric/BUILD.bazel | 41 +
.../3rdparty/abseil/absl/numeric/CMakeLists.txt | 62 +
.../3rdparty/abseil/absl/numeric/int128.cc | 225 +
.../3rdparty/abseil/absl/numeric/int128.h | 656 ++
.../absl/numeric/int128_have_intrinsic.inc | 18 +
.../abseil/absl/numeric/int128_no_intrinsic.inc | 18 +
.../abseil/absl/numeric/int128_stream_test.cc | 666 ++
.../3rdparty/abseil/absl/numeric/int128_test.cc | 431 +
.../3rdparty/abseil/absl/strings/BUILD.bazel | 322 +
.../3rdparty/abseil/absl/strings/CMakeLists.txt | 304 +
.../3rdparty/abseil/absl/strings/ascii.cc | 198 +
.../3rdparty/abseil/absl/strings/ascii.h | 239 +
.../3rdparty/abseil/absl/strings/ascii_test.cc | 354 +
.../3rdparty/abseil/absl/strings/escaping.cc | 1109 +++
.../3rdparty/abseil/absl/strings/escaping.h | 161 +
.../abseil/absl/strings/escaping_test.cc | 641 ++
.../abseil/absl/strings/internal/char_map.h | 154 +
.../absl/strings/internal/char_map_test.cc | 172 +
.../strings/internal/escaping_test_common.inc | 113 +
.../abseil/absl/strings/internal/memutil.cc | 110 +
.../abseil/absl/strings/internal/memutil.h | 146 +
.../absl/strings/internal/memutil_test.cc | 179 +
.../strings/internal/numbers_test_common.inc | 156 +
.../absl/strings/internal/ostringstream.cc | 34 +
.../absl/strings/internal/ostringstream.h | 87 +
.../absl/strings/internal/ostringstream_test.cc | 102 +
.../strings/internal/resize_uninitialized.h | 69 +
.../internal/resize_uninitialized_test.cc | 68 +
.../absl/strings/internal/stl_type_traits.h | 246 +
.../absl/strings/internal/str_join_internal.h | 309 +
.../absl/strings/internal/str_split_internal.h | 435 +
.../abseil/absl/strings/internal/utf8.cc | 51 +
.../abseil/absl/strings/internal/utf8.h | 47 +
.../abseil/absl/strings/internal/utf8_test.cc | 57 +
.../3rdparty/abseil/absl/strings/match.cc | 40 +
.../3rdparty/abseil/absl/strings/match.h | 84 +
.../3rdparty/abseil/absl/strings/match_test.cc | 99 +
.../3rdparty/abseil/absl/strings/numbers.cc | 919 +++
.../3rdparty/abseil/absl/strings/numbers.h | 172 +
.../abseil/absl/strings/numbers_test.cc | 1186 +++
.../3rdparty/abseil/absl/strings/str_cat.cc | 239 +
.../3rdparty/abseil/absl/strings/str_cat.h | 385 +
.../abseil/absl/strings/str_cat_test.cc | 539 ++
.../3rdparty/abseil/absl/strings/str_join.h | 288 +
.../abseil/absl/strings/str_join_test.cc | 473 ++
.../3rdparty/abseil/absl/strings/str_replace.cc | 79 +
.../3rdparty/abseil/absl/strings/str_replace.h | 213 +
.../abseil/absl/strings/str_replace_test.cc | 341 +
.../3rdparty/abseil/absl/strings/str_split.cc | 136 +
.../3rdparty/abseil/absl/strings/str_split.h | 511 ++
.../abseil/absl/strings/str_split_test.cc | 907 ++
.../3rdparty/abseil/absl/strings/string_view.cc | 247 +
.../3rdparty/abseil/absl/strings/string_view.h | 570 ++
.../abseil/absl/strings/string_view_test.cc | 1136 +++
.../3rdparty/abseil/absl/strings/strip.h | 89 +
.../3rdparty/abseil/absl/strings/strip_test.cc | 201 +
.../3rdparty/abseil/absl/strings/substitute.cc | 170 +
.../3rdparty/abseil/absl/strings/substitute.h | 668 ++
.../abseil/absl/strings/substitute_test.cc | 192 +
.../abseil/absl/strings/testdata/getline-1.txt | 3 +
.../abseil/absl/strings/testdata/getline-2.txt | 1 +
.../abseil/absl/synchronization/BUILD.bazel | 206 +
.../abseil/absl/synchronization/CMakeLists.txt | 154 +
.../abseil/absl/synchronization/barrier.cc | 50 +
.../abseil/absl/synchronization/barrier.h | 77 +
.../abseil/absl/synchronization/barrier_test.cc | 75 +
.../absl/synchronization/blocking_counter.cc | 55 +
.../absl/synchronization/blocking_counter.h | 97 +
.../synchronization/blocking_counter_test.cc | 66 +
.../internal/create_thread_identity.cc | 112 +
.../internal/create_thread_identity.h | 53 +
.../synchronization/internal/graphcycles.cc | 709 ++
.../absl/synchronization/internal/graphcycles.h | 136 +
.../internal/graphcycles_test.cc | 462 ++
.../synchronization/internal/kernel_timeout.h | 149 +
.../synchronization/internal/mutex_nonprod.cc | 318 +
.../synchronization/internal/mutex_nonprod.inc | 256 +
.../synchronization/internal/per_thread_sem.cc | 99 +
.../synchronization/internal/per_thread_sem.h | 107 +
.../internal/per_thread_sem_test.cc | 172 +
.../absl/synchronization/internal/thread_pool.h | 90 +
.../absl/synchronization/internal/waiter.cc | 412 +
.../absl/synchronization/internal/waiter.h | 139 +
.../absl/synchronization/lifetime_test.cc | 132 +
.../abseil/absl/synchronization/mutex.cc | 2688 ++++++
.../abseil/absl/synchronization/mutex.h | 1022 +++
.../abseil/absl/synchronization/mutex_test.cc | 1539 ++++
.../abseil/absl/synchronization/notification.cc | 84 +
.../abseil/absl/synchronization/notification.h | 112 +
.../absl/synchronization/notification_test.cc | 124 +
.../3rdparty/abseil/absl/time/BUILD.bazel | 97 +
.../3rdparty/abseil/absl/time/CMakeLists.txt | 96 +
.../backend/3rdparty/abseil/absl/time/clock.cc | 563 ++
.../backend/3rdparty/abseil/absl/time/clock.h | 72 +
.../3rdparty/abseil/absl/time/clock_test.cc | 70 +
.../3rdparty/abseil/absl/time/duration.cc | 908 ++
.../3rdparty/abseil/absl/time/duration_test.cc | 1688 ++++
.../backend/3rdparty/abseil/absl/time/format.cc | 142 +
.../3rdparty/abseil/absl/time/format_test.cc | 437 +
.../abseil/absl/time/internal/cctz/BUILD.bazel | 105 +
.../internal/cctz/include/cctz/civil_time.h | 329 +
.../cctz/include/cctz/civil_time_detail.h | 564 ++
.../time/internal/cctz/include/cctz/time_zone.h | 316 +
.../cctz/include/cctz/zone_info_source.h | 91 +
.../time/internal/cctz/src/civil_time_detail.cc | 90 +
.../time/internal/cctz/src/civil_time_test.cc | 1049 +++
.../time/internal/cctz/src/time_zone_fixed.cc | 133 +
.../time/internal/cctz/src/time_zone_fixed.h | 49 +
.../time/internal/cctz/src/time_zone_format.cc | 848 ++
.../internal/cctz/src/time_zone_format_test.cc | 1408 ++++
.../absl/time/internal/cctz/src/time_zone_if.cc | 41 +
.../absl/time/internal/cctz/src/time_zone_if.h | 70 +
.../time/internal/cctz/src/time_zone_impl.cc | 117 +
.../time/internal/cctz/src/time_zone_impl.h | 97 +
.../time/internal/cctz/src/time_zone_info.cc | 956 +++
.../time/internal/cctz/src/time_zone_info.h | 132 +
.../time/internal/cctz/src/time_zone_libc.cc | 156 +
.../time/internal/cctz/src/time_zone_libc.h | 50 +
.../time/internal/cctz/src/time_zone_lookup.cc | 142 +
.../internal/cctz/src/time_zone_lookup_test.cc | 1259 +++
.../time/internal/cctz/src/time_zone_posix.cc | 155 +
.../time/internal/cctz/src/time_zone_posix.h | 118 +
.../abseil/absl/time/internal/cctz/src/tzfile.h | 117 +
.../time/internal/cctz/src/zone_info_source.cc | 70 +
.../time/internal/cctz/testdata/README.zoneinfo | 37 +
.../absl/time/internal/cctz/testdata/version | 1 +
.../cctz/testdata/zoneinfo/Africa/Abidjan | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Accra | Bin 0 -> 842 bytes
.../cctz/testdata/zoneinfo/Africa/Addis_Ababa | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Algiers | Bin 0 -> 760 bytes
.../cctz/testdata/zoneinfo/Africa/Asmara | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Asmera | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Bamako | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Bangui | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Banjul | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Bissau | Bin 0 -> 208 bytes
.../cctz/testdata/zoneinfo/Africa/Blantyre | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Brazzaville | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Bujumbura | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Cairo | Bin 0 -> 1972 bytes
.../cctz/testdata/zoneinfo/Africa/Casablanca | Bin 0 -> 1643 bytes
.../cctz/testdata/zoneinfo/Africa/Ceuta | Bin 0 -> 2059 bytes
.../cctz/testdata/zoneinfo/Africa/Conakry | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Dakar | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Dar_es_Salaam | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Djibouti | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Douala | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/El_Aaiun | Bin 0 -> 1473 bytes
.../cctz/testdata/zoneinfo/Africa/Freetown | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Gaborone | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Harare | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Johannesburg | Bin 0 -> 271 bytes
.../internal/cctz/testdata/zoneinfo/Africa/Juba | Bin 0 -> 683 bytes
.../cctz/testdata/zoneinfo/Africa/Kampala | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Khartoum | Bin 0 -> 713 bytes
.../cctz/testdata/zoneinfo/Africa/Kigali | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Kinshasa | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lagos | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Libreville | Bin 0 -> 171 bytes
.../internal/cctz/testdata/zoneinfo/Africa/Lome | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Luanda | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lubumbashi | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Lusaka | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Malabo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Maputo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Maseru | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/Africa/Mbabane | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/Africa/Mogadishu | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Monrovia | Bin 0 -> 233 bytes
.../cctz/testdata/zoneinfo/Africa/Nairobi | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Africa/Ndjamena | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Africa/Niamey | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Nouakchott | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Ouagadougou | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Porto-Novo | Bin 0 -> 171 bytes
.../cctz/testdata/zoneinfo/Africa/Sao_Tome | Bin 0 -> 234 bytes
.../cctz/testdata/zoneinfo/Africa/Timbuktu | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Africa/Tripoli | Bin 0 -> 655 bytes
.../cctz/testdata/zoneinfo/Africa/Tunis | Bin 0 -> 710 bytes
.../cctz/testdata/zoneinfo/Africa/Windhoek | Bin 0 -> 1030 bytes
.../cctz/testdata/zoneinfo/America/Adak | Bin 0 -> 2365 bytes
.../cctz/testdata/zoneinfo/America/Anchorage | Bin 0 -> 2380 bytes
.../cctz/testdata/zoneinfo/America/Anguilla | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Antigua | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Araguaina | Bin 0 -> 910 bytes
.../zoneinfo/America/Argentina/Buenos_Aires | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/Catamarca | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/ComodRivadavia | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Cordoba | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Jujuy | Bin 0 -> 1081 bytes
.../zoneinfo/America/Argentina/La_Rioja | Bin 0 -> 1123 bytes
.../testdata/zoneinfo/America/Argentina/Mendoza | Bin 0 -> 1109 bytes
.../zoneinfo/America/Argentina/Rio_Gallegos | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Argentina/Salta | Bin 0 -> 1081 bytes
.../zoneinfo/America/Argentina/San_Juan | Bin 0 -> 1123 bytes
.../zoneinfo/America/Argentina/San_Luis | Bin 0 -> 1139 bytes
.../testdata/zoneinfo/America/Argentina/Tucuman | Bin 0 -> 1137 bytes
.../testdata/zoneinfo/America/Argentina/Ushuaia | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Aruba | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Asuncion | Bin 0 -> 2077 bytes
.../cctz/testdata/zoneinfo/America/Atikokan | Bin 0 -> 345 bytes
.../cctz/testdata/zoneinfo/America/Atka | Bin 0 -> 2365 bytes
.../cctz/testdata/zoneinfo/America/Bahia | Bin 0 -> 1050 bytes
.../testdata/zoneinfo/America/Bahia_Banderas | Bin 0 -> 1588 bytes
.../cctz/testdata/zoneinfo/America/Barbados | Bin 0 -> 344 bytes
.../cctz/testdata/zoneinfo/America/Belem | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/America/Belize | Bin 0 -> 978 bytes
.../cctz/testdata/zoneinfo/America/Blanc-Sablon | Bin 0 -> 307 bytes
.../cctz/testdata/zoneinfo/America/Boa_Vista | Bin 0 -> 658 bytes
.../cctz/testdata/zoneinfo/America/Bogota | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/America/Boise | Bin 0 -> 2403 bytes
.../cctz/testdata/zoneinfo/America/Buenos_Aires | Bin 0 -> 1109 bytes
.../testdata/zoneinfo/America/Cambridge_Bay | Bin 0 -> 2098 bytes
.../cctz/testdata/zoneinfo/America/Campo_Grande | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/America/Cancun | Bin 0 -> 816 bytes
.../cctz/testdata/zoneinfo/America/Caracas | Bin 0 -> 289 bytes
.../cctz/testdata/zoneinfo/America/Catamarca | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Cayenne | Bin 0 -> 224 bytes
.../cctz/testdata/zoneinfo/America/Cayman | Bin 0 -> 203 bytes
.../cctz/testdata/zoneinfo/America/Chicago | Bin 0 -> 3585 bytes
.../cctz/testdata/zoneinfo/America/Chihuahua | Bin 0 -> 1522 bytes
.../testdata/zoneinfo/America/Coral_Harbour | Bin 0 -> 345 bytes
.../cctz/testdata/zoneinfo/America/Cordoba | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Costa_Rica | Bin 0 -> 341 bytes
.../cctz/testdata/zoneinfo/America/Creston | Bin 0 -> 233 bytes
.../cctz/testdata/zoneinfo/America/Cuiaba | Bin 0 -> 1988 bytes
.../cctz/testdata/zoneinfo/America/Curacao | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Danmarkshavn | Bin 0 -> 712 bytes
.../cctz/testdata/zoneinfo/America/Dawson | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/America/Dawson_Creek | Bin 0 -> 1059 bytes
.../cctz/testdata/zoneinfo/America/Denver | Bin 0 -> 2453 bytes
.../cctz/testdata/zoneinfo/America/Detroit | Bin 0 -> 2188 bytes
.../cctz/testdata/zoneinfo/America/Dominica | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Edmonton | Bin 0 -> 2402 bytes
.../cctz/testdata/zoneinfo/America/Eirunepe | Bin 0 -> 690 bytes
.../cctz/testdata/zoneinfo/America/El_Salvador | Bin 0 -> 250 bytes
.../cctz/testdata/zoneinfo/America/Ensenada | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Fort_Nelson | Bin 0 -> 2249 bytes
.../cctz/testdata/zoneinfo/America/Fort_Wayne | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Fortaleza | Bin 0 -> 742 bytes
.../cctz/testdata/zoneinfo/America/Glace_Bay | Bin 0 -> 2206 bytes
.../cctz/testdata/zoneinfo/America/Godthab | Bin 0 -> 1892 bytes
.../cctz/testdata/zoneinfo/America/Goose_Bay | Bin 0 -> 3219 bytes
.../cctz/testdata/zoneinfo/America/Grand_Turk | Bin 0 -> 1881 bytes
.../cctz/testdata/zoneinfo/America/Grenada | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Guadeloupe | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Guatemala | Bin 0 -> 306 bytes
.../cctz/testdata/zoneinfo/America/Guayaquil | Bin 0 -> 271 bytes
.../cctz/testdata/zoneinfo/America/Guyana | Bin 0 -> 266 bytes
.../cctz/testdata/zoneinfo/America/Halifax | Bin 0 -> 3438 bytes
.../cctz/testdata/zoneinfo/America/Havana | Bin 0 -> 2437 bytes
.../cctz/testdata/zoneinfo/America/Hermosillo | Bin 0 -> 454 bytes
.../zoneinfo/America/Indiana/Indianapolis | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Indiana/Knox | Bin 0 -> 2437 bytes
.../testdata/zoneinfo/America/Indiana/Marengo | Bin 0 -> 1731 bytes
.../zoneinfo/America/Indiana/Petersburg | Bin 0 -> 1913 bytes
.../testdata/zoneinfo/America/Indiana/Tell_City | Bin 0 -> 1735 bytes
.../testdata/zoneinfo/America/Indiana/Vevay | Bin 0 -> 1423 bytes
.../testdata/zoneinfo/America/Indiana/Vincennes | Bin 0 -> 1703 bytes
.../testdata/zoneinfo/America/Indiana/Winamac | Bin 0 -> 1787 bytes
.../cctz/testdata/zoneinfo/America/Indianapolis | Bin 0 -> 1675 bytes
.../cctz/testdata/zoneinfo/America/Inuvik | Bin 0 -> 1928 bytes
.../cctz/testdata/zoneinfo/America/Iqaluit | Bin 0 -> 2046 bytes
.../cctz/testdata/zoneinfo/America/Jamaica | Bin 0 -> 507 bytes
.../cctz/testdata/zoneinfo/America/Jujuy | Bin 0 -> 1081 bytes
.../cctz/testdata/zoneinfo/America/Juneau | Bin 0 -> 2362 bytes
.../zoneinfo/America/Kentucky/Louisville | Bin 0 -> 2781 bytes
.../zoneinfo/America/Kentucky/Monticello | Bin 0 -> 2361 bytes
.../cctz/testdata/zoneinfo/America/Knox_IN | Bin 0 -> 2437 bytes
.../cctz/testdata/zoneinfo/America/Kralendijk | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/La_Paz | Bin 0 -> 257 bytes
.../cctz/testdata/zoneinfo/America/Lima | Bin 0 -> 431 bytes
.../cctz/testdata/zoneinfo/America/Los_Angeles | Bin 0 -> 2845 bytes
.../cctz/testdata/zoneinfo/America/Louisville | Bin 0 -> 2781 bytes
.../testdata/zoneinfo/America/Lower_Princes | Bin 0 -> 212 bytes
.../cctz/testdata/zoneinfo/America/Maceio | Bin 0 -> 770 bytes
.../cctz/testdata/zoneinfo/America/Managua | Bin 0 -> 463 bytes
.../cctz/testdata/zoneinfo/America/Manaus | Bin 0 -> 630 bytes
.../cctz/testdata/zoneinfo/America/Marigot | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Martinique | Bin 0 -> 257 bytes
.../cctz/testdata/zoneinfo/America/Matamoros | Bin 0 -> 1416 bytes
.../cctz/testdata/zoneinfo/America/Mazatlan | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/America/Mendoza | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Menominee | Bin 0 -> 2283 bytes
.../cctz/testdata/zoneinfo/America/Merida | Bin 0 -> 1456 bytes
.../cctz/testdata/zoneinfo/America/Metlakatla | Bin 0 -> 1418 bytes
.../cctz/testdata/zoneinfo/America/Mexico_City | Bin 0 -> 1618 bytes
.../cctz/testdata/zoneinfo/America/Miquelon | Bin 0 -> 1696 bytes
.../cctz/testdata/zoneinfo/America/Moncton | Bin 0 -> 3163 bytes
.../cctz/testdata/zoneinfo/America/Monterrey | Bin 0 -> 1416 bytes
.../cctz/testdata/zoneinfo/America/Montevideo | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/America/Montreal | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/America/Montserrat | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Nassau | Bin 0 -> 2284 bytes
.../cctz/testdata/zoneinfo/America/New_York | Bin 0 -> 3545 bytes
.../cctz/testdata/zoneinfo/America/Nipigon | Bin 0 -> 2131 bytes
.../cctz/testdata/zoneinfo/America/Nome | Bin 0 -> 2376 bytes
.../cctz/testdata/zoneinfo/America/Noronha | Bin 0 -> 742 bytes
.../zoneinfo/America/North_Dakota/Beulah | Bin 0 -> 2389 bytes
.../zoneinfo/America/North_Dakota/Center | Bin 0 -> 2389 bytes
.../zoneinfo/America/North_Dakota/New_Salem | Bin 0 -> 2389 bytes
.../cctz/testdata/zoneinfo/America/Ojinaga | Bin 0 -> 1522 bytes
.../cctz/testdata/zoneinfo/America/Panama | Bin 0 -> 203 bytes
.../cctz/testdata/zoneinfo/America/Pangnirtung | Bin 0 -> 2108 bytes
.../cctz/testdata/zoneinfo/America/Paramaribo | Bin 0 -> 296 bytes
.../cctz/testdata/zoneinfo/America/Phoenix | Bin 0 -> 353 bytes
.../testdata/zoneinfo/America/Port-au-Prince | Bin 0 -> 1455 bytes
.../testdata/zoneinfo/America/Port_of_Spain | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Porto_Acre | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/America/Porto_Velho | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/America/Puerto_Rico | Bin 0 -> 255 bytes
.../cctz/testdata/zoneinfo/America/Punta_Arenas | Bin 0 -> 1911 bytes
.../cctz/testdata/zoneinfo/America/Rainy_River | Bin 0 -> 2131 bytes
.../cctz/testdata/zoneinfo/America/Rankin_Inlet | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Recife | Bin 0 -> 742 bytes
.../cctz/testdata/zoneinfo/America/Regina | Bin 0 -> 994 bytes
.../cctz/testdata/zoneinfo/America/Resolute | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Rio_Branco | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/America/Rosario | Bin 0 -> 1109 bytes
.../cctz/testdata/zoneinfo/America/Santa_Isabel | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Santarem | Bin 0 -> 632 bytes
.../cctz/testdata/zoneinfo/America/Santiago | Bin 0 -> 2538 bytes
.../testdata/zoneinfo/America/Santo_Domingo | Bin 0 -> 491 bytes
.../cctz/testdata/zoneinfo/America/Sao_Paulo | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/America/Scoresbysund | Bin 0 -> 1930 bytes
.../cctz/testdata/zoneinfo/America/Shiprock | Bin 0 -> 2453 bytes
.../cctz/testdata/zoneinfo/America/Sitka | Bin 0 -> 2350 bytes
.../testdata/zoneinfo/America/St_Barthelemy | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Johns | Bin 0 -> 3664 bytes
.../cctz/testdata/zoneinfo/America/St_Kitts | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Lucia | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Thomas | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/St_Vincent | Bin 0 -> 170 bytes
.../testdata/zoneinfo/America/Swift_Current | Bin 0 -> 574 bytes
.../cctz/testdata/zoneinfo/America/Tegucigalpa | Bin 0 -> 278 bytes
.../cctz/testdata/zoneinfo/America/Thule | Bin 0 -> 1528 bytes
.../cctz/testdata/zoneinfo/America/Thunder_Bay | Bin 0 -> 2211 bytes
.../cctz/testdata/zoneinfo/America/Tijuana | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/America/Toronto | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/America/Tortola | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Vancouver | Bin 0 -> 2901 bytes
.../cctz/testdata/zoneinfo/America/Virgin | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/America/Whitehorse | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/America/Winnipeg | Bin 0 -> 2891 bytes
.../cctz/testdata/zoneinfo/America/Yakutat | Bin 0 -> 2314 bytes
.../cctz/testdata/zoneinfo/America/Yellowknife | Bin 0 -> 1980 bytes
.../cctz/testdata/zoneinfo/Antarctica/Casey | Bin 0 -> 311 bytes
.../cctz/testdata/zoneinfo/Antarctica/Davis | Bin 0 -> 311 bytes
.../testdata/zoneinfo/Antarctica/DumontDUrville | Bin 0 -> 216 bytes
.../cctz/testdata/zoneinfo/Antarctica/Macquarie | Bin 0 -> 1543 bytes
.../cctz/testdata/zoneinfo/Antarctica/Mawson | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Antarctica/McMurdo | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Antarctica/Palmer | Bin 0 -> 1432 bytes
.../cctz/testdata/zoneinfo/Antarctica/Rothera | Bin 0 -> 186 bytes
.../testdata/zoneinfo/Antarctica/South_Pole | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Antarctica/Syowa | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Antarctica/Troll | Bin 0 -> 1176 bytes
.../cctz/testdata/zoneinfo/Antarctica/Vostok | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Arctic/Longyearbyen | Bin 0 -> 2251 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aden | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Almaty | Bin 0 -> 1031 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Amman | Bin 0 -> 1877 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Anadyr | Bin 0 -> 1222 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aqtau | Bin 0 -> 1017 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Aqtobe | Bin 0 -> 1047 bytes
.../cctz/testdata/zoneinfo/Asia/Ashgabat | Bin 0 -> 651 bytes
.../cctz/testdata/zoneinfo/Asia/Ashkhabad | Bin 0 -> 651 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Atyrau | Bin 0 -> 1025 bytes
.../cctz/testdata/zoneinfo/Asia/Baghdad | Bin 0 -> 1004 bytes
.../cctz/testdata/zoneinfo/Asia/Bahrain | Bin 0 -> 225 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Baku | Bin 0 -> 1269 bytes
.../cctz/testdata/zoneinfo/Asia/Bangkok | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Barnaul | Bin 0 -> 1255 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Beirut | Bin 0 -> 2175 bytes
.../cctz/testdata/zoneinfo/Asia/Bishkek | Bin 0 -> 1045 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Brunei | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Calcutta | Bin 0 -> 312 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Chita | Bin 0 -> 1257 bytes
.../cctz/testdata/zoneinfo/Asia/Choibalsan | Bin 0 -> 991 bytes
.../cctz/testdata/zoneinfo/Asia/Chongqing | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Chungking | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Colombo | Bin 0 -> 413 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dacca | Bin 0 -> 370 bytes
.../cctz/testdata/zoneinfo/Asia/Damascus | Bin 0 -> 2320 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dhaka | Bin 0 -> 370 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dili | Bin 0 -> 253 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Dubai | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Dushanbe | Bin 0 -> 621 bytes
.../cctz/testdata/zoneinfo/Asia/Famagusta | Bin 0 -> 2042 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Gaza | Bin 0 -> 2295 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Harbin | Bin 0 -> 414 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Hebron | Bin 0 -> 2323 bytes
.../cctz/testdata/zoneinfo/Asia/Ho_Chi_Minh | Bin 0 -> 389 bytes
.../cctz/testdata/zoneinfo/Asia/Hong_Kong | Bin 0 -> 1189 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Hovd | Bin 0 -> 921 bytes
.../cctz/testdata/zoneinfo/Asia/Irkutsk | Bin 0 -> 1276 bytes
.../cctz/testdata/zoneinfo/Asia/Istanbul | Bin 0 -> 2166 bytes
.../cctz/testdata/zoneinfo/Asia/Jakarta | Bin 0 -> 392 bytes
.../cctz/testdata/zoneinfo/Asia/Jayapura | Bin 0 -> 251 bytes
.../cctz/testdata/zoneinfo/Asia/Jerusalem | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Kabul | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Kamchatka | Bin 0 -> 1198 bytes
.../cctz/testdata/zoneinfo/Asia/Karachi | Bin 0 -> 417 bytes
.../cctz/testdata/zoneinfo/Asia/Kashgar | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Kathmandu | Bin 0 -> 238 bytes
.../cctz/testdata/zoneinfo/Asia/Katmandu | Bin 0 -> 238 bytes
.../cctz/testdata/zoneinfo/Asia/Khandyga | Bin 0 -> 1311 bytes
.../cctz/testdata/zoneinfo/Asia/Kolkata | Bin 0 -> 312 bytes
.../cctz/testdata/zoneinfo/Asia/Krasnoyarsk | Bin 0 -> 1243 bytes
.../cctz/testdata/zoneinfo/Asia/Kuala_Lumpur | Bin 0 -> 424 bytes
.../cctz/testdata/zoneinfo/Asia/Kuching | Bin 0 -> 521 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Kuwait | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Macao | Bin 0 -> 771 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Macau | Bin 0 -> 771 bytes
.../cctz/testdata/zoneinfo/Asia/Magadan | Bin 0 -> 1258 bytes
.../cctz/testdata/zoneinfo/Asia/Makassar | Bin 0 -> 288 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Manila | Bin 0 -> 367 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Muscat | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Nicosia | Bin 0 -> 2016 bytes
.../cctz/testdata/zoneinfo/Asia/Novokuznetsk | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Asia/Novosibirsk | Bin 0 -> 1255 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Omsk | Bin 0 -> 1243 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Oral | Bin 0 -> 1039 bytes
.../cctz/testdata/zoneinfo/Asia/Phnom_Penh | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Pontianak | Bin 0 -> 395 bytes
.../cctz/testdata/zoneinfo/Asia/Pyongyang | Bin 0 -> 272 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Qatar | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Asia/Qyzylorda | Bin 0 -> 1047 bytes
.../cctz/testdata/zoneinfo/Asia/Rangoon | Bin 0 -> 297 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Riyadh | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Saigon | Bin 0 -> 389 bytes
.../cctz/testdata/zoneinfo/Asia/Sakhalin | Bin 0 -> 1234 bytes
.../cctz/testdata/zoneinfo/Asia/Samarkand | Bin 0 -> 619 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Seoul | Bin 0 -> 531 bytes
.../cctz/testdata/zoneinfo/Asia/Shanghai | Bin 0 -> 414 bytes
.../cctz/testdata/zoneinfo/Asia/Singapore | Bin 0 -> 424 bytes
.../cctz/testdata/zoneinfo/Asia/Srednekolymsk | Bin 0 -> 1244 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Taipei | Bin 0 -> 790 bytes
.../cctz/testdata/zoneinfo/Asia/Tashkent | Bin 0 -> 635 bytes
.../cctz/testdata/zoneinfo/Asia/Tbilisi | Bin 0 -> 1080 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tehran | Bin 0 -> 1718 bytes
.../cctz/testdata/zoneinfo/Asia/Tel_Aviv | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Thimbu | Bin 0 -> 229 bytes
.../cctz/testdata/zoneinfo/Asia/Thimphu | Bin 0 -> 229 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tokyo | Bin 0 -> 318 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Tomsk | Bin 0 -> 1255 bytes
.../cctz/testdata/zoneinfo/Asia/Ujung_Pandang | Bin 0 -> 288 bytes
.../cctz/testdata/zoneinfo/Asia/Ulaanbaatar | Bin 0 -> 921 bytes
.../cctz/testdata/zoneinfo/Asia/Ulan_Bator | Bin 0 -> 921 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Urumqi | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Asia/Ust-Nera | Bin 0 -> 1290 bytes
.../cctz/testdata/zoneinfo/Asia/Vientiane | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Asia/Vladivostok | Bin 0 -> 1244 bytes
.../cctz/testdata/zoneinfo/Asia/Yakutsk | Bin 0 -> 1243 bytes
.../internal/cctz/testdata/zoneinfo/Asia/Yangon | Bin 0 -> 297 bytes
.../cctz/testdata/zoneinfo/Asia/Yekaterinburg | Bin 0 -> 1281 bytes
.../cctz/testdata/zoneinfo/Asia/Yerevan | Bin 0 -> 1213 bytes
.../cctz/testdata/zoneinfo/Atlantic/Azores | Bin 0 -> 3493 bytes
.../cctz/testdata/zoneinfo/Atlantic/Bermuda | Bin 0 -> 2004 bytes
.../cctz/testdata/zoneinfo/Atlantic/Canary | Bin 0 -> 1911 bytes
.../cctz/testdata/zoneinfo/Atlantic/Cape_Verde | Bin 0 -> 284 bytes
.../cctz/testdata/zoneinfo/Atlantic/Faeroe | Bin 0 -> 1829 bytes
.../cctz/testdata/zoneinfo/Atlantic/Faroe | Bin 0 -> 1829 bytes
.../cctz/testdata/zoneinfo/Atlantic/Jan_Mayen | Bin 0 -> 2251 bytes
.../cctz/testdata/zoneinfo/Atlantic/Madeira | Bin 0 -> 3484 bytes
.../cctz/testdata/zoneinfo/Atlantic/Reykjavik | Bin 0 -> 1188 bytes
.../testdata/zoneinfo/Atlantic/South_Georgia | Bin 0 -> 181 bytes
.../cctz/testdata/zoneinfo/Atlantic/St_Helena | Bin 0 -> 170 bytes
.../cctz/testdata/zoneinfo/Atlantic/Stanley | Bin 0 -> 1251 bytes
.../cctz/testdata/zoneinfo/Australia/ACT | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Adelaide | Bin 0 -> 2238 bytes
.../cctz/testdata/zoneinfo/Australia/Brisbane | Bin 0 -> 452 bytes
.../testdata/zoneinfo/Australia/Broken_Hill | Bin 0 -> 2274 bytes
.../cctz/testdata/zoneinfo/Australia/Canberra | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Currie | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Darwin | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Australia/Eucla | Bin 0 -> 503 bytes
.../cctz/testdata/zoneinfo/Australia/Hobart | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Australia/LHI | Bin 0 -> 1889 bytes
.../cctz/testdata/zoneinfo/Australia/Lindeman | Bin 0 -> 522 bytes
.../cctz/testdata/zoneinfo/Australia/Lord_Howe | Bin 0 -> 1889 bytes
.../cctz/testdata/zoneinfo/Australia/Melbourne | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/NSW | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/North | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Australia/Perth | Bin 0 -> 479 bytes
.../cctz/testdata/zoneinfo/Australia/Queensland | Bin 0 -> 452 bytes
.../cctz/testdata/zoneinfo/Australia/South | Bin 0 -> 2238 bytes
.../cctz/testdata/zoneinfo/Australia/Sydney | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/Tasmania | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Australia/Victoria | Bin 0 -> 2223 bytes
.../cctz/testdata/zoneinfo/Australia/West | Bin 0 -> 479 bytes
.../cctz/testdata/zoneinfo/Australia/Yancowinna | Bin 0 -> 2274 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/Acre | Bin 0 -> 662 bytes
.../cctz/testdata/zoneinfo/Brazil/DeNoronha | Bin 0 -> 742 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/East | Bin 0 -> 2016 bytes
.../internal/cctz/testdata/zoneinfo/Brazil/West | Bin 0 -> 630 bytes
.../time/internal/cctz/testdata/zoneinfo/CET | Bin 0 -> 2102 bytes
.../internal/cctz/testdata/zoneinfo/CST6CDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Canada/Atlantic | Bin 0 -> 3438 bytes
.../cctz/testdata/zoneinfo/Canada/Central | Bin 0 -> 2891 bytes
.../cctz/testdata/zoneinfo/Canada/Eastern | Bin 0 -> 3503 bytes
.../cctz/testdata/zoneinfo/Canada/Mountain | Bin 0 -> 2402 bytes
.../cctz/testdata/zoneinfo/Canada/Newfoundland | Bin 0 -> 3664 bytes
.../cctz/testdata/zoneinfo/Canada/Pacific | Bin 0 -> 2901 bytes
.../cctz/testdata/zoneinfo/Canada/Saskatchewan | Bin 0 -> 994 bytes
.../cctz/testdata/zoneinfo/Canada/Yukon | Bin 0 -> 2093 bytes
.../cctz/testdata/zoneinfo/Chile/Continental | Bin 0 -> 2538 bytes
.../cctz/testdata/zoneinfo/Chile/EasterIsland | Bin 0 -> 2242 bytes
.../time/internal/cctz/testdata/zoneinfo/Cuba | Bin 0 -> 2437 bytes
.../time/internal/cctz/testdata/zoneinfo/EET | Bin 0 -> 1876 bytes
.../time/internal/cctz/testdata/zoneinfo/EST | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/EST5EDT | Bin 0 -> 2294 bytes
.../time/internal/cctz/testdata/zoneinfo/Egypt | Bin 0 -> 1972 bytes
.../time/internal/cctz/testdata/zoneinfo/Eire | Bin 0 -> 3531 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+1 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+10 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+11 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+12 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+2 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+3 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+4 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+5 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+6 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+7 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+8 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT+9 | Bin 0 -> 148 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-1 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-10 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-11 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-12 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-13 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-14 | Bin 0 -> 150 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-2 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-3 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-4 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-5 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-6 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-7 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-8 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT-9 | Bin 0 -> 149 bytes
.../internal/cctz/testdata/zoneinfo/Etc/GMT0 | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Etc/Greenwich | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/UCT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/UTC | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Etc/Universal | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Etc/Zulu | Bin 0 -> 127 bytes
.../cctz/testdata/zoneinfo/Europe/Amsterdam | Bin 0 -> 2949 bytes
.../cctz/testdata/zoneinfo/Europe/Andorra | Bin 0 -> 1751 bytes
.../cctz/testdata/zoneinfo/Europe/Astrakhan | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Europe/Athens | Bin 0 -> 2271 bytes
.../cctz/testdata/zoneinfo/Europe/Belfast | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Belgrade | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Berlin | Bin 0 -> 2335 bytes
.../cctz/testdata/zoneinfo/Europe/Bratislava | Bin 0 -> 2272 bytes
.../cctz/testdata/zoneinfo/Europe/Brussels | Bin 0 -> 2970 bytes
.../cctz/testdata/zoneinfo/Europe/Bucharest | Bin 0 -> 2221 bytes
.../cctz/testdata/zoneinfo/Europe/Budapest | Bin 0 -> 2405 bytes
.../cctz/testdata/zoneinfo/Europe/Busingen | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Chisinau | Bin 0 -> 2445 bytes
.../cctz/testdata/zoneinfo/Europe/Copenhagen | Bin 0 -> 2160 bytes
.../cctz/testdata/zoneinfo/Europe/Dublin | Bin 0 -> 3531 bytes
.../cctz/testdata/zoneinfo/Europe/Gibraltar | Bin 0 -> 3061 bytes
.../cctz/testdata/zoneinfo/Europe/Guernsey | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Helsinki | Bin 0 -> 1909 bytes
.../cctz/testdata/zoneinfo/Europe/Isle_of_Man | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Istanbul | Bin 0 -> 2166 bytes
.../cctz/testdata/zoneinfo/Europe/Jersey | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Kaliningrad | Bin 0 -> 1518 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Kiev | Bin 0 -> 2097 bytes
.../cctz/testdata/zoneinfo/Europe/Kirov | Bin 0 -> 1167 bytes
.../cctz/testdata/zoneinfo/Europe/Lisbon | Bin 0 -> 3469 bytes
.../cctz/testdata/zoneinfo/Europe/Ljubljana | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/London | Bin 0 -> 3687 bytes
.../cctz/testdata/zoneinfo/Europe/Luxembourg | Bin 0 -> 2974 bytes
.../cctz/testdata/zoneinfo/Europe/Madrid | Bin 0 -> 2637 bytes
.../cctz/testdata/zoneinfo/Europe/Malta | Bin 0 -> 2629 bytes
.../cctz/testdata/zoneinfo/Europe/Mariehamn | Bin 0 -> 1909 bytes
.../cctz/testdata/zoneinfo/Europe/Minsk | Bin 0 -> 1370 bytes
.../cctz/testdata/zoneinfo/Europe/Monaco | Bin 0 -> 2953 bytes
.../cctz/testdata/zoneinfo/Europe/Moscow | Bin 0 -> 1544 bytes
.../cctz/testdata/zoneinfo/Europe/Nicosia | Bin 0 -> 2016 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Oslo | Bin 0 -> 2251 bytes
.../cctz/testdata/zoneinfo/Europe/Paris | Bin 0 -> 2971 bytes
.../cctz/testdata/zoneinfo/Europe/Podgorica | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Prague | Bin 0 -> 2272 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Riga | Bin 0 -> 2235 bytes
.../internal/cctz/testdata/zoneinfo/Europe/Rome | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Samara | Bin 0 -> 1253 bytes
.../cctz/testdata/zoneinfo/Europe/San_Marino | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Sarajevo | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Saratov | Bin 0 -> 1197 bytes
.../cctz/testdata/zoneinfo/Europe/Simferopol | Bin 0 -> 1490 bytes
.../cctz/testdata/zoneinfo/Europe/Skopje | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Sofia | Bin 0 -> 2130 bytes
.../cctz/testdata/zoneinfo/Europe/Stockholm | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Tallinn | Bin 0 -> 2187 bytes
.../cctz/testdata/zoneinfo/Europe/Tirane | Bin 0 -> 2098 bytes
.../cctz/testdata/zoneinfo/Europe/Tiraspol | Bin 0 -> 2445 bytes
.../cctz/testdata/zoneinfo/Europe/Ulyanovsk | Bin 0 -> 1281 bytes
.../cctz/testdata/zoneinfo/Europe/Uzhgorod | Bin 0 -> 2103 bytes
.../cctz/testdata/zoneinfo/Europe/Vaduz | Bin 0 -> 1918 bytes
.../cctz/testdata/zoneinfo/Europe/Vatican | Bin 0 -> 2692 bytes
.../cctz/testdata/zoneinfo/Europe/Vienna | Bin 0 -> 2237 bytes
.../cctz/testdata/zoneinfo/Europe/Vilnius | Bin 0 -> 2199 bytes
.../cctz/testdata/zoneinfo/Europe/Volgograd | Bin 0 -> 1167 bytes
.../cctz/testdata/zoneinfo/Europe/Warsaw | Bin 0 -> 2705 bytes
.../cctz/testdata/zoneinfo/Europe/Zagreb | Bin 0 -> 1957 bytes
.../cctz/testdata/zoneinfo/Europe/Zaporozhye | Bin 0 -> 2115 bytes
.../cctz/testdata/zoneinfo/Europe/Zurich | Bin 0 -> 1918 bytes
.../internal/cctz/testdata/zoneinfo/Factory | Bin 0 -> 148 bytes
.../time/internal/cctz/testdata/zoneinfo/GB | Bin 0 -> 3687 bytes
.../internal/cctz/testdata/zoneinfo/GB-Eire | Bin 0 -> 3687 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT+0 | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT-0 | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/GMT0 | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Greenwich | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/HST | Bin 0 -> 128 bytes
.../internal/cctz/testdata/zoneinfo/Hongkong | Bin 0 -> 1189 bytes
.../internal/cctz/testdata/zoneinfo/Iceland | Bin 0 -> 1188 bytes
.../cctz/testdata/zoneinfo/Indian/Antananarivo | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Chagos | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Indian/Christmas | Bin 0 -> 182 bytes
.../cctz/testdata/zoneinfo/Indian/Cocos | Bin 0 -> 191 bytes
.../cctz/testdata/zoneinfo/Indian/Comoro | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Kerguelen | Bin 0 -> 187 bytes
.../internal/cctz/testdata/zoneinfo/Indian/Mahe | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Indian/Maldives | Bin 0 -> 220 bytes
.../cctz/testdata/zoneinfo/Indian/Mauritius | Bin 0 -> 267 bytes
.../cctz/testdata/zoneinfo/Indian/Mayotte | Bin 0 -> 285 bytes
.../cctz/testdata/zoneinfo/Indian/Reunion | Bin 0 -> 187 bytes
.../time/internal/cctz/testdata/zoneinfo/Iran | Bin 0 -> 1718 bytes
.../time/internal/cctz/testdata/zoneinfo/Israel | Bin 0 -> 2265 bytes
.../internal/cctz/testdata/zoneinfo/Jamaica | Bin 0 -> 507 bytes
.../time/internal/cctz/testdata/zoneinfo/Japan | Bin 0 -> 318 bytes
.../internal/cctz/testdata/zoneinfo/Kwajalein | Bin 0 -> 259 bytes
.../time/internal/cctz/testdata/zoneinfo/Libya | Bin 0 -> 655 bytes
.../time/internal/cctz/testdata/zoneinfo/MET | Bin 0 -> 2102 bytes
.../time/internal/cctz/testdata/zoneinfo/MST | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/MST7MDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Mexico/BajaNorte | Bin 0 -> 2356 bytes
.../cctz/testdata/zoneinfo/Mexico/BajaSur | Bin 0 -> 1564 bytes
.../cctz/testdata/zoneinfo/Mexico/General | Bin 0 -> 1618 bytes
.../time/internal/cctz/testdata/zoneinfo/NZ | Bin 0 -> 2460 bytes
.../internal/cctz/testdata/zoneinfo/NZ-CHAT | Bin 0 -> 2087 bytes
.../time/internal/cctz/testdata/zoneinfo/Navajo | Bin 0 -> 2453 bytes
.../time/internal/cctz/testdata/zoneinfo/PRC | Bin 0 -> 414 bytes
.../internal/cctz/testdata/zoneinfo/PST8PDT | Bin 0 -> 2294 bytes
.../cctz/testdata/zoneinfo/Pacific/Apia | Bin 0 -> 1134 bytes
.../cctz/testdata/zoneinfo/Pacific/Auckland | Bin 0 -> 2460 bytes
.../cctz/testdata/zoneinfo/Pacific/Bougainville | Bin 0 -> 296 bytes
.../cctz/testdata/zoneinfo/Pacific/Chatham | Bin 0 -> 2087 bytes
.../cctz/testdata/zoneinfo/Pacific/Chuuk | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Easter | Bin 0 -> 2242 bytes
.../cctz/testdata/zoneinfo/Pacific/Efate | Bin 0 -> 492 bytes
.../cctz/testdata/zoneinfo/Pacific/Enderbury | Bin 0 -> 259 bytes
.../cctz/testdata/zoneinfo/Pacific/Fakaofo | Bin 0 -> 221 bytes
.../cctz/testdata/zoneinfo/Pacific/Fiji | Bin 0 -> 1104 bytes
.../cctz/testdata/zoneinfo/Pacific/Funafuti | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Galapagos | Bin 0 -> 268 bytes
.../cctz/testdata/zoneinfo/Pacific/Gambier | Bin 0 -> 186 bytes
.../cctz/testdata/zoneinfo/Pacific/Guadalcanal | Bin 0 -> 188 bytes
.../cctz/testdata/zoneinfo/Pacific/Guam | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Pacific/Honolulu | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/Pacific/Johnston | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/Pacific/Kiritimati | Bin 0 -> 263 bytes
.../cctz/testdata/zoneinfo/Pacific/Kosrae | Bin 0 -> 251 bytes
.../cctz/testdata/zoneinfo/Pacific/Kwajalein | Bin 0 -> 259 bytes
.../cctz/testdata/zoneinfo/Pacific/Majuro | Bin 0 -> 221 bytes
.../cctz/testdata/zoneinfo/Pacific/Marquesas | Bin 0 -> 195 bytes
.../cctz/testdata/zoneinfo/Pacific/Midway | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Nauru | Bin 0 -> 282 bytes
.../cctz/testdata/zoneinfo/Pacific/Niue | Bin 0 -> 266 bytes
.../cctz/testdata/zoneinfo/Pacific/Norfolk | Bin 0 -> 323 bytes
.../cctz/testdata/zoneinfo/Pacific/Noumea | Bin 0 -> 328 bytes
.../cctz/testdata/zoneinfo/Pacific/Pago_Pago | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Palau | Bin 0 -> 182 bytes
.../cctz/testdata/zoneinfo/Pacific/Pitcairn | Bin 0 -> 223 bytes
.../cctz/testdata/zoneinfo/Pacific/Pohnpei | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Ponape | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Port_Moresby | Bin 0 -> 206 bytes
.../cctz/testdata/zoneinfo/Pacific/Rarotonga | Bin 0 -> 602 bytes
.../cctz/testdata/zoneinfo/Pacific/Saipan | Bin 0 -> 225 bytes
.../cctz/testdata/zoneinfo/Pacific/Samoa | Bin 0 -> 196 bytes
.../cctz/testdata/zoneinfo/Pacific/Tahiti | Bin 0 -> 187 bytes
.../cctz/testdata/zoneinfo/Pacific/Tarawa | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Tongatapu | Bin 0 -> 393 bytes
.../cctz/testdata/zoneinfo/Pacific/Truk | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Wake | Bin 0 -> 183 bytes
.../cctz/testdata/zoneinfo/Pacific/Wallis | Bin 0 -> 183 bytes
.../internal/cctz/testdata/zoneinfo/Pacific/Yap | Bin 0 -> 183 bytes
.../time/internal/cctz/testdata/zoneinfo/Poland | Bin 0 -> 2705 bytes
.../internal/cctz/testdata/zoneinfo/Portugal | Bin 0 -> 3469 bytes
.../time/internal/cctz/testdata/zoneinfo/ROC | Bin 0 -> 790 bytes
.../time/internal/cctz/testdata/zoneinfo/ROK | Bin 0 -> 531 bytes
.../internal/cctz/testdata/zoneinfo/Singapore | Bin 0 -> 424 bytes
.../time/internal/cctz/testdata/zoneinfo/Turkey | Bin 0 -> 2166 bytes
.../time/internal/cctz/testdata/zoneinfo/UCT | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/US/Alaska | Bin 0 -> 2380 bytes
.../internal/cctz/testdata/zoneinfo/US/Aleutian | Bin 0 -> 2365 bytes
.../internal/cctz/testdata/zoneinfo/US/Arizona | Bin 0 -> 353 bytes
.../internal/cctz/testdata/zoneinfo/US/Central | Bin 0 -> 3585 bytes
.../cctz/testdata/zoneinfo/US/East-Indiana | Bin 0 -> 1675 bytes
.../internal/cctz/testdata/zoneinfo/US/Eastern | Bin 0 -> 3545 bytes
.../internal/cctz/testdata/zoneinfo/US/Hawaii | Bin 0 -> 276 bytes
.../cctz/testdata/zoneinfo/US/Indiana-Starke | Bin 0 -> 2437 bytes
.../internal/cctz/testdata/zoneinfo/US/Michigan | Bin 0 -> 2188 bytes
.../internal/cctz/testdata/zoneinfo/US/Mountain | Bin 0 -> 2453 bytes
.../internal/cctz/testdata/zoneinfo/US/Pacific | Bin 0 -> 2845 bytes
.../internal/cctz/testdata/zoneinfo/US/Samoa | Bin 0 -> 196 bytes
.../time/internal/cctz/testdata/zoneinfo/UTC | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/Universal | Bin 0 -> 127 bytes
.../time/internal/cctz/testdata/zoneinfo/W-SU | Bin 0 -> 1544 bytes
.../time/internal/cctz/testdata/zoneinfo/WET | Bin 0 -> 1873 bytes
.../time/internal/cctz/testdata/zoneinfo/Zulu | Bin 0 -> 127 bytes
.../internal/cctz/testdata/zoneinfo/iso3166.tab | 274 +
.../internal/cctz/testdata/zoneinfo/localtime | Bin 0 -> 148 bytes
.../cctz/testdata/zoneinfo/zone1970.tab | 382 +
.../absl/time/internal/get_current_time_ios.inc | 80 +
.../time/internal/get_current_time_posix.inc | 22 +
.../time/internal/get_current_time_windows.inc | 17 +
.../abseil/absl/time/internal/test_util.cc | 123 +
.../abseil/absl/time/internal/test_util.h | 49 +
.../abseil/absl/time/internal/zoneinfo.inc | 729 ++
.../backend/3rdparty/abseil/absl/time/time.cc | 385 +
.../backend/3rdparty/abseil/absl/time/time.h | 1342 +++
.../3rdparty/abseil/absl/time/time_norm_test.cc | 306 +
.../3rdparty/abseil/absl/time/time_test.cc | 1088 +++
.../3rdparty/abseil/absl/time/time_zone_test.cc | 97 +
.../3rdparty/abseil/absl/types/BUILD.bazel | 225 +
.../3rdparty/abseil/absl/types/CMakeLists.txt | 201 +
.../backend/3rdparty/abseil/absl/types/any.h | 539 ++
.../absl/types/any_exception_safety_test.cc | 166 +
.../3rdparty/abseil/absl/types/any_test.cc | 724 ++
.../3rdparty/abseil/absl/types/bad_any_cast.cc | 40 +
.../3rdparty/abseil/absl/types/bad_any_cast.h | 57 +
.../abseil/absl/types/bad_optional_access.cc | 42 +
.../abseil/absl/types/bad_optional_access.h | 60 +
.../abseil/absl/types/bad_variant_access.cc | 58 +
.../abseil/absl/types/bad_variant_access.h | 64 +
.../abseil/absl/types/internal/variant.h | 1387 ++++
.../3rdparty/abseil/absl/types/optional.cc | 24 +
.../3rdparty/abseil/absl/types/optional.h | 1131 +++
.../3rdparty/abseil/absl/types/optional_test.cc | 1625 ++++
.../backend/3rdparty/abseil/absl/types/span.h | 748 ++
.../3rdparty/abseil/absl/types/span_test.cc | 781 ++
.../3rdparty/abseil/absl/types/variant.h | 838 ++
.../3rdparty/abseil/absl/types/variant_test.cc | 2612 ++++++
.../3rdparty/abseil/absl/utility/BUILD.bazel | 33 +
.../3rdparty/abseil/absl/utility/CMakeLists.txt | 45 +
.../3rdparty/abseil/absl/utility/utility.h | 291 +
.../abseil/absl/utility/utility_test.cc | 345 +
.../ostrich/backend/3rdparty/gtest/.gitignore | 40 +
.../ostrich/backend/3rdparty/gtest/.travis.yml | 78 +
.../ostrich/backend/3rdparty/gtest/BUILD.bazel | 175 +
.../backend/3rdparty/gtest/CMakeLists.txt | 33 +
.../backend/3rdparty/gtest/CONTRIBUTING.md | 160 +
.../ostrich/backend/3rdparty/gtest/LICENSE | 28 +
.../ostrich/backend/3rdparty/gtest/Makefile.am | 14 +
.../ostrich/backend/3rdparty/gtest/README.md | 122 +
.../ostrich/backend/3rdparty/gtest/WORKSPACE | 8 +
.../ostrich/backend/3rdparty/gtest/appveyor.yml | 99 +
.../3rdparty/gtest/ci/build-linux-autotools.sh | 44 +
.../3rdparty/gtest/ci/build-linux-bazel.sh | 36 +
.../backend/3rdparty/gtest/ci/env-linux.sh | 41 +
.../backend/3rdparty/gtest/ci/env-osx.sh | 40 +
.../3rdparty/gtest/ci/get-nprocessors.sh | 48 +
.../backend/3rdparty/gtest/ci/install-linux.sh | 49 +
.../backend/3rdparty/gtest/ci/install-osx.sh | 39 +
.../backend/3rdparty/gtest/ci/log-config.sh | 51 +
.../ostrich/backend/3rdparty/gtest/ci/travis.sh | 36 +
.../ostrich/backend/3rdparty/gtest/configure.ac | 16 +
.../backend/3rdparty/gtest/googlemock/CHANGES | 126 +
.../3rdparty/gtest/googlemock/CMakeLists.txt | 242 +
.../3rdparty/gtest/googlemock/CONTRIBUTORS | 40 +
.../backend/3rdparty/gtest/googlemock/LICENSE | 28 +
.../3rdparty/gtest/googlemock/Makefile.am | 224 +
.../backend/3rdparty/gtest/googlemock/README.md | 344 +
.../3rdparty/gtest/googlemock/cmake/gmock.pc.in | 9 +
.../gtest/googlemock/cmake/gmock_main.pc.in | 9 +
.../3rdparty/gtest/googlemock/configure.ac | 146 +
.../gtest/googlemock/docs/CheatSheet.md | 564 ++
.../3rdparty/gtest/googlemock/docs/CookBook.md | 3660 +++++++++
.../3rdparty/gtest/googlemock/docs/DesignDoc.md | 280 +
.../gtest/googlemock/docs/Documentation.md | 15 +
.../gtest/googlemock/docs/ForDummies.md | 447 +
.../googlemock/docs/FrequentlyAskedQuestions.md | 628 ++
.../gtest/googlemock/docs/KnownIssues.md | 19 +
.../googlemock/include/gmock/gmock-actions.h | 1262 +++
.../include/gmock/gmock-cardinalities.h | 147 +
.../include/gmock/gmock-generated-actions.h | 2571 ++++++
.../gmock/gmock-generated-actions.h.pump | 833 ++
.../gmock/gmock-generated-function-mockers.h | 1379 ++++
.../gmock-generated-function-mockers.h.pump | 347 +
.../include/gmock/gmock-generated-matchers.h | 2258 +++++
.../gmock/gmock-generated-matchers.h.pump | 675 ++
.../include/gmock/gmock-generated-nice-strict.h | 458 ++
.../gmock/gmock-generated-nice-strict.h.pump | 178 +
.../googlemock/include/gmock/gmock-matchers.h | 5255 ++++++++++++
.../include/gmock/gmock-more-actions.h | 246 +
.../include/gmock/gmock-more-matchers.h | 91 +
.../include/gmock/gmock-spec-builders.h | 1918 +++++
.../gtest/googlemock/include/gmock/gmock.h | 95 +
.../internal/custom/gmock-generated-actions.h | 8 +
.../custom/gmock-generated-actions.h.pump | 10 +
.../gmock/internal/custom/gmock-matchers.h | 38 +
.../include/gmock/internal/custom/gmock-port.h | 46 +
.../internal/gmock-generated-internal-utils.h | 286 +
.../gmock-generated-internal-utils.h.pump | 136 +
.../gmock/internal/gmock-internal-utils.h | 574 ++
.../include/gmock/internal/gmock-port.h | 87 +
.../3rdparty/gtest/googlemock/make/Makefile | 101 +
.../gtest/googlemock/msvc/2005/gmock.sln | 32 +
.../gtest/googlemock/msvc/2005/gmock.vcproj | 191 +
.../googlemock/msvc/2005/gmock_config.vsprops | 15 +
.../googlemock/msvc/2005/gmock_main.vcproj | 187 +
.../googlemock/msvc/2005/gmock_test.vcproj | 201 +
.../gtest/googlemock/msvc/2010/gmock.sln | 46 +
.../gtest/googlemock/msvc/2010/gmock.vcxproj | 145 +
.../googlemock/msvc/2010/gmock_config.props | 19 +
.../googlemock/msvc/2010/gmock_main.vcxproj | 151 +
.../googlemock/msvc/2010/gmock_test.vcxproj | 176 +
.../gtest/googlemock/msvc/2015/gmock.sln | 46 +
.../gtest/googlemock/msvc/2015/gmock.vcxproj | 145 +
.../googlemock/msvc/2015/gmock_config.props | 19 +
.../googlemock/msvc/2015/gmock_main.vcxproj | 151 +
.../googlemock/msvc/2015/gmock_test.vcxproj | 176 +
.../googlemock/scripts/fuse_gmock_files.py | 240 +
.../gtest/googlemock/scripts/generator/LICENSE | 203 +
.../gtest/googlemock/scripts/generator/README | 35 +
.../scripts/generator/README.cppclean | 115 +
.../scripts/generator/cpp/__init__.py | 0
.../googlemock/scripts/generator/cpp/ast.py | 1733 ++++
.../scripts/generator/cpp/gmock_class.py | 227 +
.../scripts/generator/cpp/gmock_class_test.py | 448 +
.../scripts/generator/cpp/keywords.py | 59 +
.../scripts/generator/cpp/tokenize.py | 287 +
.../googlemock/scripts/generator/cpp/utils.py | 41 +
.../googlemock/scripts/generator/gmock_gen.py | 31 +
.../gtest/googlemock/scripts/gmock-config.in | 303 +
.../gtest/googlemock/scripts/gmock_doctor.py | 640 ++
.../3rdparty/gtest/googlemock/scripts/upload.py | 1387 ++++
.../gtest/googlemock/scripts/upload_gmock.py | 78 +
.../3rdparty/gtest/googlemock/src/gmock-all.cc | 47 +
.../gtest/googlemock/src/gmock-cardinalities.cc | 156 +
.../googlemock/src/gmock-internal-utils.cc | 204 +
.../gtest/googlemock/src/gmock-matchers.cc | 573 ++
.../gtest/googlemock/src/gmock-spec-builders.cc | 883 ++
.../3rdparty/gtest/googlemock/src/gmock.cc | 205 +
.../3rdparty/gtest/googlemock/src/gmock_main.cc | 54 +
.../3rdparty/gtest/googlemock/test/BUILD.bazel | 123 +
.../gtest/googlemock/test/gmock-actions_test.cc | 1575 ++++
.../googlemock/test/gmock-cardinalities_test.cc | 428 +
.../test/gmock-generated-actions_test.cc | 1230 +++
.../gmock-generated-function-mockers_test.cc | 647 ++
.../test/gmock-generated-internal-utils_test.cc | 129 +
.../test/gmock-generated-matchers_test.cc | 1341 +++
.../test/gmock-internal-utils_test.cc | 718 ++
.../googlemock/test/gmock-matchers_test.cc | 6769 +++++++++++++++
.../googlemock/test/gmock-more-actions_test.cc | 710 ++
.../googlemock/test/gmock-nice-strict_test.cc | 511 ++
.../gtest/googlemock/test/gmock-port_test.cc | 43 +
.../googlemock/test/gmock-spec-builders_test.cc | 2771 +++++++
.../gtest/googlemock/test/gmock_all_test.cc | 51 +
.../gtest/googlemock/test/gmock_ex_test.cc | 81 +
.../gtest/googlemock/test/gmock_leak_test.py | 108 +
.../gtest/googlemock/test/gmock_leak_test_.cc | 100 +
.../gtest/googlemock/test/gmock_link2_test.cc | 40 +
.../gtest/googlemock/test/gmock_link_test.cc | 40 +
.../gtest/googlemock/test/gmock_link_test.h | 691 ++
.../gtest/googlemock/test/gmock_output_test.py | 183 +
.../gtest/googlemock/test/gmock_output_test_.cc | 310 +
.../test/gmock_output_test_golden.txt | 317 +
.../gtest/googlemock/test/gmock_stress_test.cc | 323 +
.../gtest/googlemock/test/gmock_test.cc | 262 +
.../gtest/googlemock/test/gmock_test_utils.py | 110 +
.../backend/3rdparty/gtest/googletest/CHANGES | 157 +
.../3rdparty/gtest/googletest/CMakeLists.txt | 312 +
.../3rdparty/gtest/googletest/CONTRIBUTORS | 37 +
.../backend/3rdparty/gtest/googletest/LICENSE | 28 +
.../3rdparty/gtest/googletest/Makefile.am | 339 +
.../backend/3rdparty/gtest/googletest/README.md | 360 +
.../3rdparty/gtest/googletest/cmake/gtest.pc.in | 9 +
.../gtest/googletest/cmake/gtest_main.pc.in | 10 +
.../gtest/googletest/cmake/internal_utils.cmake | 280 +
.../gtest/googletest/codegear/gtest.cbproj | 138 +
.../gtest/googletest/codegear/gtest.groupproj | 54 +
.../gtest/googletest/codegear/gtest_all.cc | 38 +
.../gtest/googletest/codegear/gtest_link.cc | 40 +
.../gtest/googletest/codegear/gtest_main.cbproj | 82 +
.../googletest/codegear/gtest_unittest.cbproj | 88 +
.../3rdparty/gtest/googletest/configure.ac | 68 +
.../gtest/googletest/docs/AdvancedGuide.md | 2416 ++++++
.../gtest/googletest/docs/Documentation.md | 16 +
.../3rdparty/gtest/googletest/docs/FAQ.md | 1092 +++
.../3rdparty/gtest/googletest/docs/Pkgconfig.md | 146 +
.../3rdparty/gtest/googletest/docs/Primer.md | 536 ++
.../gtest/googletest/docs/PumpManual.md | 177 +
.../3rdparty/gtest/googletest/docs/Samples.md | 14 +
.../gtest/googletest/docs/XcodeGuide.md | 93 +
.../googletest/include/gtest/gtest-death-test.h | 342 +
.../googletest/include/gtest/gtest-message.h | 249 +
.../googletest/include/gtest/gtest-param-test.h | 1438 ++++
.../include/gtest/gtest-param-test.h.pump | 501 ++
.../googletest/include/gtest/gtest-printers.h | 1078 +++
.../gtest/googletest/include/gtest/gtest-spi.h | 231 +
.../googletest/include/gtest/gtest-test-part.h | 179 +
.../googletest/include/gtest/gtest-typed-test.h | 264 +
.../gtest/googletest/include/gtest/gtest.h | 2330 ++++++
.../googletest/include/gtest/gtest_pred_impl.h | 357 +
.../gtest/googletest/include/gtest/gtest_prod.h | 61 +
.../include/gtest/internal/custom/gtest-port.h | 75 +
.../gtest/internal/custom/gtest-printers.h | 42 +
.../include/gtest/internal/custom/gtest.h | 45 +
.../gtest/internal/gtest-death-test-internal.h | 275 +
.../include/gtest/internal/gtest-filepath.h | 205 +
.../include/gtest/internal/gtest-internal.h | 1277 +++
.../include/gtest/internal/gtest-linked_ptr.h | 243 +
.../gtest/internal/gtest-param-util-generated.h | 5139 ++++++++++++
.../internal/gtest-param-util-generated.h.pump | 279 +
.../include/gtest/internal/gtest-param-util.h | 723 ++
.../include/gtest/internal/gtest-port-arch.h | 100 +
.../include/gtest/internal/gtest-port.h | 2686 ++++++
.../include/gtest/internal/gtest-string.h | 167 +
.../include/gtest/internal/gtest-tuple.h | 1020 +++
.../include/gtest/internal/gtest-tuple.h.pump | 347 +
.../include/gtest/internal/gtest-type-util.h | 3331 ++++++++
.../gtest/internal/gtest-type-util.h.pump | 297 +
.../3rdparty/gtest/googletest/m4/acx_pthread.m4 | 363 +
.../3rdparty/gtest/googletest/m4/gtest.m4 | 74 +
.../3rdparty/gtest/googletest/make/Makefile | 82 +
.../gtest/googletest/msvc/2010/gtest-md.sln | 55 +
.../gtest/googletest/msvc/2010/gtest-md.vcxproj | 149 +
.../msvc/2010/gtest-md.vcxproj.filters | 18 +
.../gtest/googletest/msvc/2010/gtest.sln | 55 +
.../gtest/googletest/msvc/2010/gtest.vcxproj | 149 +
.../googletest/msvc/2010/gtest.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_main-md.vcxproj | 154 +
.../msvc/2010/gtest_main-md.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_main.vcxproj | 162 +
.../msvc/2010/gtest_main.vcxproj.filters | 18 +
.../msvc/2010/gtest_prod_test-md.vcxproj | 199 +
.../2010/gtest_prod_test-md.vcxproj.filters | 26 +
.../msvc/2010/gtest_prod_test.vcxproj | 191 +
.../msvc/2010/gtest_prod_test.vcxproj.filters | 26 +
.../msvc/2010/gtest_unittest-md.vcxproj | 188 +
.../msvc/2010/gtest_unittest-md.vcxproj.filters | 18 +
.../googletest/msvc/2010/gtest_unittest.vcxproj | 180 +
.../msvc/2010/gtest_unittest.vcxproj.filters | 18 +
.../gtest/googletest/samples/prime_tables.h | 127 +
.../gtest/googletest/samples/sample1.cc | 68 +
.../3rdparty/gtest/googletest/samples/sample1.h | 43 +
.../googletest/samples/sample10_unittest.cc | 140 +
.../googletest/samples/sample1_unittest.cc | 154 +
.../gtest/googletest/samples/sample2.cc | 56 +
.../3rdparty/gtest/googletest/samples/sample2.h | 85 +
.../googletest/samples/sample2_unittest.cc | 110 +
.../gtest/googletest/samples/sample3-inl.h | 172 +
.../googletest/samples/sample3_unittest.cc | 152 +
.../gtest/googletest/samples/sample4.cc | 46 +
.../3rdparty/gtest/googletest/samples/sample4.h | 53 +
.../googletest/samples/sample4_unittest.cc | 49 +
.../googletest/samples/sample5_unittest.cc | 199 +
.../googletest/samples/sample6_unittest.cc | 225 +
.../googletest/samples/sample7_unittest.cc | 118 +
.../googletest/samples/sample8_unittest.cc | 174 +
.../googletest/samples/sample9_unittest.cc | 157 +
.../3rdparty/gtest/googletest/scripts/common.py | 83 +
.../googletest/scripts/fuse_gtest_files.py | 253 +
.../googletest/scripts/gen_gtest_pred_impl.py | 730 ++
.../gtest/googletest/scripts/gtest-config.in | 274 +
.../3rdparty/gtest/googletest/scripts/pump.py | 855 ++
.../gtest/googletest/scripts/release_docs.py | 158 +
.../gtest/googletest/scripts/test/Makefile | 59 +
.../3rdparty/gtest/googletest/scripts/upload.py | 1387 ++++
.../gtest/googletest/scripts/upload_gtest.py | 78 +
.../3rdparty/gtest/googletest/src/gtest-all.cc | 48 +
.../gtest/googletest/src/gtest-death-test.cc | 1346 +++
.../gtest/googletest/src/gtest-filepath.cc | 385 +
.../gtest/googletest/src/gtest-internal-inl.h | 1175 +++
.../3rdparty/gtest/googletest/src/gtest-port.cc | 1253 +++
.../gtest/googletest/src/gtest-printers.cc | 458 ++
.../gtest/googletest/src/gtest-test-part.cc | 102 +
.../gtest/googletest/src/gtest-typed-test.cc | 119 +
.../3rdparty/gtest/googletest/src/gtest.cc | 5841 +++++++++++++
.../3rdparty/gtest/googletest/src/gtest_main.cc | 38 +
.../3rdparty/gtest/googletest/test/BUILD.bazel | 380 +
.../googletest/test/gtest-death-test_ex_test.cc | 93 +
.../googletest/test/gtest-death-test_test.cc | 1423 ++++
.../googletest/test/gtest-filepath_test.cc | 652 ++
.../googletest/test/gtest-linked_ptr_test.cc | 154 +
.../googletest/test/gtest-listener_test.cc | 311 +
.../gtest/googletest/test/gtest-message_test.cc | 159 +
.../gtest/googletest/test/gtest-options_test.cc | 207 +
.../googletest/test/gtest-param-test2_test.cc | 61 +
.../googletest/test/gtest-param-test_test.cc | 1110 +++
.../googletest/test/gtest-param-test_test.h | 53 +
.../gtest/googletest/test/gtest-port_test.cc | 1303 +++
.../googletest/test/gtest-printers_test.cc | 1731 ++++
.../googletest/test/gtest-test-part_test.cc | 208 +
.../gtest/googletest/test/gtest-tuple_test.cc | 320 +
.../googletest/test/gtest-typed-test2_test.cc | 45 +
.../googletest/test/gtest-typed-test_test.cc | 380 +
.../googletest/test/gtest-typed-test_test.h | 66 +
.../googletest/test/gtest-unittest-api_test.cc | 341 +
.../gtest/googletest/test/gtest_all_test.cc | 47 +
.../test/gtest_assert_by_exception_test.cc | 119 +
.../test/gtest_break_on_failure_unittest.py | 210 +
.../test/gtest_break_on_failure_unittest_.cc | 87 +
.../test/gtest_catch_exceptions_test.py | 235 +
.../test/gtest_catch_exceptions_test_.cc | 311 +
.../gtest/googletest/test/gtest_color_test.py | 129 +
.../gtest/googletest/test/gtest_color_test_.cc | 63 +
.../gtest/googletest/test/gtest_env_var_test.py | 119 +
.../googletest/test/gtest_env_var_test_.cc | 124 +
.../googletest/test/gtest_environment_test.cc | 189 +
.../googletest/test/gtest_filter_unittest.py | 638 ++
.../googletest/test/gtest_filter_unittest_.cc | 138 +
.../gtest/googletest/test/gtest_help_test.py | 172 +
.../gtest/googletest/test/gtest_help_test_.cc | 46 +
.../googletest/test/gtest_json_outfiles_test.py | 162 +
.../test/gtest_json_output_unittest.py | 611 ++
.../googletest/test/gtest_json_test_utils.py | 60 +
.../test/gtest_list_tests_unittest.py | 207 +
.../test/gtest_list_tests_unittest_.cc | 157 +
.../googletest/test/gtest_main_unittest.cc | 45 +
.../googletest/test/gtest_no_test_unittest.cc | 56 +
.../gtest/googletest/test/gtest_output_test.py | 344 +
.../gtest/googletest/test/gtest_output_test_.cc | 1067 +++
.../test/gtest_output_test_golden_lin.txt | 781 ++
.../googletest/test/gtest_pred_impl_unittest.cc | 2427 ++++++
.../test/gtest_premature_exit_test.cc | 127 +
.../gtest/googletest/test/gtest_prod_test.cc | 57 +
.../gtest/googletest/test/gtest_repeat_test.cc | 236 +
.../gtest/googletest/test/gtest_shuffle_test.py | 325 +
.../googletest/test/gtest_shuffle_test_.cc | 103 +
.../googletest/test/gtest_sole_header_test.cc | 57 +
.../gtest/googletest/test/gtest_stress_test.cc | 250 +
.../gtest/googletest/test/gtest_test_utils.py | 318 +
.../test/gtest_throw_on_failure_ex_test.cc | 92 +
.../test/gtest_throw_on_failure_test.py | 171 +
.../test/gtest_throw_on_failure_test_.cc | 72 +
.../googletest/test/gtest_uninitialized_test.py | 69 +
.../test/gtest_uninitialized_test_.cc | 43 +
.../gtest/googletest/test/gtest_unittest.cc | 7750 ++++++++++++++++++
.../googletest/test/gtest_xml_outfile1_test_.cc | 48 +
.../googletest/test/gtest_xml_outfile2_test_.cc | 48 +
.../googletest/test/gtest_xml_outfiles_test.py | 140 +
.../test/gtest_xml_output_unittest.py | 378 +
.../test/gtest_xml_output_unittest_.cc | 179 +
.../googletest/test/gtest_xml_test_utils.py | 196 +
.../gtest/googletest/test/production.cc | 36 +
.../3rdparty/gtest/googletest/test/production.h | 55 +
.../xcode/Config/DebugProject.xcconfig | 30 +
.../xcode/Config/FrameworkTarget.xcconfig | 17 +
.../googletest/xcode/Config/General.xcconfig | 41 +
.../xcode/Config/ReleaseProject.xcconfig | 32 +
.../xcode/Config/StaticLibraryTarget.xcconfig | 18 +
.../googletest/xcode/Config/TestTarget.xcconfig | 8 +
.../gtest/googletest/xcode/Resources/Info.plist | 30 +
.../xcode/Samples/FrameworkSample/Info.plist | 28 +
.../WidgetFramework.xcodeproj/project.pbxproj | 457 ++
.../xcode/Samples/FrameworkSample/runtests.sh | 62 +
.../xcode/Samples/FrameworkSample/widget.cc | 63 +
.../xcode/Samples/FrameworkSample/widget.h | 59 +
.../Samples/FrameworkSample/widget_test.cc | 68 +
.../gtest/googletest/xcode/Scripts/runtests.sh | 65 +
.../googletest/xcode/Scripts/versiongenerate.py | 100 +
.../xcode/gtest.xcodeproj/project.pbxproj | 1182 +++
libraries/ostrich/backend/CMakeLists.txt | 57 +
libraries/ostrich/backend/client/CMakeLists.txt | 9 +
libraries/ostrich/backend/client/client.cc | 386 +
.../ostrich/backend/cmake/FindGFlags.cmake | 48 +
libraries/ostrich/backend/cmake/FindGLog.cmake | 18 +
libraries/ostrich/backend/cmake/FindGRPC.cmake | 67 +
.../ostrich/backend/cmake/FindLevelDB.cmake | 18 +
.../ostrich/backend/cmake/FindRAPTOR.cmake | 103 +
.../ostrich/backend/cmake/FindRasqal.cmake | 99 +
.../ostrich/backend/cmake/FindRocksDB.cmake | 18 +
.../ostrich/backend/cmake/FindTcmalloc.cmake | 39 +
libraries/ostrich/backend/model/CMakeLists.txt | 6 +
libraries/ostrich/backend/model/model.proto | 77 +
libraries/ostrich/backend/model/rdf_model.cc | 349 +
libraries/ostrich/backend/model/rdf_model.h | 709 ++
.../ostrich/backend/model/rdf_namespaces.cc | 67 +
.../ostrich/backend/model/rdf_namespaces.h | 169 +
.../ostrich/backend/model/rdf_operators.cc | 65 +
libraries/ostrich/backend/model/rdf_operators.h | 240 +
libraries/ostrich/backend/parser/CMakeLists.txt | 6 +
libraries/ostrich/backend/parser/rdf_parser.cc | 168 +
libraries/ostrich/backend/parser/rdf_parser.h | 94 +
.../ostrich/backend/persistence/CMakeLists.txt | 28 +
.../backend/persistence/base_persistence.cc | 194 +
.../backend/persistence/base_persistence.h | 220 +
.../backend/persistence/leveldb_persistence.cc | 560 ++
.../backend/persistence/leveldb_persistence.h | 176 +
.../backend/persistence/leveldb_server.cc | 76 +
.../backend/persistence/leveldb_service.cc | 304 +
.../backend/persistence/leveldb_service.h | 128 +
.../backend/persistence/leveldb_sparql.cc | 87 +
.../backend/persistence/leveldb_sparql.h | 58 +
.../backend/persistence/marmotta_updatedb.cc | 217 +
.../ostrich/backend/serializer/CMakeLists.txt | 10 +
.../ostrich/backend/serializer/serializer.cc | 49 +
.../ostrich/backend/serializer/serializer.h | 54 +
.../backend/serializer/serializer_base.cc | 76 +
.../backend/serializer/serializer_base.h | 104 +
.../backend/serializer/serializer_proto.cc | 56 +
.../backend/serializer/serializer_proto.h | 50 +
.../backend/serializer/serializer_raptor.cc | 175 +
.../backend/serializer/serializer_raptor.h | 55 +
.../ostrich/backend/service/CMakeLists.txt | 9 +
libraries/ostrich/backend/service/sail.proto | 102 +
libraries/ostrich/backend/service/sparql.proto | 53 +
.../ostrich/backend/sharding/CMakeLists.txt | 11 +
libraries/ostrich/backend/sharding/server.cc | 66 +
libraries/ostrich/backend/sharding/sharding.cc | 335 +
libraries/ostrich/backend/sharding/sharding.h | 174 +
libraries/ostrich/backend/sparql/CMakeLists.txt | 8 +
.../ostrich/backend/sparql/rasqal_adapter.cc | 380 +
.../ostrich/backend/sparql/rasqal_adapter.h | 127 +
.../ostrich/backend/sparql/rasqal_model.cc | 205 +
libraries/ostrich/backend/sparql/rasqal_model.h | 73 +
libraries/ostrich/backend/test/CMakeLists.txt | 25 +
libraries/ostrich/backend/test/LevelDBTest.cc | 457 ++
libraries/ostrich/backend/test/NamespaceTest.cc | 78 +
.../ostrich/backend/test/PersistenceTest.cc | 80 +
libraries/ostrich/backend/test/SparqlTest.cc | 307 +
libraries/ostrich/backend/test/StatementTest.cc | 148 +
libraries/ostrich/backend/util/CMakeLists.txt | 7 +
libraries/ostrich/backend/util/iterator.h | 315 +
libraries/ostrich/backend/util/murmur3.cc | 313 +
libraries/ostrich/backend/util/murmur3.h | 18 +
libraries/ostrich/backend/util/raptor_util.cc | 190 +
libraries/ostrich/backend/util/raptor_util.h | 74 +
libraries/ostrich/backend/util/threadpool.h | 251 +
libraries/ostrich/backend/util/time_logger.cc | 30 +
libraries/ostrich/backend/util/time_logger.h | 45 +
libraries/ostrich/client/pom.xml | 217 +
.../ostrich/sail/ClosableResponseStream.java | 163 +
.../marmotta/ostrich/sail/OstrichSail.java | 87 +
.../ostrich/sail/OstrichSailConnection.java | 618 ++
.../ostrich/sail/OstrichValueFactory.java | 260 +
.../ostrich/sail/test/CMarmottaSailTest.java | 74 +
.../ostrich/sail/test/TestSailConnection.java | 80 +
libraries/ostrich/model/pom.xml | 202 +
.../marmotta/ostrich/model/ProtoBNode.java | 79 +
.../ostrich/model/ProtoDatatypeLiteral.java | 106 +
.../ostrich/model/ProtoLiteralBase.java | 186 +
.../marmotta/ostrich/model/ProtoNamespace.java | 86 +
.../marmotta/ostrich/model/ProtoStatement.java | 221 +
.../ostrich/model/ProtoStringLiteral.java | 101 +
.../apache/marmotta/ostrich/model/ProtoURI.java | 113 +
.../ostrich/model/test/StatementTest.java | 68 +
.../marmotta/ostrich/model/test/URITest.java | 57 +
.../model/src/test/resources/logback.xml | 28 +
libraries/ostrich/pom.xml | 66 +
libraries/pom.xml | 11 +-
loader/marmotta-loader-berkeley/pom.xml | 2 +-
.../src/main/resources/logback.xml | 4 +-
loader/marmotta-loader-core/pom.xml | 2 +-
.../marmotta/loader/api/LoaderBackend.java | 6 +-
.../marmotta/loader/api/LoaderHandler.java | 4 +-
.../marmotta/loader/core/MarmottaLoader.java | 15 +-
loader/marmotta-loader-hbase/pom.xml | 2 +-
.../src/main/resources/logback.xml | 4 +-
loader/marmotta-loader-kiwi/pom.xml | 2 +-
loader/marmotta-loader-ostrich/pom.xml | 83 +
.../loader/ostrich/OstrichLoaderBackend.java | 100 +
.../loader/ostrich/OstrichLoaderHandler.java | 156 +
...org.apache.marmotta.loader.api.LoaderBackend | 18 +
.../src/main/resources/logback.xml | 32 +
loader/marmotta-loader-titan/pom.xml | 2 +-
loader/pom.xml | 12 +-
parent/pom.xml | 65 +-
.../marmotta-backend-accumulograph/pom.xml | 60 +
.../AccumuloGraphLoggingModule.java | 79 +
.../accumulograph/AccumuloGraphProvider.java | 122 +
.../src/main/resources/META-INF/beans.xml | 28 +
.../main/resources/config-defaults.properties | 28 +
.../resources/config-descriptions.properties | 133 +
.../src/main/resources/kiwi-module.properties | 37 +
.../src/main/resources/web/admin/about.html | 36 +
.../main/resources/web/admin/configuration.html | 54 +
.../backends/marmotta-backend-bigdata/pom.xml | 2 +-
.../bigdata/BigDataSesame27Repository.java | 2 +-
platform/backends/marmotta-backend-http/pom.xml | 2 +-
platform/backends/marmotta-backend-kiwi/pom.xml | 2 +-
.../backend/kiwi/KiWiStoreProvider.java | 1 -
.../main/resources/config-defaults.properties | 13 +-
.../resources/config-descriptions.properties | 4 -
.../src/main/resources/web/admin/about.html | 41 +-
.../main/resources/web/admin/configuration.html | 9 +-
.../src/main/resources/web/admin/console.html | 2 +-
.../src/main/resources/web/admin/database.html | 2 +-
.../backends/marmotta-backend-memory/pom.xml | 2 +-
.../backends/marmotta-backend-native/pom.xml | 2 +-
.../backends/marmotta-backend-ostrich/pom.xml | 176 +
.../backend/ostrich/OstrichProvider.java | 97 +
.../backend/ostrich/OstrichSailRepository.java | 171 +
.../src/main/resources/META-INF/beans.xml | 28 +
.../main/resources/config-defaults.properties | 25 +
.../resources/config-descriptions.properties | 31 +
.../src/main/resources/kiwi-module.properties | 38 +
.../src/main/resources/web/admin/about.html | 36 +
.../main/resources/web/admin/configuration.html | 52 +
.../backends/marmotta-backend-sparql/pom.xml | 2 +-
.../backends/marmotta-backend-titan/pom.xml | 4 +-
platform/backends/pom.xml | 4 +-
.../ldcache/marmotta-ldcache-common/pom.xml | 2 +-
.../api/endpoint/LinkedDataEndpointService.java | 16 +-
.../model/filter/MarmottaNotCachedFilter.java | 2 +-
.../endpoint/LinkedDataEndpointServiceImpl.java | 2 +-
.../LinkedDataCachingWebService.java | 4 +-
platform/ldcache/marmotta-ldcache-file/pom.xml | 2 +-
.../services/kiwi/FileLDCacheSailProvider.java | 14 +-
platform/ldcache/marmotta-ldcache-kiwi/pom.xml | 2 +-
.../services/kiwi/KiWiLDCacheSailProvider.java | 2 +-
platform/ldcache/pom.xml | 2 +-
platform/marmotta-core/pom.xml | 2 +-
.../platform/core/api/cache/CachingService.java | 10 +-
.../core/api/config/ConfigurationService.java | 42 +-
.../core/api/config/DependenciesService.java | 2 +-
.../core/api/content/ContentReader.java | 14 +-
.../core/api/content/ContentService.java | 20 +-
.../core/api/content/ContentWriter.java | 10 +-
.../core/api/exporter/ExportService.java | 16 +-
.../core/api/http/HttpClientService.java | 30 +-
.../core/api/importer/ImportService.java | 10 +-
.../core/api/importer/ImportWatchService.java | 2 +-
.../platform/core/api/importer/Importer.java | 14 +-
.../platform/core/api/io/MarmottaIOService.java | 10 +-
.../platform/core/api/io/RDFHtmlWriter.java | 4 +-
.../platform/core/api/io/RDFWriterPriority.java | 4 +-
.../core/api/logging/LoggingModule.java | 20 +-
.../core/api/logging/LoggingService.java | 16 +-
.../core/api/modules/MarmottaHttpFilter.java | 16 +-
.../api/modules/MarmottaResourceService.java | 6 +-
.../core/api/modules/ModuleService.java | 33 +-
.../core/api/modules/ResourceEntry.java | 2 +-
.../core/api/prefix/PrefixProvider.java | 9 +-
.../platform/core/api/prefix/PrefixService.java | 2 +-
.../platform/core/api/ssl/SSLService.java | 4 +-
.../core/api/statistics/StatisticsModule.java | 14 +-
.../core/api/statistics/StatisticsService.java | 22 +-
.../marmotta/platform/core/api/task/Task.java | 2 +-
.../platform/core/api/task/TaskInfo.java | 8 +-
.../core/api/task/TaskManagerService.java | 20 +-
.../api/templating/AdminInterfaceService.java | 8 +-
.../core/api/templating/TemplatingService.java | 30 +-
.../core/api/triplestore/ContextService.java | 8 +-
.../triplestore/GarbageCollectionProvider.java | 2 +-
.../api/triplestore/NotifyingSailProvider.java | 4 +-
.../core/api/triplestore/SailProvider.java | 6 +-
.../core/api/triplestore/SesameService.java | 2 +-
.../api/triplestore/StandardSailProvider.java | 4 +-
.../core/api/triplestore/StoreProvider.java | 4 +-
.../triplestore/TransactionalSailProvider.java | 4 +-
.../core/api/ui/MarmottaSystrayLink.java | 10 +-
.../platform/core/api/user/UserService.java | 24 +-
.../events/ConfigurationServiceInitEvent.java | 2 +-
.../core/exception/HttpErrorException.java | 4 +-
.../exception/InvalidArgumentException.java | 2 +-
.../MarmottaConfigurationException.java | 2 +-
.../core/exception/MarmottaException.java | 2 +-
.../core/exception/ResolvingException.java | 2 +-
.../core/exception/TemplatingException.java | 2 +-
.../core/exception/UserExistsException.java | 2 +-
.../exception/WritingNotSupportedException.java | 2 +-
.../authentication/LoginFailedException.java | 2 +-
.../exception/io/MarmottaExportException.java | 2 +-
.../exception/io/MarmottaImportException.java | 2 +-
.../io/UnsupportedExporterException.java | 2 +-
.../security/AccessDeniedException.java | 2 +-
.../exception/webservice/NotFoundException.java | 2 +-
.../exception/webservice/ServerException.java | 2 +-
.../core/filters/MarmottaServerNameFilter.java | 2 +-
.../core/filters/ModuleResourceFilter.java | 11 +-
.../platform/core/filters/TemplatingFilter.java | 27 +-
.../platform/core/jaxrs/ErrorMessage.java | 2 +-
.../jaxrs/exceptionmappers/ErrorResponse.java | 2 +-
.../platform/core/jndi/MarmottaContext.java | 15 +-
.../core/jndi/MarmottaContextFactory.java | 5 +-
.../core/jndi/MarmottaInitialContext.java | 2 +-
.../MarmottaInitialContextFactoryBuilder.java | 2 +-
.../core/jndi/MarmottaJndiListener.java | 2 +-
.../platform/core/model/content/Content.java | 2 +-
.../core/model/content/MediaContent.java | 2 +-
.../core/model/content/MediaContentItem.java | 10 +-
.../core/model/filter/MarmottaLocalFilter.java | 2 +-
.../core/model/logging/LoggingOutput.java | 3 +-
.../core/model/module/ModuleConfiguration.java | 2 +-
.../platform/core/model/template/MenuItem.java | 9 +-
.../platform/core/model/user/MarmottaUser.java | 26 +-
.../platform/core/model/user/OnlineAccount.java | 10 +-
.../core/qualifiers/cache/MarmottaCache.java | 4 +-
.../core/qualifiers/event/ContentCreated.java | 2 +-
.../platform/core/qualifiers/event/Created.java | 2 +-
.../platform/core/qualifiers/event/Removed.java | 2 +-
.../platform/core/qualifiers/event/Updated.java | 2 +-
.../event/transaction/AfterCommit.java | 2 +-
.../event/transaction/AfterRollback.java | 2 +-
.../event/transaction/BeforeCommit.java | 2 +-
.../event/transaction/BeforeRollback.java | 2 +-
.../qualifiers/event/transaction/OnAbort.java | 2 +-
.../kspace/ActiveKnowledgeSpaces.java | 2 +-
.../kspace/CurrentKnowledgeSpace.java | 2 +-
.../kspace/DefaultKnowledgeSpace.java | 2 +-
.../kspace/InferredKnowledgeSpace.java | 2 +-
.../qualifiers/kspace/SystemKnowledgeSpace.java | 2 +-
.../core/qualifiers/user/AdminUser.java | 2 +-
.../core/qualifiers/user/AnonymousUser.java | 2 +-
.../core/qualifiers/user/CurrentUser.java | 2 +-
.../platform/core/rio/RDFHtmlFormat.java | 5 +-
.../platform/core/rio/RDFHtmlWriterFactory.java | 2 +-
.../platform/core/rio/RDFHtmlWriterImpl.java | 26 +-
.../core/services/cache/CachingServiceImpl.java | 2 +-
.../config/ConfigurationServiceImpl.java | 61 +-
.../config/DependenciesServiceImpl.java | 16 +-
.../services/content/ContentServiceImpl.java | 35 +-
.../content/FileSystemContentReader.java | 7 +-
.../content/FileSystemContentWriter.java | 2 +-
.../services/content/HTTPContentReader.java | 4 +-
.../services/exporter/ExporterServiceImpl.java | 2 +-
.../services/http/HttpClientServiceImpl.java | 36 +-
.../core/services/http/MonitoredHttpEntity.java | 2 +-
.../response/LastModifiedResponseHandler.java | 4 +-
.../response/StatusCodeResponseHandler.java | 4 +-
.../response/StringBodyResponseHandler.java | 4 +-
.../services/importer/ImportServiceImpl.java | 7 +-
.../services/importer/rdf/RDFImporterImpl.java | 12 +-
.../core/services/io/MarmottaIOServiceImpl.java | 10 +-
.../services/logging/LoggingServiceImpl.java | 4 +-
.../modules/MarmottaResourceServiceImpl.java | 2 +-
.../services/modules/ModuleServiceImpl.java | 34 +-
.../platform/core/services/prefix/PrefixCC.java | 31 +-
.../core/services/prefix/PrefixServiceCC.java | 2 +-
.../core/services/prefix/PrefixServiceImpl.java | 34 +-
.../sesame/ResourceSubjectMetadata.java | 8 +-
.../core/services/ssl/SSLServiceImpl.java | 25 +-
.../statistics/StatisticsServiceImpl.java | 6 +-
.../system/SystemStatisticsModule.java | 6 +-
.../platform/core/services/task/TaskImpl.java | 2 +-
.../services/task/TaskManagerServiceImpl.java | 47 +-
.../templating/AdminTemplatingServiceImpl.java | 29 +-
.../templating/TemplatingServiceImpl.java | 34 +-
.../triplestore/ContextServiceImpl.java | 81 +-
.../services/triplestore/SesameServiceImpl.java | 10 +-
.../core/services/user/UserServiceImpl.java | 4 +-
.../core/servlet/MarmottaH2ConsoleFilter.java | 2 +-
.../core/servlet/MarmottaOptionsFilter.java | 2 +-
.../core/servlet/MarmottaPostStartupFilter.java | 2 +-
.../core/servlet/MarmottaPreStartupFilter.java | 2 +-
.../servlet/MarmottaPreStartupListener.java | 2 +-
.../core/servlet/MarmottaResourceFilter.java | 19 +-
.../core/startup/MarmottaStartupService.java | 2 +-
.../marmotta/platform/core/util/CDIContext.java | 8 +-
.../marmotta/platform/core/util/CDIUtils.java | 2 +-
.../marmotta/platform/core/util/DateUtil.java | 2 +-
.../core/util/FallbackConfiguration.java | 2 +-
.../marmotta/platform/core/util/KiWiIO.java | 2 +-
.../core/util/LinkedHashSetBlockingQueue.java | 6 +-
.../platform/core/util/ReflectionUtils.java | 2 +-
.../platform/core/util/WebServiceUtil.java | 16 +-
.../core/util/http/HttpRequestUtil.java | 2 +-
.../core/webservices/CoreApplication.java | 6 +-
.../config/ConfigurationWebService.java | 47 +-
.../config/DependenciesWebService.java | 2 +-
.../core/webservices/io/ExportWebService.java | 2 +-
.../core/webservices/io/ImportWebService.java | 4 +-
.../webservices/modules/ModuleWebService.java | 19 +-
.../webservices/prefix/PrefixWebService.java | 21 +-
.../resource/AnonResourceWebService.java | 2 +-
.../webservices/resource/ContentWebService.java | 4 +-
.../resource/InspectionWebService.java | 12 +-
.../webservices/resource/MetaWebService.java | 12 +-
.../resource/ResourceWebService.java | 4 +-
.../resource/ResourceWebServiceHelper.java | 4 +-
.../statistics/StatisticsWebService.java | 13 +-
.../webservices/status/StatusWebservice.java | 327 +
.../webservices/system/SystemWebService.java | 2 +-
.../webservices/task/TaskManagerWebService.java | 7 +-
.../triplestore/ContextWebService.java | 6 +-
.../main/resources/config-defaults.properties | 5 +-
.../src/main/resources/kiwi-module.properties | 3 +-
.../src/main/resources/web/admin/export.html | 16 +-
.../resources/web/admin/js/widgets/system.js | 4 +-
.../web/public/img/logo/marmotta-logo.png | Bin 36723 -> 38984 bytes
.../resources/web/public/style/blue/rdfhtml.css | 2 -
.../resources/web/public/style/blue/style.css | 3 +-
.../main/resources/web/public/style/red/404.css | 43 +
.../resources/web/public/style/red/code.css | 51 +
.../resources/web/public/style/red/error.css | 31 +
.../resources/web/public/style/red/javadoc.css | 113 +
.../resources/web/public/style/red/rdfhtml.css | 39 +
.../web/public/style/red/sgvizler.chart.css | 53 +
.../resources/web/public/style/red/style.css | 339 +
.../resources/web/public/style/white/style.css | 2 +-
.../core/test/base/AbstractMarmotta.java | 2 +-
.../core/test/base/EmbeddedMarmotta.java | 2 +-
.../platform/core/test/base/JettyMarmotta.java | 2 +-
.../core/test/base/jetty/TestApplication.java | 2 +-
.../test/base/jetty/TestInjectorFactory.java | 2 +-
.../test/config/ConfigurationServiceTest.java | 2 +-
.../config/ConfigurationWebServiceTest.java | 2 +-
.../test/embedded/EmbeddedMarmottaTest.java | 2 +-
.../modules/MarmottaResourceServiceTest.java | 2 +-
.../platform/core/test/prefix/PrefixCCTest.java | 14 +-
.../core/test/prefix/PrefixServiceTest.java | 2 +-
.../core/test/prefix/PrefixWebServiceTest.java | 2 +-
.../test/triplestore/ContextServiceTest.java | 95 +
.../core/test/user/UserServiceTest.java | 2 +-
.../platform/core/util/http/UriUtilTests.java | 2 +-
platform/marmotta-ldp/pom.xml | 2 +-
.../marmotta/platform/ldp/api/LdpService.java | 8 +-
.../platform/ldp/services/LdpServiceImpl.java | 4 +-
.../marmotta/platform/ldp/util/LdpUtils.java | 4 +-
.../platform/ldp/webservices/LdpWebService.java | 14 +-
.../services/LdpBinaryStoreServiceImplTest.java | 7 +-
.../ldp/webservices/LdpWebServiceTest.java | 7 +-
platform/marmotta-ldpath/pom.xml | 2 +-
.../api/AutoRegisteredLDPathFunction.java | 2 +-
.../platform/ldpath/api/LDPathService.java | 17 +-
.../platform/ldpath/backend/LMFBackend.java | 2 +-
.../ldpath/model/functions/ContentFunction.java | 2 +-
.../ldpath/model/functions/JsoupFunction.java | 2 +-
.../ldpath/services/LDPathServiceImpl.java | 2 +-
.../webservices/LDPathUtilWebService.java | 35 +-
.../ldpath/webservices/LDPathWebService.java | 2 +-
platform/marmotta-reasoner-kiwi/pom.xml | 2 +-
.../services/ReasoningSailProvider.java | 2 +-
.../reasoner/webservices/ProgramWebService.java | 2 +-
.../webservices/ReasonerWebService.java | 2 +-
platform/marmotta-security/pom.xml | 2 +-
.../platform/security/api/SecurityService.java | 10 +-
.../filters/MarmottaAccessControlFilter.java | 2 +-
.../platform/security/model/HTTPMethods.java | 2 +-
.../security/model/SecurityConstraint.java | 4 +-
.../security/services/SecurityServiceImpl.java | 2 +-
.../platform/security/util/IPv4SubnetInfo.java | 2 +-
.../platform/security/util/IPv6SubnetInfo.java | 2 +-
.../platform/security/util/SubnetInfo.java | 2 +-
.../webservices/SecurityWebService.java | 2 +-
platform/marmotta-sparql/pom.xml | 6 +-
.../platform/sparql/api/sparql/QueryType.java | 4 +-
.../sparql/api/sparql/SparqlService.java | 20 +-
.../services/sparql/SparqlServiceImpl.java | 26 +-
.../services/sparql/SparqlWritersHelper.java | 2 +-
.../sparqlio/rdf/SPARQLGraphResultWriter.java | 2 +-
.../sparqlhtml/SPARQLBooleanHTMLFormat.java | 2 +-
.../sparqlhtml/SPARQLBooleanHTMLWriter.java | 2 +-
.../SPARQLBooleanHTMLWriterFactory.java | 2 +-
.../sparqlio/sparqlhtml/SPARQLHTMLSettings.java | 6 +-
.../sparqlhtml/SPARQLResultsHTMLFormat.java | 2 +-
.../sparqlhtml/SPARQLResultsHTMLWriter.java | 25 +-
.../SPARQLResultsHTMLWriterFactory.java | 2 +-
.../sparqlhtml/SPARQLResultsHTMLWriterXSL.java | 17 +-
.../sparql/webservices/SparqlWebService.java | 270 +-
.../main/resources/web/admin/configuration.html | 2 +-
.../main/resources/web/admin/configuration.js | 2 +-
.../src/main/resources/web/admin/sgvizler.html | 4 +-
.../src/main/resources/web/admin/squebi.html | 10 +-
.../webservices/SparqlWebServiceTest.java | 14 +
platform/marmotta-user/pom.xml | 59 +-
.../platform/user/api/AccountService.java | 2 +-
.../user/api/AuthenticationProvider.java | 2 +-
.../user/api/AuthenticationService.java | 14 +-
.../user/api/UserConfigurationService.java | 18 +-
.../filters/MarmottaAuthenticationFilter.java | 8 +-
.../platform/user/model/UserAccount.java | 13 +-
.../user/services/AccountServiceImpl.java | 22 +-
.../services/AuthenticationServiceImpl.java | 6 +-
.../services/UserConfigurationServiceImpl.java | 2 +-
.../user/services/auth/LMFAuthProviderImpl.java | 49 -
.../user/services/auth/LdapAuthProvider.java | 2 +-
.../services/auth/MarmottaAuthProviderImpl.java | 49 +
.../webservices/UserManagementWebService.java | 20 +-
.../user/webservices/UserWebService.java | 53 +-
.../main/resources/config-defaults.properties | 2 +-
.../main/resources/web/admin/widgets/user.js | 33 +-
.../user/services/AccountServiceTest.java | 69 +
.../user/webservices/UserWebServiceTest.java | 55 +
platform/marmotta-versioning-common/pom.xml | 2 +-
platform/marmotta-versioning-kiwi/pom.xml | 2 +-
.../platform/versioning/api/MementoService.java | 6 +-
.../api/VersionSerializerService.java | 4 +-
.../versioning/exception/MementoException.java | 2 +-
.../versioning/filter/MementoFilter.java | 2 +-
.../versioning/io/HtmlVersionSerializer.java | 2 +-
.../versioning/io/LinkVersionSerializer.java | 2 +-
.../versioning/io/VersionSerializer.java | 8 +-
.../versioning/model/MementoVersionSet.java | 2 +-
.../versioning/services/MementoServiceImpl.java | 2 +-
.../services/VersionSerializerServiceImpl.java | 2 +-
.../services/VersioningSailProvider.java | 35 +-
.../platform/versioning/utils/MementoUtils.java | 2 +-
.../webservices/MementoWebService.java | 2 +-
.../webservices/VersioningWebService.java | 2 +-
platform/marmotta-zookeeper/pom.xml | 2 +-
.../zookeeper/api/ZookeeperService.java | 8 +-
.../services/ZookeeperServiceImpl.java | 4 +-
platform/pom.xml | 2 +-
pom.xml | 13 +-
2482 files changed, 247825 insertions(+), 7257 deletions(-)
----------------------------------------------------------------------
[58/62] [abbrv] marmotta git commit: [maven-release-plugin] prepare
release 3.4.0
Posted by ja...@apache.org.
[maven-release-plugin] prepare release 3.4.0
Project: http://git-wip-us.apache.org/repos/asf/marmotta/repo
Commit: http://git-wip-us.apache.org/repos/asf/marmotta/commit/b0e5b937
Tree: http://git-wip-us.apache.org/repos/asf/marmotta/tree/b0e5b937
Diff: http://git-wip-us.apache.org/repos/asf/marmotta/diff/b0e5b937
Branch: refs/heads/develop
Commit: b0e5b93772fe16d2cdfc0ed7b444cda160ecdd3a
Parents: b7e0dd4
Author: Jakob Frank <ja...@apache.org>
Authored: Tue Jun 12 13:27:17 2018 +0200
Committer: Jakob Frank <ja...@apache.org>
Committed: Tue Jun 12 13:27:17 2018 +0200
----------------------------------------------------------------------
build/archetypes/marmotta-archetype-module/pom.xml | 2 +-
build/archetypes/marmotta-archetype-webapp/pom.xml | 2 +-
build/archetypes/pom.xml | 2 +-
build/checkstyle-resources/pom.xml | 2 +-
build/dependency-resource-supplement/pom.xml | 2 +-
build/plugins/buildinfo-maven-plugin/pom.xml | 2 +-
build/plugins/marmotta-maven-plugin/pom.xml | 2 +-
build/plugins/pom.xml | 2 +-
build/plugins/refpack-maven-plugin/pom.xml | 2 +-
build/plugins/repocheck-maven-plugin/pom.xml | 2 +-
build/pom.xml | 2 +-
client/marmotta-client-java/pom.xml | 2 +-
client/marmotta-client-js-sample-webapp/pom.xml | 2 +-
client/marmotta-client-js/pom.xml | 2 +-
client/pom.xml | 2 +-
commons/marmotta-commons/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml | 2 +-
.../marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml | 2 +-
.../marmotta-sesame-tools/marmotta-sail-transactions/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml | 2 +-
commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml | 2 +-
.../marmotta-sesame-tools/marmotta-util-tripletable/pom.xml | 2 +-
commons/marmotta-sesame-tools/pom.xml | 2 +-
commons/pom.xml | 2 +-
extras/pom.xml | 2 +-
extras/webjars/codemirror/pom.xml | 2 +-
extras/webjars/pom.xml | 2 +-
extras/webjars/strftime/pom.xml | 2 +-
launchers/marmotta-installer/pom.xml | 2 +-
launchers/marmotta-splash/pom.xml | 2 +-
launchers/marmotta-webapp/pom.xml | 2 +-
launchers/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-ehcache/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-hazelcast/pom.xml | 2 +-
libraries/kiwi/kiwi-caching-infinispan/pom.xml | 2 +-
libraries/kiwi/kiwi-loader/pom.xml | 2 +-
libraries/kiwi/kiwi-reasoner/pom.xml | 2 +-
libraries/kiwi/kiwi-sparql/pom.xml | 2 +-
libraries/kiwi/kiwi-triplestore/pom.xml | 2 +-
libraries/kiwi/kiwi-versioning/pom.xml | 2 +-
libraries/kiwi/pom.xml | 2 +-
libraries/ldcache/ldcache-api/pom.xml | 2 +-
libraries/ldcache/ldcache-backend-file/pom.xml | 2 +-
libraries/ldcache/ldcache-backend-infinispan/pom.xml | 2 +-
libraries/ldcache/ldcache-backend-kiwi/pom.xml | 2 +-
libraries/ldcache/ldcache-core/pom.xml | 2 +-
libraries/ldcache/ldcache-sail-generic/pom.xml | 2 +-
libraries/ldcache/ldcache-sail-kiwi/pom.xml | 2 +-
libraries/ldcache/pom.xml | 2 +-
libraries/ldclient/ldclient-api/pom.xml | 2 +-
libraries/ldclient/ldclient-core/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-facebook/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-html/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-ldap/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-mediawiki/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-phpbb/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-rdf/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-rdfa/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-vimeo/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-xml/pom.xml | 2 +-
libraries/ldclient/ldclient-provider-youtube/pom.xml | 2 +-
libraries/ldclient/pom.xml | 2 +-
libraries/ldpath/ldpath-api/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-file/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-jena/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-linkeddata/pom.xml | 2 +-
libraries/ldpath/ldpath-backend-sesame/pom.xml | 2 +-
libraries/ldpath/ldpath-core-bundle/pom.xml | 2 +-
libraries/ldpath/ldpath-core/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-collections/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-date/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-html/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-json/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-math/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-text/pom.xml | 2 +-
libraries/ldpath/ldpath-functions-xml/pom.xml | 2 +-
libraries/ldpath/ldpath-ldquery-cli/pom.xml | 2 +-
libraries/ldpath/ldpath-template-linkeddata/pom.xml | 2 +-
libraries/ldpath/ldpath-template/pom.xml | 2 +-
libraries/ldpath/pom.xml | 2 +-
libraries/pom.xml | 2 +-
loader/marmotta-loader-berkeley/pom.xml | 2 +-
loader/marmotta-loader-core/pom.xml | 2 +-
loader/marmotta-loader-hbase/pom.xml | 2 +-
loader/marmotta-loader-kiwi/pom.xml | 2 +-
loader/marmotta-loader-titan/pom.xml | 2 +-
loader/pom.xml | 2 +-
parent/pom.xml | 6 +++++-
platform/backends/marmotta-backend-accumulograph/pom.xml | 6 ++----
platform/backends/marmotta-backend-kiwi/pom.xml | 2 +-
platform/backends/marmotta-backend-memory/pom.xml | 2 +-
platform/backends/marmotta-backend-native/pom.xml | 2 +-
platform/backends/marmotta-backend-titan/pom.xml | 2 +-
platform/backends/pom.xml | 2 +-
platform/ldcache/marmotta-ldcache-common/pom.xml | 2 +-
platform/ldcache/marmotta-ldcache-file/pom.xml | 2 +-
platform/ldcache/marmotta-ldcache-kiwi/pom.xml | 2 +-
platform/ldcache/pom.xml | 2 +-
platform/marmotta-core/pom.xml | 2 +-
platform/marmotta-ldp/pom.xml | 2 +-
platform/marmotta-ldpath/pom.xml | 2 +-
platform/marmotta-reasoner-kiwi/pom.xml | 2 +-
platform/marmotta-security/pom.xml | 2 +-
platform/marmotta-sparql/pom.xml | 2 +-
platform/marmotta-user/pom.xml | 2 +-
platform/marmotta-versioning-common/pom.xml | 2 +-
platform/marmotta-versioning-kiwi/pom.xml | 2 +-
platform/marmotta-zookeeper/pom.xml | 2 +-
platform/pom.xml | 2 +-
pom.xml | 4 ++--
116 files changed, 122 insertions(+), 120 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/archetypes/marmotta-archetype-module/pom.xml
----------------------------------------------------------------------
diff --git a/build/archetypes/marmotta-archetype-module/pom.xml b/build/archetypes/marmotta-archetype-module/pom.xml
index ce2c1d6..2a00be0 100644
--- a/build/archetypes/marmotta-archetype-module/pom.xml
+++ b/build/archetypes/marmotta-archetype-module/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/archetypes/marmotta-archetype-webapp/pom.xml
----------------------------------------------------------------------
diff --git a/build/archetypes/marmotta-archetype-webapp/pom.xml b/build/archetypes/marmotta-archetype-webapp/pom.xml
index fea0092..087135f 100644
--- a/build/archetypes/marmotta-archetype-webapp/pom.xml
+++ b/build/archetypes/marmotta-archetype-webapp/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/archetypes/pom.xml
----------------------------------------------------------------------
diff --git a/build/archetypes/pom.xml b/build/archetypes/pom.xml
index ffb3cc3..2338f04 100644
--- a/build/archetypes/pom.xml
+++ b/build/archetypes/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
<artifactId>archetypes-reactor</artifactId>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/checkstyle-resources/pom.xml
----------------------------------------------------------------------
diff --git a/build/checkstyle-resources/pom.xml b/build/checkstyle-resources/pom.xml
index 1a1a314..e1ccbb7 100644
--- a/build/checkstyle-resources/pom.xml
+++ b/build/checkstyle-resources/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/dependency-resource-supplement/pom.xml
----------------------------------------------------------------------
diff --git a/build/dependency-resource-supplement/pom.xml b/build/dependency-resource-supplement/pom.xml
index d9b87ac..7e0ec1b 100644
--- a/build/dependency-resource-supplement/pom.xml
+++ b/build/dependency-resource-supplement/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/plugins/buildinfo-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/buildinfo-maven-plugin/pom.xml b/build/plugins/buildinfo-maven-plugin/pom.xml
index 39e2c68..eee29df 100644
--- a/build/plugins/buildinfo-maven-plugin/pom.xml
+++ b/build/plugins/buildinfo-maven-plugin/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/plugins/marmotta-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/marmotta-maven-plugin/pom.xml b/build/plugins/marmotta-maven-plugin/pom.xml
index e87f3c9..c0ce8e9 100644
--- a/build/plugins/marmotta-maven-plugin/pom.xml
+++ b/build/plugins/marmotta-maven-plugin/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
<artifactId>plugins-reactor</artifactId>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/plugins/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/pom.xml b/build/plugins/pom.xml
index b680532..ba775ac 100644
--- a/build/plugins/pom.xml
+++ b/build/plugins/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/plugins/refpack-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/refpack-maven-plugin/pom.xml b/build/plugins/refpack-maven-plugin/pom.xml
index 9433d98..f1fe33c 100644
--- a/build/plugins/refpack-maven-plugin/pom.xml
+++ b/build/plugins/refpack-maven-plugin/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<artifactId>plugins-reactor</artifactId>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/plugins/repocheck-maven-plugin/pom.xml
----------------------------------------------------------------------
diff --git a/build/plugins/repocheck-maven-plugin/pom.xml b/build/plugins/repocheck-maven-plugin/pom.xml
index b755ab7..c1beb9e 100644
--- a/build/plugins/repocheck-maven-plugin/pom.xml
+++ b/build/plugins/repocheck-maven-plugin/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>plugins-reactor</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
<!-- <artifactId>maven-plugins</artifactId> <groupId>org.apache.maven.plugins</groupId>
<version>23</version> <relativePath /> -->
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/build/pom.xml
----------------------------------------------------------------------
diff --git a/build/pom.xml b/build/pom.xml
index e27ab3b..0bebd2e 100644
--- a/build/pom.xml
+++ b/build/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/client/marmotta-client-java/pom.xml
----------------------------------------------------------------------
diff --git a/client/marmotta-client-java/pom.xml b/client/marmotta-client-java/pom.xml
index eb88957..6a38fb2 100644
--- a/client/marmotta-client-java/pom.xml
+++ b/client/marmotta-client-java/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/client/marmotta-client-js-sample-webapp/pom.xml
----------------------------------------------------------------------
diff --git a/client/marmotta-client-js-sample-webapp/pom.xml b/client/marmotta-client-js-sample-webapp/pom.xml
index 9de908b..584251d 100644
--- a/client/marmotta-client-js-sample-webapp/pom.xml
+++ b/client/marmotta-client-js-sample-webapp/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent/pom.xml</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/client/marmotta-client-js/pom.xml
----------------------------------------------------------------------
diff --git a/client/marmotta-client-js/pom.xml b/client/marmotta-client-js/pom.xml
index e724481..8245b8c 100644
--- a/client/marmotta-client-js/pom.xml
+++ b/client/marmotta-client-js/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent/pom.xml</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/client/pom.xml
----------------------------------------------------------------------
diff --git a/client/pom.xml b/client/pom.xml
index 6ba9da1..9dc1dd7 100644
--- a/client/pom.xml
+++ b/client/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-commons/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-commons/pom.xml b/commons/marmotta-commons/pom.xml
index cb4a754..39c0de3 100644
--- a/commons/marmotta-commons/pom.xml
+++ b/commons/marmotta-commons/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml b/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
index 94b60af..c0a38bb 100644
--- a/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-model-vocabs/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
index 5611307..be494cc 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
index 6ec8c52..f10b42b 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-ical/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
index e1ab020..ebdb353 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-rss/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml b/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
index 6518e36..b6cc99f 100644
--- a/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-rio-vcard/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml b/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
index 277ee42..1aa196d 100644
--- a/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-sail-contextaware/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml b/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
index 85d98cb..85e0071 100644
--- a/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-sail-transactions/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml b/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
index 36314c0..f9ec969 100644
--- a/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-sesame-matchers/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
index d9b3225..9a41a0d 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-facading/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
index 34eee31..f840141 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-filter/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
index 4ae2133..01c6c85 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-rdfpatch/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml b/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
index 39fcf7f..e556426 100644
--- a/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
+++ b/commons/marmotta-sesame-tools/marmotta-util-tripletable/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/marmotta-sesame-tools/pom.xml
----------------------------------------------------------------------
diff --git a/commons/marmotta-sesame-tools/pom.xml b/commons/marmotta-sesame-tools/pom.xml
index 56213d1..f0a1af9 100644
--- a/commons/marmotta-sesame-tools/pom.xml
+++ b/commons/marmotta-sesame-tools/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/commons/pom.xml
----------------------------------------------------------------------
diff --git a/commons/pom.xml b/commons/pom.xml
index e79b480..3697ca3 100644
--- a/commons/pom.xml
+++ b/commons/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/extras/pom.xml
----------------------------------------------------------------------
diff --git a/extras/pom.xml b/extras/pom.xml
index a234cb4..50aafd5 100644
--- a/extras/pom.xml
+++ b/extras/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/extras/webjars/codemirror/pom.xml
----------------------------------------------------------------------
diff --git a/extras/webjars/codemirror/pom.xml b/extras/webjars/codemirror/pom.xml
index c5242ab..24057c6 100644
--- a/extras/webjars/codemirror/pom.xml
+++ b/extras/webjars/codemirror/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/extras/webjars/pom.xml
----------------------------------------------------------------------
diff --git a/extras/webjars/pom.xml b/extras/webjars/pom.xml
index b0a4290..1407c83 100644
--- a/extras/webjars/pom.xml
+++ b/extras/webjars/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/extras/webjars/strftime/pom.xml
----------------------------------------------------------------------
diff --git a/extras/webjars/strftime/pom.xml b/extras/webjars/strftime/pom.xml
index 83c48fc..2ebb335 100644
--- a/extras/webjars/strftime/pom.xml
+++ b/extras/webjars/strftime/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/launchers/marmotta-installer/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/marmotta-installer/pom.xml b/launchers/marmotta-installer/pom.xml
index df03f8e..045adb8 100644
--- a/launchers/marmotta-installer/pom.xml
+++ b/launchers/marmotta-installer/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/launchers/marmotta-splash/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/marmotta-splash/pom.xml b/launchers/marmotta-splash/pom.xml
index 8e37731..e464ee3 100644
--- a/launchers/marmotta-splash/pom.xml
+++ b/launchers/marmotta-splash/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/launchers/marmotta-webapp/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/marmotta-webapp/pom.xml b/launchers/marmotta-webapp/pom.xml
index 6636410..3718b17 100644
--- a/launchers/marmotta-webapp/pom.xml
+++ b/launchers/marmotta-webapp/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/launchers/pom.xml
----------------------------------------------------------------------
diff --git a/launchers/pom.xml b/launchers/pom.xml
index e138762..0df37e6 100644
--- a/launchers/pom.xml
+++ b/launchers/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-caching-ehcache/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-caching-ehcache/pom.xml b/libraries/kiwi/kiwi-caching-ehcache/pom.xml
index d6c7cdf..8e0dbf2 100644
--- a/libraries/kiwi/kiwi-caching-ehcache/pom.xml
+++ b/libraries/kiwi/kiwi-caching-ehcache/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-caching-hazelcast/pom.xml b/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
index bdbda65..8b19a26 100644
--- a/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
+++ b/libraries/kiwi/kiwi-caching-hazelcast/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-caching-infinispan/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-caching-infinispan/pom.xml b/libraries/kiwi/kiwi-caching-infinispan/pom.xml
index bb7a7f4..833c4a9 100644
--- a/libraries/kiwi/kiwi-caching-infinispan/pom.xml
+++ b/libraries/kiwi/kiwi-caching-infinispan/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-loader/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-loader/pom.xml b/libraries/kiwi/kiwi-loader/pom.xml
index 7823e49..c0df08e 100644
--- a/libraries/kiwi/kiwi-loader/pom.xml
+++ b/libraries/kiwi/kiwi-loader/pom.xml
@@ -14,7 +14,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
</parent>
<artifactId>kiwi-loader</artifactId>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-reasoner/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-reasoner/pom.xml b/libraries/kiwi/kiwi-reasoner/pom.xml
index f2322ee..7432004 100644
--- a/libraries/kiwi/kiwi-reasoner/pom.xml
+++ b/libraries/kiwi/kiwi-reasoner/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-sparql/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-sparql/pom.xml b/libraries/kiwi/kiwi-sparql/pom.xml
index 3860d7a..782277c 100644
--- a/libraries/kiwi/kiwi-sparql/pom.xml
+++ b/libraries/kiwi/kiwi-sparql/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-triplestore/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-triplestore/pom.xml b/libraries/kiwi/kiwi-triplestore/pom.xml
index 77263ac..9c98c20 100644
--- a/libraries/kiwi/kiwi-triplestore/pom.xml
+++ b/libraries/kiwi/kiwi-triplestore/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/kiwi-versioning/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/kiwi-versioning/pom.xml b/libraries/kiwi/kiwi-versioning/pom.xml
index 3f73fa0..6ce814c 100644
--- a/libraries/kiwi/kiwi-versioning/pom.xml
+++ b/libraries/kiwi/kiwi-versioning/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>kiwi-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/kiwi/pom.xml b/libraries/kiwi/pom.xml
index 37b1e2c..a6a7a58 100644
--- a/libraries/kiwi/pom.xml
+++ b/libraries/kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-api/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-api/pom.xml b/libraries/ldcache/ldcache-api/pom.xml
index 63db71a..cf1634b 100644
--- a/libraries/ldcache/ldcache-api/pom.xml
+++ b/libraries/ldcache/ldcache-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-backend-file/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-backend-file/pom.xml b/libraries/ldcache/ldcache-backend-file/pom.xml
index 461ecfe..ba8b274 100644
--- a/libraries/ldcache/ldcache-backend-file/pom.xml
+++ b/libraries/ldcache/ldcache-backend-file/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-backend-infinispan/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-backend-infinispan/pom.xml b/libraries/ldcache/ldcache-backend-infinispan/pom.xml
index ad0cae2..41aaf9f 100644
--- a/libraries/ldcache/ldcache-backend-infinispan/pom.xml
+++ b/libraries/ldcache/ldcache-backend-infinispan/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-backend-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-backend-kiwi/pom.xml b/libraries/ldcache/ldcache-backend-kiwi/pom.xml
index 71c105d..b227eab 100644
--- a/libraries/ldcache/ldcache-backend-kiwi/pom.xml
+++ b/libraries/ldcache/ldcache-backend-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-core/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-core/pom.xml b/libraries/ldcache/ldcache-core/pom.xml
index e8ed25f..21997b9 100644
--- a/libraries/ldcache/ldcache-core/pom.xml
+++ b/libraries/ldcache/ldcache-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-sail-generic/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-sail-generic/pom.xml b/libraries/ldcache/ldcache-sail-generic/pom.xml
index d70a3f4..4a0e6f4 100644
--- a/libraries/ldcache/ldcache-sail-generic/pom.xml
+++ b/libraries/ldcache/ldcache-sail-generic/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/ldcache-sail-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/ldcache-sail-kiwi/pom.xml b/libraries/ldcache/ldcache-sail-kiwi/pom.xml
index 65c5adf..a844934 100644
--- a/libraries/ldcache/ldcache-sail-kiwi/pom.xml
+++ b/libraries/ldcache/ldcache-sail-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldcache/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldcache/pom.xml b/libraries/ldcache/pom.xml
index b5d13c0..2874143 100644
--- a/libraries/ldcache/pom.xml
+++ b/libraries/ldcache/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-api/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-api/pom.xml b/libraries/ldclient/ldclient-api/pom.xml
index fe9949d..1634c79 100644
--- a/libraries/ldclient/ldclient-api/pom.xml
+++ b/libraries/ldclient/ldclient-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-core/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-core/pom.xml b/libraries/ldclient/ldclient-core/pom.xml
index 2c353f1..d350020 100644
--- a/libraries/ldclient/ldclient-core/pom.xml
+++ b/libraries/ldclient/ldclient-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-facebook/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-facebook/pom.xml b/libraries/ldclient/ldclient-provider-facebook/pom.xml
index af07251..7ab6d44 100644
--- a/libraries/ldclient/ldclient-provider-facebook/pom.xml
+++ b/libraries/ldclient/ldclient-provider-facebook/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-html/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-html/pom.xml b/libraries/ldclient/ldclient-provider-html/pom.xml
index 7a92db8..3c7c6a3 100644
--- a/libraries/ldclient/ldclient-provider-html/pom.xml
+++ b/libraries/ldclient/ldclient-provider-html/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-ldap/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-ldap/pom.xml b/libraries/ldclient/ldclient-provider-ldap/pom.xml
index c30d427..5697646 100644
--- a/libraries/ldclient/ldclient-provider-ldap/pom.xml
+++ b/libraries/ldclient/ldclient-provider-ldap/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-mediawiki/pom.xml b/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
index 23b90c0..636c533 100644
--- a/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
+++ b/libraries/ldclient/ldclient-provider-mediawiki/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-phpbb/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-phpbb/pom.xml b/libraries/ldclient/ldclient-provider-phpbb/pom.xml
index 7db5a25..b73f601 100644
--- a/libraries/ldclient/ldclient-provider-phpbb/pom.xml
+++ b/libraries/ldclient/ldclient-provider-phpbb/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-rdf/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-rdf/pom.xml b/libraries/ldclient/ldclient-provider-rdf/pom.xml
index ba90ead..fbbd3be 100644
--- a/libraries/ldclient/ldclient-provider-rdf/pom.xml
+++ b/libraries/ldclient/ldclient-provider-rdf/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-rdfa/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-rdfa/pom.xml b/libraries/ldclient/ldclient-provider-rdfa/pom.xml
index 312f345..e3c4020 100644
--- a/libraries/ldclient/ldclient-provider-rdfa/pom.xml
+++ b/libraries/ldclient/ldclient-provider-rdfa/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-vimeo/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-vimeo/pom.xml b/libraries/ldclient/ldclient-provider-vimeo/pom.xml
index 5d2648e..dd6eb6b 100644
--- a/libraries/ldclient/ldclient-provider-vimeo/pom.xml
+++ b/libraries/ldclient/ldclient-provider-vimeo/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-xml/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-xml/pom.xml b/libraries/ldclient/ldclient-provider-xml/pom.xml
index 8de6ea3..1146025 100644
--- a/libraries/ldclient/ldclient-provider-xml/pom.xml
+++ b/libraries/ldclient/ldclient-provider-xml/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/ldclient-provider-youtube/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/ldclient-provider-youtube/pom.xml b/libraries/ldclient/ldclient-provider-youtube/pom.xml
index 01a5de8..d49b755 100644
--- a/libraries/ldclient/ldclient-provider-youtube/pom.xml
+++ b/libraries/ldclient/ldclient-provider-youtube/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldclient/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldclient/pom.xml b/libraries/ldclient/pom.xml
index 79f1c33..c66058b 100644
--- a/libraries/ldclient/pom.xml
+++ b/libraries/ldclient/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-api/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-api/pom.xml b/libraries/ldpath/ldpath-api/pom.xml
index 6e20f23..8bacad0 100644
--- a/libraries/ldpath/ldpath-api/pom.xml
+++ b/libraries/ldpath/ldpath-api/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-backend-file/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-file/pom.xml b/libraries/ldpath/ldpath-backend-file/pom.xml
index 69fa596..0584f0d 100644
--- a/libraries/ldpath/ldpath-backend-file/pom.xml
+++ b/libraries/ldpath/ldpath-backend-file/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-backend-jena/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-jena/pom.xml b/libraries/ldpath/ldpath-backend-jena/pom.xml
index ed0edd6..1b83d2f 100644
--- a/libraries/ldpath/ldpath-backend-jena/pom.xml
+++ b/libraries/ldpath/ldpath-backend-jena/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-linkeddata/pom.xml b/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
index 0a76197..fbb5388 100644
--- a/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
+++ b/libraries/ldpath/ldpath-backend-linkeddata/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-backend-sesame/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-backend-sesame/pom.xml b/libraries/ldpath/ldpath-backend-sesame/pom.xml
index 47b7312..4de5163 100644
--- a/libraries/ldpath/ldpath-backend-sesame/pom.xml
+++ b/libraries/ldpath/ldpath-backend-sesame/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-core-bundle/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-core-bundle/pom.xml b/libraries/ldpath/ldpath-core-bundle/pom.xml
index 03bbdca..0797860 100644
--- a/libraries/ldpath/ldpath-core-bundle/pom.xml
+++ b/libraries/ldpath/ldpath-core-bundle/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-core/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-core/pom.xml b/libraries/ldpath/ldpath-core/pom.xml
index 15c16a0..085d86c 100644
--- a/libraries/ldpath/ldpath-core/pom.xml
+++ b/libraries/ldpath/ldpath-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-collections/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-collections/pom.xml b/libraries/ldpath/ldpath-functions-collections/pom.xml
index cc2b348..3644308 100644
--- a/libraries/ldpath/ldpath-functions-collections/pom.xml
+++ b/libraries/ldpath/ldpath-functions-collections/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-date/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-date/pom.xml b/libraries/ldpath/ldpath-functions-date/pom.xml
index 097d59e..bdbd631 100644
--- a/libraries/ldpath/ldpath-functions-date/pom.xml
+++ b/libraries/ldpath/ldpath-functions-date/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-html/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-html/pom.xml b/libraries/ldpath/ldpath-functions-html/pom.xml
index 3b29cb2..d2c2de9 100644
--- a/libraries/ldpath/ldpath-functions-html/pom.xml
+++ b/libraries/ldpath/ldpath-functions-html/pom.xml
@@ -19,7 +19,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-json/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-json/pom.xml b/libraries/ldpath/ldpath-functions-json/pom.xml
index d3ef877..89569c6 100644
--- a/libraries/ldpath/ldpath-functions-json/pom.xml
+++ b/libraries/ldpath/ldpath-functions-json/pom.xml
@@ -19,7 +19,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-math/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-math/pom.xml b/libraries/ldpath/ldpath-functions-math/pom.xml
index a014708..b726355 100644
--- a/libraries/ldpath/ldpath-functions-math/pom.xml
+++ b/libraries/ldpath/ldpath-functions-math/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-text/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-text/pom.xml b/libraries/ldpath/ldpath-functions-text/pom.xml
index 3419d40..962035f 100644
--- a/libraries/ldpath/ldpath-functions-text/pom.xml
+++ b/libraries/ldpath/ldpath-functions-text/pom.xml
@@ -20,7 +20,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-functions-xml/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-functions-xml/pom.xml b/libraries/ldpath/ldpath-functions-xml/pom.xml
index a353ce9..859ab99 100644
--- a/libraries/ldpath/ldpath-functions-xml/pom.xml
+++ b/libraries/ldpath/ldpath-functions-xml/pom.xml
@@ -19,7 +19,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-ldquery-cli/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-ldquery-cli/pom.xml b/libraries/ldpath/ldpath-ldquery-cli/pom.xml
index f5f98fa..4237db3 100644
--- a/libraries/ldpath/ldpath-ldquery-cli/pom.xml
+++ b/libraries/ldpath/ldpath-ldquery-cli/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-template-linkeddata/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-template-linkeddata/pom.xml b/libraries/ldpath/ldpath-template-linkeddata/pom.xml
index 1bb9c13..29e3d42 100644
--- a/libraries/ldpath/ldpath-template-linkeddata/pom.xml
+++ b/libraries/ldpath/ldpath-template-linkeddata/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/ldpath-template/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/ldpath-template/pom.xml b/libraries/ldpath/ldpath-template/pom.xml
index 74cabaa..5ba307b 100644
--- a/libraries/ldpath/ldpath-template/pom.xml
+++ b/libraries/ldpath/ldpath-template/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/ldpath/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/ldpath/pom.xml b/libraries/ldpath/pom.xml
index c1fdae1..b2a4f48 100644
--- a/libraries/ldpath/pom.xml
+++ b/libraries/ldpath/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/libraries/pom.xml
----------------------------------------------------------------------
diff --git a/libraries/pom.xml b/libraries/pom.xml
index 7dbcf41..e130fe8 100644
--- a/libraries/pom.xml
+++ b/libraries/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/marmotta-loader-berkeley/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-berkeley/pom.xml b/loader/marmotta-loader-berkeley/pom.xml
index 9a40202..b684f49 100644
--- a/loader/marmotta-loader-berkeley/pom.xml
+++ b/loader/marmotta-loader-berkeley/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/marmotta-loader-core/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-core/pom.xml b/loader/marmotta-loader-core/pom.xml
index a2168d9..4a903a9 100644
--- a/loader/marmotta-loader-core/pom.xml
+++ b/loader/marmotta-loader-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/marmotta-loader-hbase/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-hbase/pom.xml b/loader/marmotta-loader-hbase/pom.xml
index 9bdc437..0a8b525 100644
--- a/loader/marmotta-loader-hbase/pom.xml
+++ b/loader/marmotta-loader-hbase/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/marmotta-loader-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-kiwi/pom.xml b/loader/marmotta-loader-kiwi/pom.xml
index 4d80693..f2bf1bc 100644
--- a/loader/marmotta-loader-kiwi/pom.xml
+++ b/loader/marmotta-loader-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/marmotta-loader-titan/pom.xml
----------------------------------------------------------------------
diff --git a/loader/marmotta-loader-titan/pom.xml b/loader/marmotta-loader-titan/pom.xml
index 6d4a7bc..dc60e45 100644
--- a/loader/marmotta-loader-titan/pom.xml
+++ b/loader/marmotta-loader-titan/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/loader/pom.xml
----------------------------------------------------------------------
diff --git a/loader/pom.xml b/loader/pom.xml
index 4771f28..78ebc16 100644
--- a/loader/pom.xml
+++ b/loader/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/parent/pom.xml
----------------------------------------------------------------------
diff --git a/parent/pom.xml b/parent/pom.xml
index 073455f..62dafff 100644
--- a/parent/pom.xml
+++ b/parent/pom.xml
@@ -29,7 +29,7 @@
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
<packaging>pom</packaging>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<name>Apache Marmotta Parent</name>
<description>Parent POM for the Apache Marmotta project</description>
@@ -1841,4 +1841,8 @@
</properties>
</profile>
</profiles>
+
+ <scm>
+ <tag>3.4.0</tag>
+ </scm>
</project>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/marmotta-backend-accumulograph/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-accumulograph/pom.xml b/platform/backends/marmotta-backend-accumulograph/pom.xml
index 40bb6c2..ede3aa9 100644
--- a/platform/backends/marmotta-backend-accumulograph/pom.xml
+++ b/platform/backends/marmotta-backend-accumulograph/pom.xml
@@ -16,13 +16,11 @@
~ limitations under the License.
-->
-<project xmlns="http://maven.apache.org/POM/4.0.0"
- xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
- xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/marmotta-backend-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-kiwi/pom.xml b/platform/backends/marmotta-backend-kiwi/pom.xml
index 2b64595..9a28ed6 100644
--- a/platform/backends/marmotta-backend-kiwi/pom.xml
+++ b/platform/backends/marmotta-backend-kiwi/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/marmotta-backend-memory/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-memory/pom.xml b/platform/backends/marmotta-backend-memory/pom.xml
index 516cb1d..c29b8c0 100644
--- a/platform/backends/marmotta-backend-memory/pom.xml
+++ b/platform/backends/marmotta-backend-memory/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/marmotta-backend-native/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-native/pom.xml b/platform/backends/marmotta-backend-native/pom.xml
index f4e49d4..7c4657c 100644
--- a/platform/backends/marmotta-backend-native/pom.xml
+++ b/platform/backends/marmotta-backend-native/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/marmotta-backend-titan/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/marmotta-backend-titan/pom.xml b/platform/backends/marmotta-backend-titan/pom.xml
index ea2d48f..e726410 100644
--- a/platform/backends/marmotta-backend-titan/pom.xml
+++ b/platform/backends/marmotta-backend-titan/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent/pom.xml</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/backends/pom.xml
----------------------------------------------------------------------
diff --git a/platform/backends/pom.xml b/platform/backends/pom.xml
index ecc5375..519bf64 100644
--- a/platform/backends/pom.xml
+++ b/platform/backends/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/ldcache/marmotta-ldcache-common/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/marmotta-ldcache-common/pom.xml b/platform/ldcache/marmotta-ldcache-common/pom.xml
index 2f6763f..784db15 100644
--- a/platform/ldcache/marmotta-ldcache-common/pom.xml
+++ b/platform/ldcache/marmotta-ldcache-common/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/ldcache/marmotta-ldcache-file/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/marmotta-ldcache-file/pom.xml b/platform/ldcache/marmotta-ldcache-file/pom.xml
index 5373af4..48b185b 100644
--- a/platform/ldcache/marmotta-ldcache-file/pom.xml
+++ b/platform/ldcache/marmotta-ldcache-file/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/marmotta-ldcache-kiwi/pom.xml b/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
index 5d6b079..c6bf7b2 100644
--- a/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
+++ b/platform/ldcache/marmotta-ldcache-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/ldcache/pom.xml
----------------------------------------------------------------------
diff --git a/platform/ldcache/pom.xml b/platform/ldcache/pom.xml
index 5a0327b..484097a 100644
--- a/platform/ldcache/pom.xml
+++ b/platform/ldcache/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-core/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-core/pom.xml b/platform/marmotta-core/pom.xml
index 671a51a..6e85133 100644
--- a/platform/marmotta-core/pom.xml
+++ b/platform/marmotta-core/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-ldp/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-ldp/pom.xml b/platform/marmotta-ldp/pom.xml
index d2053de..c0ed328 100644
--- a/platform/marmotta-ldp/pom.xml
+++ b/platform/marmotta-ldp/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-ldpath/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-ldpath/pom.xml b/platform/marmotta-ldpath/pom.xml
index 4260c6e..9d5c986 100644
--- a/platform/marmotta-ldpath/pom.xml
+++ b/platform/marmotta-ldpath/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-reasoner-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-reasoner-kiwi/pom.xml b/platform/marmotta-reasoner-kiwi/pom.xml
index 84d54c0..c253b67 100644
--- a/platform/marmotta-reasoner-kiwi/pom.xml
+++ b/platform/marmotta-reasoner-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-security/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-security/pom.xml b/platform/marmotta-security/pom.xml
index 4993a73..845721e 100644
--- a/platform/marmotta-security/pom.xml
+++ b/platform/marmotta-security/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-sparql/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-sparql/pom.xml b/platform/marmotta-sparql/pom.xml
index 732c47d..1123ab8 100644
--- a/platform/marmotta-sparql/pom.xml
+++ b/platform/marmotta-sparql/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-user/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-user/pom.xml b/platform/marmotta-user/pom.xml
index 573cd61..4ee022f 100644
--- a/platform/marmotta-user/pom.xml
+++ b/platform/marmotta-user/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-versioning-common/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-versioning-common/pom.xml b/platform/marmotta-versioning-common/pom.xml
index 51ff785..6da4aa0 100644
--- a/platform/marmotta-versioning-common/pom.xml
+++ b/platform/marmotta-versioning-common/pom.xml
@@ -22,7 +22,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-versioning-kiwi/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-versioning-kiwi/pom.xml b/platform/marmotta-versioning-kiwi/pom.xml
index f49926d..f979e58 100644
--- a/platform/marmotta-versioning-kiwi/pom.xml
+++ b/platform/marmotta-versioning-kiwi/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/marmotta-zookeeper/pom.xml
----------------------------------------------------------------------
diff --git a/platform/marmotta-zookeeper/pom.xml b/platform/marmotta-zookeeper/pom.xml
index f02374e..53513f7 100644
--- a/platform/marmotta-zookeeper/pom.xml
+++ b/platform/marmotta-zookeeper/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/platform/pom.xml
----------------------------------------------------------------------
diff --git a/platform/pom.xml b/platform/pom.xml
index 6d9d9ea..2adc9b6 100644
--- a/platform/pom.xml
+++ b/platform/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>../parent</relativePath>
</parent>
http://git-wip-us.apache.org/repos/asf/marmotta/blob/b0e5b937/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 360fdf5..089c6eb 100644
--- a/pom.xml
+++ b/pom.xml
@@ -21,7 +21,7 @@
<parent>
<groupId>org.apache.marmotta</groupId>
<artifactId>marmotta-parent</artifactId>
- <version>3.4.0-SNAPSHOT</version>
+ <version>3.4.0</version>
<relativePath>parent</relativePath>
</parent>
@@ -145,7 +145,7 @@
<url>https://git-wip-us.apache.org/repos/asf/marmotta.git</url>
<connection>scm:git:https://git-wip-us.apache.org/repos/asf/marmotta.git</connection>
<developerConnection>scm:git:https://git-wip-us.apache.org/repos/asf/marmotta.git</developerConnection>
- <tag>HEAD</tag>
+ <tag>3.4.0</tag>
</scm>
<issueManagement>
[09/62] [abbrv] [partial] marmotta git commit: * Replace gtest with
upstream version,
including LICENSE header. * Include absl library for faster and safer string
operations. * Update license headers where needed. * Removed custom code
replaced by absl.
Posted by ja...@apache.org.
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/zone1970.tab
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/zone1970.tab b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/zone1970.tab
new file mode 100644
index 0000000..2d90ed7
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/cctz/testdata/zoneinfo/zone1970.tab
@@ -0,0 +1,382 @@
+# tz zone descriptions
+#
+# This file is in the public domain.
+#
+# From Paul Eggert (2017-10-01):
+# This file contains a table where each row stands for a zone where
+# civil time stamps have agreed since 1970. Columns are separated by
+# a single tab. Lines beginning with '#' are comments. All text uses
+# UTF-8 encoding. The columns of the table are as follows:
+#
+# 1. The countries that overlap the zone, as a comma-separated list
+# of ISO 3166 2-character country codes. See the file 'iso3166.tab'.
+# 2. Latitude and longitude of the zone's principal location
+# in ISO 6709 sign-degrees-minutes-seconds format,
+# either ±DDMM±DDDMM or ±DDMMSS±DDDMMSS,
+# first latitude (+ is north), then longitude (+ is east).
+# 3. Zone name used in value of TZ environment variable.
+# Please see the theory.html file for how zone names are chosen.
+# If multiple zones overlap a country, each has a row in the
+# table, with each column 1 containing the country code.
+# 4. Comments; present if and only if a country has multiple zones.
+#
+# If a zone covers multiple countries, the most-populous city is used,
+# and that country is listed first in column 1; any other countries
+# are listed alphabetically by country code. The table is sorted
+# first by country code, then (if possible) by an order within the
+# country that (1) makes some geographical sense, and (2) puts the
+# most populous zones first, where that does not contradict (1).
+#
+# This table is intended as an aid for users, to help them select time
+# zone data entries appropriate for their practical needs. It is not
+# intended to take or endorse any position on legal or territorial claims.
+#
+#country-
+#codes coordinates TZ comments
+AD +4230+00131 Europe/Andorra
+AE,OM +2518+05518 Asia/Dubai
+AF +3431+06912 Asia/Kabul
+AL +4120+01950 Europe/Tirane
+AM +4011+04430 Asia/Yerevan
+AQ -6617+11031 Antarctica/Casey Casey
+AQ -6835+07758 Antarctica/Davis Davis
+AQ -6640+14001 Antarctica/DumontDUrville Dumont-d'Urville
+AQ -6736+06253 Antarctica/Mawson Mawson
+AQ -6448-06406 Antarctica/Palmer Palmer
+AQ -6734-06808 Antarctica/Rothera Rothera
+AQ -690022+0393524 Antarctica/Syowa Syowa
+AQ -720041+0023206 Antarctica/Troll Troll
+AQ -7824+10654 Antarctica/Vostok Vostok
+AR -3436-05827 America/Argentina/Buenos_Aires Buenos Aires (BA, CF)
+AR -3124-06411 America/Argentina/Cordoba Argentina (most areas: CB, CC, CN, ER, FM, MN, SE, SF)
+AR -2447-06525 America/Argentina/Salta Salta (SA, LP, NQ, RN)
+AR -2411-06518 America/Argentina/Jujuy Jujuy (JY)
+AR -2649-06513 America/Argentina/Tucuman Tucumán (TM)
+AR -2828-06547 America/Argentina/Catamarca Catamarca (CT); Chubut (CH)
+AR -2926-06651 America/Argentina/La_Rioja La Rioja (LR)
+AR -3132-06831 America/Argentina/San_Juan San Juan (SJ)
+AR -3253-06849 America/Argentina/Mendoza Mendoza (MZ)
+AR -3319-06621 America/Argentina/San_Luis San Luis (SL)
+AR -5138-06913 America/Argentina/Rio_Gallegos Santa Cruz (SC)
+AR -5448-06818 America/Argentina/Ushuaia Tierra del Fuego (TF)
+AS,UM -1416-17042 Pacific/Pago_Pago Samoa, Midway
+AT +4813+01620 Europe/Vienna
+AU -3133+15905 Australia/Lord_Howe Lord Howe Island
+AU -5430+15857 Antarctica/Macquarie Macquarie Island
+AU -4253+14719 Australia/Hobart Tasmania (most areas)
+AU -3956+14352 Australia/Currie Tasmania (King Island)
+AU -3749+14458 Australia/Melbourne Victoria
+AU -3352+15113 Australia/Sydney New South Wales (most areas)
+AU -3157+14127 Australia/Broken_Hill New South Wales (Yancowinna)
+AU -2728+15302 Australia/Brisbane Queensland (most areas)
+AU -2016+14900 Australia/Lindeman Queensland (Whitsunday Islands)
+AU -3455+13835 Australia/Adelaide South Australia
+AU -1228+13050 Australia/Darwin Northern Territory
+AU -3157+11551 Australia/Perth Western Australia (most areas)
+AU -3143+12852 Australia/Eucla Western Australia (Eucla)
+AZ +4023+04951 Asia/Baku
+BB +1306-05937 America/Barbados
+BD +2343+09025 Asia/Dhaka
+BE +5050+00420 Europe/Brussels
+BG +4241+02319 Europe/Sofia
+BM +3217-06446 Atlantic/Bermuda
+BN +0456+11455 Asia/Brunei
+BO -1630-06809 America/La_Paz
+BR -0351-03225 America/Noronha Atlantic islands
+BR -0127-04829 America/Belem Pará (east); Amapá
+BR -0343-03830 America/Fortaleza Brazil (northeast: MA, PI, CE, RN, PB)
+BR -0803-03454 America/Recife Pernambuco
+BR -0712-04812 America/Araguaina Tocantins
+BR -0940-03543 America/Maceio Alagoas, Sergipe
+BR -1259-03831 America/Bahia Bahia
+BR -2332-04637 America/Sao_Paulo Brazil (southeast: GO, DF, MG, ES, RJ, SP, PR, SC, RS)
+BR -2027-05437 America/Campo_Grande Mato Grosso do Sul
+BR -1535-05605 America/Cuiaba Mato Grosso
+BR -0226-05452 America/Santarem Pará (west)
+BR -0846-06354 America/Porto_Velho Rondônia
+BR +0249-06040 America/Boa_Vista Roraima
+BR -0308-06001 America/Manaus Amazonas (east)
+BR -0640-06952 America/Eirunepe Amazonas (west)
+BR -0958-06748 America/Rio_Branco Acre
+BS +2505-07721 America/Nassau
+BT +2728+08939 Asia/Thimphu
+BY +5354+02734 Europe/Minsk
+BZ +1730-08812 America/Belize
+CA +4734-05243 America/St_Johns Newfoundland; Labrador (southeast)
+CA +4439-06336 America/Halifax Atlantic - NS (most areas); PE
+CA +4612-05957 America/Glace_Bay Atlantic - NS (Cape Breton)
+CA +4606-06447 America/Moncton Atlantic - New Brunswick
+CA +5320-06025 America/Goose_Bay Atlantic - Labrador (most areas)
+CA +5125-05707 America/Blanc-Sablon AST - QC (Lower North Shore)
+CA +4339-07923 America/Toronto Eastern - ON, QC (most areas)
+CA +4901-08816 America/Nipigon Eastern - ON, QC (no DST 1967-73)
+CA +4823-08915 America/Thunder_Bay Eastern - ON (Thunder Bay)
+CA +6344-06828 America/Iqaluit Eastern - NU (most east areas)
+CA +6608-06544 America/Pangnirtung Eastern - NU (Pangnirtung)
+CA +484531-0913718 America/Atikokan EST - ON (Atikokan); NU (Coral H)
+CA +4953-09709 America/Winnipeg Central - ON (west); Manitoba
+CA +4843-09434 America/Rainy_River Central - ON (Rainy R, Ft Frances)
+CA +744144-0944945 America/Resolute Central - NU (Resolute)
+CA +624900-0920459 America/Rankin_Inlet Central - NU (central)
+CA +5024-10439 America/Regina CST - SK (most areas)
+CA +5017-10750 America/Swift_Current CST - SK (midwest)
+CA +5333-11328 America/Edmonton Mountain - AB; BC (E); SK (W)
+CA +690650-1050310 America/Cambridge_Bay Mountain - NU (west)
+CA +6227-11421 America/Yellowknife Mountain - NT (central)
+CA +682059-1334300 America/Inuvik Mountain - NT (west)
+CA +4906-11631 America/Creston MST - BC (Creston)
+CA +5946-12014 America/Dawson_Creek MST - BC (Dawson Cr, Ft St John)
+CA +5848-12242 America/Fort_Nelson MST - BC (Ft Nelson)
+CA +4916-12307 America/Vancouver Pacific - BC (most areas)
+CA +6043-13503 America/Whitehorse Pacific - Yukon (south)
+CA +6404-13925 America/Dawson Pacific - Yukon (north)
+CC -1210+09655 Indian/Cocos
+CH,DE,LI +4723+00832 Europe/Zurich Swiss time
+CI,BF,GM,GN,ML,MR,SH,SL,SN,TG +0519-00402 Africa/Abidjan
+CK -2114-15946 Pacific/Rarotonga
+CL -3327-07040 America/Santiago Chile (most areas)
+CL -5309-07055 America/Punta_Arenas Region of Magallanes
+CL -2709-10926 Pacific/Easter Easter Island
+CN +3114+12128 Asia/Shanghai Beijing Time
+CN +4348+08735 Asia/Urumqi Xinjiang Time
+CO +0436-07405 America/Bogota
+CR +0956-08405 America/Costa_Rica
+CU +2308-08222 America/Havana
+CV +1455-02331 Atlantic/Cape_Verde
+CW,AW,BQ,SX +1211-06900 America/Curacao
+CX -1025+10543 Indian/Christmas
+CY +3510+03322 Asia/Nicosia Cyprus (most areas)
+CY +3507+03357 Asia/Famagusta Northern Cyprus
+CZ,SK +5005+01426 Europe/Prague
+DE +5230+01322 Europe/Berlin Germany (most areas)
+DK +5540+01235 Europe/Copenhagen
+DO +1828-06954 America/Santo_Domingo
+DZ +3647+00303 Africa/Algiers
+EC -0210-07950 America/Guayaquil Ecuador (mainland)
+EC -0054-08936 Pacific/Galapagos Galápagos Islands
+EE +5925+02445 Europe/Tallinn
+EG +3003+03115 Africa/Cairo
+EH +2709-01312 Africa/El_Aaiun
+ES +4024-00341 Europe/Madrid Spain (mainland)
+ES +3553-00519 Africa/Ceuta Ceuta, Melilla
+ES +2806-01524 Atlantic/Canary Canary Islands
+FI,AX +6010+02458 Europe/Helsinki
+FJ -1808+17825 Pacific/Fiji
+FK -5142-05751 Atlantic/Stanley
+FM +0725+15147 Pacific/Chuuk Chuuk/Truk, Yap
+FM +0658+15813 Pacific/Pohnpei Pohnpei/Ponape
+FM +0519+16259 Pacific/Kosrae Kosrae
+FO +6201-00646 Atlantic/Faroe
+FR +4852+00220 Europe/Paris
+GB,GG,IM,JE +513030-0000731 Europe/London
+GE +4143+04449 Asia/Tbilisi
+GF +0456-05220 America/Cayenne
+GH +0533-00013 Africa/Accra
+GI +3608-00521 Europe/Gibraltar
+GL +6411-05144 America/Godthab Greenland (most areas)
+GL +7646-01840 America/Danmarkshavn National Park (east coast)
+GL +7029-02158 America/Scoresbysund Scoresbysund/Ittoqqortoormiit
+GL +7634-06847 America/Thule Thule/Pituffik
+GR +3758+02343 Europe/Athens
+GS -5416-03632 Atlantic/South_Georgia
+GT +1438-09031 America/Guatemala
+GU,MP +1328+14445 Pacific/Guam
+GW +1151-01535 Africa/Bissau
+GY +0648-05810 America/Guyana
+HK +2217+11409 Asia/Hong_Kong
+HN +1406-08713 America/Tegucigalpa
+HT +1832-07220 America/Port-au-Prince
+HU +4730+01905 Europe/Budapest
+ID -0610+10648 Asia/Jakarta Java, Sumatra
+ID -0002+10920 Asia/Pontianak Borneo (west, central)
+ID -0507+11924 Asia/Makassar Borneo (east, south); Sulawesi/Celebes, Bali, Nusa Tengarra; Timor (west)
+ID -0232+14042 Asia/Jayapura New Guinea (West Papua / Irian Jaya); Malukus/Moluccas
+IE +5320-00615 Europe/Dublin
+IL +314650+0351326 Asia/Jerusalem
+IN +2232+08822 Asia/Kolkata
+IO -0720+07225 Indian/Chagos
+IQ +3321+04425 Asia/Baghdad
+IR +3540+05126 Asia/Tehran
+IS +6409-02151 Atlantic/Reykjavik
+IT,SM,VA +4154+01229 Europe/Rome
+JM +175805-0764736 America/Jamaica
+JO +3157+03556 Asia/Amman
+JP +353916+1394441 Asia/Tokyo
+KE,DJ,ER,ET,KM,MG,SO,TZ,UG,YT -0117+03649 Africa/Nairobi
+KG +4254+07436 Asia/Bishkek
+KI +0125+17300 Pacific/Tarawa Gilbert Islands
+KI -0308-17105 Pacific/Enderbury Phoenix Islands
+KI +0152-15720 Pacific/Kiritimati Line Islands
+KP +3901+12545 Asia/Pyongyang
+KR +3733+12658 Asia/Seoul
+KZ +4315+07657 Asia/Almaty Kazakhstan (most areas)
+KZ +4448+06528 Asia/Qyzylorda Qyzylorda/Kyzylorda/Kzyl-Orda
+KZ +5017+05710 Asia/Aqtobe Aqtöbe/Aktobe
+KZ +4431+05016 Asia/Aqtau Mangghystaū/Mankistau
+KZ +4707+05156 Asia/Atyrau Atyraū/Atirau/Gur'yev
+KZ +5113+05121 Asia/Oral West Kazakhstan
+LB +3353+03530 Asia/Beirut
+LK +0656+07951 Asia/Colombo
+LR +0618-01047 Africa/Monrovia
+LT +5441+02519 Europe/Vilnius
+LU +4936+00609 Europe/Luxembourg
+LV +5657+02406 Europe/Riga
+LY +3254+01311 Africa/Tripoli
+MA +3339-00735 Africa/Casablanca
+MC +4342+00723 Europe/Monaco
+MD +4700+02850 Europe/Chisinau
+MH +0709+17112 Pacific/Majuro Marshall Islands (most areas)
+MH +0905+16720 Pacific/Kwajalein Kwajalein
+MM +1647+09610 Asia/Yangon
+MN +4755+10653 Asia/Ulaanbaatar Mongolia (most areas)
+MN +4801+09139 Asia/Hovd Bayan-Ölgii, Govi-Altai, Hovd, Uvs, Zavkhan
+MN +4804+11430 Asia/Choibalsan Dornod, Sükhbaatar
+MO +2214+11335 Asia/Macau
+MQ +1436-06105 America/Martinique
+MT +3554+01431 Europe/Malta
+MU -2010+05730 Indian/Mauritius
+MV +0410+07330 Indian/Maldives
+MX +1924-09909 America/Mexico_City Central Time
+MX +2105-08646 America/Cancun Eastern Standard Time - Quintana Roo
+MX +2058-08937 America/Merida Central Time - Campeche, Yucatán
+MX +2540-10019 America/Monterrey Central Time - Durango; Coahuila, Nuevo León, Tamaulipas (most areas)
+MX +2550-09730 America/Matamoros Central Time US - Coahuila, Nuevo León, Tamaulipas (US border)
+MX +2313-10625 America/Mazatlan Mountain Time - Baja California Sur, Nayarit, Sinaloa
+MX +2838-10605 America/Chihuahua Mountain Time - Chihuahua (most areas)
+MX +2934-10425 America/Ojinaga Mountain Time US - Chihuahua (US border)
+MX +2904-11058 America/Hermosillo Mountain Standard Time - Sonora
+MX +3232-11701 America/Tijuana Pacific Time US - Baja California
+MX +2048-10515 America/Bahia_Banderas Central Time - Bahía de Banderas
+MY +0310+10142 Asia/Kuala_Lumpur Malaysia (peninsula)
+MY +0133+11020 Asia/Kuching Sabah, Sarawak
+MZ,BI,BW,CD,MW,RW,ZM,ZW -2558+03235 Africa/Maputo Central Africa Time
+NA -2234+01706 Africa/Windhoek
+NC -2216+16627 Pacific/Noumea
+NF -2903+16758 Pacific/Norfolk
+NG,AO,BJ,CD,CF,CG,CM,GA,GQ,NE +0627+00324 Africa/Lagos West Africa Time
+NI +1209-08617 America/Managua
+NL +5222+00454 Europe/Amsterdam
+NO,SJ +5955+01045 Europe/Oslo
+NP +2743+08519 Asia/Kathmandu
+NR -0031+16655 Pacific/Nauru
+NU -1901-16955 Pacific/Niue
+NZ,AQ -3652+17446 Pacific/Auckland New Zealand time
+NZ -4357-17633 Pacific/Chatham Chatham Islands
+PA,KY +0858-07932 America/Panama
+PE -1203-07703 America/Lima
+PF -1732-14934 Pacific/Tahiti Society Islands
+PF -0900-13930 Pacific/Marquesas Marquesas Islands
+PF -2308-13457 Pacific/Gambier Gambier Islands
+PG -0930+14710 Pacific/Port_Moresby Papua New Guinea (most areas)
+PG -0613+15534 Pacific/Bougainville Bougainville
+PH +1435+12100 Asia/Manila
+PK +2452+06703 Asia/Karachi
+PL +5215+02100 Europe/Warsaw
+PM +4703-05620 America/Miquelon
+PN -2504-13005 Pacific/Pitcairn
+PR +182806-0660622 America/Puerto_Rico
+PS +3130+03428 Asia/Gaza Gaza Strip
+PS +313200+0350542 Asia/Hebron West Bank
+PT +3843-00908 Europe/Lisbon Portugal (mainland)
+PT +3238-01654 Atlantic/Madeira Madeira Islands
+PT +3744-02540 Atlantic/Azores Azores
+PW +0720+13429 Pacific/Palau
+PY -2516-05740 America/Asuncion
+QA,BH +2517+05132 Asia/Qatar
+RE,TF -2052+05528 Indian/Reunion Réunion, Crozet, Scattered Islands
+RO +4426+02606 Europe/Bucharest
+RS,BA,HR,ME,MK,SI +4450+02030 Europe/Belgrade
+RU +5443+02030 Europe/Kaliningrad MSK-01 - Kaliningrad
+RU +554521+0373704 Europe/Moscow MSK+00 - Moscow area
+RU +4457+03406 Europe/Simferopol MSK+00 - Crimea
+RU +4844+04425 Europe/Volgograd MSK+00 - Volgograd
+RU +5836+04939 Europe/Kirov MSK+00 - Kirov
+RU +4621+04803 Europe/Astrakhan MSK+01 - Astrakhan
+RU +5134+04602 Europe/Saratov MSK+01 - Saratov
+RU +5420+04824 Europe/Ulyanovsk MSK+01 - Ulyanovsk
+RU +5312+05009 Europe/Samara MSK+01 - Samara, Udmurtia
+RU +5651+06036 Asia/Yekaterinburg MSK+02 - Urals
+RU +5500+07324 Asia/Omsk MSK+03 - Omsk
+RU +5502+08255 Asia/Novosibirsk MSK+04 - Novosibirsk
+RU +5322+08345 Asia/Barnaul MSK+04 - Altai
+RU +5630+08458 Asia/Tomsk MSK+04 - Tomsk
+RU +5345+08707 Asia/Novokuznetsk MSK+04 - Kemerovo
+RU +5601+09250 Asia/Krasnoyarsk MSK+04 - Krasnoyarsk area
+RU +5216+10420 Asia/Irkutsk MSK+05 - Irkutsk, Buryatia
+RU +5203+11328 Asia/Chita MSK+06 - Zabaykalsky
+RU +6200+12940 Asia/Yakutsk MSK+06 - Lena River
+RU +623923+1353314 Asia/Khandyga MSK+06 - Tomponsky, Ust-Maysky
+RU +4310+13156 Asia/Vladivostok MSK+07 - Amur River
+RU +643337+1431336 Asia/Ust-Nera MSK+07 - Oymyakonsky
+RU +5934+15048 Asia/Magadan MSK+08 - Magadan
+RU +4658+14242 Asia/Sakhalin MSK+08 - Sakhalin Island
+RU +6728+15343 Asia/Srednekolymsk MSK+08 - Sakha (E); North Kuril Is
+RU +5301+15839 Asia/Kamchatka MSK+09 - Kamchatka
+RU +6445+17729 Asia/Anadyr MSK+09 - Bering Sea
+SA,KW,YE +2438+04643 Asia/Riyadh
+SB -0932+16012 Pacific/Guadalcanal
+SC -0440+05528 Indian/Mahe
+SD +1536+03232 Africa/Khartoum
+SE +5920+01803 Europe/Stockholm
+SG +0117+10351 Asia/Singapore
+SR +0550-05510 America/Paramaribo
+SS +0451+03137 Africa/Juba
+ST +0020+00644 Africa/Sao_Tome
+SV +1342-08912 America/El_Salvador
+SY +3330+03618 Asia/Damascus
+TC +2128-07108 America/Grand_Turk
+TD +1207+01503 Africa/Ndjamena
+TF -492110+0701303 Indian/Kerguelen Kerguelen, St Paul Island, Amsterdam Island
+TH,KH,LA,VN +1345+10031 Asia/Bangkok Indochina (most areas)
+TJ +3835+06848 Asia/Dushanbe
+TK -0922-17114 Pacific/Fakaofo
+TL -0833+12535 Asia/Dili
+TM +3757+05823 Asia/Ashgabat
+TN +3648+01011 Africa/Tunis
+TO -2110-17510 Pacific/Tongatapu
+TR +4101+02858 Europe/Istanbul
+TT,AG,AI,BL,DM,GD,GP,KN,LC,MF,MS,VC,VG,VI +1039-06131 America/Port_of_Spain
+TV -0831+17913 Pacific/Funafuti
+TW +2503+12130 Asia/Taipei
+UA +5026+03031 Europe/Kiev Ukraine (most areas)
+UA +4837+02218 Europe/Uzhgorod Ruthenia
+UA +4750+03510 Europe/Zaporozhye Zaporozh'ye/Zaporizhia; Lugansk/Luhansk (east)
+UM +1917+16637 Pacific/Wake Wake Island
+US +404251-0740023 America/New_York Eastern (most areas)
+US +421953-0830245 America/Detroit Eastern - MI (most areas)
+US +381515-0854534 America/Kentucky/Louisville Eastern - KY (Louisville area)
+US +364947-0845057 America/Kentucky/Monticello Eastern - KY (Wayne)
+US +394606-0860929 America/Indiana/Indianapolis Eastern - IN (most areas)
+US +384038-0873143 America/Indiana/Vincennes Eastern - IN (Da, Du, K, Mn)
+US +410305-0863611 America/Indiana/Winamac Eastern - IN (Pulaski)
+US +382232-0862041 America/Indiana/Marengo Eastern - IN (Crawford)
+US +382931-0871643 America/Indiana/Petersburg Eastern - IN (Pike)
+US +384452-0850402 America/Indiana/Vevay Eastern - IN (Switzerland)
+US +415100-0873900 America/Chicago Central (most areas)
+US +375711-0864541 America/Indiana/Tell_City Central - IN (Perry)
+US +411745-0863730 America/Indiana/Knox Central - IN (Starke)
+US +450628-0873651 America/Menominee Central - MI (Wisconsin border)
+US +470659-1011757 America/North_Dakota/Center Central - ND (Oliver)
+US +465042-1012439 America/North_Dakota/New_Salem Central - ND (Morton rural)
+US +471551-1014640 America/North_Dakota/Beulah Central - ND (Mercer)
+US +394421-1045903 America/Denver Mountain (most areas)
+US +433649-1161209 America/Boise Mountain - ID (south); OR (east)
+US +332654-1120424 America/Phoenix MST - Arizona (except Navajo)
+US +340308-1181434 America/Los_Angeles Pacific
+US +611305-1495401 America/Anchorage Alaska (most areas)
+US +581807-1342511 America/Juneau Alaska - Juneau area
+US +571035-1351807 America/Sitka Alaska - Sitka area
+US +550737-1313435 America/Metlakatla Alaska - Annette Island
+US +593249-1394338 America/Yakutat Alaska - Yakutat
+US +643004-1652423 America/Nome Alaska (west)
+US +515248-1763929 America/Adak Aleutian Islands
+US,UM +211825-1575130 Pacific/Honolulu Hawaii
+UY -345433-0561245 America/Montevideo
+UZ +3940+06648 Asia/Samarkand Uzbekistan (west)
+UZ +4120+06918 Asia/Tashkent Uzbekistan (east)
+VE +1030-06656 America/Caracas
+VN +1045+10640 Asia/Ho_Chi_Minh Vietnam (south)
+VU -1740+16825 Pacific/Efate
+WF -1318-17610 Pacific/Wallis
+WS -1350-17144 Pacific/Apia
+ZA,LS,SZ -2615+02800 Africa/Johannesburg
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_ios.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_ios.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_ios.inc
new file mode 100644
index 0000000..f3db32b
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_ios.inc
@@ -0,0 +1,80 @@
+#include "absl/time/clock.h"
+
+#include <sys/time.h>
+#include <ctime>
+#include <cstdint>
+
+#include "absl/base/internal/raw_logging.h"
+
+// These are not defined in the Xcode 7.3.1 SDK Headers.
+// Once we are no longer supporting Xcode 7.3.1 we can
+// remove these.
+#ifndef __WATCHOS_3_0
+#define __WATCHOS_3_0 30000
+#endif
+
+#ifndef __TVOS_10_0
+#define __TVOS_10_0 100000
+#endif
+
+#ifndef __IPHONE_10_0
+#define __IPHONE_10_0 100000
+#endif
+
+#ifndef __MAC_10_12
+#define __MAC_10_12 101200
+#endif
+
+namespace absl {
+namespace time_internal {
+
+static int64_t GetCurrentTimeNanosFromSystem() {
+#if (__MAC_OS_X_VERSION_MAX_ALLOWED >= __MAC_10_12) || \
+ (__IPHONE_OS_VERSION_MAX_ALLOWED >= __IPHONE_10_0) || \
+ (__WATCH_OS_VERSION_MAX_ALLOWED >= __WATCHOS_3_0) || \
+ (__TV_OS_VERSION_MAX_ALLOWED >= __TVOS_10_0)
+ // clock_gettime_nsec_np is not defined on SDKs before Xcode 8.0.
+ // This preprocessor logic is based upon __CLOCK_AVAILABILITY in
+ // usr/include/time.h. Once we are no longer supporting Xcode 7.3.1 we can
+ // remove this #if.
+ // We must continue to check if it is defined until we are sure that ALL the
+ // platforms we are shipping on support it.
+ // clock_gettime_nsec_np is preferred because it may give higher accuracy than
+ // gettimeofday in future Apple operating systems.
+ // Currently (macOS 10.12/iOS 10.2) clock_gettime_nsec_np accuracy is
+ // microsecond accuracy (i.e. equivalent to gettimeofday).
+ if (&clock_gettime_nsec_np != nullptr) {
+ return clock_gettime_nsec_np(CLOCK_REALTIME);
+ }
+#endif
+#if (defined(__MAC_OS_X_VERSION_MIN_REQUIRED) && \
+ (__MAC_OS_X_VERSION_MIN_REQUIRED < __MAC_10_12)) || \
+ (defined(__IPHONE_OS_VERSION_MIN_REQUIRED) && \
+ (__IPHONE_OS_VERSION_MIN_REQUIRED < __IPHONE_10_0)) || \
+ (defined(__WATCH_OS_VERSION_MIN_REQUIRED) && \
+ (__WATCH_OS_VERSION_MIN_REQUIRED < __WATCHOS_3_0)) || \
+ (defined(__TV_OS_VERSION_MIN_REQUIRED) && \
+ (__TV_OS_VERSION_MIN_REQUIRED < __TVOS_10_0))
+ // We need this block in 2 different cases:
+ // a) where we are compiling with Xcode 7 in which case the block above
+ // will not be compiled in, and this is the only block executed.
+ // b) where we are compiling with Xcode 8+ but supporting operating systems
+ // that do not define clock_gettime_nsec_np, so this is in effect
+ // an else block to the block above.
+ // This block will not be compiled if the min supported version is
+ // guaranteed to supply clock_gettime_nsec_np.
+ //
+ // Once we know that clock_gettime_nsec_np is in the SDK *AND* exists on
+ // all the platforms we support, we can remove both this block and alter the
+ // block above to just call clock_gettime_nsec_np directly.
+ const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
+ const int64_t kNanosPerMicrosecond = 1000;
+ struct timeval tp;
+ ABSL_RAW_CHECK(gettimeofday(&tp, nullptr) == 0, "Failed gettimeofday");
+ return (int64_t{tp.tv_sec} * kNanosPerSecond +
+ int64_t{tp.tv_usec} * kNanosPerMicrosecond);
+#endif
+}
+
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_posix.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_posix.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_posix.inc
new file mode 100644
index 0000000..65474ca
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_posix.inc
@@ -0,0 +1,22 @@
+#include "absl/time/clock.h"
+
+#include <sys/time.h>
+#include <ctime>
+#include <cstdint>
+
+#include "absl/base/internal/raw_logging.h"
+
+namespace absl {
+namespace time_internal {
+
+static int64_t GetCurrentTimeNanosFromSystem() {
+ const int64_t kNanosPerSecond = 1000 * 1000 * 1000;
+ struct timespec ts;
+ ABSL_RAW_CHECK(clock_gettime(CLOCK_REALTIME, &ts) == 0,
+ "Failed to read real-time clock.");
+ return (int64_t{ts.tv_sec} * kNanosPerSecond +
+ int64_t{ts.tv_nsec});
+}
+
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_windows.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_windows.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_windows.inc
new file mode 100644
index 0000000..b22a9c9
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/get_current_time_windows.inc
@@ -0,0 +1,17 @@
+#include "absl/time/clock.h"
+
+#include <chrono>
+#include <cstdint>
+
+namespace absl {
+namespace time_internal {
+
+static int64_t GetCurrentTimeNanosFromSystem() {
+ return std::chrono::duration_cast<std::chrono::nanoseconds>(
+ std::chrono::system_clock::now() -
+ std::chrono::system_clock::from_time_t(0))
+ .count();
+}
+
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/test_util.cc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/test_util.cc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/test_util.cc
new file mode 100644
index 0000000..4483f2a
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/test_util.cc
@@ -0,0 +1,123 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "absl/time/internal/test_util.h"
+
+#include <algorithm>
+#include <cstddef>
+#include <cstring>
+
+#include "absl/base/internal/raw_logging.h"
+#include "absl/time/internal/cctz/include/cctz/zone_info_source.h"
+
+namespace cctz = absl::time_internal::cctz;
+
+namespace absl {
+namespace time_internal {
+
+TimeZone LoadTimeZone(const std::string& name) {
+ TimeZone tz;
+ ABSL_RAW_CHECK(LoadTimeZone(name, &tz), name.c_str());
+ return tz;
+}
+
+} // namespace time_internal
+} // namespace absl
+
+namespace absl {
+namespace time_internal {
+namespace cctz_extension {
+namespace {
+
+// Embed the zoneinfo data for time zones used during tests and benchmarks.
+// The data was generated using "xxd -i zoneinfo-file". There is no need
+// to update the data as long as the tests do not depend on recent changes
+// (and the past rules remain the same).
+#include "absl/time/internal/zoneinfo.inc"
+
+const struct ZoneInfo {
+ const char* name;
+ const char* data;
+ std::size_t length;
+} kZoneInfo[] = {
+ // The three real time zones used by :time_test and :time_benchmark.
+ {"America/Los_Angeles", //
+ reinterpret_cast<char*>(America_Los_Angeles), America_Los_Angeles_len},
+ {"America/New_York", //
+ reinterpret_cast<char*>(America_New_York), America_New_York_len},
+ {"Australia/Sydney", //
+ reinterpret_cast<char*>(Australia_Sydney), Australia_Sydney_len},
+
+ // Other zones named in tests but which should fail to load.
+ {"Invalid/TimeZone", nullptr, 0},
+ {"", nullptr, 0},
+
+ // Also allow for loading the local time zone under TZ=US/Pacific.
+ {"US/Pacific", //
+ reinterpret_cast<char*>(America_Los_Angeles), America_Los_Angeles_len},
+
+ // Allows use of the local time zone from a system-specific location.
+#ifdef _MSC_VER
+ {"localtime", //
+ reinterpret_cast<char*>(America_Los_Angeles), America_Los_Angeles_len},
+#else
+ {"/etc/localtime", //
+ reinterpret_cast<char*>(America_Los_Angeles), America_Los_Angeles_len},
+#endif
+};
+
+class TestZoneInfoSource : public cctz::ZoneInfoSource {
+ public:
+ TestZoneInfoSource(const char* data, std::size_t size)
+ : data_(data), end_(data + size) {}
+
+ std::size_t Read(void* ptr, std::size_t size) override {
+ const std::size_t len = std::min<std::size_t>(size, end_ - data_);
+ memcpy(ptr, data_, len);
+ data_ += len;
+ return len;
+ }
+
+ int Skip(std::size_t offset) override {
+ data_ += std::min<std::size_t>(offset, end_ - data_);
+ return 0;
+ }
+
+ private:
+ const char* data_;
+ const char* const end_;
+};
+
+std::unique_ptr<cctz::ZoneInfoSource> TestFactory(
+ const std::string& name,
+ const std::function<std::unique_ptr<cctz::ZoneInfoSource>(
+ const std::string& name)>& /*fallback_factory*/) {
+ for (const ZoneInfo& zoneinfo : kZoneInfo) {
+ if (name == zoneinfo.name) {
+ if (zoneinfo.data == nullptr) return nullptr;
+ return std::unique_ptr<cctz::ZoneInfoSource>(
+ new TestZoneInfoSource(zoneinfo.data, zoneinfo.length));
+ }
+ }
+ ABSL_RAW_LOG(FATAL, "Unexpected time zone \"%s\" in test", name.c_str());
+ return nullptr;
+}
+
+} // namespace
+
+ZoneInfoSourceFactory zone_info_source_factory = TestFactory;
+
+} // namespace cctz_extension
+} // namespace time_internal
+} // namespace absl
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/test_util.h
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/test_util.h b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/test_util.h
new file mode 100644
index 0000000..81a2d29
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/test_util.h
@@ -0,0 +1,49 @@
+// Copyright 2017 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_TIME_INTERNAL_TEST_UTIL_H_
+#define ABSL_TIME_INTERNAL_TEST_UTIL_H_
+
+#include <string>
+
+#include "absl/time/time.h"
+
+// This helper is a macro so that failed expectations show up with the
+// correct line numbers.
+//
+// This is for internal testing of the Base Time library itself. This is not
+// part of a public API.
+#define ABSL_INTERNAL_EXPECT_TIME(bd, y, m, d, h, min, s, off, isdst, zone) \
+ do { \
+ EXPECT_EQ(y, bd.year); \
+ EXPECT_EQ(m, bd.month); \
+ EXPECT_EQ(d, bd.day); \
+ EXPECT_EQ(h, bd.hour); \
+ EXPECT_EQ(min, bd.minute); \
+ EXPECT_EQ(s, bd.second); \
+ EXPECT_EQ(off, bd.offset); \
+ EXPECT_EQ(isdst, bd.is_dst); \
+ EXPECT_STREQ(zone, bd.zone_abbr); \
+ } while (0)
+
+namespace absl {
+namespace time_internal {
+
+// Loads the named timezone, but dies on any failure.
+absl::TimeZone LoadTimeZone(const std::string& name);
+
+} // namespace time_internal
+} // namespace absl
+
+#endif // ABSL_TIME_INTERNAL_TEST_UTIL_H_
http://git-wip-us.apache.org/repos/asf/marmotta/blob/0eb556da/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/zoneinfo.inc
----------------------------------------------------------------------
diff --git a/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/zoneinfo.inc b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/zoneinfo.inc
new file mode 100644
index 0000000..bfed829
--- /dev/null
+++ b/libraries/ostrich/backend/3rdparty/abseil/absl/time/internal/zoneinfo.inc
@@ -0,0 +1,729 @@
+unsigned char America_Los_Angeles[] = {
+ 0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xba,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0x80, 0x00, 0x00, 0x00,
+ 0x9e, 0xa6, 0x48, 0xa0, 0x9f, 0xbb, 0x15, 0x90, 0xa0, 0x86, 0x2a, 0xa0,
+ 0xa1, 0x9a, 0xf7, 0x90, 0xcb, 0x89, 0x1a, 0xa0, 0xd2, 0x23, 0xf4, 0x70,
+ 0xd2, 0x61, 0x26, 0x10, 0xd6, 0xfe, 0x74, 0x5c, 0xd8, 0x80, 0xad, 0x90,
+ 0xda, 0xfe, 0xc3, 0x90, 0xdb, 0xc0, 0x90, 0x10, 0xdc, 0xde, 0xa5, 0x90,
+ 0xdd, 0xa9, 0xac, 0x90, 0xde, 0xbe, 0x87, 0x90, 0xdf, 0x89, 0x8e, 0x90,
+ 0xe0, 0x9e, 0x69, 0x90, 0xe1, 0x69, 0x70, 0x90, 0xe2, 0x7e, 0x4b, 0x90,
+ 0xe3, 0x49, 0x52, 0x90, 0xe4, 0x5e, 0x2d, 0x90, 0xe5, 0x29, 0x34, 0x90,
+ 0xe6, 0x47, 0x4a, 0x10, 0xe7, 0x12, 0x51, 0x10, 0xe8, 0x27, 0x2c, 0x10,
+ 0xe8, 0xf2, 0x33, 0x10, 0xea, 0x07, 0x0e, 0x10, 0xea, 0xd2, 0x15, 0x10,
+ 0xeb, 0xe6, 0xf0, 0x10, 0xec, 0xb1, 0xf7, 0x10, 0xed, 0xc6, 0xd2, 0x10,
+ 0xee, 0x91, 0xd9, 0x10, 0xef, 0xaf, 0xee, 0x90, 0xf0, 0x71, 0xbb, 0x10,
+ 0xf1, 0x8f, 0xd0, 0x90, 0xf2, 0x7f, 0xc1, 0x90, 0xf3, 0x6f, 0xb2, 0x90,
+ 0xf4, 0x5f, 0xa3, 0x90, 0xf5, 0x4f, 0x94, 0x90, 0xf6, 0x3f, 0x85, 0x90,
+ 0xf7, 0x2f, 0x76, 0x90, 0xf8, 0x28, 0xa2, 0x10, 0xf9, 0x0f, 0x58, 0x90,
+ 0xfa, 0x08, 0x84, 0x10, 0xfa, 0xf8, 0x83, 0x20, 0xfb, 0xe8, 0x66, 0x10,
+ 0xfc, 0xd8, 0x65, 0x20, 0xfd, 0xc8, 0x48, 0x10, 0xfe, 0xb8, 0x47, 0x20,
+ 0xff, 0xa8, 0x2a, 0x10, 0x00, 0x98, 0x29, 0x20, 0x01, 0x88, 0x0c, 0x10,
+ 0x02, 0x78, 0x0b, 0x20, 0x03, 0x71, 0x28, 0x90, 0x04, 0x61, 0x27, 0xa0,
+ 0x05, 0x51, 0x0a, 0x90, 0x06, 0x41, 0x09, 0xa0, 0x07, 0x30, 0xec, 0x90,
+ 0x07, 0x8d, 0x43, 0xa0, 0x09, 0x10, 0xce, 0x90, 0x09, 0xad, 0xbf, 0x20,
+ 0x0a, 0xf0, 0xb0, 0x90, 0x0b, 0xe0, 0xaf, 0xa0, 0x0c, 0xd9, 0xcd, 0x10,
+ 0x0d, 0xc0, 0x91, 0xa0, 0x0e, 0xb9, 0xaf, 0x10, 0x0f, 0xa9, 0xae, 0x20,
+ 0x10, 0x99, 0x91, 0x10, 0x11, 0x89, 0x90, 0x20, 0x12, 0x79, 0x73, 0x10,
+ 0x13, 0x69, 0x72, 0x20, 0x14, 0x59, 0x55, 0x10, 0x15, 0x49, 0x54, 0x20,
+ 0x16, 0x39, 0x37, 0x10, 0x17, 0x29, 0x36, 0x20, 0x18, 0x22, 0x53, 0x90,
+ 0x19, 0x09, 0x18, 0x20, 0x1a, 0x02, 0x35, 0x90, 0x1a, 0xf2, 0x34, 0xa0,
+ 0x1b, 0xe2, 0x17, 0x90, 0x1c, 0xd2, 0x16, 0xa0, 0x1d, 0xc1, 0xf9, 0x90,
+ 0x1e, 0xb1, 0xf8, 0xa0, 0x1f, 0xa1, 0xdb, 0x90, 0x20, 0x76, 0x2b, 0x20,
+ 0x21, 0x81, 0xbd, 0x90, 0x22, 0x56, 0x0d, 0x20, 0x23, 0x6a, 0xda, 0x10,
+ 0x24, 0x35, 0xef, 0x20, 0x25, 0x4a, 0xbc, 0x10, 0x26, 0x15, 0xd1, 0x20,
+ 0x27, 0x2a, 0x9e, 0x10, 0x27, 0xfe, 0xed, 0xa0, 0x29, 0x0a, 0x80, 0x10,
+ 0x29, 0xde, 0xcf, 0xa0, 0x2a, 0xea, 0x62, 0x10, 0x2b, 0xbe, 0xb1, 0xa0,
+ 0x2c, 0xd3, 0x7e, 0x90, 0x2d, 0x9e, 0x93, 0xa0, 0x2e, 0xb3, 0x60, 0x90,
+ 0x2f, 0x7e, 0x75, 0xa0, 0x30, 0x93, 0x42, 0x90, 0x31, 0x67, 0x92, 0x20,
+ 0x32, 0x73, 0x24, 0x90, 0x33, 0x47, 0x74, 0x20, 0x34, 0x53, 0x06, 0x90,
+ 0x35, 0x27, 0x56, 0x20, 0x36, 0x32, 0xe8, 0x90, 0x37, 0x07, 0x38, 0x20,
+ 0x38, 0x1c, 0x05, 0x10, 0x38, 0xe7, 0x1a, 0x20, 0x39, 0xfb, 0xe7, 0x10,
+ 0x3a, 0xc6, 0xfc, 0x20, 0x3b, 0xdb, 0xc9, 0x10, 0x3c, 0xb0, 0x18, 0xa0,
+ 0x3d, 0xbb, 0xab, 0x10, 0x3e, 0x8f, 0xfa, 0xa0, 0x3f, 0x9b, 0x8d, 0x10,
+ 0x40, 0x6f, 0xdc, 0xa0, 0x41, 0x84, 0xa9, 0x90, 0x42, 0x4f, 0xbe, 0xa0,
+ 0x43, 0x64, 0x8b, 0x90, 0x44, 0x2f, 0xa0, 0xa0, 0x45, 0x44, 0x6d, 0x90,
+ 0x45, 0xf3, 0xd3, 0x20, 0x47, 0x2d, 0x8a, 0x10, 0x47, 0xd3, 0xb5, 0x20,
+ 0x49, 0x0d, 0x6c, 0x10, 0x49, 0xb3, 0x97, 0x20, 0x4a, 0xed, 0x4e, 0x10,
+ 0x4b, 0x9c, 0xb3, 0xa0, 0x4c, 0xd6, 0x6a, 0x90, 0x4d, 0x7c, 0x95, 0xa0,
+ 0x4e, 0xb6, 0x4c, 0x90, 0x4f, 0x5c, 0x77, 0xa0, 0x50, 0x96, 0x2e, 0x90,
+ 0x51, 0x3c, 0x59, 0xa0, 0x52, 0x76, 0x10, 0x90, 0x53, 0x1c, 0x3b, 0xa0,
+ 0x54, 0x55, 0xf2, 0x90, 0x54, 0xfc, 0x1d, 0xa0, 0x56, 0x35, 0xd4, 0x90,
+ 0x56, 0xe5, 0x3a, 0x20, 0x58, 0x1e, 0xf1, 0x10, 0x58, 0xc5, 0x1c, 0x20,
+ 0x59, 0xfe, 0xd3, 0x10, 0x5a, 0xa4, 0xfe, 0x20, 0x5b, 0xde, 0xb5, 0x10,
+ 0x5c, 0x84, 0xe0, 0x20, 0x5d, 0xbe, 0x97, 0x10, 0x5e, 0x64, 0xc2, 0x20,
+ 0x5f, 0x9e, 0x79, 0x10, 0x60, 0x4d, 0xde, 0xa0, 0x61, 0x87, 0x95, 0x90,
+ 0x62, 0x2d, 0xc0, 0xa0, 0x63, 0x67, 0x77, 0x90, 0x64, 0x0d, 0xa2, 0xa0,
+ 0x65, 0x47, 0x59, 0x90, 0x65, 0xed, 0x84, 0xa0, 0x67, 0x27, 0x3b, 0x90,
+ 0x67, 0xcd, 0x66, 0xa0, 0x69, 0x07, 0x1d, 0x90, 0x69, 0xad, 0x48, 0xa0,
+ 0x6a, 0xe6, 0xff, 0x90, 0x6b, 0x96, 0x65, 0x20, 0x6c, 0xd0, 0x1c, 0x10,
+ 0x6d, 0x76, 0x47, 0x20, 0x6e, 0xaf, 0xfe, 0x10, 0x6f, 0x56, 0x29, 0x20,
+ 0x70, 0x8f, 0xe0, 0x10, 0x71, 0x36, 0x0b, 0x20, 0x72, 0x6f, 0xc2, 0x10,
+ 0x73, 0x15, 0xed, 0x20, 0x74, 0x4f, 0xa4, 0x10, 0x74, 0xff, 0x09, 0xa0,
+ 0x76, 0x38, 0xc0, 0x90, 0x76, 0xde, 0xeb, 0xa0, 0x78, 0x18, 0xa2, 0x90,
+ 0x78, 0xbe, 0xcd, 0xa0, 0x79, 0xf8, 0x84, 0x90, 0x7a, 0x9e, 0xaf, 0xa0,
+ 0x7b, 0xd8, 0x66, 0x90, 0x7c, 0x7e, 0x91, 0xa0, 0x7d, 0xb8, 0x48, 0x90,
+ 0x7e, 0x5e, 0x73, 0xa0, 0x7f, 0x98, 0x2a, 0x90, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x03, 0x04, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0xff, 0xff, 0x91, 0x26, 0x00, 0x00, 0xff, 0xff, 0x9d, 0x90,
+ 0x01, 0x04, 0xff, 0xff, 0x8f, 0x80, 0x00, 0x08, 0xff, 0xff, 0x9d, 0x90,
+ 0x01, 0x0c, 0xff, 0xff, 0x9d, 0x90, 0x01, 0x10, 0x4c, 0x4d, 0x54, 0x00,
+ 0x50, 0x44, 0x54, 0x00, 0x50, 0x53, 0x54, 0x00, 0x50, 0x57, 0x54, 0x00,
+ 0x50, 0x50, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+ 0x00, 0x01, 0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0xbb, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0xf8, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x5e, 0x04,
+ 0x1a, 0xc0, 0xff, 0xff, 0xff, 0xff, 0x9e, 0xa6, 0x48, 0xa0, 0xff, 0xff,
+ 0xff, 0xff, 0x9f, 0xbb, 0x15, 0x90, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x86,
+ 0x2a, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xa1, 0x9a, 0xf7, 0x90, 0xff, 0xff,
+ 0xff, 0xff, 0xcb, 0x89, 0x1a, 0xa0, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x23,
+ 0xf4, 0x70, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x61, 0x26, 0x10, 0xff, 0xff,
+ 0xff, 0xff, 0xd6, 0xfe, 0x74, 0x5c, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x80,
+ 0xad, 0x90, 0xff, 0xff, 0xff, 0xff, 0xda, 0xfe, 0xc3, 0x90, 0xff, 0xff,
+ 0xff, 0xff, 0xdb, 0xc0, 0x90, 0x10, 0xff, 0xff, 0xff, 0xff, 0xdc, 0xde,
+ 0xa5, 0x90, 0xff, 0xff, 0xff, 0xff, 0xdd, 0xa9, 0xac, 0x90, 0xff, 0xff,
+ 0xff, 0xff, 0xde, 0xbe, 0x87, 0x90, 0xff, 0xff, 0xff, 0xff, 0xdf, 0x89,
+ 0x8e, 0x90, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x9e, 0x69, 0x90, 0xff, 0xff,
+ 0xff, 0xff, 0xe1, 0x69, 0x70, 0x90, 0xff, 0xff, 0xff, 0xff, 0xe2, 0x7e,
+ 0x4b, 0x90, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x49, 0x52, 0x90, 0xff, 0xff,
+ 0xff, 0xff, 0xe4, 0x5e, 0x2d, 0x90, 0xff, 0xff, 0xff, 0xff, 0xe5, 0x29,
+ 0x34, 0x90, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x47, 0x4a, 0x10, 0xff, 0xff,
+ 0xff, 0xff, 0xe7, 0x12, 0x51, 0x10, 0xff, 0xff, 0xff, 0xff, 0xe8, 0x27,
+ 0x2c, 0x10, 0xff, 0xff, 0xff, 0xff, 0xe8, 0xf2, 0x33, 0x10, 0xff, 0xff,
+ 0xff, 0xff, 0xea, 0x07, 0x0e, 0x10, 0xff, 0xff, 0xff, 0xff, 0xea, 0xd2,
+ 0x15, 0x10, 0xff, 0xff, 0xff, 0xff, 0xeb, 0xe6, 0xf0, 0x10, 0xff, 0xff,
+ 0xff, 0xff, 0xec, 0xb1, 0xf7, 0x10, 0xff, 0xff, 0xff, 0xff, 0xed, 0xc6,
+ 0xd2, 0x10, 0xff, 0xff, 0xff, 0xff, 0xee, 0x91, 0xd9, 0x10, 0xff, 0xff,
+ 0xff, 0xff, 0xef, 0xaf, 0xee, 0x90, 0xff, 0xff, 0xff, 0xff, 0xf0, 0x71,
+ 0xbb, 0x10, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x8f, 0xd0, 0x90, 0xff, 0xff,
+ 0xff, 0xff, 0xf2, 0x7f, 0xc1, 0x90, 0xff, 0xff, 0xff, 0xff, 0xf3, 0x6f,
+ 0xb2, 0x90, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x5f, 0xa3, 0x90, 0xff, 0xff,
+ 0xff, 0xff, 0xf5, 0x4f, 0x94, 0x90, 0xff, 0xff, 0xff, 0xff, 0xf6, 0x3f,
+ 0x85, 0x90, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x2f, 0x76, 0x90, 0xff, 0xff,
+ 0xff, 0xff, 0xf8, 0x28, 0xa2, 0x10, 0xff, 0xff, 0xff, 0xff, 0xf9, 0x0f,
+ 0x58, 0x90, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x08, 0x84, 0x10, 0xff, 0xff,
+ 0xff, 0xff, 0xfa, 0xf8, 0x83, 0x20, 0xff, 0xff, 0xff, 0xff, 0xfb, 0xe8,
+ 0x66, 0x10, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xd8, 0x65, 0x20, 0xff, 0xff,
+ 0xff, 0xff, 0xfd, 0xc8, 0x48, 0x10, 0xff, 0xff, 0xff, 0xff, 0xfe, 0xb8,
+ 0x47, 0x20, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa8, 0x2a, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x98, 0x29, 0x20, 0x00, 0x00, 0x00, 0x00, 0x01, 0x88,
+ 0x0c, 0x10, 0x00, 0x00, 0x00, 0x00, 0x02, 0x78, 0x0b, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x03, 0x71, 0x28, 0x90, 0x00, 0x00, 0x00, 0x00, 0x04, 0x61,
+ 0x27, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x05, 0x51, 0x0a, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x06, 0x41, 0x09, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x07, 0x30,
+ 0xec, 0x90, 0x00, 0x00, 0x00, 0x00, 0x07, 0x8d, 0x43, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x09, 0x10, 0xce, 0x90, 0x00, 0x00, 0x00, 0x00, 0x09, 0xad,
+ 0xbf, 0x20, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xf0, 0xb0, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x0b, 0xe0, 0xaf, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xd9,
+ 0xcd, 0x10, 0x00, 0x00, 0x00, 0x00, 0x0d, 0xc0, 0x91, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x0e, 0xb9, 0xaf, 0x10, 0x00, 0x00, 0x00, 0x00, 0x0f, 0xa9,
+ 0xae, 0x20, 0x00, 0x00, 0x00, 0x00, 0x10, 0x99, 0x91, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x11, 0x89, 0x90, 0x20, 0x00, 0x00, 0x00, 0x00, 0x12, 0x79,
+ 0x73, 0x10, 0x00, 0x00, 0x00, 0x00, 0x13, 0x69, 0x72, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x14, 0x59, 0x55, 0x10, 0x00, 0x00, 0x00, 0x00, 0x15, 0x49,
+ 0x54, 0x20, 0x00, 0x00, 0x00, 0x00, 0x16, 0x39, 0x37, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x17, 0x29, 0x36, 0x20, 0x00, 0x00, 0x00, 0x00, 0x18, 0x22,
+ 0x53, 0x90, 0x00, 0x00, 0x00, 0x00, 0x19, 0x09, 0x18, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x1a, 0x02, 0x35, 0x90, 0x00, 0x00, 0x00, 0x00, 0x1a, 0xf2,
+ 0x34, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x1b, 0xe2, 0x17, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x1c, 0xd2, 0x16, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x1d, 0xc1,
+ 0xf9, 0x90, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xb1, 0xf8, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x1f, 0xa1, 0xdb, 0x90, 0x00, 0x00, 0x00, 0x00, 0x20, 0x76,
+ 0x2b, 0x20, 0x00, 0x00, 0x00, 0x00, 0x21, 0x81, 0xbd, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x22, 0x56, 0x0d, 0x20, 0x00, 0x00, 0x00, 0x00, 0x23, 0x6a,
+ 0xda, 0x10, 0x00, 0x00, 0x00, 0x00, 0x24, 0x35, 0xef, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x25, 0x4a, 0xbc, 0x10, 0x00, 0x00, 0x00, 0x00, 0x26, 0x15,
+ 0xd1, 0x20, 0x00, 0x00, 0x00, 0x00, 0x27, 0x2a, 0x9e, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x27, 0xfe, 0xed, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x29, 0x0a,
+ 0x80, 0x10, 0x00, 0x00, 0x00, 0x00, 0x29, 0xde, 0xcf, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x2a, 0xea, 0x62, 0x10, 0x00, 0x00, 0x00, 0x00, 0x2b, 0xbe,
+ 0xb1, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x2c, 0xd3, 0x7e, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x2d, 0x9e, 0x93, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x2e, 0xb3,
+ 0x60, 0x90, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x7e, 0x75, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x30, 0x93, 0x42, 0x90, 0x00, 0x00, 0x00, 0x00, 0x31, 0x67,
+ 0x92, 0x20, 0x00, 0x00, 0x00, 0x00, 0x32, 0x73, 0x24, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x33, 0x47, 0x74, 0x20, 0x00, 0x00, 0x00, 0x00, 0x34, 0x53,
+ 0x06, 0x90, 0x00, 0x00, 0x00, 0x00, 0x35, 0x27, 0x56, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x36, 0x32, 0xe8, 0x90, 0x00, 0x00, 0x00, 0x00, 0x37, 0x07,
+ 0x38, 0x20, 0x00, 0x00, 0x00, 0x00, 0x38, 0x1c, 0x05, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x38, 0xe7, 0x1a, 0x20, 0x00, 0x00, 0x00, 0x00, 0x39, 0xfb,
+ 0xe7, 0x10, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xc6, 0xfc, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x3b, 0xdb, 0xc9, 0x10, 0x00, 0x00, 0x00, 0x00, 0x3c, 0xb0,
+ 0x18, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x3d, 0xbb, 0xab, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x3e, 0x8f, 0xfa, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x9b,
+ 0x8d, 0x10, 0x00, 0x00, 0x00, 0x00, 0x40, 0x6f, 0xdc, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x41, 0x84, 0xa9, 0x90, 0x00, 0x00, 0x00, 0x00, 0x42, 0x4f,
+ 0xbe, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x43, 0x64, 0x8b, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x44, 0x2f, 0xa0, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x45, 0x44,
+ 0x6d, 0x90, 0x00, 0x00, 0x00, 0x00, 0x45, 0xf3, 0xd3, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x47, 0x2d, 0x8a, 0x10, 0x00, 0x00, 0x00, 0x00, 0x47, 0xd3,
+ 0xb5, 0x20, 0x00, 0x00, 0x00, 0x00, 0x49, 0x0d, 0x6c, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x49, 0xb3, 0x97, 0x20, 0x00, 0x00, 0x00, 0x00, 0x4a, 0xed,
+ 0x4e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x4b, 0x9c, 0xb3, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x4c, 0xd6, 0x6a, 0x90, 0x00, 0x00, 0x00, 0x00, 0x4d, 0x7c,
+ 0x95, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x4e, 0xb6, 0x4c, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x4f, 0x5c, 0x77, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x50, 0x96,
+ 0x2e, 0x90, 0x00, 0x00, 0x00, 0x00, 0x51, 0x3c, 0x59, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x52, 0x76, 0x10, 0x90, 0x00, 0x00, 0x00, 0x00, 0x53, 0x1c,
+ 0x3b, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x54, 0x55, 0xf2, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x54, 0xfc, 0x1d, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x56, 0x35,
+ 0xd4, 0x90, 0x00, 0x00, 0x00, 0x00, 0x56, 0xe5, 0x3a, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x58, 0x1e, 0xf1, 0x10, 0x00, 0x00, 0x00, 0x00, 0x58, 0xc5,
+ 0x1c, 0x20, 0x00, 0x00, 0x00, 0x00, 0x59, 0xfe, 0xd3, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x5a, 0xa4, 0xfe, 0x20, 0x00, 0x00, 0x00, 0x00, 0x5b, 0xde,
+ 0xb5, 0x10, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x84, 0xe0, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x5d, 0xbe, 0x97, 0x10, 0x00, 0x00, 0x00, 0x00, 0x5e, 0x64,
+ 0xc2, 0x20, 0x00, 0x00, 0x00, 0x00, 0x5f, 0x9e, 0x79, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x60, 0x4d, 0xde, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x61, 0x87,
+ 0x95, 0x90, 0x00, 0x00, 0x00, 0x00, 0x62, 0x2d, 0xc0, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x63, 0x67, 0x77, 0x90, 0x00, 0x00, 0x00, 0x00, 0x64, 0x0d,
+ 0xa2, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x65, 0x47, 0x59, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x65, 0xed, 0x84, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x67, 0x27,
+ 0x3b, 0x90, 0x00, 0x00, 0x00, 0x00, 0x67, 0xcd, 0x66, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x69, 0x07, 0x1d, 0x90, 0x00, 0x00, 0x00, 0x00, 0x69, 0xad,
+ 0x48, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x6a, 0xe6, 0xff, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x6b, 0x96, 0x65, 0x20, 0x00, 0x00, 0x00, 0x00, 0x6c, 0xd0,
+ 0x1c, 0x10, 0x00, 0x00, 0x00, 0x00, 0x6d, 0x76, 0x47, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x6e, 0xaf, 0xfe, 0x10, 0x00, 0x00, 0x00, 0x00, 0x6f, 0x56,
+ 0x29, 0x20, 0x00, 0x00, 0x00, 0x00, 0x70, 0x8f, 0xe0, 0x10, 0x00, 0x00,
+ 0x00, 0x00, 0x71, 0x36, 0x0b, 0x20, 0x00, 0x00, 0x00, 0x00, 0x72, 0x6f,
+ 0xc2, 0x10, 0x00, 0x00, 0x00, 0x00, 0x73, 0x15, 0xed, 0x20, 0x00, 0x00,
+ 0x00, 0x00, 0x74, 0x4f, 0xa4, 0x10, 0x00, 0x00, 0x00, 0x00, 0x74, 0xff,
+ 0x09, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x76, 0x38, 0xc0, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x76, 0xde, 0xeb, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x78, 0x18,
+ 0xa2, 0x90, 0x00, 0x00, 0x00, 0x00, 0x78, 0xbe, 0xcd, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x79, 0xf8, 0x84, 0x90, 0x00, 0x00, 0x00, 0x00, 0x7a, 0x9e,
+ 0xaf, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x7b, 0xd8, 0x66, 0x90, 0x00, 0x00,
+ 0x00, 0x00, 0x7c, 0x7e, 0x91, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x7d, 0xb8,
+ 0x48, 0x90, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x5e, 0x73, 0xa0, 0x00, 0x00,
+ 0x00, 0x00, 0x7f, 0x98, 0x2a, 0x90, 0x00, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x03, 0x04, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0xff, 0xff, 0x91, 0x26, 0x00, 0x00, 0xff, 0xff, 0x9d, 0x90, 0x01,
+ 0x04, 0xff, 0xff, 0x8f, 0x80, 0x00, 0x08, 0xff, 0xff, 0x9d, 0x90, 0x01,
+ 0x0c, 0xff, 0xff, 0x9d, 0x90, 0x01, 0x10, 0x4c, 0x4d, 0x54, 0x00, 0x50,
+ 0x44, 0x54, 0x00, 0x50, 0x53, 0x54, 0x00, 0x50, 0x57, 0x54, 0x00, 0x50,
+ 0x50, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+ 0x01, 0x0a, 0x50, 0x53, 0x54, 0x38, 0x50, 0x44, 0x54, 0x2c, 0x4d, 0x33,
+ 0x2e, 0x32, 0x2e, 0x30, 0x2c, 0x4d, 0x31, 0x31, 0x2e, 0x31, 0x2e, 0x30,
+ 0x0a
+};
+unsigned int America_Los_Angeles_len = 2845;
+unsigned char America_New_York[] = {
+ 0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xec,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0x80, 0x00, 0x00, 0x00,
+ 0x9e, 0xa6, 0x1e, 0x70, 0x9f, 0xba, 0xeb, 0x60, 0xa0, 0x86, 0x00, 0x70,
+ 0xa1, 0x9a, 0xcd, 0x60, 0xa2, 0x65, 0xe2, 0x70, 0xa3, 0x83, 0xe9, 0xe0,
+ 0xa4, 0x6a, 0xae, 0x70, 0xa5, 0x35, 0xa7, 0x60, 0xa6, 0x53, 0xca, 0xf0,
+ 0xa7, 0x15, 0x89, 0x60, 0xa8, 0x33, 0xac, 0xf0, 0xa8, 0xfe, 0xa5, 0xe0,
+ 0xaa, 0x13, 0x8e, 0xf0, 0xaa, 0xde, 0x87, 0xe0, 0xab, 0xf3, 0x70, 0xf0,
+ 0xac, 0xbe, 0x69, 0xe0, 0xad, 0xd3, 0x52, 0xf0, 0xae, 0x9e, 0x4b, 0xe0,
+ 0xaf, 0xb3, 0x34, 0xf0, 0xb0, 0x7e, 0x2d, 0xe0, 0xb1, 0x9c, 0x51, 0x70,
+ 0xb2, 0x67, 0x4a, 0x60, 0xb3, 0x7c, 0x33, 0x70, 0xb4, 0x47, 0x2c, 0x60,
+ 0xb5, 0x5c, 0x15, 0x70, 0xb6, 0x27, 0x0e, 0x60, 0xb7, 0x3b, 0xf7, 0x70,
+ 0xb8, 0x06, 0xf0, 0x60, 0xb9, 0x1b, 0xd9, 0x70, 0xb9, 0xe6, 0xd2, 0x60,
+ 0xbb, 0x04, 0xf5, 0xf0, 0xbb, 0xc6, 0xb4, 0x60, 0xbc, 0xe4, 0xd7, 0xf0,
+ 0xbd, 0xaf, 0xd0, 0xe0, 0xbe, 0xc4, 0xb9, 0xf0, 0xbf, 0x8f, 0xb2, 0xe0,
+ 0xc0, 0xa4, 0x9b, 0xf0, 0xc1, 0x6f, 0x94, 0xe0, 0xc2, 0x84, 0x7d, 0xf0,
+ 0xc3, 0x4f, 0x76, 0xe0, 0xc4, 0x64, 0x5f, 0xf0, 0xc5, 0x2f, 0x58, 0xe0,
+ 0xc6, 0x4d, 0x7c, 0x70, 0xc7, 0x0f, 0x3a, 0xe0, 0xc8, 0x2d, 0x5e, 0x70,
+ 0xc8, 0xf8, 0x57, 0x60, 0xca, 0x0d, 0x40, 0x70, 0xca, 0xd8, 0x39, 0x60,
+ 0xcb, 0x88, 0xf0, 0x70, 0xd2, 0x23, 0xf4, 0x70, 0xd2, 0x60, 0xfb, 0xe0,
+ 0xd3, 0x75, 0xe4, 0xf0, 0xd4, 0x40, 0xdd, 0xe0, 0xd5, 0x55, 0xc6, 0xf0,
+ 0xd6, 0x20, 0xbf, 0xe0, 0xd7, 0x35, 0xa8, 0xf0, 0xd8, 0x00, 0xa1, 0xe0,
+ 0xd9, 0x15, 0x8a, 0xf0, 0xd9, 0xe0, 0x83, 0xe0, 0xda, 0xfe, 0xa7, 0x70,
+ 0xdb, 0xc0, 0x65, 0xe0, 0xdc, 0xde, 0x89, 0x70, 0xdd, 0xa9, 0x82, 0x60,
+ 0xde, 0xbe, 0x6b, 0x70, 0xdf, 0x89, 0x64, 0x60, 0xe0, 0x9e, 0x4d, 0x70,
+ 0xe1, 0x69, 0x46, 0x60, 0xe2, 0x7e, 0x2f, 0x70, 0xe3, 0x49, 0x28, 0x60,
+ 0xe4, 0x5e, 0x11, 0x70, 0xe5, 0x57, 0x2e, 0xe0, 0xe6, 0x47, 0x2d, 0xf0,
+ 0xe7, 0x37, 0x10, 0xe0, 0xe8, 0x27, 0x0f, 0xf0, 0xe9, 0x16, 0xf2, 0xe0,
+ 0xea, 0x06, 0xf1, 0xf0, 0xea, 0xf6, 0xd4, 0xe0, 0xeb, 0xe6, 0xd3, 0xf0,
+ 0xec, 0xd6, 0xb6, 0xe0, 0xed, 0xc6, 0xb5, 0xf0, 0xee, 0xbf, 0xd3, 0x60,
+ 0xef, 0xaf, 0xd2, 0x70, 0xf0, 0x9f, 0xb5, 0x60, 0xf1, 0x8f, 0xb4, 0x70,
+ 0xf2, 0x7f, 0x97, 0x60, 0xf3, 0x6f, 0x96, 0x70, 0xf4, 0x5f, 0x79, 0x60,
+ 0xf5, 0x4f, 0x78, 0x70, 0xf6, 0x3f, 0x5b, 0x60, 0xf7, 0x2f, 0x5a, 0x70,
+ 0xf8, 0x28, 0x77, 0xe0, 0xf9, 0x0f, 0x3c, 0x70, 0xfa, 0x08, 0x59, 0xe0,
+ 0xfa, 0xf8, 0x58, 0xf0, 0xfb, 0xe8, 0x3b, 0xe0, 0xfc, 0xd8, 0x3a, 0xf0,
+ 0xfd, 0xc8, 0x1d, 0xe0, 0xfe, 0xb8, 0x1c, 0xf0, 0xff, 0xa7, 0xff, 0xe0,
+ 0x00, 0x97, 0xfe, 0xf0, 0x01, 0x87, 0xe1, 0xe0, 0x02, 0x77, 0xe0, 0xf0,
+ 0x03, 0x70, 0xfe, 0x60, 0x04, 0x60, 0xfd, 0x70, 0x05, 0x50, 0xe0, 0x60,
+ 0x06, 0x40, 0xdf, 0x70, 0x07, 0x30, 0xc2, 0x60, 0x07, 0x8d, 0x19, 0x70,
+ 0x09, 0x10, 0xa4, 0x60, 0x09, 0xad, 0x94, 0xf0, 0x0a, 0xf0, 0x86, 0x60,
+ 0x0b, 0xe0, 0x85, 0x70, 0x0c, 0xd9, 0xa2, 0xe0, 0x0d, 0xc0, 0x67, 0x70,
+ 0x0e, 0xb9, 0x84, 0xe0, 0x0f, 0xa9, 0x83, 0xf0, 0x10, 0x99, 0x66, 0xe0,
+ 0x11, 0x89, 0x65, 0xf0, 0x12, 0x79, 0x48, 0xe0, 0x13, 0x69, 0x47, 0xf0,
+ 0x14, 0x59, 0x2a, 0xe0, 0x15, 0x49, 0x29, 0xf0, 0x16, 0x39, 0x0c, 0xe0,
+ 0x17, 0x29, 0x0b, 0xf0, 0x18, 0x22, 0x29, 0x60, 0x19, 0x08, 0xed, 0xf0,
+ 0x1a, 0x02, 0x0b, 0x60, 0x1a, 0xf2, 0x0a, 0x70, 0x1b, 0xe1, 0xed, 0x60,
+ 0x1c, 0xd1, 0xec, 0x70, 0x1d, 0xc1, 0xcf, 0x60, 0x1e, 0xb1, 0xce, 0x70,
+ 0x1f, 0xa1, 0xb1, 0x60, 0x20, 0x76, 0x00, 0xf0, 0x21, 0x81, 0x93, 0x60,
+ 0x22, 0x55, 0xe2, 0xf0, 0x23, 0x6a, 0xaf, 0xe0, 0x24, 0x35, 0xc4, 0xf0,
+ 0x25, 0x4a, 0x91, 0xe0, 0x26, 0x15, 0xa6, 0xf0, 0x27, 0x2a, 0x73, 0xe0,
+ 0x27, 0xfe, 0xc3, 0x70, 0x29, 0x0a, 0x55, 0xe0, 0x29, 0xde, 0xa5, 0x70,
+ 0x2a, 0xea, 0x37, 0xe0, 0x2b, 0xbe, 0x87, 0x70, 0x2c, 0xd3, 0x54, 0x60,
+ 0x2d, 0x9e, 0x69, 0x70, 0x2e, 0xb3, 0x36, 0x60, 0x2f, 0x7e, 0x4b, 0x70,
+ 0x30, 0x93, 0x18, 0x60, 0x31, 0x67, 0x67, 0xf0, 0x32, 0x72, 0xfa, 0x60,
+ 0x33, 0x47, 0x49, 0xf0, 0x34, 0x52, 0xdc, 0x60, 0x35, 0x27, 0x2b, 0xf0,
+ 0x36, 0x32, 0xbe, 0x60, 0x37, 0x07, 0x0d, 0xf0, 0x38, 0x1b, 0xda, 0xe0,
+ 0x38, 0xe6, 0xef, 0xf0, 0x39, 0xfb, 0xbc, 0xe0, 0x3a, 0xc6, 0xd1, 0xf0,
+ 0x3b, 0xdb, 0x9e, 0xe0, 0x3c, 0xaf, 0xee, 0x70, 0x3d, 0xbb, 0x80, 0xe0,
+ 0x3e, 0x8f, 0xd0, 0x70, 0x3f, 0x9b, 0x62, 0xe0, 0x40, 0x6f, 0xb2, 0x70,
+ 0x41, 0x84, 0x7f, 0x60, 0x42, 0x4f, 0x94, 0x70, 0x43, 0x64, 0x61, 0x60,
+ 0x44, 0x2f, 0x76, 0x70, 0x45, 0x44, 0x43, 0x60, 0x45, 0xf3, 0xa8, 0xf0,
+ 0x47, 0x2d, 0x5f, 0xe0, 0x47, 0xd3, 0x8a, 0xf0, 0x49, 0x0d, 0x41, 0xe0,
+ 0x49, 0xb3, 0x6c, 0xf0, 0x4a, 0xed, 0x23, 0xe0, 0x4b, 0x9c, 0x89, 0x70,
+ 0x4c, 0xd6, 0x40, 0x60, 0x4d, 0x7c, 0x6b, 0x70, 0x4e, 0xb6, 0x22, 0x60,
+ 0x4f, 0x5c, 0x4d, 0x70, 0x50, 0x96, 0x04, 0x60, 0x51, 0x3c, 0x2f, 0x70,
+ 0x52, 0x75, 0xe6, 0x60, 0x53, 0x1c, 0x11, 0x70, 0x54, 0x55, 0xc8, 0x60,
+ 0x54, 0xfb, 0xf3, 0x70, 0x56, 0x35, 0xaa, 0x60, 0x56, 0xe5, 0x0f, 0xf0,
+ 0x58, 0x1e, 0xc6, 0xe0, 0x58, 0xc4, 0xf1, 0xf0, 0x59, 0xfe, 0xa8, 0xe0,
+ 0x5a, 0xa4, 0xd3, 0xf0, 0x5b, 0xde, 0x8a, 0xe0, 0x5c, 0x84, 0xb5, 0xf0,
+ 0x5d, 0xbe, 0x6c, 0xe0, 0x5e, 0x64, 0x97, 0xf0, 0x5f, 0x9e, 0x4e, 0xe0,
+ 0x60, 0x4d, 0xb4, 0x70, 0x61, 0x87, 0x6b, 0x60, 0x62, 0x2d, 0x96, 0x70,
+ 0x63, 0x67, 0x4d, 0x60, 0x64, 0x0d, 0x78, 0x70, 0x65, 0x47, 0x2f, 0x60,
+ 0x65, 0xed, 0x5a, 0x70, 0x67, 0x27, 0x11, 0x60, 0x67, 0xcd, 0x3c, 0x70,
+ 0x69, 0x06, 0xf3, 0x60, 0x69, 0xad, 0x1e, 0x70, 0x6a, 0xe6, 0xd5, 0x60,
+ 0x6b, 0x96, 0x3a, 0xf0, 0x6c, 0xcf, 0xf1, 0xe0, 0x6d, 0x76, 0x1c, 0xf0,
+ 0x6e, 0xaf, 0xd3, 0xe0, 0x6f, 0x55, 0xfe, 0xf0, 0x70, 0x8f, 0xb5, 0xe0,
+ 0x71, 0x35, 0xe0, 0xf0, 0x72, 0x6f, 0x97, 0xe0, 0x73, 0x15, 0xc2, 0xf0,
+ 0x74, 0x4f, 0x79, 0xe0, 0x74, 0xfe, 0xdf, 0x70, 0x76, 0x38, 0x96, 0x60,
+ 0x76, 0xde, 0xc1, 0x70, 0x78, 0x18, 0x78, 0x60, 0x78, 0xbe, 0xa3, 0x70,
+ 0x79, 0xf8, 0x5a, 0x60, 0x7a, 0x9e, 0x85, 0x70, 0x7b, 0xd8, 0x3c, 0x60,
+ 0x7c, 0x7e, 0x67, 0x70, 0x7d, 0xb8, 0x1e, 0x60, 0x7e, 0x5e, 0x49, 0x70,
+ 0x7f, 0x98, 0x00, 0x60, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x03, 0x04, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0xff, 0xff, 0xba, 0x9e, 0x00, 0x00, 0xff, 0xff, 0xc7, 0xc0, 0x01, 0x04,
+ 0xff, 0xff, 0xb9, 0xb0, 0x00, 0x08, 0xff, 0xff, 0xc7, 0xc0, 0x01, 0x0c,
+ 0xff, 0xff, 0xc7, 0xc0, 0x01, 0x10, 0x4c, 0x4d, 0x54, 0x00, 0x45, 0x44,
+ 0x54, 0x00, 0x45, 0x53, 0x54, 0x00, 0x45, 0x57, 0x54, 0x00, 0x45, 0x50,
+ 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xed,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x14, 0xf8, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x5e, 0x03, 0xf0, 0x90,
+ 0xff, 0xff, 0xff, 0xff, 0x9e, 0xa6, 0x1e, 0x70, 0xff, 0xff, 0xff, 0xff,
+ 0x9f, 0xba, 0xeb, 0x60, 0xff, 0xff, 0xff, 0xff, 0xa0, 0x86, 0x00, 0x70,
+ 0xff, 0xff, 0xff, 0xff, 0xa1, 0x9a, 0xcd, 0x60, 0xff, 0xff, 0xff, 0xff,
+ 0xa2, 0x65, 0xe2, 0x70, 0xff, 0xff, 0xff, 0xff, 0xa3, 0x83, 0xe9, 0xe0,
+ 0xff, 0xff, 0xff, 0xff, 0xa4, 0x6a, 0xae, 0x70, 0xff, 0xff, 0xff, 0xff,
+ 0xa5, 0x35, 0xa7, 0x60, 0xff, 0xff, 0xff, 0xff, 0xa6, 0x53, 0xca, 0xf0,
+ 0xff, 0xff, 0xff, 0xff, 0xa7, 0x15, 0x89, 0x60, 0xff, 0xff, 0xff, 0xff,
+ 0xa8, 0x33, 0xac, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xa8, 0xfe, 0xa5, 0xe0,
+ 0xff, 0xff, 0xff, 0xff, 0xaa, 0x13, 0x8e, 0xf0, 0xff, 0xff, 0xff, 0xff,
+ 0xaa, 0xde, 0x87, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xab, 0xf3, 0x70, 0xf0,
+ 0xff, 0xff, 0xff, 0xff, 0xac, 0xbe, 0x69, 0xe0, 0xff, 0xff, 0xff, 0xff,
+ 0xad, 0xd3, 0x52, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xae, 0x9e, 0x4b, 0xe0,
+ 0xff, 0xff, 0xff, 0xff, 0xaf, 0xb3, 0x34, 0xf0, 0xff, 0xff, 0xff, 0xff,
+ 0xb0, 0x7e, 0x2d, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xb1, 0x9c, 0x51, 0x70,
+ 0xff, 0xff, 0xff, 0xff, 0xb2, 0x67, 0x4a, 0x60, 0xff, 0xff, 0xff, 0xff,
+ 0xb3, 0x7c, 0x33, 0x70, 0xff, 0xff, 0xff, 0xff, 0xb4, 0x47, 0x2c, 0x60,
+ 0xff, 0xff, 0xff, 0xff, 0xb5, 0x5c, 0x15, 0x70, 0xff, 0xff, 0xff, 0xff,
+ 0xb6, 0x27, 0x0e, 0x60, 0xff, 0xff, 0xff, 0xff, 0xb7, 0x3b, 0xf7, 0x70,
+ 0xff, 0xff, 0xff, 0xff, 0xb8, 0x06, 0xf0, 0x60, 0xff, 0xff, 0xff, 0xff,
+ 0xb9, 0x1b, 0xd9, 0x70, 0xff, 0xff, 0xff, 0xff, 0xb9, 0xe6, 0xd2, 0x60,
+ 0xff, 0xff, 0xff, 0xff, 0xbb, 0x04, 0xf5, 0xf0, 0xff, 0xff, 0xff, 0xff,
+ 0xbb, 0xc6, 0xb4, 0x60, 0xff, 0xff, 0xff, 0xff, 0xbc, 0xe4, 0xd7, 0xf0,
+ 0xff, 0xff, 0xff, 0xff, 0xbd, 0xaf, 0xd0, 0xe0, 0xff, 0xff, 0xff, 0xff,
+ 0xbe, 0xc4, 0xb9, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xbf, 0x8f, 0xb2, 0xe0,
+ 0xff, 0xff, 0xff, 0xff, 0xc0, 0xa4, 0x9b, 0xf0, 0xff, 0xff, 0xff, 0xff,
+ 0xc1, 0x6f, 0x94, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xc2, 0x84, 0x7d, 0xf0,
+ 0xff, 0xff, 0xff, 0xff, 0xc3, 0x4f, 0x76, 0xe0, 0xff, 0xff, 0xff, 0xff,
+ 0xc4, 0x64, 0x5f, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xc5, 0x2f, 0x58, 0xe0,
+ 0xff, 0xff, 0xff, 0xff, 0xc6, 0x4d, 0x7c, 0x70, 0xff, 0xff, 0xff, 0xff,
+ 0xc7, 0x0f, 0x3a, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xc8, 0x2d, 0x5e, 0x70,
+ 0xff, 0xff, 0xff, 0xff, 0xc8, 0xf8, 0x57, 0x60, 0xff, 0xff, 0xff, 0xff,
+ 0xca, 0x0d, 0x40, 0x70, 0xff, 0xff, 0xff, 0xff, 0xca, 0xd8, 0x39, 0x60,
+ 0xff, 0xff, 0xff, 0xff, 0xcb, 0x88, 0xf0, 0x70, 0xff, 0xff, 0xff, 0xff,
+ 0xd2, 0x23, 0xf4, 0x70, 0xff, 0xff, 0xff, 0xff, 0xd2, 0x60, 0xfb, 0xe0,
+ 0xff, 0xff, 0xff, 0xff, 0xd3, 0x75, 0xe4, 0xf0, 0xff, 0xff, 0xff, 0xff,
+ 0xd4, 0x40, 0xdd, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xd5, 0x55, 0xc6, 0xf0,
+ 0xff, 0xff, 0xff, 0xff, 0xd6, 0x20, 0xbf, 0xe0, 0xff, 0xff, 0xff, 0xff,
+ 0xd7, 0x35, 0xa8, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xd8, 0x00, 0xa1, 0xe0,
+ 0xff, 0xff, 0xff, 0xff, 0xd9, 0x15, 0x8a, 0xf0, 0xff, 0xff, 0xff, 0xff,
+ 0xd9, 0xe0, 0x83, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xda, 0xfe, 0xa7, 0x70,
+ 0xff, 0xff, 0xff, 0xff, 0xdb, 0xc0, 0x65, 0xe0, 0xff, 0xff, 0xff, 0xff,
+ 0xdc, 0xde, 0x89, 0x70, 0xff, 0xff, 0xff, 0xff, 0xdd, 0xa9, 0x82, 0x60,
+ 0xff, 0xff, 0xff, 0xff, 0xde, 0xbe, 0x6b, 0x70, 0xff, 0xff, 0xff, 0xff,
+ 0xdf, 0x89, 0x64, 0x60, 0xff, 0xff, 0xff, 0xff, 0xe0, 0x9e, 0x4d, 0x70,
+ 0xff, 0xff, 0xff, 0xff, 0xe1, 0x69, 0x46, 0x60, 0xff, 0xff, 0xff, 0xff,
+ 0xe2, 0x7e, 0x2f, 0x70, 0xff, 0xff, 0xff, 0xff, 0xe3, 0x49, 0x28, 0x60,
+ 0xff, 0xff, 0xff, 0xff, 0xe4, 0x5e, 0x11, 0x70, 0xff, 0xff, 0xff, 0xff,
+ 0xe5, 0x57, 0x2e, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xe6, 0x47, 0x2d, 0xf0,
+ 0xff, 0xff, 0xff, 0xff, 0xe7, 0x37, 0x10, 0xe0, 0xff, 0xff, 0xff, 0xff,
+ 0xe8, 0x27, 0x0f, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xe9, 0x16, 0xf2, 0xe0,
+ 0xff, 0xff, 0xff, 0xff, 0xea, 0x06, 0xf1, 0xf0, 0xff, 0xff, 0xff, 0xff,
+ 0xea, 0xf6, 0xd4, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xeb, 0xe6, 0xd3, 0xf0,
+ 0xff, 0xff, 0xff, 0xff, 0xec, 0xd6, 0xb6, 0xe0, 0xff, 0xff, 0xff, 0xff,
+ 0xed, 0xc6, 0xb5, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xee, 0xbf, 0xd3, 0x60,
+ 0xff, 0xff, 0xff, 0xff, 0xef, 0xaf, 0xd2, 0x70, 0xff, 0xff, 0xff, 0xff,
+ 0xf0, 0x9f, 0xb5, 0x60, 0xff, 0xff, 0xff, 0xff, 0xf1, 0x8f, 0xb4, 0x70,
+ 0xff, 0xff, 0xff, 0xff, 0xf2, 0x7f, 0x97, 0x60, 0xff, 0xff, 0xff, 0xff,
+ 0xf3, 0x6f, 0x96, 0x70, 0xff, 0xff, 0xff, 0xff, 0xf4, 0x5f, 0x79, 0x60,
+ 0xff, 0xff, 0xff, 0xff, 0xf5, 0x4f, 0x78, 0x70, 0xff, 0xff, 0xff, 0xff,
+ 0xf6, 0x3f, 0x5b, 0x60, 0xff, 0xff, 0xff, 0xff, 0xf7, 0x2f, 0x5a, 0x70,
+ 0xff, 0xff, 0xff, 0xff, 0xf8, 0x28, 0x77, 0xe0, 0xff, 0xff, 0xff, 0xff,
+ 0xf9, 0x0f, 0x3c, 0x70, 0xff, 0xff, 0xff, 0xff, 0xfa, 0x08, 0x59, 0xe0,
+ 0xff, 0xff, 0xff, 0xff, 0xfa, 0xf8, 0x58, 0xf0, 0xff, 0xff, 0xff, 0xff,
+ 0xfb, 0xe8, 0x3b, 0xe0, 0xff, 0xff, 0xff, 0xff, 0xfc, 0xd8, 0x3a, 0xf0,
+ 0xff, 0xff, 0xff, 0xff, 0xfd, 0xc8, 0x1d, 0xe0, 0xff, 0xff, 0xff, 0xff,
+ 0xfe, 0xb8, 0x1c, 0xf0, 0xff, 0xff, 0xff, 0xff, 0xff, 0xa7, 0xff, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x97, 0xfe, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x01, 0x87, 0xe1, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x02, 0x77, 0xe0, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x03, 0x70, 0xfe, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x04, 0x60, 0xfd, 0x70, 0x00, 0x00, 0x00, 0x00, 0x05, 0x50, 0xe0, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x06, 0x40, 0xdf, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x07, 0x30, 0xc2, 0x60, 0x00, 0x00, 0x00, 0x00, 0x07, 0x8d, 0x19, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x09, 0x10, 0xa4, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x09, 0xad, 0x94, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x0a, 0xf0, 0x86, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x0b, 0xe0, 0x85, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x0c, 0xd9, 0xa2, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x0d, 0xc0, 0x67, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x0e, 0xb9, 0x84, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x0f, 0xa9, 0x83, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x10, 0x99, 0x66, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x11, 0x89, 0x65, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x12, 0x79, 0x48, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x13, 0x69, 0x47, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x14, 0x59, 0x2a, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x15, 0x49, 0x29, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x16, 0x39, 0x0c, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x17, 0x29, 0x0b, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x18, 0x22, 0x29, 0x60, 0x00, 0x00, 0x00, 0x00, 0x19, 0x08, 0xed, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x1a, 0x02, 0x0b, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x1a, 0xf2, 0x0a, 0x70, 0x00, 0x00, 0x00, 0x00, 0x1b, 0xe1, 0xed, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x1c, 0xd1, 0xec, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x1d, 0xc1, 0xcf, 0x60, 0x00, 0x00, 0x00, 0x00, 0x1e, 0xb1, 0xce, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x1f, 0xa1, 0xb1, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x20, 0x76, 0x00, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x21, 0x81, 0x93, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x22, 0x55, 0xe2, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x23, 0x6a, 0xaf, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x24, 0x35, 0xc4, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x25, 0x4a, 0x91, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x26, 0x15, 0xa6, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x27, 0x2a, 0x73, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x27, 0xfe, 0xc3, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x29, 0x0a, 0x55, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x29, 0xde, 0xa5, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x2a, 0xea, 0x37, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x2b, 0xbe, 0x87, 0x70, 0x00, 0x00, 0x00, 0x00, 0x2c, 0xd3, 0x54, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x2d, 0x9e, 0x69, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x2e, 0xb3, 0x36, 0x60, 0x00, 0x00, 0x00, 0x00, 0x2f, 0x7e, 0x4b, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x30, 0x93, 0x18, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x31, 0x67, 0x67, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x32, 0x72, 0xfa, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x33, 0x47, 0x49, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x34, 0x52, 0xdc, 0x60, 0x00, 0x00, 0x00, 0x00, 0x35, 0x27, 0x2b, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x36, 0x32, 0xbe, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x37, 0x07, 0x0d, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x38, 0x1b, 0xda, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x38, 0xe6, 0xef, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x39, 0xfb, 0xbc, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x3a, 0xc6, 0xd1, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x3b, 0xdb, 0x9e, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x3c, 0xaf, 0xee, 0x70, 0x00, 0x00, 0x00, 0x00, 0x3d, 0xbb, 0x80, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x3e, 0x8f, 0xd0, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x3f, 0x9b, 0x62, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x40, 0x6f, 0xb2, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x41, 0x84, 0x7f, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x42, 0x4f, 0x94, 0x70, 0x00, 0x00, 0x00, 0x00, 0x43, 0x64, 0x61, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x44, 0x2f, 0x76, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x45, 0x44, 0x43, 0x60, 0x00, 0x00, 0x00, 0x00, 0x45, 0xf3, 0xa8, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x47, 0x2d, 0x5f, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x47, 0xd3, 0x8a, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x49, 0x0d, 0x41, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x49, 0xb3, 0x6c, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x4a, 0xed, 0x23, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x4b, 0x9c, 0x89, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x4c, 0xd6, 0x40, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x4d, 0x7c, 0x6b, 0x70, 0x00, 0x00, 0x00, 0x00, 0x4e, 0xb6, 0x22, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x4f, 0x5c, 0x4d, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x50, 0x96, 0x04, 0x60, 0x00, 0x00, 0x00, 0x00, 0x51, 0x3c, 0x2f, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x52, 0x75, 0xe6, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x53, 0x1c, 0x11, 0x70, 0x00, 0x00, 0x00, 0x00, 0x54, 0x55, 0xc8, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x54, 0xfb, 0xf3, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x56, 0x35, 0xaa, 0x60, 0x00, 0x00, 0x00, 0x00, 0x56, 0xe5, 0x0f, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x58, 0x1e, 0xc6, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x58, 0xc4, 0xf1, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x59, 0xfe, 0xa8, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x5a, 0xa4, 0xd3, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x5b, 0xde, 0x8a, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x5c, 0x84, 0xb5, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x5d, 0xbe, 0x6c, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x5e, 0x64, 0x97, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x5f, 0x9e, 0x4e, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x60, 0x4d, 0xb4, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x61, 0x87, 0x6b, 0x60, 0x00, 0x00, 0x00, 0x00, 0x62, 0x2d, 0x96, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x63, 0x67, 0x4d, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x64, 0x0d, 0x78, 0x70, 0x00, 0x00, 0x00, 0x00, 0x65, 0x47, 0x2f, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x65, 0xed, 0x5a, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x67, 0x27, 0x11, 0x60, 0x00, 0x00, 0x00, 0x00, 0x67, 0xcd, 0x3c, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x69, 0x06, 0xf3, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x69, 0xad, 0x1e, 0x70, 0x00, 0x00, 0x00, 0x00, 0x6a, 0xe6, 0xd5, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x6b, 0x96, 0x3a, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x6c, 0xcf, 0xf1, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x6d, 0x76, 0x1c, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x6e, 0xaf, 0xd3, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x6f, 0x55, 0xfe, 0xf0, 0x00, 0x00, 0x00, 0x00, 0x70, 0x8f, 0xb5, 0xe0,
+ 0x00, 0x00, 0x00, 0x00, 0x71, 0x35, 0xe0, 0xf0, 0x00, 0x00, 0x00, 0x00,
+ 0x72, 0x6f, 0x97, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x73, 0x15, 0xc2, 0xf0,
+ 0x00, 0x00, 0x00, 0x00, 0x74, 0x4f, 0x79, 0xe0, 0x00, 0x00, 0x00, 0x00,
+ 0x74, 0xfe, 0xdf, 0x70, 0x00, 0x00, 0x00, 0x00, 0x76, 0x38, 0x96, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x76, 0xde, 0xc1, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x78, 0x18, 0x78, 0x60, 0x00, 0x00, 0x00, 0x00, 0x78, 0xbe, 0xa3, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x79, 0xf8, 0x5a, 0x60, 0x00, 0x00, 0x00, 0x00,
+ 0x7a, 0x9e, 0x85, 0x70, 0x00, 0x00, 0x00, 0x00, 0x7b, 0xd8, 0x3c, 0x60,
+ 0x00, 0x00, 0x00, 0x00, 0x7c, 0x7e, 0x67, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x7d, 0xb8, 0x1e, 0x60, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x5e, 0x49, 0x70,
+ 0x00, 0x00, 0x00, 0x00, 0x7f, 0x98, 0x00, 0x60, 0x00, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x03, 0x04,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0xff, 0xff, 0xba, 0x9e, 0x00, 0x00, 0xff,
+ 0xff, 0xc7, 0xc0, 0x01, 0x04, 0xff, 0xff, 0xb9, 0xb0, 0x00, 0x08, 0xff,
+ 0xff, 0xc7, 0xc0, 0x01, 0x0c, 0xff, 0xff, 0xc7, 0xc0, 0x01, 0x10, 0x4c,
+ 0x4d, 0x54, 0x00, 0x45, 0x44, 0x54, 0x00, 0x45, 0x53, 0x54, 0x00, 0x45,
+ 0x57, 0x54, 0x00, 0x45, 0x50, 0x54, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
+ 0x00, 0x00, 0x00, 0x00, 0x01, 0x0a, 0x45, 0x53, 0x54, 0x35, 0x45, 0x44,
+ 0x54, 0x2c, 0x4d, 0x33, 0x2e, 0x32, 0x2e, 0x30, 0x2c, 0x4d, 0x31, 0x31,
+ 0x2e, 0x31, 0x2e, 0x30, 0x0a
+};
+unsigned int America_New_York_len = 3545;
+unsigned char Australia_Sydney[] = {
+ 0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8e,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0e, 0x80, 0x00, 0x00, 0x00,
+ 0x9c, 0x4e, 0xa6, 0x9c, 0x9c, 0xbc, 0x20, 0xf0, 0xcb, 0x54, 0xb3, 0x00,
+ 0xcb, 0xc7, 0x57, 0x70, 0xcc, 0xb7, 0x56, 0x80, 0xcd, 0xa7, 0x39, 0x70,
+ 0xce, 0xa0, 0x73, 0x00, 0xcf, 0x87, 0x1b, 0x70, 0x03, 0x70, 0x39, 0x80,
+ 0x04, 0x0d, 0x1c, 0x00, 0x05, 0x50, 0x1b, 0x80, 0x05, 0xf6, 0x38, 0x80,
+ 0x07, 0x2f, 0xfd, 0x80, 0x07, 0xd6, 0x1a, 0x80, 0x09, 0x0f, 0xdf, 0x80,
+ 0x09, 0xb5, 0xfc, 0x80, 0x0a, 0xef, 0xc1, 0x80, 0x0b, 0x9f, 0x19, 0x00,
+ 0x0c, 0xd8, 0xde, 0x00, 0x0d, 0x7e, 0xfb, 0x00, 0x0e, 0xb8, 0xc0, 0x00,
+ 0x0f, 0x5e, 0xdd, 0x00, 0x10, 0x98, 0xa2, 0x00, 0x11, 0x3e, 0xbf, 0x00,
+ 0x12, 0x78, 0x84, 0x00, 0x13, 0x1e, 0xa1, 0x00, 0x14, 0x58, 0x66, 0x00,
+ 0x14, 0xfe, 0x83, 0x00, 0x16, 0x38, 0x48, 0x00, 0x17, 0x0c, 0x89, 0x80,
+ 0x18, 0x21, 0x64, 0x80, 0x18, 0xc7, 0x81, 0x80, 0x1a, 0x01, 0x46, 0x80,
+ 0x1a, 0xa7, 0x63, 0x80, 0x1b, 0xe1, 0x28, 0x80, 0x1c, 0x87, 0x45, 0x80,
+ 0x1d, 0xc1, 0x0a, 0x80, 0x1e, 0x79, 0x9c, 0x80, 0x1f, 0x97, 0xb2, 0x00,
+ 0x20, 0x59, 0x7e, 0x80, 0x21, 0x80, 0xce, 0x80, 0x22, 0x42, 0x9b, 0x00,
+ 0x23, 0x69, 0xeb, 0x00, 0x24, 0x22, 0x7d, 0x00, 0x25, 0x49, 0xcd, 0x00,
+ 0x25, 0xef, 0xea, 0x00, 0x27, 0x29, 0xaf, 0x00, 0x27, 0xcf, 0xcc, 0x00,
+ 0x29, 0x09, 0x91, 0x00, 0x29, 0xaf, 0xae, 0x00, 0x2a, 0xe9, 0x73, 0x00,
+ 0x2b, 0x98, 0xca, 0x80, 0x2c, 0xd2, 0x8f, 0x80, 0x2d, 0x78, 0xac, 0x80,
+ 0x2e, 0xb2, 0x71, 0x80, 0x2f, 0x58, 0x8e, 0x80, 0x30, 0x92, 0x53, 0x80,
+ 0x31, 0x5d, 0x5a, 0x80, 0x32, 0x72, 0x35, 0x80, 0x33, 0x3d, 0x3c, 0x80,
+ 0x34, 0x52, 0x17, 0x80, 0x35, 0x1d, 0x1e, 0x80, 0x36, 0x31, 0xf9, 0x80,
+ 0x36, 0xfd, 0x00, 0x80, 0x38, 0x1b, 0x16, 0x00, 0x38, 0xdc, 0xe2, 0x80,
+ 0x39, 0xa7, 0xe9, 0x80, 0x3a, 0xbc, 0xc4, 0x80, 0x3b, 0xda, 0xda, 0x00,
+ 0x3c, 0xa5, 0xe1, 0x00, 0x3d, 0xba, 0xbc, 0x00, 0x3e, 0x85, 0xc3, 0x00,
+ 0x3f, 0x9a, 0x9e, 0x00, 0x40, 0x65, 0xa5, 0x00, 0x41, 0x83, 0xba, 0x80,
+ 0x42, 0x45, 0x87, 0x00, 0x43, 0x63, 0x9c, 0x80, 0x44, 0x2e, 0xa3, 0x80,
+ 0x45, 0x43, 0x7e, 0x80, 0x46, 0x05, 0x4b, 0x00, 0x47, 0x23, 0x60, 0x80,
+ 0x47, 0xf7, 0xa2, 0x00, 0x48, 0xe7, 0x93, 0x00, 0x49, 0xd7, 0x84, 0x00,
+ 0x4a, 0xc7, 0x75, 0x00, 0x4b, 0xb7, 0x66, 0x00, 0x4c, 0xa7, 0x57, 0x00,
+ 0x4d, 0x97, 0x48, 0x00, 0x4e, 0x87, 0x39, 0x00, 0x4f, 0x77, 0x2a, 0x00,
+ 0x50, 0x70, 0x55, 0x80, 0x51, 0x60, 0x46, 0x80, 0x52, 0x50, 0x37, 0x80,
+ 0x53, 0x40, 0x28, 0x80, 0x54, 0x30, 0x19, 0x80, 0x55, 0x20, 0x0a, 0x80,
+ 0x56, 0x0f, 0xfb, 0x80, 0x56, 0xff, 0xec, 0x80, 0x57, 0xef, 0xdd, 0x80,
+ 0x58, 0xdf, 0xce, 0x80, 0x59, 0xcf, 0xbf, 0x80, 0x5a, 0xbf, 0xb0, 0x80,
+ 0x5b, 0xb8, 0xdc, 0x00, 0x5c, 0xa8, 0xcd, 0x00, 0x5d, 0x98, 0xbe, 0x00,
+ 0x5e, 0x88, 0xaf, 0x00, 0x5f, 0x78, 0xa0, 0x00, 0x60, 0x68, 0x91, 0x00,
+ 0x61, 0x58, 0x82, 0x00, 0x62, 0x48, 0x73, 0x00, 0x63, 0x38, 0x64, 0x00,
+ 0x64, 0x28, 0x55, 0x00, 0x65, 0x18, 0x46, 0x00, 0x66, 0x11, 0x71, 0x80,
+ 0x67, 0x01, 0x62, 0x80, 0x67, 0xf1, 0x53, 0x80, 0x68, 0xe1, 0x44, 0x80,
+ 0x69, 0xd1, 0x35, 0x80, 0x6a, 0xc1, 0x26, 0x80, 0x6b, 0xb1, 0x17, 0x80,
+ 0x6c, 0xa1, 0x08, 0x80, 0x6d, 0x90, 0xf9, 0x80, 0x6e, 0x80, 0xea, 0x80,
+ 0x6f, 0x70, 0xdb, 0x80, 0x70, 0x6a, 0x07, 0x00, 0x71, 0x59, 0xf8, 0x00,
+ 0x72, 0x49, 0xe9, 0x00, 0x73, 0x39, 0xda, 0x00, 0x74, 0x29, 0xcb, 0x00,
+ 0x75, 0x19, 0xbc, 0x00, 0x76, 0x09, 0xad, 0x00, 0x76, 0xf9, 0x9e, 0x00,
+ 0x77, 0xe9, 0x8f, 0x00, 0x78, 0xd9, 0x80, 0x00, 0x79, 0xc9, 0x71, 0x00,
+ 0x7a, 0xb9, 0x62, 0x00, 0x7b, 0xb2, 0x8d, 0x80, 0x7c, 0xa2, 0x7e, 0x80,
+ 0x7d, 0x92, 0x6f, 0x80, 0x7e, 0x82, 0x60, 0x80, 0x7f, 0x72, 0x51, 0x80,
+ 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03,
+ 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x00, 0x00,
+ 0x8d, 0xc4, 0x00, 0x00, 0x00, 0x00, 0x9a, 0xb0, 0x01, 0x04, 0x00, 0x00,
+ 0x8c, 0xa0, 0x00, 0x09, 0x00, 0x00, 0x9a, 0xb0, 0x01, 0x04, 0x00, 0x00,
+ 0x8c, 0xa0, 0x00, 0x09, 0x4c, 0x4d, 0x54, 0x00, 0x41, 0x45, 0x44, 0x54,
+ 0x00, 0x41, 0x45, 0x53, 0x54, 0x00, 0x00, 0x00, 0x00, 0x01, 0x01, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x54, 0x5a, 0x69, 0x66, 0x32, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x8f, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x0e,
+ 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
+ 0x73, 0x16, 0x7f, 0x3c, 0xff, 0xff, 0xff, 0xff, 0x9c, 0x4e, 0xa6, 0x9c,
+ 0xff, 0xff, 0xff, 0xff, 0x9c, 0xbc, 0x20, 0xf0, 0xff, 0xff, 0xff, 0xff,
+ 0xcb, 0x54, 0xb3, 0x00, 0xff, 0xff, 0xff, 0xff, 0xcb, 0xc7, 0x57, 0x70,
+ 0xff, 0xff, 0xff, 0xff, 0xcc, 0xb7, 0x56, 0x80, 0xff, 0xff, 0xff, 0xff,
+ 0xcd, 0xa7, 0x39, 0x70, 0xff, 0xff, 0xff, 0xff, 0xce, 0xa0, 0x73, 0x00,
+ 0xff, 0xff, 0xff, 0xff, 0xcf, 0x87, 0x1b, 0x70, 0x00, 0x00, 0x00, 0x00,
+ 0x03, 0x70, 0x39, 0x80, 0x00, 0x00, 0x00, 0x00, 0x04, 0x0d, 0x1c, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x05, 0x50, 0x1b, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x05, 0xf6, 0x38, 0x80, 0x00, 0x00, 0x00, 0x00, 0x07, 0x2f, 0xfd, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x07, 0xd6, 0x1a, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x09, 0x0f, 0xdf, 0x80, 0x00, 0x00, 0x00, 0x00, 0x09, 0xb5, 0xfc, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x0a, 0xef, 0xc1, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x0b, 0x9f, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0xd8, 0xde, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x0d, 0x7e, 0xfb, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x0e, 0xb8, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0f, 0x5e, 0xdd, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x10, 0x98, 0xa2, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x11, 0x3e, 0xbf, 0x00, 0x00, 0x00, 0x00, 0x00, 0x12, 0x78, 0x84, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x13, 0x1e, 0xa1, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x14, 0x58, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x14, 0xfe, 0x83, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x16, 0x38, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x17, 0x0c, 0x89, 0x80, 0x00, 0x00, 0x00, 0x00, 0x18, 0x21, 0x64, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x18, 0xc7, 0x81, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x1a, 0x01, 0x46, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1a, 0xa7, 0x63, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x1b, 0xe1, 0x28, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x1c, 0x87, 0x45, 0x80, 0x00, 0x00, 0x00, 0x00, 0x1d, 0xc1, 0x0a, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x1e, 0x79, 0x9c, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x1f, 0x97, 0xb2, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x59, 0x7e, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x21, 0x80, 0xce, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x22, 0x42, 0x9b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x23, 0x69, 0xeb, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x24, 0x22, 0x7d, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x25, 0x49, 0xcd, 0x00, 0x00, 0x00, 0x00, 0x00, 0x25, 0xef, 0xea, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x27, 0x29, 0xaf, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x27, 0xcf, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x29, 0x09, 0x91, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x29, 0xaf, 0xae, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x2a, 0xe9, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2b, 0x98, 0xca, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x2c, 0xd2, 0x8f, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x2d, 0x78, 0xac, 0x80, 0x00, 0x00, 0x00, 0x00, 0x2e, 0xb2, 0x71, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x2f, 0x58, 0x8e, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x30, 0x92, 0x53, 0x80, 0x00, 0x00, 0x00, 0x00, 0x31, 0x5d, 0x5a, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x32, 0x72, 0x35, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x33, 0x3d, 0x3c, 0x80, 0x00, 0x00, 0x00, 0x00, 0x34, 0x52, 0x17, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x35, 0x1d, 0x1e, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x36, 0x31, 0xf9, 0x80, 0x00, 0x00, 0x00, 0x00, 0x36, 0xfd, 0x00, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x38, 0x1b, 0x16, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x38, 0xdc, 0xe2, 0x80, 0x00, 0x00, 0x00, 0x00, 0x39, 0xa7, 0xe9, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x3a, 0xbc, 0xc4, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x3b, 0xda, 0xda, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0xa5, 0xe1, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x3d, 0xba, 0xbc, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x3e, 0x85, 0xc3, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3f, 0x9a, 0x9e, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x40, 0x65, 0xa5, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x41, 0x83, 0xba, 0x80, 0x00, 0x00, 0x00, 0x00, 0x42, 0x45, 0x87, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x43, 0x63, 0x9c, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x44, 0x2e, 0xa3, 0x80, 0x00, 0x00, 0x00, 0x00, 0x45, 0x43, 0x7e, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x46, 0x05, 0x4b, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x47, 0x23, 0x60, 0x80, 0x00, 0x00, 0x00, 0x00, 0x47, 0xf7, 0xa2, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x48, 0xe7, 0x93, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x49, 0xd7, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4a, 0xc7, 0x75, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x4b, 0xb7, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x4c, 0xa7, 0x57, 0x00, 0x00, 0x00, 0x00, 0x00, 0x4d, 0x97, 0x48, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x4e, 0x87, 0x39, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x4f, 0x77, 0x2a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x50, 0x70, 0x55, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x51, 0x60, 0x46, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x52, 0x50, 0x37, 0x80, 0x00, 0x00, 0x00, 0x00, 0x53, 0x40, 0x28, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x54, 0x30, 0x19, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x55, 0x20, 0x0a, 0x80, 0x00, 0x00, 0x00, 0x00, 0x56, 0x0f, 0xfb, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x56, 0xff, 0xec, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x57, 0xef, 0xdd, 0x80, 0x00, 0x00, 0x00, 0x00, 0x58, 0xdf, 0xce, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x59, 0xcf, 0xbf, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x5a, 0xbf, 0xb0, 0x80, 0x00, 0x00, 0x00, 0x00, 0x5b, 0xb8, 0xdc, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x5c, 0xa8, 0xcd, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x5d, 0x98, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5e, 0x88, 0xaf, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x5f, 0x78, 0xa0, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x60, 0x68, 0x91, 0x00, 0x00, 0x00, 0x00, 0x00, 0x61, 0x58, 0x82, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x62, 0x48, 0x73, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x63, 0x38, 0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x64, 0x28, 0x55, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x65, 0x18, 0x46, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x66, 0x11, 0x71, 0x80, 0x00, 0x00, 0x00, 0x00, 0x67, 0x01, 0x62, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x67, 0xf1, 0x53, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x68, 0xe1, 0x44, 0x80, 0x00, 0x00, 0x00, 0x00, 0x69, 0xd1, 0x35, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x6a, 0xc1, 0x26, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x6b, 0xb1, 0x17, 0x80, 0x00, 0x00, 0x00, 0x00, 0x6c, 0xa1, 0x08, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x6d, 0x90, 0xf9, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x6e, 0x80, 0xea, 0x80, 0x00, 0x00, 0x00, 0x00, 0x6f, 0x70, 0xdb, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x70, 0x6a, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x71, 0x59, 0xf8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x72, 0x49, 0xe9, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x73, 0x39, 0xda, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x74, 0x29, 0xcb, 0x00, 0x00, 0x00, 0x00, 0x00, 0x75, 0x19, 0xbc, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x76, 0x09, 0xad, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x76, 0xf9, 0x9e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x77, 0xe9, 0x8f, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x78, 0xd9, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x79, 0xc9, 0x71, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7a, 0xb9, 0x62, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x7b, 0xb2, 0x8d, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x7c, 0xa2, 0x7e, 0x80, 0x00, 0x00, 0x00, 0x00, 0x7d, 0x92, 0x6f, 0x80,
+ 0x00, 0x00, 0x00, 0x00, 0x7e, 0x82, 0x60, 0x80, 0x00, 0x00, 0x00, 0x00,
+ 0x7f, 0x72, 0x51, 0x80, 0x00, 0x02, 0x01, 0x02, 0x01, 0x02, 0x01, 0x02,
+ 0x01, 0x02, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04, 0x03, 0x04,
+ 0x03, 0x04, 0x03, 0x00, 0x00, 0x8d, 0xc4, 0x00, 0x00, 0x00, 0x00, 0x9a,
+ 0xb0, 0x01, 0x04, 0x00, 0x00, 0x8c, 0xa0, 0x00, 0x09, 0x00, 0x00, 0x9a,
+ 0xb0, 0x01, 0x04, 0x00, 0x00, 0x8c, 0xa0, 0x00, 0x09, 0x4c, 0x4d, 0x54,
+ 0x00, 0x41, 0x45, 0x44, 0x54, 0x00, 0x41, 0x45, 0x53, 0x54, 0x00, 0x00,
+ 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x41, 0x45,
+ 0x53, 0x54, 0x2d, 0x31, 0x30, 0x41, 0x45, 0x44, 0x54, 0x2c, 0x4d, 0x31,
+ 0x30, 0x2e, 0x31, 0x2e, 0x30, 0x2c, 0x4d, 0x34, 0x2e, 0x31, 0x2e, 0x30,
+ 0x2f, 0x33, 0x0a
+};
+unsigned int Australia_Sydney_len = 2223;