type.h

浏览该文件的文档.

#pragma once
 
#include <string.h>
#include <stdarg.h>
 
#include <cstddef>
#include <cstdint>
#include <vector>
#include <queue>
#include <map>
#include <type_traits>
#include <unordered_map>
#include <algorithm>
#include <functional>
#include <memory>
#include <optional>
#include <variant>
#include <regex>
#include <list>
#include <chrono>
#include <string>
#include <stdexcept>
#include <variant>
#include <chrono>
#include <nx/api.h>
 
#define NX_PLATFORM_WINDOW 1
#define NX_PLATFORM_LINUX  2
 
#if defined(WIN32)
    #define NX_PLATFORM NX_PLATFORM_WINDOW
#else
    #define NX_PLATFORM NX_PLATFORM_LINUX
#endif
 
namespace nx {
 
using ByteBuffer = std::vector<uint8_t>;
 
template <class T>
using Optional = std::optional<T>;
 
template <class T>
using Vector = std::vector<T>;
 
template <class T>
using Queue = std::queue<T>;
 
using String = std::string;
 
template <class... T>
using Variant = std::variant<T...>;
 
template <class T>
using UniquePtr = std::unique_ptr<T>;
 
template <class T>
using SharedPtr = std::shared_ptr<T>;
 
template <class K, class V>
using Map = std::map<K, V>;
 
template <class T>
using Function = std::function<T>;
 
template <class T>
using List = std::list<T>;
 
class NX_API Uncopyable {
public:
    Uncopyable() = default;
    ~Uncopyable() = default;
 
    Uncopyable(const Uncopyable&) = delete;
    Uncopyable& operator=(const Uncopyable&) = delete;
 
    Uncopyable(Uncopyable&&) = default;
    Uncopyable& operator=(Uncopyable&&) = default;
};
 
 
NX_API void panic_fmt(const char* fmt, ...);
 
constexpr size_t operator""_kb(unsigned long long int n) { return n * 1024; }
 
enum class OpenMode {
    WRITE,
    READ,
};
 
struct IO_Success {
    size_t bytes;
};
 
struct EndOfFile {
};
 
enum class IO_Error {
    NOT_OPEN,
    IO_FAIL,
};
 
using ReadResult = Variant<IO_Error, EndOfFile, IO_Success>;
using ReadAllResult = Variant<IO_Error, ByteBuffer>;
 
class NX_API Read {
public:
    virtual ~Read() = 0;
    virtual ReadResult read(void* buffer, size_t bytes) = 0;
    bool read_exact(void* buffer, size_t bytes);
    ReadAllResult read_all();
};
 
using WriteResult = Variant<IO_Error, IO_Success>;
 
class NX_API Write {
public:
    virtual ~Write() = 0;
    virtual WriteResult write(const void* buffer, size_t bytes) = 0;
    virtual bool write_all(const void* buffer, size_t bytes);
};
 
NX_API bool pipe(Read& reader, Write& writer);
NX_API bool pipe(Read* reader, Write* writer);
 
class NX_API MemoryFile : public Read, private Uncopyable {
public:
    MemoryFile(const uint8_t* buffer, size_t buf_len);
    ReadResult read(void* buffer, size_t bytes) override;
 
private:
    const uint8_t* buffer_;
    size_t buf_len_;
    size_t read_pos_;
};
 
using TimePoint = std::chrono::time_point<std::chrono::system_clock>;
 
using TimeDuration = int64_t;
 
inline TimePoint time_now() { return std::chrono::system_clock::now(); }
 
inline TimeDuration time_diff(const TimePoint& t_old, const TimePoint& t_new)
{
    using std_ms = std::chrono::milliseconds;
    return std::chrono::duration_cast<std_ms>(t_new - t_old).count();
}
 
inline TimeDuration time_diff_epoch(const TimePoint& t)
{
    using std_ms = std::chrono::milliseconds;
    return std::chrono::duration_cast<std_ms>(t.time_since_epoch()).count();
}
 
inline uint8_t ceil_pow2(uint8_t n)
{
    n -= 1;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    return n + 1;
}
 
inline uint16_t ceil_pow2(uint16_t n)
{
    n -= 1;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    return n + 1;
}
 
inline uint32_t ceil_pow2(uint32_t n)
{
    n -= 1;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    return n + 1;
}
 
inline uint64_t ceil_pow2(uint64_t n)
{
    n -= 1;
    n |= n >> 1;
    n |= n >> 2;
    n |= n >> 4;
    n |= n >> 8;
    n |= n >> 16;
    n |= n >> 32;
    return n + 1;
}
 
template<class T>
inline bool is_pow2(T x) { return ((x - 1) & x) == 0; }
 
// using PrintLike = void (*)(const char* fmt, ...);
// NX_API void set_error_log(PrintLike fn);
// NX_API void set_no_error_log();
 
NX_API ByteBuffer zlib_compress(const uint8_t* buf, size_t len);
NX_API ByteBuffer zlib_uncompress(const uint8_t* buf, size_t len);
 
} // namespace nx
 
#define NX_PANIC(msg, ...) nx::panic_fmt(msg, ##__VA_ARGS__)
 
#define NX_ASSERT(cond, msg, ...)                                              \
    if (!(cond)) {                                                             \
        NX_PANIC(msg " file:%s line:%d", ##__VA_ARGS__, __FILE__, __LINE__);   \
    }
 
#define NX_GET_BIT(x, bit)      (((x) >> (bit)) & 1)
#define NX_SET_BIT(x, bit)      ((x) | (1 << (bit)))
#define NX_CLEAR_BIT(x, bit)    ((x) & (~(1 << (bit))))
 
#define NX_GET_BIT_BOOL(x, bit) (NX_GET_BIT((x), (bit)) == 1)
#define NX_SET_BIT_BOOL(x, bit, value)                                         \
    ((value) ? NX_SET_BIT((x), (bit)) : NX_CLEAR_BIT((x), (bit)))