cpp/src/utils/util_define.h - tsfile - Git at Google

 /*
  * 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.
  */
 #ifndef UTILS_UTIL_DEFINE_H
 #define UTILS_UTIL_DEFINE_H

 #include <assert.h>
 #include <stdint.h>
 #include <stdlib.h>

 /* ======== platform compatibility ========
  *
  * MSVC does not provide several POSIX types/functions/macros used across the
  * codebase. Provide drop-in equivalents so the same source compiles on both
  * GCC/Clang (Linux) and MSVC (Windows) without scattering #ifdefs.
  */
 #ifdef _WIN32
 #include <io.h>
 #include <string.h>

 #if defined(_MSC_VER)
 // ssize_t is a signed, pointer-sized integer; intptr_t (from <stdint.h>,
 // included above) is exactly that. We deliberately avoid <BaseTsd.h>/SSIZE_T
 // because that header also pollutes the global namespace with INT32/INT64
 // typedefs, which collide with the project's own INT32/INT64 enum values.
 typedef intptr_t ssize_t;
 typedef int mode_t;
 #endif  // _MSC_VER

 // access() mode flags (POSIX <unistd.h>); MSVC's _access uses the same bits.
 #ifndef F_OK
 #define F_OK 0
 #endif
 #ifndef X_OK
 #define X_OK 1
 #endif
 #ifndef W_OK
 #define W_OK 2
 #endif
 #ifndef R_OK
 #define R_OK 4
 #endif

 #ifndef strcasecmp
 #define strcasecmp _stricmp
 #endif
 #ifndef strncasecmp
 #define strncasecmp _strnicmp
 #endif
 #endif  // _WIN32

 /* ======== shared-library symbol visibility ========
  *
  * Functions are exported from tsfile.dll automatically via
  * CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS, but global DATA symbols (plain variables,
  * static class members) are not reliably auto-exported, and a consumer must
  * see __declspec(dllimport) to reference them across the DLL boundary. Mark
  * such symbols with TSFILE_API: it expands to dllexport while building the
  * library (TSFILE_BUILDING is defined for its own translation units),
  * dllimport for external consumers, and nothing on non-MSVC toolchains.
  */
 #if defined(_MSC_VER)
 #if defined(TSFILE_BUILDING)
 #define TSFILE_API __declspec(dllexport)
 #else
 #define TSFILE_API __declspec(dllimport)
 #endif
 #else
 #define TSFILE_API
 #endif

 /* ======== unused ======== */
 #define UNUSED(v) ((void)(v))
 #if __cplusplus >= 201703L
 #define MAYBE_UNUSED [[maybe_unused]]
 #elif defined(__GNUC__) || defined(__clang__)
 #define MAYBE_UNUSED __attribute__((unused))
 #else
 #define MAYBE_UNUSED
 #endif

 /* ======== inline ======== */
 #if defined(__GNUC__) || defined(__clang__)
 #define FORCE_INLINE inline __attribute__((always_inline))
 #elif defined(_MSC_VER)
 #define FORCE_INLINE __forceinline
 #else
 #define FORCE_INLINE inline
 #endif  // __GNUC__

 #ifdef BUILD_FOR_SMALL_BINARY
 #define INLINE FORCE_INLINE
 #else
 #define INLINE
 #endif  // BUILD_FOR_SMALL_BINARY

 /* ======== likely ======== */
 #if defined(__GNUC__) && __GNUC__ >= 4
 #define LIKELY(x) (__builtin_expect((x), 1))
 #define UNLIKELY(x) (__builtin_expect((x), 0))
 #else
 #define LIKELY(x) (x)
 #define UNLIKELY(x) (x)
 #endif  // __GNUC__ >= 4

 /* ======== nullptr ======== */
 #if __cplusplus < 201103L
 #ifndef nullptr
 #define nullptr NULL
 #endif
 #define OVERRIDE
 #else
 #define OVERRIDE override
 #endif  // __cplusplus < 201103L

 /* ======== cache line ======== */
 #ifndef CACHE_LINE_SIZE
 #define CACHE_LINE_SIZE 64
 #endif  // CACHE_LINE_SIZE

 /* ======== assert ======== */
 #ifdef NDEBUG
 #define ASSERT(condition) ((void)0)
 #else
 #define ASSERT(condition) assert((condition))
 #endif  // NDEBUG

 /* ======== statis assert ======== */
 /*
  * To be compatible with C++ before C++11,
  * @msg should be a single word (use -/_ to concat)
  * such as This_should_be_TRUE
  */
 #if __cplusplus < 201103L
 // TODO only define this when DEBUG
 #define STATIC_ASSERT(cond, msg) \
     typedef char static_assertion_##msg[(cond) ? 1 : -1] __attribute__((unused))
 #else
 #define STATIC_ASSERT(cond, msg) static_assert((cond), #msg)
 #endif  // __cplusplus < 201103L

 /* ======== atomic operation ========
  *
  * The ATOMIC_* macros operate on the address of a plain (non-std::atomic)
  * scalar, matching the semantics of the GCC/Clang __atomic builtins.
  *
  * - On GCC/Clang the builtins are used directly (unchanged behaviour).
  * - On other compilers (MSVC) they are implemented on top of C++11 <atomic>
  *   via helper templates. Reinterpreting a plain scalar's address as a
  *   std::atomic<T>* is well-defined in practice for lock-free integral types
  *   (this is exactly what C++20 std::atomic_ref formalizes); all current call
  *   sites use naturally-aligned integral members.
  */
 #if defined(__GNUC__) || defined(__clang__)
 #define ATOMIC_FAA(val_addr, addv) \
     __atomic_fetch_add((val_addr), (addv), __ATOMIC_SEQ_CST)
 #define ATOMIC_AAF(val_addr, addv) \
     __atomic_add_fetch((val_addr), (addv), __ATOMIC_SEQ_CST)
 /*
  * It implements an atomic compare and exchange operation.
  * This compares the contents of *ptr with the contents of *expected.
  * - If equal, the operation is a reader-modify-writer operation that writes
  * desired into *ptr.
  * - If they are not equal, the operation is a reader and the current contents
  * of *ptr are written into *expected
  */
 #define ATOMIC_CAS(val_addr, expected, desired)                            \
     __atomic_compare_exchange_n((val_addr), (expected), (desired),         \
                                 /* weak = */ false,                        \
                                 /* success_memorder = */ __ATOMIC_SEQ_CST, \
                                 /* failure_memorder = */ __ATOMIC_SEQ_CST)
 #define ATOMIC_LOAD(val_addr) __atomic_load_n((val_addr), __ATOMIC_SEQ_CST)
 #define ATOMIC_STORE(val_addr, val) \
     __atomic_store_n((val_addr), (val), __ATOMIC_SEQ_CST)
 #elif defined(__cplusplus)
 #include <atomic>
 namespace common {
 namespace util_atomic {
 template <typename T>
 inline std::atomic<T>* as_atomic(T* p) {
     return reinterpret_cast<std::atomic<T>*>(p);
 }
 template <typename T>
 inline const std::atomic<T>* as_atomic(const T* p) {
     return reinterpret_cast<const std::atomic<T>*>(p);
 }
 // fetch-and-add: returns the value held *before* the addition.
 template <typename T, typename V>
 inline T faa(T* p, V v) {
     return as_atomic(p)->fetch_add(static_cast<T>(v),
                                    std::memory_order_seq_cst);
 }
 // add-and-fetch: returns the value held *after* the addition.
 template <typename T, typename V>
 inline T aaf(T* p, V v) {
     return static_cast<T>(
         as_atomic(p)->fetch_add(static_cast<T>(v), std::memory_order_seq_cst) +
         static_cast<T>(v));
 }
 // compare-and-swap: returns true on success; on failure writes the current
 // value into *expected (same contract as __atomic_compare_exchange_n).
 template <typename T, typename D>
 inline bool cas(T* p, T* expected, D desired) {
     return as_atomic(p)->compare_exchange_strong(
         *expected, static_cast<T>(desired), std::memory_order_seq_cst);
 }
 template <typename T>
 inline T load(const T* p) {
     return as_atomic(p)->load(std::memory_order_seq_cst);
 }
 template <typename T, typename V>
 inline void store(T* p, V v) {
     as_atomic(p)->store(static_cast<T>(v), std::memory_order_seq_cst);
 }
 }  // namespace util_atomic
 }  // namespace common
 #define ATOMIC_FAA(val_addr, addv) \
     (::common::util_atomic::faa((val_addr), (addv)))
 #define ATOMIC_AAF(val_addr, addv) \
     (::common::util_atomic::aaf((val_addr), (addv)))
 #define ATOMIC_CAS(val_addr, expected, desired) \
     (::common::util_atomic::cas((val_addr), (expected), (desired)))
 #define ATOMIC_LOAD(val_addr) (::common::util_atomic::load((val_addr)))
 #define ATOMIC_STORE(val_addr, val) \
     (::common::util_atomic::store((val_addr), (val)))
 #endif  // atomic operation

 /* ======== align ======== */
 #if defined(__GNUC__) || defined(__clang__)
 #define ALIGNED(a) __attribute__((aligned(a)))
 #elif defined(_MSC_VER)
 #define ALIGNED(a) __declspec(align(a))
 #else
 #define ALIGNED(a)
 #endif
 #define ALIGNED_4 ALIGNED(4)
 #define ALIGNED_8 ALIGNED(8)

 /* ======== disallow copy and assign ======== */
 #if __cplusplus < 201103L
 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
     TypeName(const TypeName&);             \
     void operator=(const TypeName&)
 #else
 #define DISALLOW_COPY_AND_ASSIGN(TypeName) \
     TypeName(const TypeName&) = delete;    \
     TypeName& operator=(const TypeName&) = delete;
 #endif

 /* ======== return value check ======== */
 #define RET_FAIL(expr) UNLIKELY(common::E_OK != (ret = (expr)))
 #define RFAIL(expr) UNLIKELY(common::E_OK != (ret = (expr)))
 #define RET_SUCC(expr) LIKELY(common::E_OK == (ret = (expr)))
 #define RSUCC(expr) LIKELY(common::E_OK != (ret = (exprt)))
 #define IS_SUCC(ret) LIKELY(common::E_OK == (ret))
 #define IS_FAIL(ret) UNLIKELY(common::E_OK != (ret))

 #define IS_NULL(ptr) UNLIKELY((ptr) == nullptr)

 /* ======== min/max ======== */
 #define UTIL_MAX(a, b) ((a) > (b) ? (a) : (b))
 #define UTIL_MIN(a, b) ((a) > (b) ? (b) : (a))

 /*
  * int64_max < 10^20
  * consider +/- and the '\0' tail. 24 is enough
  */
 #define INT64_TO_BASE10_MAX_LEN 24

 #endif  // UTILS_UTIL_DEFINE_H
	/*
	* 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.
	*/
	#ifndef UTILS_UTIL_DEFINE_H
	#define UTILS_UTIL_DEFINE_H

	#include <assert.h>
	#include <stdint.h>
	#include <stdlib.h>

	/* ======== platform compatibility ========
	*
	* MSVC does not provide several POSIX types/functions/macros used across the
	* codebase. Provide drop-in equivalents so the same source compiles on both
	* GCC/Clang (Linux) and MSVC (Windows) without scattering #ifdefs.
	*/
	#ifdef _WIN32
	#include <io.h>
	#include <string.h>

	#if defined(_MSC_VER)
	// ssize_t is a signed, pointer-sized integer; intptr_t (from <stdint.h>,
	// included above) is exactly that. We deliberately avoid <BaseTsd.h>/SSIZE_T
	// because that header also pollutes the global namespace with INT32/INT64
	// typedefs, which collide with the project's own INT32/INT64 enum values.
	typedef intptr_t ssize_t;
	typedef int mode_t;
	#endif // _MSC_VER

	// access() mode flags (POSIX <unistd.h>); MSVC's _access uses the same bits.
	#ifndef F_OK
	#define F_OK 0
	#endif
	#ifndef X_OK
	#define X_OK 1
	#endif
	#ifndef W_OK
	#define W_OK 2
	#endif
	#ifndef R_OK
	#define R_OK 4
	#endif

	#ifndef strcasecmp
	#define strcasecmp _stricmp
	#endif
	#ifndef strncasecmp
	#define strncasecmp _strnicmp
	#endif
	#endif // _WIN32

	/* ======== shared-library symbol visibility ========
	*
	* Functions are exported from tsfile.dll automatically via
	* CMAKE_WINDOWS_EXPORT_ALL_SYMBOLS, but global DATA symbols (plain variables,
	* static class members) are not reliably auto-exported, and a consumer must
	* see __declspec(dllimport) to reference them across the DLL boundary. Mark
	* such symbols with TSFILE_API: it expands to dllexport while building the
	* library (TSFILE_BUILDING is defined for its own translation units),
	* dllimport for external consumers, and nothing on non-MSVC toolchains.
	*/
	#if defined(_MSC_VER)
	#if defined(TSFILE_BUILDING)
	#define TSFILE_API __declspec(dllexport)
	#else
	#define TSFILE_API __declspec(dllimport)
	#endif
	#else
	#define TSFILE_API
	#endif

	/* ======== unused ======== */
	#define UNUSED(v) ((void)(v))
	#if __cplusplus >= 201703L
	#define MAYBE_UNUSED [[maybe_unused]]
	#elif defined(__GNUC__) \|\| defined(__clang__)
	#define MAYBE_UNUSED __attribute__((unused))
	#else
	#define MAYBE_UNUSED
	#endif

	/* ======== inline ======== */
	#if defined(__GNUC__) \|\| defined(__clang__)
	#define FORCE_INLINE inline __attribute__((always_inline))
	#elif defined(_MSC_VER)
	#define FORCE_INLINE __forceinline
	#else
	#define FORCE_INLINE inline
	#endif // __GNUC__

	#ifdef BUILD_FOR_SMALL_BINARY
	#define INLINE FORCE_INLINE
	#else
	#define INLINE
	#endif // BUILD_FOR_SMALL_BINARY

	/* ======== likely ======== */
	#if defined(__GNUC__) && __GNUC__ >= 4
	#define LIKELY(x) (__builtin_expect((x), 1))
	#define UNLIKELY(x) (__builtin_expect((x), 0))
	#else
	#define LIKELY(x) (x)
	#define UNLIKELY(x) (x)
	#endif // __GNUC__ >= 4

	/* ======== nullptr ======== */
	#if __cplusplus < 201103L
	#ifndef nullptr
	#define nullptr NULL
	#endif
	#define OVERRIDE
	#else
	#define OVERRIDE override
	#endif // __cplusplus < 201103L

	/* ======== cache line ======== */
	#ifndef CACHE_LINE_SIZE
	#define CACHE_LINE_SIZE 64
	#endif // CACHE_LINE_SIZE

	/* ======== assert ======== */
	#ifdef NDEBUG
	#define ASSERT(condition) ((void)0)
	#else
	#define ASSERT(condition) assert((condition))
	#endif // NDEBUG

	/* ======== statis assert ======== */
	/*
	* To be compatible with C++ before C++11,
	* @msg should be a single word (use -/_ to concat)
	* such as This_should_be_TRUE
	*/
	#if __cplusplus < 201103L
	// TODO only define this when DEBUG
	#define STATIC_ASSERT(cond, msg) \
	typedef char static_assertion_##msg[(cond) ? 1 : -1] __attribute__((unused))
	#else
	#define STATIC_ASSERT(cond, msg) static_assert((cond), #msg)
	#endif // __cplusplus < 201103L

	/* ======== atomic operation ========
	*
	* The ATOMIC_* macros operate on the address of a plain (non-std::atomic)
	* scalar, matching the semantics of the GCC/Clang __atomic builtins.
	*
	* - On GCC/Clang the builtins are used directly (unchanged behaviour).
	* - On other compilers (MSVC) they are implemented on top of C++11 <atomic>
	* via helper templates. Reinterpreting a plain scalar's address as a
	* std::atomic<T>* is well-defined in practice for lock-free integral types
	* (this is exactly what C++20 std::atomic_ref formalizes); all current call
	* sites use naturally-aligned integral members.
	*/
	#if defined(__GNUC__) \|\| defined(__clang__)
	#define ATOMIC_FAA(val_addr, addv) \
	__atomic_fetch_add((val_addr), (addv), __ATOMIC_SEQ_CST)
	#define ATOMIC_AAF(val_addr, addv) \
	__atomic_add_fetch((val_addr), (addv), __ATOMIC_SEQ_CST)
	/*
	* It implements an atomic compare and exchange operation.
	* This compares the contents of ptr with the contents of expected.
	* - If equal, the operation is a reader-modify-writer operation that writes
	* desired into *ptr.
	* - If they are not equal, the operation is a reader and the current contents
	* of ptr are written into expected
	*/
	#define ATOMIC_CAS(val_addr, expected, desired) \
	__atomic_compare_exchange_n((val_addr), (expected), (desired), \
	/* weak = */ false, \
	/* success_memorder = */ __ATOMIC_SEQ_CST, \
	/* failure_memorder = */ __ATOMIC_SEQ_CST)
	#define ATOMIC_LOAD(val_addr) __atomic_load_n((val_addr), __ATOMIC_SEQ_CST)
	#define ATOMIC_STORE(val_addr, val) \
	__atomic_store_n((val_addr), (val), __ATOMIC_SEQ_CST)
	#elif defined(__cplusplus)
	#include <atomic>
	namespace common {
	namespace util_atomic {
	template <typename T>
	inline std::atomic<T>* as_atomic(T* p) {
	return reinterpret_cast<std::atomic<T>*>(p);
	}
	template <typename T>
	inline const std::atomic<T>* as_atomic(const T* p) {
	return reinterpret_cast<const std::atomic<T>*>(p);
	}
	// fetch-and-add: returns the value held before the addition.
	template <typename T, typename V>
	inline T faa(T* p, V v) {
	return as_atomic(p)->fetch_add(static_cast<T>(v),
	std::memory_order_seq_cst);
	}
	// add-and-fetch: returns the value held after the addition.
	template <typename T, typename V>
	inline T aaf(T* p, V v) {
	return static_cast<T>(
	as_atomic(p)->fetch_add(static_cast<T>(v), std::memory_order_seq_cst) +
	static_cast<T>(v));
	}
	// compare-and-swap: returns true on success; on failure writes the current
	// value into *expected (same contract as __atomic_compare_exchange_n).
	template <typename T, typename D>
	inline bool cas(T* p, T* expected, D desired) {
	return as_atomic(p)->compare_exchange_strong(
	*expected, static_cast<T>(desired), std::memory_order_seq_cst);
	}
	template <typename T>
	inline T load(const T* p) {
	return as_atomic(p)->load(std::memory_order_seq_cst);
	}
	template <typename T, typename V>
	inline void store(T* p, V v) {
	as_atomic(p)->store(static_cast<T>(v), std::memory_order_seq_cst);
	}
	} // namespace util_atomic
	} // namespace common
	#define ATOMIC_FAA(val_addr, addv) \
	(::common::util_atomic::faa((val_addr), (addv)))
	#define ATOMIC_AAF(val_addr, addv) \
	(::common::util_atomic::aaf((val_addr), (addv)))
	#define ATOMIC_CAS(val_addr, expected, desired) \
	(::common::util_atomic::cas((val_addr), (expected), (desired)))
	#define ATOMIC_LOAD(val_addr) (::common::util_atomic::load((val_addr)))
	#define ATOMIC_STORE(val_addr, val) \
	(::common::util_atomic::store((val_addr), (val)))
	#endif // atomic operation

	/* ======== align ======== */
	#if defined(__GNUC__) \|\| defined(__clang__)
	#define ALIGNED(a) __attribute__((aligned(a)))
	#elif defined(_MSC_VER)
	#define ALIGNED(a) __declspec(align(a))
	#else
	#define ALIGNED(a)
	#endif
	#define ALIGNED_4 ALIGNED(4)
	#define ALIGNED_8 ALIGNED(8)

	/* ======== disallow copy and assign ======== */
	#if __cplusplus < 201103L
	#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
	TypeName(const TypeName&); \
	void operator=(const TypeName&)
	#else
	#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
	TypeName(const TypeName&) = delete; \
	TypeName& operator=(const TypeName&) = delete;
	#endif

	/* ======== return value check ======== */
	#define RET_FAIL(expr) UNLIKELY(common::E_OK != (ret = (expr)))
	#define RFAIL(expr) UNLIKELY(common::E_OK != (ret = (expr)))
	#define RET_SUCC(expr) LIKELY(common::E_OK == (ret = (expr)))
	#define RSUCC(expr) LIKELY(common::E_OK != (ret = (exprt)))
	#define IS_SUCC(ret) LIKELY(common::E_OK == (ret))
	#define IS_FAIL(ret) UNLIKELY(common::E_OK != (ret))

	#define IS_NULL(ptr) UNLIKELY((ptr) == nullptr)

	/* ======== min/max ======== */
	#define UTIL_MAX(a, b) ((a) > (b) ? (a) : (b))
	#define UTIL_MIN(a, b) ((a) > (b) ? (b) : (a))

	/*
	* int64_max < 10^20
	* consider +/- and the '\0' tail. 24 is enough
	*/
	#define INT64_TO_BASE10_MAX_LEN 24

	#endif // UTILS_UTIL_DEFINE_H