git / moonbite-core / src/leveldb/port/port_stdcxx.h · raw

// Copyright (c) 2018 The LevelDB Authors. All rights reserved.// Use of this source code is governed by a BSD-style license that can be// found in the LICENSE file. See the AUTHORS file for names of contributors.#ifndef STORAGE_LEVELDB_PORT_PORT_STDCXX_H_#define STORAGE_LEVELDB_PORT_PORT_STDCXX_H_// port/port_config.h availability is automatically detected via __has_include// in newer compilers. If LEVELDB_HAS_PORT_CONFIG_H is defined, it overrides the// configuration detection.#if defined(LEVELDB_HAS_PORT_CONFIG_H)#if LEVELDB_HAS_PORT_CONFIG_H#include "port/port_config.h"#endif  // LEVELDB_HAS_PORT_CONFIG_H#elif defined(__has_include)#if __has_include("port/port_config.h")#include "port/port_config.h"#endif  // __has_include("port/port_config.h")#endif  // defined(LEVELDB_HAS_PORT_CONFIG_H)#if HAVE_CRC32C#include <crc32c/crc32c.h>#endif  // HAVE_CRC32C#if HAVE_SNAPPY#include <snappy.h>#endif  // HAVE_SNAPPY#include <cassert>#include <condition_variable>  // NOLINT#include <cstddef>#include <cstdint>#include <mutex>  // NOLINT#include <string>#include "port/thread_annotations.h"namespace leveldb {namespace port {static const bool kLittleEndian = !LEVELDB_IS_BIG_ENDIAN;class CondVar;// Thinly wraps std::mutex.class LOCKABLE Mutex { public:  Mutex() = default;  ~Mutex() = default;  Mutex(const Mutex&) = delete;  Mutex& operator=(const Mutex&) = delete;  void Lock() EXCLUSIVE_LOCK_FUNCTION() { mu_.lock(); }  void Unlock() UNLOCK_FUNCTION() { mu_.unlock(); }  void AssertHeld() ASSERT_EXCLUSIVE_LOCK() {} private:  friend class CondVar;  std::mutex mu_;};// Thinly wraps std::condition_variable.class CondVar { public:  explicit CondVar(Mutex* mu) : mu_(mu) { assert(mu != nullptr); }  ~CondVar() = default;  CondVar(const CondVar&) = delete;  CondVar& operator=(const CondVar&) = delete;  void Wait() {    std::unique_lock<std::mutex> lock(mu_->mu_, std::adopt_lock);    cv_.wait(lock);    lock.release();  }  void Signal() { cv_.notify_one(); }  void SignalAll() { cv_.notify_all(); } private:  std::condition_variable cv_;  Mutex* const mu_;};inline bool Snappy_Compress(const char* input, size_t length,                            std::string* output) {#if HAVE_SNAPPY  output->resize(snappy::MaxCompressedLength(length));  size_t outlen;  snappy::RawCompress(input, length, &(*output)[0], &outlen);  output->resize(outlen);  return true;#else  // Silence compiler warnings about unused arguments.  (void)input;  (void)length;  (void)output;#endif  // HAVE_SNAPPY  return false;}inline bool Snappy_GetUncompressedLength(const char* input, size_t length,                                         size_t* result) {#if HAVE_SNAPPY  return snappy::GetUncompressedLength(input, length, result);#else  // Silence compiler warnings about unused arguments.  (void)input;  (void)length;  (void)result;  return false;#endif  // HAVE_SNAPPY}inline bool Snappy_Uncompress(const char* input, size_t length, char* output) {#if HAVE_SNAPPY  return snappy::RawUncompress(input, length, output);#else  // Silence compiler warnings about unused arguments.  (void)input;  (void)length;  (void)output;  return false;#endif  // HAVE_SNAPPY}inline bool GetHeapProfile(void (*func)(void*, const char*, int), void* arg) {  // Silence compiler warnings about unused arguments.  (void)func;  (void)arg;  return false;}inline uint32_t AcceleratedCRC32C(uint32_t crc, const char* buf, size_t size) {#if HAVE_CRC32C  return ::crc32c::Extend(crc, reinterpret_cast<const uint8_t*>(buf), size);#else  // Silence compiler warnings about unused arguments.  (void)crc;  (void)buf;  (void)size;  return 0;#endif  // HAVE_CRC32C}}  // namespace port}  // namespace leveldb#endif  // STORAGE_LEVELDB_PORT_PORT_STDCXX_H_