node-haystack Episode-4: Wrapper of libuv

Preface

Before starting our project: node-haystack, we need some handful utilities. Using the C style libuv is boring. Then here comes the wrappers.

Environment

Hardware

Type	Brand	Capacity	Frequency
MB	MSI-Z77HD
Memory	N/A	32GB	1600Mhz
CPU	Intel® Core™ i7-4790	4Core Hyper-thread	3.60GHzx8
HD(os)	LSI MR9260-8i	120GBx2
HD(data)	Seagate	8T(Ext enclosure, raid 0, USB3.0)

---

Software

Type	Name	Ver
OS	CentOS	7.0
Compiler	Gcc	6.1
JavaScript	node.js	4.5.0
IDE	atom	1.8.0
C++ library	boost	1.6.1

Code style

The C++ code follows this google style
If you have difficulty with this site, here is the local resource.

Comments

Doxygen style comments will be applied.

Define & typedef

Here are some predefined type, macros:

namespace bst = boost;
namespace bfs = boost::filesystem;
namespace js = v8;

using u8    =   unsigned char;
using byte  =   unsigned char;
using u16   =   unsigned short;
using i16   =   signed short;
using u32   =   unsigned int;
using i32   =   signed int;
using u64   =   unsigned long long;
using i64   =   signed long long;
using u128  =   unsigned __int128;
using i128  =   signed __int128;

#define DECL_CB(name, ...) \
        using callback_ ## name = bst::function<void(__VA_ARGS__)>; \
        using cb_ ## name ## _t = callback_ ## name;

template<typename T>
using vec_t = std::vector<T>;

template<typename T>
using list_t = std::list<T>;

template<typename T>
using shared_t = std::shared_ptr<T>;

template<typename K, typename T>
using map_t = std::unordered_map<K, T>;

using uuid_t = buid::uuid;

using shared_mtx_t = bst::shared_mutex;
using slock_t = bst::upgrade_lock<bst::shared_mutex>;
using ulock_t = bst::upgrade_to_unique_lock<bst::shared_mutex>;

Errors

A script is used for generate errors automatically from a template, which is a plaint text and is easy to change.
The script:

#!/bin/bash

input="error.def"
output="error.hpp"

date=$(date +%d/%b/%Y)
header="
/*!\n
\t\\\file\terror.hpp\n
\t\\\brief\tDefine error and according messages.\n
\t\\\note\tDo NOT modify this file manually, it's automatically\n
\t\t\tgenerated by script. Instead, you should modify the error.def\n
\t\t\tand re-run gen-err.sh to apply the change.\n
\t\\\author\tHailing.Zhou\n
\t\\\date\t$date\n
*/\n
//////////////////////////////////////////////////////////\n
// CAUTION:\n
// DO NOT modify this file manually.\n
// This file is automatically generated by scripts.\n
//////////////////////////////////////////////////////////\n
#ifndef ERROR_HPP\n
#define ERROR_HPP\n
\n
namespace hhcloud {\n
\t#define _ERR(name)    HC_ERROR_## name\n
\t#define _ERR_STR(name) ErrorToString(_ERR(name))\n"

footer="\n
} // ns hhcloud\n
\n
#endif // ERROR_HPP\n"

func_beg="\n\tstatic const char* ErrorToString(int err) {\n
\t\tswitch(err) {"

func_end="\t\t\tdefault: return \"Unknown error\";\n
\t\t} // End of switch\n
\t} // End of ErrorToString\n"

gen_content() {
  declare -a def_array
  declare -a case_array
  count=0
  err_code=-8000
  err_name=

  while IFS='' read -r line || [[ -n "$line" ]]; do
        line=$(echo $line)
        [[ ${#line} -eq 0 ]] && continue

        if echo $line | grep -qE "^\/\/.*"; then
            def_array[$count]="\n\t$line"
            case_array[$count]="\n\t\t\t$line"

            count=$((count + 1))
        else
            if echo $line | grep -qiE "^code=\d*"; then
                err_code=${line#*=}
            else
            err_name=${line%:*}
            err_msg=${line#*:}

                # If error message not defined, use error name as the message
                if [ "$err_msg" == "" ]; then
                    err_msg=$err_name
                fi

            def_array[$count]="\tconst int _ERR($err_name) = $err_code;"
            case_array[$count]="\t\t\tcase _ERR($err_name): return \"$err_msg\";"

            err_code=$((err_code - 1))
            count=$((count + 1))
            fi
        fi
  done < $input

  n=0
  while [[ $n -lt $count ]]; do
    echo -e ${def_array[$n]} >> $output
    n=$((n + 1))
  done

  # output function
  echo -e $func_beg >> $output

  n=0
  while [[ $n -lt $count ]]; do
        echo -e ${case_array[$n]} >> $output
    n=$((n + 1))
  done

  # end of function
  echo -e $func_end >> $output
}

gen_err() {
  echo "" > $output
  echo -e $header >> $output

  gen_content

  echo -e $footer >> $output
}

echo "Generate $output"
gen_err

A sample of error template:

Code=0
NOERROR:

// Common error, begins from -8000
FAIL:
INVALID:
INTERNAL:
NOT_EXIST:
NOT_FOUND:
NOT_IMPL:
ALLOC_MEM:

// File operation, starts from -8100
Code=-8100
NOT_OPEN:
FAIL_OPEN:

// Haystack Volume, starts from -8200
Code=-8200
VOL_READ_BLOCK:
VOL_CACHE_FULL:
VOL_INVALID_FILE:
VOL_INVALID_VOL:
VOL_INVALID_BLOCK_HEADER:
VOL_INVALID_BLOCK_FOOTER:
VOL_EXCEED_BLOCKS:
VOL_EXCEED_SIZE:
VOL_NONIDENTICAL:
VOL_FAILED_TO_WRITE:
VOL_FAILED_TO_UNLINK:

// Command library, starts from -8300
Code=-8300
CMD_LIB_LOADED:
CMD_LIB_LOAD:
CMD_LIB_UNLOAD:
CMD_LIB_NO_FUNC:
CMD_LIB_INVALID_CMD:

// Command, starts from -8400
Code=-8400
CMD_NO_SRC:
CMD_INVALID_SRC:

// Text Render, starts from -8500
Code=-8500
CMD_TXT_EMPTY:
CMD_TXT_NO_FONT:
CMD_TXT_INIT_FONT:
CMD_TXT_READ_FONT:
CMD_TXT_INIT_RENDER:
CMD_TXT_RENDER_TXT:

// Add more errors here

// End of errors

The generated error.hpp looks like:

/*!
    \file   error.hpp
    \brief  Define error and according messages.
    \note   Do NOT modify this file manually, it's automatically
            generated by script. Instead, you should modify the error.def
            and re-run gen-err.sh to apply the change.
    \author igame
    \date   07/Sep/2016
 */
 //////////////////////////////////////////////////////////
 // CAUTION:
 // DO NOT modify this file manually.
 // This file is automatically generated by scripts.
 //////////////////////////////////////////////////////////
 #ifndef ERROR_HPP
 #define ERROR_HPP

 namespace hhcloud {
    #define _ERR(name) HC_ERROR_## name
    #define _ERR_STR(name) ErrorToString(_ERR(name))

    const int _ERR(NOERROR) = 0;

    // Common error, begins from -8000
    const int _ERR(FAIL) = -1;
    const int _ERR(INVALID) = -2;
    const int _ERR(INTERNAL) = -3;
    const int _ERR(NOT_EXIST) = -4;
    const int _ERR(NOT_FOUND) = -5;
    const int _ERR(NOT_IMPL) = -6;
    const int _ERR(ALLOC_MEM) = -7;

    // File operation, starts from -8100
    const int _ERR(NOT_OPEN) = -8100;
    const int _ERR(FAIL_OPEN) = -8101;

    // Haystack Volume, starts from -8200
    const int _ERR(VOL_READ_BLOCK) = -8200;
    const int _ERR(VOL_CACHE_FULL) = -8201;
    const int _ERR(VOL_INVALID_FILE) = -8202;
    const int _ERR(VOL_INVALID_VOL) = -8203;
    const int _ERR(VOL_INVALID_BLOCK_HEADER) = -8204;
    const int _ERR(VOL_INVALID_BLOCK_FOOTER) = -8205;
    const int _ERR(VOL_EXCEED_BLOCKS) = -8206;
    const int _ERR(VOL_EXCEED_SIZE) = -8207;
    const int _ERR(VOL_NONIDENTICAL) = -8208;
    const int _ERR(VOL_FAILED_TO_WRITE) = -8209;
    const int _ERR(VOL_FAILED_TO_UNLINK) = -8210;

    // Command library, starts from -8300
    const int _ERR(CMD_LIB_LOADED) = -8300;
    const int _ERR(CMD_LIB_LOAD) = -8301;
    const int _ERR(CMD_LIB_UNLOAD) = -8302;
    const int _ERR(CMD_LIB_NO_FUNC) = -8303;
    const int _ERR(CMD_LIB_INVALID_CMD) = -8304;

    // Command, starts from -8400
    const int _ERR(CMD_NO_SRC) = -8400;
    const int _ERR(CMD_INVALID_SRC) = -8401;

    // Text Render, starts from -8500
    const int _ERR(CMD_TXT_EMPTY) = -8500;
    const int _ERR(CMD_TXT_NO_FONT) = -8501;
    const int _ERR(CMD_TXT_INIT_FONT) = -8502;
    const int _ERR(CMD_TXT_READ_FONT) = -8503;
    const int _ERR(CMD_TXT_INIT_RENDER) = -8504;
    const int _ERR(CMD_TXT_RENDER_TXT) = -8505;

    // Add more errors here

    // End of errors

    static const char* ErrorToString(int err) {
        switch(err) {
            case _ERR(NOERROR): return "NOERROR";

            // Common error, begins from -8000
            case _ERR(FAIL): return "FAIL";
            case _ERR(INVALID): return "INVALID";
            case _ERR(INTERNAL): return "INTERNAL";
            case _ERR(NOT_EXIST): return "NOT_EXIST";
            case _ERR(NOT_FOUND): return "NOT_FOUND";
            case _ERR(NOT_IMPL): return "NOT_IMPL";
            case _ERR(ALLOC_MEM): return "ALLOC_MEM";

            // File operation, starts from -8100
            case _ERR(NOT_OPEN): return "NOT_OPEN";
            case _ERR(FAIL_OPEN): return "FAIL_OPEN";

            // Haystack Volume, starts from -8200
            case _ERR(VOL_READ_BLOCK): return "VOL_READ_BLOCK";
            case _ERR(VOL_CACHE_FULL): return "VOL_CACHE_FULL";
            case _ERR(VOL_INVALID_FILE): return "VOL_INVALID_FILE";
            case _ERR(VOL_INVALID_VOL): return "VOL_INVALID_VOL";
            case _ERR(VOL_INVALID_BLOCK_HEADER): return "VOL_INVALID_BLOCK_HEADER";
            case _ERR(VOL_INVALID_BLOCK_FOOTER): return "VOL_INVALID_BLOCK_FOOTER";
            case _ERR(VOL_EXCEED_BLOCKS): return "VOL_EXCEED_BLOCKS";
            case _ERR(VOL_EXCEED_SIZE): return "VOL_EXCEED_SIZE";
            case _ERR(VOL_NONIDENTICAL): return "VOL_NONIDENTICAL";
            case _ERR(VOL_FAILED_TO_WRITE): return "VOL_FAILED_TO_WRITE";
            case _ERR(VOL_FAILED_TO_UNLINK): return "VOL_FAILED_TO_UNLINK";

            // Command library, starts from -8300
            case _ERR(CMD_LIB_LOADED): return "CMD_LIB_LOADED";
            case _ERR(CMD_LIB_LOAD): return "CMD_LIB_LOAD";
            case _ERR(CMD_LIB_UNLOAD): return "CMD_LIB_UNLOAD";
            case _ERR(CMD_LIB_NO_FUNC): return "CMD_LIB_NO_FUNC";
            case _ERR(CMD_LIB_INVALID_CMD): return "CMD_LIB_INVALID_CMD";

            // Command, starts from -8400
            case _ERR(CMD_NO_SRC): return "CMD_NO_SRC";
            case _ERR(CMD_INVALID_SRC): return "CMD_INVALID_SRC";

            // Text Render, starts from -8500
            case _ERR(CMD_TXT_EMPTY): return "CMD_TXT_EMPTY";
            case _ERR(CMD_TXT_NO_FONT): return "CMD_TXT_NO_FONT";
            case _ERR(CMD_TXT_INIT_FONT): return "CMD_TXT_INIT_FONT";
            case _ERR(CMD_TXT_READ_FONT): return "CMD_TXT_READ_FONT";
            case _ERR(CMD_TXT_INIT_RENDER): return "CMD_TXT_INIT_RENDER";
            case _ERR(CMD_TXT_RENDER_TXT): return "CMD_TXT_RENDER_TXT";

            // Add more errors here

            // End of errors
            default: return "Unknown error";
        } // End of switch
    } // End of ErrorToString
 } // ns hhcloud

 #endif // ERROR_HPP

Wrapper of Async File Access

There a dozen of file relative functions in libuv, but we only concentrate on functions about stating and read/write. Let code talk:

/*!
   \brief Asyncronous file read/write class, which hides the details of libuv and expose it as C++ style.
*/
class AsyncFile {
public:
    /** A copy of uv_time_t */
    typedef struct {
        i64 sec;
        i64 nsec;
    } time_type;

    /** File attributes */
    typedef struct {
        u64 dev;
        u64 mode;
        u64 nlink;
        u64 uid;
        u64 gid;
        u64 rdev;
        u64 ino;
        u64 size;
        u64 blksize;
        u64 blocks;
        u64 flags;
        u64 gen;
        time_type atim;
        time_type mtim;
        time_type ctim;
        time_type birthtim;
    } file_stat_t;

    DECL_CB(stat, int /*!< Error code: 0 succeeded; otherwise failed. */, const file_stat_t& /*!< Set of file attributes if succeded. */, void* /*!< User data */)
    DECL_CB(open, int /*!< Error code. */, void* /*!< User data */)
    DECL_CB(read, int /*!< Error code. */, shared_t<vec_t<char>>& /*!< Fetched data if succeeded. */, void* /*!< User data */)
    DECL_CB(write, int, u64 /*!< Number of bytes writed. */, void* /*!< User data */)
    DECL_CB(close, int, void*  /*!< User data */)


private:
    /** callback information which will be used to bring necessary into libuv callback */
    template< class T >
    struct callback_info_t{
        typedef T   callback_type;
        AsyncFile*  sender;
        shared_t<vec_t<char>>   data;
        uv_buf_t    buf;
        void*   user_data;
        callback_type cb;
    }; // callback_info_t;

    using ci_read_t = callback_info_t<cb_read_t>;
    using ci_write_t = callback_info_t<cb_write_t>;

public:
    AsyncFile() {}
    AsyncFile(const AsyncFile&) = delete;

    ~AsyncFile() {
        Close();
    }
    /*!
       \brief open a file for asynchronous operation.
       \return None
    */
    void Open(const std::string& path /*!< File path. */, const cb_open_t& cb /*!< Callback function. */, void* user_data = nullptr /*!< Extra user data which will be passed to callback */) {
        uv_fs_t* req = this->CreateReq<cb_open_t>(cb, user_data);

        uv_fs_open(uv_default_loop(), req, path.c_str(), O_CREAT | O_RDWR, 0, AsyncFile::OnOpen);
    }

    /*!
       \brief close opened file.
       \return None.
    */
    void Close(const cb_close_t& cb = [&](int, void*) { return; }/*!< Callback function */, void* user_data = nullptr /*!< Extra user data which will be passed to callback */) {
        if (m_fd > 0) {
            uv_fs_t* req = this->CreateReq<cb_close_t>(cb, user_data);

            uv_fs_close(uv_default_loop(), req, m_fd, AsyncFile::OnClose);
        } else {
            cb(_ERR(NOT_OPEN), user_data);
        }
    }

    /*!
       \brief stat a file.
       \return None.
    */
    void Stat(const std::string& path /*!< File path. */, const cb_stat_t& cb /*!< Callback function */, void* user_data = nullptr  /*!< Extra user data which will be passed to callback */) {
        uv_fs_t* req = this->CreateReq<cb_stat_t>(cb, user_data);

        uv_fs_stat(uv_default_loop(), req, path.c_str(), AsyncFile::OnStat);
    }

    /*!
       \brief read an amount of data from opened file begining at specified offset.
       \return None.
    */
    void Read(u64 offset, size_t size, const cb_read_t& cb, void* user_data = nullptr  /*!< Extra user data which will be passed to callback */) {
        assert(m_fd != 0);

        auto req = this->CreateReq<cb_read_t>(cb, user_data, size);
        auto ci = reinterpret_cast<ci_read_t *>(req->data);

        uv_fs_read(uv_default_loop(), req, m_fd, &ci->buf, 1, offset, AsyncFile::OnRead);
    }

    /*!
       \brief write data into file from specified offset.
    */
    void Write(u64 offset, shared_t<vec_t<char>>& array, const cb_write_t& cb, void* user_data = nullptr  /*!< Extra user data which will be passed to callback */) {
        assert(m_fd != 0);

        auto req = this->CreateReq<cb_write_t>(cb, user_data, array);
        auto ci = reinterpret_cast<ci_write_t *>(req->data);

        uv_fs_write(uv_default_loop(), req, m_fd, &ci->buf, 1, offset, AsyncFile::OnWrite);
    }

private:
    /*!
       \brief Create a uv_fs_t object.
       \return Pointer to uv_fs_t object.
    */
    template< class T>
    inline uv_fs_t* CreateReq(const T& cb, void* user_data) {
        uv_fs_t* req = (uv_fs_t *)malloc(sizeof(uv_fs_t));
        std::memset(req, 0x0, sizeof(uv_fs_t));

        callback_info_t<T>* ci = new callback_info_t<T>;

        ci->sender = this;
        ci->cb = cb;
        ci->user_data = user_data;

        req->data = ci;

        return req;
    }

    template<class T>
    inline uv_fs_t* CreateReq(const T& cb, void* user_data, size_t size) {
        auto req = CreateReq<T>(cb, user_data);
        auto ci = reinterpret_cast<callback_info_t<T> *>(req->data);

        ci->data = mk_shared<vec_t<char>>();
        ci->data->resize(size);

        ci->buf.base = &(*ci->data)[0];
        ci->buf.len = ci->data->size();

        return req;
    }

    template<class T>
    inline uv_fs_t* CreateReq(const T& cb, void* user_data, shared_t<vec_t<char>>& svec) {
        auto req = CreateReq<T>(cb, user_data);
        auto ci = reinterpret_cast<callback_info_t<T> *>(req->data);

        ci->data = svec;
        ci->buf.base = &(*ci->data)[0];
        ci->buf.len = ci->data->size();

        return req;
    }

    /*!
       \brief Release created uv_fs_t object.
    */
    template< class T >
    inline void DelReq(uv_fs_t* req) {
        auto ci = reinterpret_cast<callback_info_t<T> *>(req->data);

        delete ci;
        uv_fs_req_cleanup(req);
    }

private:
    /*!
       \brief Callback for uv_fs_stat.
    */
    static void OnStat(uv_fs_t* req) {
        auto ci = reinterpret_cast<callback_info_t<cb_stat_t> *>(req->data);

        if (req->result < 0) {
            int err = req->result;
            ci->cb(err, {}, ci->user_data);
        } else {
            auto ft = reinterpret_cast<file_stat_t *>(&req->statbuf);

            ci->cb(0, *ft, ci->user_data);
        }

        ci->sender->DelReq<cb_stat_t>(req);
    }

    /*!
       \brief Callback for uv_fs_open.
    */
    static void OnOpen(uv_fs_t* req) {
        auto ci = reinterpret_cast<callback_info_t<cb_open_t> *>(req->data);

        if (req->result < 0) {
            ci->cb(req->result, ci->user_data);
        } else {
            ci->sender->m_fd = req->result;
            ci->cb(0, ci->user_data);
        }

        ci->sender->DelReq<cb_open_t>(req);
    }

    /*!
       \brief Callback for uv_fs_close
    */
    static void OnClose(uv_fs_t* req) {
        auto ci = reinterpret_cast<callback_info_t<cb_close_t> *>(req->data);

        if (req->result < 0) {
            ci->cb(req->result, ci->user_data);
        } else {
            ci->cb(0, ci->user_data);
        }

        ci->sender->DelReq<cb_close_t>(req);
        // ci->sender->m_fd = 0;
    }

    /*!
       \brief Callback for uv_fs_read
    */
    static void OnRead(uv_fs_t* req) {
        auto ci = reinterpret_cast<callback_info_t<cb_read_t> *>(req->data);

        if (req->result < 0) {
            auto temp = mk_shared<vec_t<char>>();

            ci->cb(req->result, temp, ci->user_data);
        } else {
            if (req->result == 0) {
                auto temp = mk_shared<vec_t<char>>();

                ci->cb(0, temp, ci->user_data);
            } else {
                if (req->result != ci->data->size()) {
                    auto temp = mk_shared<vec_t<char>>();

                    ci->cb(_ERR(FAIL), temp, ci->user_data);
                } else {
                    ci->cb(0, ci->data, ci->user_data);
                }
            }
        }

        ci->sender->DelReq<cb_read_t>(req);
    }

    /*!
       \brief Callback for uv_fs_write.
    */
    static void OnWrite(uv_fs_t* req) {
        auto ci = reinterpret_cast<callback_info_t<cb_write_t> *>(req->data);

        if (req->result < 0) {
            ci->cb(req->result, 0, ci->user_data);
        } else {
            ci->cb(0, req->result, ci->user_data);
        }

        ci->sender->DelReq<cb_write_t>(req);
    }
private:
    uv_file m_fd = 0; /*!< uv file handle. */
}; // class AsyncFile

Wrapper of Async Work Queue

libuv uses work queue to perform asynchronous operation. More details can be found in libuv’s official documents.
The declaration of AsyncWork looks like:

/*!
     \brief C++ wrapper for libuv asynchronous queue work.
     \note The template parameter T is the type of user data which will be used for user's extra data when posting work item into queue.
 */
 template<class T>
 class AsyncWorker {
 public:
      DECL_CB(work, T* /*!< User data. */)
      DECL_CB(after_work, T* /*!< User data. */, bool /*!< Cancelation flag */)

 private:
      typedef struct {
            AsyncWorker* sender;
            cb_work_t cb_work;
            cb_after_work_t cb_after_work;
            T* user_data;
      } callback_info_t;

      using ci_t = callback_info_t;

 public:
      /*!
          \brief Post work request to queue.
          \return None.
      */
      inline void post(T* user_data /*!< User data. */, const cb_work_t& cb_work /*!< Callback when work is been processing. */, const cb_after_work_t& cb_afterWork /*!< Callback when work has been done. */) {
            uv_work_t* req = createReq(user_data, cb_work, cb_afterWork);

            uv_queue_work(uv_default_loop(), req, AsyncWorker::onWork, AsyncWorker::onAfterWork);
      }

 private:
      /*!
          \brief Create work request.
          \return uv_work_t* libuv work request type.
      */
      inline uv_work_t* createReq(T* user_data /*!< User data. */, const cb_work_t& cb_work /*!< Callback when work is been processing. */, const cb_after_work_t& cb_afterWork /*!< Callback when work is done. */) {
            uv_work_t* req = (uv_work_t *)malloc(sizeof(uv_work_t));
            std::memset(req, 0x0, sizeof(uv_work_t));

            auto ci = new ci_t{ this, cb_work, cb_afterWork, user_data };

            req->data = ci;

            return req;
      }

      /*!
          \brief Delete work request.
          \return None.
      */
      inline void delReq(uv_work_t* req /*!< libuv work struct. */) {
            auto ci = reinterpret_cast<ci_t *>(req->data);

            delete ci;
            free(req);
      }

      /*!
          \brief Event handle for libuv work processing.
          \return None.
      */
      static void onWork(uv_work_t* req /*!< Libuv work struct. */) {
            auto ci = reinterpret_cast<ci_t *>(req->data);

            ci->cb_work(ci->user_data);
      }

      /*!
          \brief Event handle for libuv work done.
          \return None.
      */
      static void onAfterWork(uv_work_t* req /*!< libuv work struct. */, int status /*!< status of work. \note Now only UV_ECANCELED is cared about. */) {
            auto ci = reinterpret_cast<ci_t *>(req->data);

            ci->cb_after_work(ci->user_data, status == UV_ECANCELED);

            ci->sender->delReq(req);
      }
 }; // class AsyncWorker

Wrapper of Timer

Make the libuv timer featurn more easily to use.

/*!
     \brief C++ wrapper for libuv timer
 */
class AsyncTimer {
public:
    /** Timer event callback. */
    DECL_CB(timer, void)

    const u64 INTERVAL_MIN = 1; /*!< Minimum interval for timer: 1 Millisecond. */
    const u64 DEFAULT_INTERVAL = 1000;  /*!< Default interval: 1 second. */

private:
    //** Callback information. */
    typedef struct {
        AsyncTimer* sender;
        cb_timer_t cb;
    } callback_info_t;

    using ci_t = callback_info_t;

 public:
    AsyncTimer() {
        Init();
    }

    AsyncTimer(const AsyncTimer&) = delete;

    ~AsyncTimer() {
        Stop();
        assert(m_handle != nullptr);
        free(m_handle);
    }

    /*!
      \brief Check if the timer already started.
      \return bool true/false.
    */
    inline bool IsStarted() {
        return m_started;
    }

    /*!
      \brief Set interval, unit: millisecond.
      \note  interval must equal or be greater than INTERVAL_MIN.
      \return None.
    */
    inline void SetInterval(u64 msec) {
        uv_timer_set_repeat(m_handle, msec < INTERVAL_MIN ? INTERVAL_MIN : msec);
    }

    /*!
      \brief Get interval.
      \return u64 interval value.
    */
    inline u64 GetInterval() {
        return uv_timer_get_repeat(m_handle);
    }

    /*!
      \brief Start timer. When the specified interval arrives, specified callback(defined by cb_timer_t) will be called.
      \return None.
    */
    inline void Start(const cb_timer_t& cb) {
        if (IsStarted()) return;

        m_handle->data = new ci_t { this, cb };
        uv_timer_start(m_handle, AsyncTimer::OnTimer, 0, GetInterval());

        m_started = true;
    }

    /*!
      \brief Stop timer.
      \return None.
    */
    inline void Stop() {
        if (IsStarted()) {
            m_started = false;

            auto ci = reinterpret_cast<ci_t *>(m_handle->data);
            delete ci;

            m_handle->data = nullptr;
            uv_timer_stop(m_handle);

            TRACE("Timer stopped");
        }
    }

 private:
    /*!
      \brief Initialize timer handler.
      \return None.
    */
    inline void Init() {
        m_handle = (uv_timer_t *)malloc(sizeof(uv_timer_t));
        uv_timer_init(uv_default_loop(), m_handle);
        m_handle->data = nullptr;
        m_started = false;
    }

    /*!
      \brief Timer handling event for libuv.
      \return None.
    */
    static void OnTimer(uv_timer_t* handle) {
        auto ci = reinterpret_cast<ci_t *>(handle->data);

        if (ci->sender->IsStarted()) {
            ci->cb();
        }
    }

private:
    uv_timer_t* m_handle = nullptr; /*!< Timer handle */
    bst::atomic_bool m_started; /*!< Flag of if timer started/stopped */
 }; // class AsyncTimer