zupply.hpp

/* Doxygen main page */
#ifndef _ZUPPLY_ZUPPLY_HPP_
#define _ZUPPLY_ZUPPLY_HPP_

// Require C++ 11 features
#if ((defined(_MSC_VER) && _MSC_VER >= 1800) || __cplusplus >= 201103L)
// VC++ defined an older version of __cplusplus, but it should work later than vc12
#else
#error C++11 required, add -std=c++11 to CFLAG.
#endif

#ifdef _MSC_VER

// Disable silly security warnings
//#ifndef _CRT_SECURE_NO_WARNINGS
//#define _CRT_SECURE_NO_WARNINGS
//#endif

// Define __func__ macro
#ifndef __func__
#define __func__ __FUNCTION__
#endif 

// Define NDEBUG in Release Mode, ensure assert() disabled.
#if (!defined(_DEBUG) && !defined(NDEBUG))
#define NDEBUG
#endif

#if _MSC_VER < 1900
#define ZUPPLY_NOEXCEPT throw()
#endif

#endif

#ifndef ZUPPLY_NOEXCEPT
#define ZUPPLY_NOEXCEPT noexcept
#endif

// Optional header only mode, not done.
#ifdef ZUPPLY_HEADER_ONLY
#define ZUPPLY_EXPORT inline
#else
#define ZUPPLY_EXPORT
#endif

#include <string>
#include <exception>
#include <fstream>
#include <utility>
#include <iostream>
#include <vector>
#include <locale>
#include <ctime>
#include <chrono>
#include <thread>
#include <mutex>
#include <atomic>
#include <map>
#include <unordered_map>
#include <memory>
#include <type_traits>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <functional>
#include <climits>
#include <cassert>
#include <cstring>


namespace zz
{
    namespace consts
    {
        static const char* kExceptionPrefixGeneral = "[Zupply Exception] ";
        static const char* kExceptionPrefixLogic = "[Zupply Exception->Logic] ";
        static const char* kExceptionPrefixArgument = "[Zupply Exception->Logic->Argument] ";
        static const char* kExceptionPrefixRuntime = "[Zupply Exception->Runtime] ";
        static const char* kExceptionPrefixIO = "[Zupply Exception->Runtime->IO] ";
        static const char* kExceptionPrefixCast = "[Zupply Exception->Runtime->Cast] ";
        static const char* kExceptionPrefixMemory = "[Zupply Exception->Runtime->Memory] ";
        static const char* kExceptionPrefixStrictWarn = "[Zupply Exception->StrictWarn] ";
    }

    class UnCopyable
    {
    public:
        UnCopyable() {};
        // no copy constructor
        UnCopyable(const UnCopyable&) = delete;
        // no assignment
        UnCopyable& operator=(const UnCopyable&) = delete;
    };

    class UnMovable
    {
    public:
        UnMovable() {};
        // no copy constructor
        UnMovable(const UnMovable&) = delete;
        // no copy operator
        UnMovable& operator=(const UnMovable&) = delete;
        // no move constructor
        UnMovable(UnMovable&&) = delete;
        // no move operator
        UnMovable& operator=(UnMovable&&) = delete;
    };

    class Exception : public std::exception
    {
    public:
        explicit Exception(const char* message, const char* prefix = consts::kExceptionPrefixGeneral)
        {
            message_ = std::string(prefix) + message;
        };
        explicit Exception(const std::string message, const char* prefix = consts::kExceptionPrefixGeneral)
        {
            message_ = std::string(prefix) + message;
        };
        virtual ~Exception() ZUPPLY_NOEXCEPT{};

        const char* what() const ZUPPLY_NOEXCEPT{ return message_.c_str(); };
    private:
        std::string message_;
    };

    class LogicException : public Exception
    {
    public:
        explicit LogicException(const char *message) : Exception(message, consts::kExceptionPrefixLogic){};
        explicit LogicException(const std::string &message) : Exception(message, consts::kExceptionPrefixLogic){};
    };

    class ArgException : public Exception
    {
    public:
        explicit ArgException(const char *message) : Exception(message, consts::kExceptionPrefixArgument){};
        explicit ArgException(const std::string &message) : Exception(message, consts::kExceptionPrefixArgument){};
    };

    class RuntimeException : public Exception
    {
    public:
        explicit RuntimeException(const char *message) : Exception(message, consts::kExceptionPrefixRuntime){};
        explicit RuntimeException(const std::string &message) : Exception(message, consts::kExceptionPrefixRuntime){};
    };

    class CastException : public Exception
    {
    public:
        explicit CastException(const char *message) : Exception(message, consts::kExceptionPrefixCast){};
        explicit CastException(const std::string &message) : Exception(message, consts::kExceptionPrefixCast){};
    };

    class IOException : public Exception
    {
    public:
        explicit IOException(const char *message) : Exception(message, consts::kExceptionPrefixIO){};
        explicit IOException(const std::string &message) : Exception(message, consts::kExceptionPrefixIO){};
    };

    class MemException : public Exception
    {
    public:
        explicit MemException(const char *message) : Exception(message, consts::kExceptionPrefixMemory){};
        explicit MemException(const std::string &message) : Exception(message, consts::kExceptionPrefixMemory){};
    };

    class WarnException : public Exception
    {
    public:
        explicit WarnException(const char *message) : Exception(message, consts::kExceptionPrefixStrictWarn){};
        explicit WarnException(const std::string &message) : Exception(message, consts::kExceptionPrefixStrictWarn){};
    };

    template<typename _Tp> class Size_
    {
    public:
        typedef _Tp value_type;

        Size_();

        Size_(_Tp width, _Tp height);

        Size_(const Size_& sz);

        Size_& operator = (const Size_& sz);

        bool operator==(const Size_& other);

        bool operator!=(const Size_& other);

        _Tp area() const;

        template<typename _Tp2> operator Size_<_Tp2>() const;

        _Tp width, height; // the width and the height
    };
    using Size2i = Size_<int>;

    using Size2f = Size_<float>;

    using Size2d = Size_<double>;

    using Size = Size_<int>;

    template<typename _Tp> class Rect_;
    template<typename _Tp> class Point_
    {
    public:
        typedef _Tp value_type;

        Point_();

        Point_(_Tp _x, _Tp _y);

        Point_(const Point_& pt);

        Point_& operator = (const Point_& pt);

        template<typename _Tp2> operator Point_<_Tp2>() const;

        _Tp dot(const Point_& pt) const;

        double ddot(const Point_& pt) const;
        double cross(const Point_& pt) const;
        bool inside(const Rect_<_Tp>& r) const;

        _Tp x, y; 
    };

    typedef Point_<int> Point2i;

    typedef Point_<float> Point2f;

    typedef Point_<double> Point2d;

    typedef Point2i Point;

    typedef std::vector<Point> Vecpts;

    template<typename _Tp> class Rect_
    {
    public:
        typedef _Tp value_type;

        Rect_();

        Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height);

        Rect_(const Rect_& r);

        Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz);

        Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2);

        Rect_& operator = (const Rect_& r);

        Point_<_Tp> tl() const;

        Point_<_Tp> br() const;

        Size_<_Tp> size() const;

        _Tp area() const;

        template<typename _Tp2> operator Rect_<_Tp2>() const;

        bool contains(const Point_<_Tp>& pt) const;

        _Tp x, y, width, height; 
    };

    typedef Rect_<int> Rect2i;

    typedef Rect_<float> Rect2f;

    typedef Rect_<double> Rect2d;

    typedef Rect2i Rect;

    namespace detail
    {
        template<typename _Tp> class ImageBase
        {
        public:
            typedef _Tp value_type;

            ImageBase();

            ImageBase(int rows, int cols, int channels);

            ImageBase(const ImageBase& other);

            ImageBase(ImageBase&& other);


            virtual ~ImageBase();

            void create(int rows, int cols, int channels);

            void release();

            ImageBase& operator= (const ImageBase& other);

            ImageBase& operator= (ImageBase&& other);

            _Tp& operator() (int row, int col, int channel = 0);

            const _Tp& operator() (int row, int col, int channel = 0) const;

            template <typename _Tp2> operator ImageBase<_Tp2>() const;

            bool empty() const;

            int rows() const;

            int cols() const;

            int channels() const;

            _Tp at(int row, int col, int channel = 0) const;

            _Tp* ptr(int offset = 0) const;

            _Tp* ptr(int row, int col, int channel = 0) const;

            void import(_Tp* data, int rows, int cols, int channels);

            void import(std::vector<_Tp> data, int rows, int cols, int channels);

            std::vector<_Tp> export_raw() const;

            template <typename _Tp2> std::vector<_Tp2>& export_raw(std::vector<_Tp2>& out) const;

            void crop(int r0, int c0, int r1, int c1);

            void crop(Point p0, Point p1);

            void crop(Rect rect);

        protected:
            void range_check(long long pos) const;
            void range_check(int row, int col, int channel) const;
            void detach();

            int rows_;
            int cols_;
            int channels_;
            std::shared_ptr<std::vector<_Tp>> data_;

        };
    } // namespace zz::detail

    class Image : public detail::ImageBase<unsigned char>
    {
    public:
        Image() : ImageBase() {};

        Image(int rows, int cols, int channels) : ImageBase(rows, cols, channels) {};

        Image(const char* filename);

        void load(const char* filename);

        void save(const char* filename, int quality = 80) const;

        void resize(Size sz);

        void resize(int width, int height);

        void resize(double ratio);
    };

    class ImageHdr : public detail::ImageBase<float>
    {
    public:
        ImageHdr() : ImageBase() {};

        ImageHdr(int rows, int cols, int channels) : ImageBase(rows, cols, channels) {};

        ImageHdr(const char* filename);

        ImageHdr(const Image& from, float range = 1.0f);

        void load(const char* filename);

        void save_hdr(const char* filename) const;

        Image to_normal(float range = 1.0f) const;

        void from_normal(const Image& from, float range = 1.0f);
        
        void resize(Size sz);

        void resize(int width, int height);

        void resize(double ratio);
    };


    namespace math
    {
        using std::min;
        using std::max;
        using std::abs;

        template<class T> inline const T clip(const T& value, const T& low, const T& high)
        {
            // fool proof max/min values
            T h = (std::max)(low, high);
            T l = (std::min)(low, high);
            return (std::max)((std::min)(value, h), l);
        }

        template <unsigned long B, unsigned long E>
        struct Pow
        {
            static const unsigned long result = B * Pow<B, E - 1>::result;
        };

        template <unsigned long B>
        struct Pow<B, 0>
        {
            static const unsigned long result = 1;
        };


        inline int round(double value)
        {
#if ((defined _MSC_VER && defined _M_X64) || (defined __GNUC__ && defined __x86_64__ && defined __SSE2__ && !defined __APPLE__)) && !defined(__CUDACC__) && 0
            __m128d t = _mm_set_sd(value);
            return _mm_cvtsd_si32(t);
#elif defined _MSC_VER && defined _M_IX86
            int t;
            __asm
            {
                fld value;
                fistp t;
            }
            return t;
#elif defined _MSC_VER && defined _M_ARM && defined HAVE_TEGRA_OPTIMIZATION
            TEGRA_ROUND(value);
#elif defined CV_ICC || defined __GNUC__
#  ifdef HAVE_TEGRA_OPTIMIZATION
            TEGRA_ROUND(value);
#  else
            return (int)lrint(value);
#  endif
#else
            double intpart, fractpart;
            fractpart = modf(value, &intpart);
            if ((fabs(fractpart) != 0.5) || ((((int)intpart) % 2) != 0))
                return (int)(value + (value >= 0 ? 0.5 : -0.5));
            else
                return (int)intpart;
#endif
        }

    } // namespace math

    namespace misc
    {
        template<typename T>
        inline void unused(const T&) {}

        namespace detail
        {
            // To allow ADL with custom begin/end
            using std::begin;
            using std::end;

            template <typename T>
            auto is_iterable_impl(int)
                -> decltype (
                begin(std::declval<T&>()) != end(std::declval<T&>()), // begin/end and operator !=
                ++std::declval<decltype(begin(std::declval<T&>()))&>(), // operator ++
                *begin(std::declval<T&>()), // operator*
                std::true_type{});

            template <typename T>
            std::false_type is_iterable_impl(...);

        }

        template <typename T>
        using is_iterable = decltype(detail::is_iterable_impl<T>(0));

        class Callback
        {
        public:
            Callback(std::function<void()> f) : f_(f) { f_(); }
        private:
            std::function<void()> f_;
        };
    } // namespace misc

    namespace cds
    {
        inline void nop_pause()
        {
#if (defined _MSC_VER) && (defined _M_IX86 || defined _M_X64) && 0
            __asm volatile("pause" ::: "memory");
#endif
        }

        class NullMutex
        {
        public:
            void lock() {}
            void unlock() {}
            bool try_lock() { return true; }
        };

        class SpinLock : UnMovable
        {
        public:
            SpinLock(){ flag_.clear(); }
            inline void lock()
            {
                while (flag_.test_and_set(std::memory_order_acquire))
                {
                    nop_pause();    // no op or use architecture pause
                }
            }

            inline void unlock()
            {
                flag_.clear(std::memory_order_release);
            }

            inline bool try_lock()
            {
                return !flag_.test_and_set(std::memory_order_acquire);
            }
        private:
            std::atomic_flag flag_;
        };

        class RWLockable;

        class RWLock {
            friend class RWLockable;

        public:
            enum class LockType {
                none,
                read,
                write
            };

        private:
            RWLockable * lockable_;
            LockType lockType_;

            RWLock(RWLockable * const lockable, bool const exclusive);
            RWLock();

        public:
            RWLock(RWLock&& rhs);
            RWLock& operator =(RWLock&& rhs);
            ~RWLock();

            void unlock();
            LockType get_lock_type() const;
        };

        class RWLockable {
            friend RWLock::~RWLock();

        private:
            class Counters {
            private:
                uint16_t read_;
                uint8_t writeClaim_;
                uint8_t writeDone_;
            public:
                bool is_waiting_for_write() const;
                bool is_waiting_for_read() const;
                bool is_my_turn_to_write(Counters const & claim) const;

                bool want_to_read(Counters * buf) const;
                bool want_to_write(Counters * buf) const;
                Counters done_reading() const;
                Counters done_writing() const;
            };

            std::atomic<Counters> counters_;

            void unlock_read();
            void unlock_write();

        public:
            RWLock lock_for_read();
            RWLock lock_for_write();
            bool is_lock_free() const;
        };

        namespace lockfree
        {
            template <typename Key, typename Value> class UnorderedMap : public UnMovable
            {
            public:
                using MapType = std::unordered_map<Key, Value>;
                using MapPairType = std::pair<Key, Value>;

                UnorderedMap() {}

                bool is_lock_free() const
                {
                    return lockable_.is_lock_free();
                }

                bool contains(const Key& key)
                {
                    auto lock = lockable_.lock_for_read();
                    return map_.count(key) > 0;
                }

                bool get(const Key& key, Value& dst)
                {
                    auto lock = lockable_.lock_for_read();
                    if (map_.count(key) > 0)
                    {
                        dst = map_[key];
                        return true;
                    }
                    return false;
                }

                MapType snapshot()
                {
                    auto lock = lockable_.lock_for_read();
                    return map_;
                }

                bool insert(const Key& key, const Value& value)
                {
                    if (contains(key)) return false;
                    auto lock = lockable_.lock_for_write();
                    map_[key] = value;
                    return true;
                }

                bool insert(const MapPairType& pair)
                {
                    return insert(pair.first, pair.second);
                }

                void replace(const Key& key, const Value& value)
                {
                    auto lock = lockable_.lock_for_write();
                    map_[key] = value;
                }

                void replace(const MapPairType& pair)
                {
                    replace(pair.first, pair.second);
                }

                void erase(const Key& key)
                {
                    auto lock = lockable_.lock_for_write();
                    map_.erase(key);
                }

                void clear()
                {
                    auto lock = lockable_.lock_for_write();
                    map_.clear();
                }

                //template <typename Function>
                //void for_each(std::function<Function> functor)
                //{
                //  auto lock = lockable_.lock_for_read();
                //  std::for_each(map_.begin(), map_.end(), functor);
                //}

            private:

                RWLockable  lockable_;
                MapType map_;
            };

            template <typename T> class NonTrivialContainer : public UnMovable
            {
            public:
                NonTrivialContainer() {}

                bool is_lock_free() const
                {
                    return lockable_.is_lock_free();
                }

                T get()
                {
                    auto lock = lockable_.lock_for_read();
                    return obj_;
                }

                void set(const T& t)
                {
                    //std::lock_guard<std::mutex> lock(mutex_);
                    auto lock = lockable_.lock_for_write();
                    obj_ = t;
                }

            private:
                T   obj_;
                RWLockable lockable_;

            };
        }

        namespace lockbased
        {
            template <typename Key, typename Value> class UnorderedMap : public UnMovable
            {
            public:
                using MapType = std::unordered_map<Key, Value>;
                using MapPairType = std::pair<Key, Value>;

                UnorderedMap() {}

                bool is_lock_free() const
                {
                    return false;
                }

                bool contains(const Key& key)
                {
                    std::lock_guard<std::mutex> lock(mutex_);
                    return map_.count(key) > 0;
                }

                bool get(const Key& key, Value& dst)
                {
                    std::lock_guard<std::mutex> lock(mutex_);
                    if (map_.count(key) > 0)
                    {
                        dst = map_[key];
                        return true;
                    }
                    return false;
                }

                MapType snapshot()
                {
                    std::lock_guard<std::mutex> lock(mutex_);
                    return map_;
                }

                bool insert(const Key& key, const Value& value)
                {
                    if (contains(key)) return false;
                    std::lock_guard<std::mutex> lock(mutex_);
                    map_[key] = value;
                    return true;
                }

                bool insert(const MapPairType& pair)
                {
                    return insert(pair.first, pair.second);
                }

                void replace(const Key& key, const Value& value)
                {
                    std::lock_guard<std::mutex> lock(mutex_);
                    map_[key] = value;
                }

                void replace(const MapPairType& pair)
                {
                    replace(pair.first, pair.second);
                }

                void erase(const Key& key)
                {
                    std::lock_guard<std::mutex> lock(mutex_);
                    map_.erase(key);
                }

                void clear()
                {
                    std::lock_guard<std::mutex> lock(mutex_);
                    map_.clear();
                }

                //template <typename Function>
                //void for_each(std::function<Function> functor)
                //{
                //  auto lock = lockable_.lock_for_read();
                //  std::for_each(map_.begin(), map_.end(), functor);
                //}

            private:

                std::mutex mutex_;
                MapType map_;
            };

            template <typename T> class NonTrivialContainer : public UnMovable
            {
            public:
                NonTrivialContainer() {}

                bool is_lock_free() const
                {
                    return false;
                }

                T get()
                {
                    std::lock_guard<std::mutex> lock(mutex_);
                    return obj_;
                }

                void set(const T& t)
                {
                    std::lock_guard<std::mutex> lock(mutex_);
                    obj_ = t;
                }

            private:
                T   obj_;
                std::mutex mutex_;

            };
        }

        // * \brief AtomicUnorderedMap Template atomic unordered_map<>
        // * AtomicUnorderedMap is lock-free, however, modification will create copies.
        // * Thus this structure is good for read-many write-rare purposes.
        // */
        //template <typename Key, typename Value> class AtomicUnorderedMap
        //{
        //  using MapType = std::unordered_map<Key, Value>;
        //  using MapPtr = std::shared_ptr<MapType>;
        //public:
        //  AtomicUnorderedMap()
        //  {
        //      mapPtr_ = std::make_shared<MapType>();
        //  }

        //  /*!
        //   * \brief Get shared_ptr of unorderd_map instance
        //   * \return Shared_ptr of unordered_map
        //   */
        //  MapPtr get()
        //  {
        //      return std::atomic_load(&mapPtr_);
        //  }

        //  /*!
        //   * \brief Insert key-value pair to the map
        //   * \param key
        //   * \param value
        //   * \return True on success
        //   */
        //  bool insert(const Key& key, const Value& value)
        //  {
        //      MapPtr p = std::atomic_load(&mapPtr_);
        //      MapPtr copy;
        //      do
        //      {
        //          if ((*p).count(key) > 0) return false;
        //          copy = std::make_shared<MapType>(*p);
        //          (*copy).insert({ key, value });
        //      } while (!std::atomic_compare_exchange_weak(&mapPtr_, &p, std::move(copy)));
        //      return true;
        //  }

        //  /*!
        //   * \brief Erase according to key
        //   * \param key
        //   * \return True on success
        //   */
        //  bool erase(const Key& key)
        //  {
        //      MapPtr p = std::atomic_load(&mapPtr_);
        //      MapPtr copy;
        //      do
        //      {
        //          if ((*p).count(key) <= 0) return false;
        //          copy = std::make_shared<MapType>(*p);
        //          (*copy).erase(key);
        //      } while (!std::atomic_compare_exchange_weak(&mapPtr_, &p, std::move(copy)));
        //      return true;
        //  }

        //  /*!
        //   * \brief Clear all
        //   */
        //  void clear()
        //  {
        //      MapPtr p = atomic_load(&mapPtr_);
        //      auto copy = std::make_shared<MapType>();
        //      do
        //      {
        //          ;   // do clear when possible does not require old status
        //      } while (!std::atomic_compare_exchange_weak(&mapPtr_, &p, std::move(copy)));
        //  }

        //private:
        //  std::shared_ptr<MapType>    mapPtr_;
        //};

        // * \brief AtomicNonTrivial Template lock-free class
        // * AtomicNonTrivial is lock-free, however, modification will create copies.
        // * Thus this structure is good for read-many write-rare purposes.
        // */
        //template <typename T> class AtomicNonTrivial
        //{
        //public:
        //  AtomicNonTrivial()
        //  {
        //      ptr_ = std::make_shared<T>();
        //  }

        //  /*!
        //   * \brief Get shared_ptr to instance
        //   * \return Shared_ptr to instance
        //   */
        //  std::shared_ptr<T> get()
        //  {
        //      return std::atomic_load(&ptr_);
        //  }

        //  /*!
        //   * \brief Set to new value
        //   * \param val
        //   * This operation will make a copy which is only visible for future get()
        //   */
        //  void set(const T& val)
        //  {
        //      std::shared_ptr<T> copy = std::make_shared<T>(val);
        //      std::atomic_store(&ptr_, copy);
        //  }

        //private:
        //  std::shared_ptr<T>  ptr_;
        //};


        //      namespace gc
        //      {
        //          class HPRecord
        //          {
        //          public:
        //              void*   pHazard_;   //!< can be used by the thread that acquire it
        //              HPRecord*           pNext_;
        //              static HPRecord* head() { return pHead_; }
        //
        //              static HPRecord* acquire()
        //              {
        //                  // try to reuse a retired hp record
        //                  HPRecord* p = pHead_;
        //                  bool inactive(false);
        //
        //                  for (; p; p = p->pNext_)
        //                  {
        //                      if (p->active_ || (!p->active_.compare_exchange_weak(inactive, true)))
        //                      {
        //                          continue;
        //                      }
        //                      return p; // got one!
        //                  }
        //                  // increment the list length by adding one
        //                  int oldLen;
        //                  do
        //                  {
        //                      oldLen = listLen_;
        //                  } while (!listLen_.compare_exchange_weak(oldLen, oldLen + 1));
        //                  // allocate a new one
        //                  p = new HPRecord;
        //                  p->active_.store(true);
        //                  p->pHazard_ = nullptr;
        //                  // push it to the front
        //                  HPRecord* old = nullptr;
        //                  do
        //                  {
        //                      old = pHead_;
        //                      p->pNext_ = old;
        //                  } while (!pHead_.compare_exchange_weak(old, p));
        //
        //                  return p; // return acquired pointer
        //              }
        //
        //              static void release(HPRecord* p)
        //              {
        //                  p->pHazard_ = nullptr;
        //                  p->active_.store(false);
        //              }
        //
        //          private:
        //              std::atomic<bool>   active_;
        //              static std::atomic<HPRecord*>   pHead_; //!< global header of the hazard pointer list
        //              static std::atomic<int>         listLen_; //!< length of the list
        //          };
        //
        //          template <typename T> void garbage_collection(std::vector<T*> rlist)
        //          {
        //              // stage 1: scan hazard ponter list
        //              // collecting all non-null pointers
        //              std::vector<void*> hp;
        //              HPRecord* head = HPRecord::head();
        //              while (head)
        //              {
        //                  void *p = head->pHazard_;
        //                  if (p) hp.push_back(p);
        //                  head = head->pNext_;
        //              }
        //              // stage 2: sort the hazard pointers
        //              std::sort(hp.begin(), hp.end(), std::less<void*>());
        //              // stage 3: search for null
        //              std::vector<T*>::iterator iter = rlist.begin();
        //              while (iter != rlist.end())
        //              {
        //                  if (!std::binary_search(hp.begin(), hp.end(), *iter))
        //                  {
        //                      delete *iter;   // safely reclaim this memory
        //                      if (&*iter != rlist.back())
        //                      {
        //                          *iter = rlist.back();
        //                      }
        //                      rlist.pop_back();
        //                  }
        //                  else
        //                  {
        //                      ++iter;
        //                  }
        //              }
        //          }
        //
        //      } // namespace gc
        //
        //      namespace consts
        //      {
        //          static const unsigned kGarbageCollectionThreshold = 4;
        //      }
        //
        //      template <typename K, typename V> class WRRMUMap
        //      {
        //      public:
        //
        //      private:
        //          using MapType = std::unordered_map<K, V>;
        //
        //          static void retire(MapType* old)
        //          {
        //              // put old map into retire list
        //              rlist_.push_back(old);
        //              if (rlist_.size() >= consts::kGarbageCollectionThreshold)
        //              {
        //                  gc::garbage_collection(rlist_);
        //              }
        //          }
        //#if _MSC_VER
        //          static __declspec(thread)  std::vector<MapType*> rlist_;
        //#else
        //          static thread_local std::vector<MapType*> rlist_;
        //#endif
        //          MapType* pMap_;
        //      };


    } // namespace cds


    namespace os
    {
        int system(const char *const command, const char *const module_name = 0);

        std::size_t thread_id();

        int is_atty();

        std::tm localtime(std::time_t t);

        std::tm gmtime(std::time_t t);

        std::wstring utf8_to_wstring(std::string &u8str);

        std::string wstring_to_utf8(std::wstring &wstr);

        bool path_exists(std::string path, bool considerFile = true);

        bool is_file(std::string path);

        bool is_directory(std::string path);

        void fstream_open(std::fstream &stream, std::string filename, std::ios::openmode openmode);

        void ifstream_open(std::ifstream &stream, std::string filename, std::ios::openmode openmode);

        bool rename(std::string oldName, std::string newName);

        bool copyfile(std::string src, std::string dst, bool replaceDst = false);

        bool movefile(std::string src, std::string dst, bool replaceDst = false);

        bool remove_all(std::string path);

        bool remove_dir(std::string root, bool recursive = true);

        bool remove_file(std::string path);

        std::string last_error();

        std::string endl();

        std::string path_delim();

        std::string current_working_directory();

        std::string absolute_path(std::string reletivePath);

        std::vector<std::string> path_split(std::string path);

        bool path_identical(std::string first, std::string second, bool forceCaseSensitve = false);

        std::string path_join(std::vector<std::string> elems);

        std::string path_split_filename(std::string path);

        std::string path_split_directory(std::string path);

        std::string path_split_basename(std::string path);

        std::string path_split_extension(std::string path);

        std::string path_append_basename(std::string origPath, std::string whatToAppend);

        bool create_directory(std::string path);

        bool create_directory_recursive(std::string path);

        std::vector<std::string> list_directory(std::string root);

        Size console_size();

    } // namespace os

    namespace time
    {
        class DateTime
        {
        public:
            DateTime();
            virtual ~DateTime() = default;

            void to_local_time();

            void to_utc_time();

            std::string to_string(const char *format = "%y-%m-%d %H:%M:%S.%frac");

            static DateTime local_time();

            static DateTime utc_time();

        private:
            std::time_t     timeStamp_;
            int             fraction_;
            std::string     fractionStr_;
            struct std::tm  calendar_;

        };

        class Timer
        {
        public:
            Timer();
            void reset();

            void pause();

            void resume();

            std::size_t elapsed_ns();

            std::string elapsed_ns_str();

            std::size_t elapsed_us();

            std::string elapsed_us_str();

            std::size_t elapsed_ms();

            std::string elapsed_ms_str();

            std::size_t elapsed_sec();

            std::string elapsed_sec_str();

            double elapsed_sec_double();

            std::string to_string(const char *format = "[%ms ms]");

        private:
            std::chrono::steady_clock::time_point timeStamp_;
            std::size_t elapsed_;
            bool        paused_;
        };

        inline void sleep(int milliseconds)
        {
            if (milliseconds > 0)
            {
                std::this_thread::sleep_for(std::chrono::milliseconds(milliseconds));
            }
        }

    } // namespace time

    namespace fs
    {
        namespace consts
        {
            static const int kDefaultFileOpenRetryTimes = 5;
            static const int kDefaultFileOpenRetryInterval = 10;
        }

        class Path
        {
        public:
            Path(std::string path, bool isAbsolute = false);

            bool empty() const;

            bool exist() const;

            bool is_file() const;

            bool is_dir() const;

            std::string abs_path() const;

            std::string relative_path() const;

            std::string relative_path(std::string root) const;

            std::string filename() const;

        private:
            std::string abspath_;
        };

        class Directory
        {
        public:
            using iterator = std::vector<Path>::iterator;
            using const_iterator = std::vector<Path>::const_iterator;

            Directory(std::string root, bool recursive = false);

            Directory(std::string root, const std::string pattern, bool recursive = false);

            Directory(std::string root, const std::vector<std::string> patternList, bool recursive);

            Directory(std::string root, const std::vector<const char*> patternList, bool recursive);

            iterator begin() { return paths_.begin(); }

            iterator end() { return paths_.end(); }

            const_iterator cbegin() const { return paths_.cbegin(); }

            const_iterator cend() const { return paths_.cend(); }

            std::size_t size() const { return paths_.size(); }

            bool is_recursive() const;

            std::string root() const;

            void filter(const std::string pattern);

            void filter(const std::vector<const char*> patternList);

            void filter(const std::vector<std::string> patternList);

            void reset();

            std::vector<Path> to_list() const;

        private:
            void resolve();

            bool recursive_;
            Path root_;
            std::vector<Path> paths_;
        };

        class FileEditor : private UnCopyable
        {
        public:
            FileEditor() = default;

            FileEditor(std::string filename, bool truncateOrNot = false,
                int retryTimes = consts::kDefaultFileOpenRetryTimes,
                int retryInterval = consts::kDefaultFileOpenRetryInterval);

            //FileEditor(FileEditor&& other);

            virtual ~FileEditor() { this->close(); }

            // No move operator
            FileEditor& operator=(FileEditor&&) = delete;

            template <typename T>
            FileEditor& operator<<(T what) { stream_ << what; return *this; }

            std::string filename() const { return filename_; }

            bool open(std::string filename, bool truncateOrNot = false,
                int retryTimes = consts::kDefaultFileOpenRetryTimes,
                int retryInterval = consts::kDefaultFileOpenRetryInterval);

            bool open(const char* filename, bool truncateOrNot = false,
                int retryTimes = consts::kDefaultFileOpenRetryTimes,
                int retryInterval = consts::kDefaultFileOpenRetryInterval);

            bool open(bool truncateOrNot = false);

            bool reopen(bool truncateOrNot = true);

            void close();

            bool is_valid() const { return !filename_.empty(); }

            bool is_open() const { return stream_.is_open(); }

            void flush() { stream_.flush(); }
        private:

            bool try_open(int retryTime, int retryInterval, bool truncateOrNot = false);
            void check_valid() { if (!this->is_valid()) throw RuntimeException("Invalid File Editor!"); }

            std::string     filename_;
            std::fstream    stream_;
            std::streampos  readPos_;
            std::streampos  writePos_;
        };

        class FileReader : private UnCopyable
        {
        public:
            FileReader() = delete;

            FileReader(std::string filename, int retryTimes = consts::kDefaultFileOpenRetryTimes,
                int retryInterval = consts::kDefaultFileOpenRetryInterval);

            //FileReader(FileReader&& other);

            std::string filename() const { return filename_; }

            bool is_open() const { return istream_.is_open(); }

            bool is_valid() const { return !filename_.empty(); }

            void close() { istream_.close(); }

            std::size_t file_size();

            std::size_t count_lines();

            std::string next_line(bool trimWhiteSpaces = false);

            int goto_line(int n);

        private:
            bool open();
            bool try_open(int retryTime, int retryInterval);
            void check_valid(){ if (!this->is_valid()) throw RuntimeException("Invalid File Reader!"); }
            std::string     filename_;
            std::ifstream   istream_;
        };

        std::size_t get_file_size(std::string filename);

    } //namespace fs


    namespace fmt
    {
        namespace consts
        {
            static const std::string kFormatSpecifierPlaceHolder = std::string("{}");
        }

        namespace detail
        {
            template<class Facet>
            struct DeletableFacet : Facet
            {
                template<class ...Args>
                DeletableFacet(Args&& ...args) : Facet(std::forward<Args>(args)...) {}
                ~DeletableFacet() {}
            };
        } // namespace detail

        inline std::string int_to_zero_pad_str(int num, int length)
        {
            std::ostringstream ss;
            ss << std::setw(length) << std::setfill('0') << num;
            return ss.str();
        }

        bool is_digit(char c);

        bool wild_card_match(const char* str, const char* pattern);

        bool starts_with(const std::string& str, const std::string& start);

        bool ends_with(const std::string& str, const std::string& end);

        std::string& replace_all(std::string& str, const std::string& replaceWhat, const std::string& replaceWith);

        std::string& replace_all(std::string& str, char replaceWhat, char replaceWith);

        bool str_equals(const char* s1, const char* s2);

        std::string ltrim(std::string str);

        std::string rtrim(std::string str);

        std::string trim(std::string str);

        std::string lstrip(std::string str, std::string what);

        std::string rstrip(std::string str, std::string what);

        std::string lskip(std::string str, std::string delim);

        std::string rskip(std::string str, std::string delim);

        std::string rskip_all(std::string str, std::string delim);

        std::vector<std::string> split(const std::string s, char delim = ' ');

        std::vector<std::string> split(const std::string s, std::string delim);

        std::vector<std::string> split_multi_delims(const std::string s, std::string delims);

        std::vector<std::string> split_whitespace(const std::string s);

        std::pair<std::string, std::string> split_first_occurance(const std::string s, char delim);

        std::string join(std::vector<std::string> elems, char delim);

        std::vector<std::string>& erase_empty(std::vector<std::string>& vec);

        void replace_first_with_escape(std::string &str, const std::string &replaceWhat, const std::string &replaceWith);

        void replace_all_with_escape(std::string &str, const std::string &replaceWhat, const std::string &replaceWith);

        void replace_sequential_with_escape(std::string &str, const std::string &replaceWhat, const std::vector<std::string> &replaceWith);

        std::string to_lower_ascii(std::string mixed);

        std::string to_upper_ascii(std::string mixed);

        std::u16string utf8_to_utf16(std::string u8str);

        std::string utf16_to_utf8(std::u16string u16str);

        std::u32string utf8_to_utf32(std::string u8str);

        std::string utf32_to_utf8(std::u32string u32str);

        template<typename Arg>
        inline void format_string(std::string &fmt, const Arg &last)
        {
            std::stringstream ss;
            ss << last;
            replace_first_with_escape(fmt, consts::kFormatSpecifierPlaceHolder, ss.str());
        }

        template<typename Arg, typename... Args>
        inline void format_string(std::string &fmt, const Arg& current, const Args&... more)
        {
            std::stringstream ss;
            ss << current;
            replace_first_with_escape(fmt, consts::kFormatSpecifierPlaceHolder, ss.str());
            format_string(fmt, more...);
        }

    } // namespace fmt

    namespace cfg
    {
        class Value
        {
        public:
            Value(){}

            Value(const char* cstr) : str_(cstr) {}

            Value(std::string str) : str_(str) {}

            Value(const Value& other) : str_(other.str_) {}

            std::string str() const { return str_; }

            bool empty() const { return str_.empty(); }

            void clear() { str_.clear(); }

            bool operator== (const Value& other) { return str_ == other.str_; }

            Value& operator= (const Value& other) { str_ = other.str_; return *this; }

            template <typename T> std::string store(T t);

            template <typename T> std::string store(std::vector<T> t);

            template <typename T> T load(T& t);

            template <typename T> std::vector<T> load(std::vector<T>& t);

            //template <> bool load(bool& b);

            template <typename T> T load() { T t; return load(t); }

        private:
            std::string str_;
        };

        struct CfgLevel
        {
            CfgLevel() : parent(nullptr), depth(0) {}
            CfgLevel(CfgLevel* p, std::size_t d) : parent(p), depth(d) {}

            using value_map_t = std::map<std::string, Value>;
            using section_map_t = std::map<std::string, CfgLevel>;

            value_map_t values;
            section_map_t sections;
            std::string prefix;
            CfgLevel* parent;
            size_t depth;

            Value operator[](const std::string& name) { return values[name]; }
            CfgLevel& operator()(const std::string& name) { return sections[name]; }
            std::string to_string()
            {
                std::string ret;
                for (auto v : values)
                {
                    ret += prefix + v.first + " = " + v.second.str() + "\n";
                }
                for (auto s : sections)
                {
                    ret += s.second.to_string();
                }
                return ret;
            }
        };

        class CfgParser
        {
        public:
            CfgParser(std::string filename);

            CfgParser(std::istream& s) : pstream_(&s), ln_(0) { parse(root_); }

            CfgLevel& root() { return root_; }

            Value operator[](const std::string& name) { return root_.values[name]; }

            CfgLevel& operator()(const std::string& name) { return root_.sections[name]; }

        private:
            void parse(CfgLevel& lvl);
            CfgLevel* parse_section(std::string sline, CfgLevel *lvl);
            CfgLevel* parse_key_section(std::string& vline, CfgLevel *lvl);
            std::string split_key_value(std::string& line);
            void error_handler(std::string msg);

            CfgLevel        root_;
            std::ifstream   stream_;
            std::istream    *pstream_;
            std::string     line_;
            std::size_t     ln_;
        };

        class ArgOption
        {
            friend class ArgParser;
        public:

            ArgOption(char shortKey, std::string longKey);

            ArgOption(char shortKey);

            ArgOption(std::string longKey);

            ArgOption& call(std::function<void()> todo);

            ArgOption& call(std::function<void()> todo, std::function<void()> otherwise);

            ArgOption& set_help(std::string helpInfo);

            ArgOption& require(bool require = true);

            ArgOption& set_once(bool onlyOnce = true);

            ArgOption& set_type(std::string type);

            ArgOption& set_min(int minCount);

            ArgOption& set_max(int maxCount);

            Value get_value();

            int get_count();

        private:
            std::string get_help();         
            std::string get_short_help();   

            char            shortKey_;  
            std::string     longKey_;   
            std::string     type_;      
            std::string     help_;      
            std::string     default_;   
            bool            required_;  
            int             min_;       
            int             max_;       
            int             size_;      
            bool            once_;      
            int             count_;     
            Value           val_;       
            std::vector<std::function<void()>> callback_;   
            std::vector<std::function<void()>> othercall_;  
        };

        class ArgParser
        {
        public:
            ArgParser();

            void add_info(std::string info);

            ArgOption& add_opt(char shortKey, std::string longKey);

            ArgOption& add_opt(char shortKey);

            ArgOption& add_opt(std::string longKey);

            template <typename T> ArgOption& add_opt_value(char shortKey, std::string longKey,
                T& dst, T defaultValue, std::string help = "", std::string type = "", int min = 1, int max = 1);

            ArgOption& add_opt_flag(char shortKey, std::string longKey, std::string help = "", bool* dst = nullptr);

            void add_opt_help(char shortKey, std::string longKey, std::string help = "print this help and exit");

            void add_opt_version(char shortKey, std::string longKey, std::string version, std::string help = "print version and exit");

            std::string version() const { return info_[1]; }

            void parse(int argc, char** argv, bool ignoreUnknown = false);

            std::size_t count_error() { return errors_.size(); }

            int count(char shortKey);

            int count(std::string longKey);

            std::string get_error();

            std::string get_help();

            Value operator[](const std::string& longKey);

            Value operator[](const char shortKey);

            std::vector<Value> arguments() const;

        private:
            //using ArgOptIter = std::vector<ArgOption>::iterator;
            enum class Type { SHORT_KEY, LONG_KEY, ARGUMENT, INVALID };
            using ArgQueue = std::vector<std::pair<std::string, Type>>;

            ArgOption& add_opt_internal(char shortKey, std::string longKey);
            void register_keys(char shortKey, std::string longKey, std::size_t pos);
            Type check_type(std::string str);
            ArgQueue pretty_arguments(int argc, char** argv);
            void error_option(std::string opt, std::string msg = "");
            void parse_option(ArgOption* ptr);
            void parse_value(ArgOption* ptr, const std::string& value);

            std::vector<ArgOption> options_;    
            std::unordered_map<char, std::size_t> shortKeys_;       
            std::unordered_map<std::string, std::size_t> longKeys_; 
            std::vector<Value>  args_;  
            std::vector<std::string> errors_;   
            std::vector<std::string> info_; 
        };


        // implementations in cfg:: namespace

        template <typename T> inline std::string Value::store(T t)
        {
            std::ostringstream oss;
            oss << t;
            str_ = oss.str();
            return str_;
        }

        template <typename T> inline std::string Value::store(std::vector<T> t)
        {
            std::ostringstream oss;
            for (auto e : t)
            {
                oss << e << " ";
            }
            str_ = oss.str();
            return str_;
        }

        template <typename T> inline T Value::load(T& t)
        {
            std::istringstream iss(str_);
            iss >> t;
            return t;
        }

        template <> inline bool Value::load(bool& b)
        {
            b = false;
            std::string lowered = fmt::to_lower_ascii(str_);
            std::istringstream iss(lowered);
            iss >> std::boolalpha >> b;
            return b;
        }

        template <typename T> inline std::vector<T> Value::load(std::vector<T>& t)
        {
            std::istringstream iss(str_);
            t.clear();
            T val;
            std::string dummy;
            while (iss >> val || !iss.eof())
            {
                if (iss.fail())
                {
                    iss.clear();
                    iss >> dummy;
                    continue;
                }
                t.push_back(val);
            }
            return t;
        }

        template <typename T> inline ArgOption& ArgParser::add_opt_value(char shortKey, std::string longKey,
            T& dst, T defaultValue, std::string help, std::string type, int min, int max)
        {
            dst = defaultValue;
            Value dfltValue;
            dfltValue.store(defaultValue);
            auto pos = options_.size();
            auto& opt = add_opt(shortKey, longKey).call([&, pos] {options_[pos].get_value().load(dst); });
            opt.default_ = dfltValue.str();
            return opt.set_help(help).set_type(type).set_min(min).set_max(max);
        }

    } // namespace cfg

    namespace log
    {
        // \cond

        namespace detail
        {
            void zupply_internal_warn(std::string msg);
            void zupply_internal_error(std::string msg);

            class ScopedRedirect
            {
            public:
                ScopedRedirect(std::ostream &orig) : backup_(orig)
                {
                    old = orig.rdbuf(buffer_.rdbuf());
                }

                ~ScopedRedirect()
                {
                    backup_.rdbuf(old);
                    backup_ << buffer_.str();
                }

            private:
                ScopedRedirect(const ScopedRedirect&);
                ScopedRedirect& operator=(const ScopedRedirect&);

                std::ostream &backup_;
                std::streambuf *old;
                std::ostringstream buffer_;
            };
        }
        
        // \endcond

        class ProgBar
        {
        public:
            ProgBar(unsigned range = 100, std::string info = "");

            ~ProgBar();

            void step(unsigned size = 1);

            void stop();

        private:
            void start();
            void bg_work();
            void draw();
            void calc_rate(unsigned size);

            std::string             info_;
            unsigned                range_;
            std::atomic<unsigned>   pos_;
            std::thread             worker_;
            std::atomic_bool        running_;
            std::streambuf          *oldCout_;
            std::streambuf          *oldCerr_;
            std::ostream            ss_;
            std::ostringstream      buffer_;
            char                    rate_[10];
            time::Timer             timer_;
        };

        // \cond
        typedef enum LogLevelEnum
        {
            trace = 0,
            debug = 1,
            info = 2,
            warn = 3,
            error = 4,
            fatal = 5,
            off = 6,
            sentinel = 63
        }LogLevels;

        namespace consts
        {
            static const char   *kLevelNames[] { "TRACE", "DEBUG", "INFO", "WARN", "ERROR", "FATAL", "OFF"};
            static const char   *kShortLevelNames[] { "T", "D", "I", "W", "E", "F", "O"};
            static const char   *kZupplyInternalLoggerName = "zupply";
            static const int    kAsyncQueueSize = 4096; 

            static const char   *kSinkDatetimeSpecifier = "%datetime";
            static const char   *kSinkLoggerNameSpecifier = "%logger";
            static const char   *kSinkThreadSpecifier = "%thread";
            static const char   *kSinkLevelSpecifier = "%level";
            static const char   *kSinkLevelShortSpecifier = "%lvl";
            static const char   *kSinkMessageSpecifier = "%msg";
            static const char   *kStdoutSinkName = "stdout";
            static const char   *kStderrSinkName = "stderr";
            static const char   *kSimplefileSinkType = "simplefile";
            static const char   *kRotatefileSinkType = "rotatefile";
            static const char   *kOstreamSinkType = "ostream";
            static const char   *kDefaultLoggerFormat = "[%datetime][T%thread][%logger][%level] %msg";
            static const char   *kDefaultLoggerDatetimeFormat = "%y-%m-%d %H:%M:%S.%frac";

            // config file formats
            static const char   *KConfigGlobalSectionSpecifier = "global";
            static const char   *KConfigLoggerSectionSpecifier = "loggers";
            static const char   *KConfigSinkSectionSpecifier = "sinks";
            static const char   *kConfigFormatSpecifier = "format";
            static const char   *kConfigLevelsSpecifier = "levels";
            static const char   *kConfigDateTimeFormatSpecifier = "datetime_format";
            static const char   *kConfigSinkListSpecifier = "sink_list";
            static const char   *kConfigSinkTypeSpecifier = "type";
            static const char   *kConfigSinkFilenameSpecifier = "filename";
        }

        // forward declaration
        namespace detail
        {
            struct LogMessage;
            class LineLogger;
            class SinkInterface;
        } // namespace detail
        typedef std::shared_ptr<detail::SinkInterface> SinkPtr;

        inline bool level_should_log(int levelMask, LogLevels lvl)
        {
            return (LogLevels::sentinel & levelMask & (1 << lvl)) > 0;
        }

        std::string level_mask_to_string(int levelMask);

        LogLevels level_from_str(std::string level);

        int level_mask_from_string(std::string levels);

        // \endcond

        class LogConfig
        {
        public:
            static LogConfig& instance();

            static void set_default_format(std::string format);

            static void set_default_datetime_format(std::string dateFormat);

            static void set_default_sink_list(std::vector<std::string> list);

            static void set_default_level_mask(int levelMask);

            std::vector<std::string> sink_list();

            void set_sink_list(std::vector<std::string> &list);

            int log_level_mask();

            void set_log_level_mask(int newMask);

            std::string format();

            void set_format(std::string newFormat);

            std::string datetime_format();

            void set_datetime_format(std::string newDatetimeFormat);

        private:
            LogConfig();

            cds::lockbased::NonTrivialContainer<std::vector<std::string>> sinkList_;
            std::atomic_int logLevelMask_;
            cds::lockbased::NonTrivialContainer<std::string> format_;
            cds::lockbased::NonTrivialContainer<std::string> datetimeFormat_;
        };

        class Logger : UnMovable
        {
        public:
            Logger(std::string name) : name_(name)
            {
                levelMask_ = LogConfig::instance().log_level_mask();
            }

            Logger(std::string name, int levelMask) : name_(name)
            {
                levelMask_ = levelMask;
            }

            // logger.info(format string, arg1, arg2, arg3, ...) call style
            template <typename... Args> detail::LineLogger trace(const char* fmt, const Args&... args);

            template <typename... Args> detail::LineLogger debug(const char* fmt, const Args&... args);

            template <typename... Args> detail::LineLogger info(const char* fmt, const Args&... args);

            template <typename... Args> detail::LineLogger warn(const char* fmt, const Args&... args);

            template <typename... Args> detail::LineLogger error(const char* fmt, const Args&... args);

            template <typename... Args> detail::LineLogger fatal(const char* fmt, const Args&... args);


            // logger.info(msg) << ".." call style
            template <typename T> detail::LineLogger trace(const T& msg);

            template <typename T> detail::LineLogger debug(const T& msg);

            template <typename T> detail::LineLogger info(const T& msg);

            template <typename T> detail::LineLogger warn(const T& msg);

            template <typename T> detail::LineLogger error(const T& msg);

            template <typename T> detail::LineLogger fatal(const T& msg);


            // logger.info() << ".." call  style

            detail::LineLogger trace();

            detail::LineLogger debug();

            detail::LineLogger info();

            detail::LineLogger warn();

            detail::LineLogger error();

            detail::LineLogger fatal();

            //const LogLevels level() const
            //{
            //  return static_cast<LogLevels>(level_.load(std::memory_order_relaxed));
            //}

            void set_level_mask(int levelMask)
            {
                levelMask_ = levelMask & LogLevels::sentinel;
            }

            bool should_log(LogLevels msgLevel) const
            {
                return level_should_log(levelMask_, msgLevel);
            }

            std::string name() const { return name_; };

            std::string to_string();

            SinkPtr get_sink(std::string name);

            void attach_sink(SinkPtr sink);

            void detach_sink(SinkPtr sink);

            void detach_all_sinks();

            void attach_sink_list(std::vector<std::string> &sinkList);

            void attach_console();

            void detach_console();

        private:

            friend detail::LineLogger;

            detail::LineLogger log_if_enabled(LogLevels lvl);

            template <typename... Args>
            detail::LineLogger log_if_enabled(LogLevels lvl, const char* fmt, const Args&... args);

            template<typename T>
            detail::LineLogger log_if_enabled(LogLevels lvl, const T& msg);

            void log_msg(detail::LogMessage msg);

            std::string             name_;
            std::atomic_int         levelMask_;
            cds::lockbased::UnorderedMap<std::string, SinkPtr> sinks_;
        };
        typedef std::shared_ptr<Logger> LoggerPtr;


        // \cond
        namespace detail
        {
            template<typename T>
            class mpmc_bounded_queue
            {
            public:

                using item_type = T;
                mpmc_bounded_queue(size_t buffer_size)
                    : buffer_(new cell_t[buffer_size]),
                    buffer_mask_(buffer_size - 1)
                {
                    //queue size must be power of two
                    if (!((buffer_size >= 2) && ((buffer_size & (buffer_size - 1)) == 0)))
                        throw ArgException("async logger queue size must be power of two");

                    for (size_t i = 0; i != buffer_size; i += 1)
                        buffer_[i].sequence_.store(i, std::memory_order_relaxed);
                    enqueue_pos_.store(0, std::memory_order_relaxed);
                    dequeue_pos_.store(0, std::memory_order_relaxed);
                }

                ~mpmc_bounded_queue()
                {
                    delete[] buffer_;
                }


                bool enqueue(T&& data)
                {
                    cell_t* cell;
                    size_t pos = enqueue_pos_.load(std::memory_order_relaxed);
                    for (;;)
                    {
                        cell = &buffer_[pos & buffer_mask_];
                        size_t seq = cell->sequence_.load(std::memory_order_acquire);
                        intptr_t dif = (intptr_t)seq - (intptr_t)pos;
                        if (dif == 0)
                        {
                            if (enqueue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
                                break;
                        }
                        else if (dif < 0)
                        {
                            return false;
                        }
                        else
                        {
                            pos = enqueue_pos_.load(std::memory_order_relaxed);
                        }
                    }
                    cell->data_ = std::move(data);
                    cell->sequence_.store(pos + 1, std::memory_order_release);
                    return true;
                }

                bool dequeue(T& data)
                {
                    cell_t* cell;
                    size_t pos = dequeue_pos_.load(std::memory_order_relaxed);
                    for (;;)
                    {
                        cell = &buffer_[pos & buffer_mask_];
                        size_t seq =
                            cell->sequence_.load(std::memory_order_acquire);
                        intptr_t dif = (intptr_t)seq - (intptr_t)(pos + 1);
                        if (dif == 0)
                        {
                            if (dequeue_pos_.compare_exchange_weak(pos, pos + 1, std::memory_order_relaxed))
                                break;
                        }
                        else if (dif < 0)
                            return false;
                        else
                            pos = dequeue_pos_.load(std::memory_order_relaxed);
                    }
                    data = std::move(cell->data_);
                    cell->sequence_.store(pos + buffer_mask_ + 1, std::memory_order_release);
                    return true;
                }

            private:
                struct cell_t
                {
                    std::atomic<size_t>   sequence_;
                    T                     data_;
                };

                static size_t const     cacheline_size = 64;
                typedef char            cacheline_pad_t[cacheline_size];

                cacheline_pad_t         pad0_;
                cell_t* const           buffer_;
                size_t const            buffer_mask_;
                cacheline_pad_t         pad1_;
                std::atomic<size_t>     enqueue_pos_;
                cacheline_pad_t         pad2_;
                std::atomic<size_t>     dequeue_pos_;
                cacheline_pad_t         pad3_;

                mpmc_bounded_queue(mpmc_bounded_queue const&);
                void operator = (mpmc_bounded_queue const&);
            };

            struct LogMessage
            {
                std::string         loggerName_;
                LogLevels           level_;
                time::DateTime          dateTime_;
                size_t              threadId_;
                std::string         buffer_;
            };

            class LineLogger : private UnCopyable
            {
            public:
                LineLogger(Logger* callbacker, LogLevels lvl, bool enable) :callbackLogger_(callbacker), enabled_(enable)
                {
                    msg_.level_ = lvl;
                }

                LineLogger(LineLogger&& other) :
                    callbackLogger_(other.callbackLogger_),
                    msg_(std::move(other.msg_)),
                    enabled_(other.enabled_)
                {
                    other.disable();
                }

                ~LineLogger()
                {
                    if (enabled_)
                    {
                        msg_.loggerName_ = callbackLogger_->name();
                        msg_.dateTime_ = time::DateTime::local_time();
                        msg_.threadId_ = os::thread_id();
                        callbackLogger_->log_msg(msg_);
                    }
                }

                LineLogger& operator=(LineLogger&&) = delete;

                void write(const char* what)
                {
                    if (enabled_)
                        msg_.buffer_ += what;
                }

                template <typename... Args>
                void write(const char* fmt, const Args&... args)
                {
                    if (!enabled_) return;
                    std::string buf(fmt);
                    fmt::format_string(buf, args...);
                    msg_.buffer_ += buf;
                }


                LineLogger& operator<<(const char* what)
                {
                    if (enabled_) msg_.buffer_ += what;
                    return *this;
                }

                LineLogger& operator<<(const std::string& what)
                {
                    if (enabled_) msg_.buffer_ += what;
                    return *this;
                }

                template<typename T>
                LineLogger& operator<<(const T& what)
                {
                    if (enabled_)
                    {
                        std::ostringstream oss;
                        oss << std::dec << what;
                        msg_.buffer_ += oss.str();
                    }
                    return *this;
                }

                void disable()
                {
                    enabled_ = false;
                }

                bool is_enabled() const
                {
                    return enabled_;
                }
            private:
                Logger          *callbackLogger_;
                LogMessage      msg_;
                bool            enabled_;
            };

            class SinkInterface
            {
            public:
                virtual ~SinkInterface() {};
                virtual void log(const LogMessage& msg) = 0;
                virtual void flush() = 0;
                virtual std::string name() const = 0;
                virtual std::string to_string() const = 0;
                virtual void set_level_mask(int levelMask) = 0;
                virtual void set_format(const std::string &fmt) = 0;
            };

            // Due to a bug in VC12, thread join in static object dtor
            // will cause deadlock. TODO: implement async sink when
            // VS2015 ready.
            class AsyncSink : public SinkInterface, private UnCopyable
            {

            };

            class Sink : public SinkInterface, private UnCopyable
            {
            public:
                Sink()
                {
                    levelMask_ = 0x3F & LogConfig::instance().log_level_mask();
                    set_format(LogConfig::instance().format());
                };

                virtual ~Sink()  {};

                void log(const LogMessage& msg) override
                {
                    if (!level_should_log(levelMask_, msg.level_)) return;
                    std::string finalMessage = format_message(msg);
                    // mutex for multi-thread race, actually vc++ and gnu++ are ok without lock
                    // but this behavior is not guanranteed, and libc++ will have corrupt output
                    std::lock_guard<std::mutex> lock(mutex_);
                    sink_it(finalMessage);
                }

                void set_level_mask(int levelMask) override
                {
                    levelMask_ = levelMask & LogLevels::sentinel;
                }

                int level_mask() const
                {
                    return levelMask_;
                }

                void set_format(const std::string &format) override
                {
                    format_.set(format);
                }

                virtual void sink_it(const std::string &finalMsg) = 0;

            private:
                std::string format_message(const LogMessage &msg)
                {
                    std::string ret(format_.get());
                    auto dt = msg.dateTime_;
                    fmt::replace_all_with_escape(ret, consts::kSinkDatetimeSpecifier, dt.to_string(LogConfig::instance().datetime_format().c_str()));
                    fmt::replace_all_with_escape(ret, consts::kSinkLoggerNameSpecifier, msg.loggerName_);
                    fmt::replace_all_with_escape(ret, consts::kSinkThreadSpecifier, std::to_string(msg.threadId_));
                    fmt::replace_all_with_escape(ret, consts::kSinkLevelSpecifier, consts::kLevelNames[msg.level_]);
                    fmt::replace_all_with_escape(ret, consts::kSinkLevelShortSpecifier, consts::kShortLevelNames[msg.level_]);
                    fmt::replace_all_with_escape(ret, consts::kSinkMessageSpecifier, msg.buffer_);
                    // make sure new line
                    if (!fmt::ends_with(ret, "\n")) ret += os::endl();
                    return ret;
                }

                std::atomic_int     levelMask_;
                std::mutex          mutex_;
                cds::lockbased::NonTrivialContainer<std::string>        format_;
            };

            class SimpleFileSink : public Sink
            {
            public:
                SimpleFileSink(const std::string filename, bool truncate) :fileEditor_(filename, truncate)
                {
                }

                void flush() override
                {
                    fileEditor_.flush();
                }

                void sink_it(const std::string &finalMsg) override
                {
                    fileEditor_ << finalMsg;
                }

                std::string name() const override
                {
                    return fileEditor_.filename();
                }

                std::string to_string() const override
                {
                    return "SimpleFileSink->" + name() + " " + level_mask_to_string(level_mask());
                }

            private:
                fs::FileEditor fileEditor_;
            };

            class RotateFileSink : public Sink
            {
            public:
                RotateFileSink(const std::string filename, std::size_t maxSizeInByte, bool backup);

                void flush() override
                {
                    fileEditor_.flush();
                }

                void sink_it(const std::string &finalMsg) override
                {
                    currentSize_ += finalMsg.length();
                    if (currentSize_ > maxSizeInByte_)
                    {
                        rotate();
                    }
                    fileEditor_ << finalMsg;
                }

                std::string name() const override
                {
                    return fileEditor_.filename();
                }

                std::string to_string() const override
                {
                    return "RotateFileSink->" + name() + " " + level_mask_to_string(level_mask());
                }

            private:
                void back_up(std::string oldFile);
                void rotate();

                fs::FileEditor              fileEditor_;
                std::mutex                  mutex_;
                std::size_t                 maxSizeInByte_;
                std::atomic<std::size_t>    currentSize_;
                bool                        backup_;
            };

            class OStreamSink : public Sink
            {
            public:
                explicit OStreamSink(std::ostream& os, const char *name, bool forceFlush = false)
                    :ostream_(os), name_(name), forceFlush_(forceFlush)
                {
                }

                std::string name() const override
                {
                    return name_;
                }

                std::string to_string() const override
                {
                    return "OStreamSink->" + name() + " " + level_mask_to_string(level_mask());
                }

            private:
                void sink_it(const std::string &finalMsg) override
                {
                    ostream_ << finalMsg;
                    if (forceFlush_) ostream_.flush();
                }

                void flush() override
                {
                    ostream_.flush();
                }

                std::ostream&   ostream_;
                std::string     name_;
                bool            forceFlush_;
            };

            class StdoutSink : public OStreamSink
            {
            public:
                StdoutSink() : OStreamSink(std::cout, consts::kStdoutSinkName, true)
                {
                    // stdout by design should not receive warning and error message
                    // so add cout and cerr together and filter by level is a better idea
                    set_level_mask(0x07 & LogConfig::instance().log_level_mask());
                }
                static std::shared_ptr<StdoutSink> instance()
                {
                    static std::shared_ptr<StdoutSink> instance = std::make_shared<StdoutSink>();
                    return instance;
                }

                std::string to_string() const override
                {
                    return "StdoutSink->" + name() + " " + level_mask_to_string(level_mask());
                }
            };

            class StderrSink : public OStreamSink
            {
            public:
                StderrSink() : OStreamSink(std::cerr, consts::kStderrSinkName, true)
                {
                    // stderr by design should only log error/warning msg
                    set_level_mask(0x38 & LogConfig::instance().log_level_mask());
                }
                static std::shared_ptr<StderrSink> instance()
                {
                    static std::shared_ptr<StderrSink> instance = std::make_shared<StderrSink>();
                    return instance;
                }

                std::string to_string() const override
                {
                    return "StderrSink->" + name() + " " + level_mask_to_string(level_mask());
                }
            };

            class LoggerRegistry : UnMovable
            {
            public:
                static LoggerRegistry& instance();
                LoggerPtr create(const std::string &name);
                LoggerPtr ensure_get(std::string &name);
                LoggerPtr get(std::string &name);
                std::vector<LoggerPtr> get_all();
                void drop(const std::string &name);
                void drop_all();
                void lock();
                void unlock();
                bool is_locked() const;

            private:
                LoggerRegistry(){ lock_ = false; }

                LoggerPtr new_registry(const std::string &name);

                cds::lockbased::UnorderedMap<std::string, LoggerPtr> loggers_;
                std::atomic_bool    lock_;
            };
        } // namespace detail

        inline detail::LineLogger Logger::log_if_enabled(LogLevels lvl)
        {
            detail::LineLogger l(this, lvl, should_log(lvl));
            return l;
        }

        template <typename... Args>
        inline detail::LineLogger Logger::log_if_enabled(LogLevels lvl, const char* fmt, const Args&... args)
        {
            detail::LineLogger l(this, lvl, should_log(lvl));
            l.write(fmt, args...);
            return l;
        }

        template<typename T>
        inline detail::LineLogger Logger::log_if_enabled(LogLevels lvl, const T& msg)
        {
            detail::LineLogger l(this, lvl, should_log(lvl));
            l.write(msg);
            return l;
        }

        // logger.info(format string, arg1, arg2, arg3, ...) call style
        template <typename... Args>
        inline detail::LineLogger Logger::trace(const char* fmt, const Args&... args)
        {
            return log_if_enabled(LogLevels::trace, fmt, args...);
        }
        template <typename... Args>
        inline detail::LineLogger Logger::debug(const char* fmt, const Args&... args)
        {
            return log_if_enabled(LogLevels::debug, fmt, args...);
        }
        template <typename... Args>
        inline detail::LineLogger Logger::info(const char* fmt, const Args&... args)
        {
            return log_if_enabled(LogLevels::info, fmt, args...);
        }
        template <typename... Args>
        inline detail::LineLogger Logger::warn(const char* fmt, const Args&... args)
        {
            return log_if_enabled(LogLevels::warn, fmt, args...);
        }
        template <typename... Args>
        inline detail::LineLogger Logger::error(const char* fmt, const Args&... args)
        {
            return log_if_enabled(LogLevels::error, fmt, args...);
        }
        template <typename... Args>
        inline detail::LineLogger Logger::fatal(const char* fmt, const Args&... args)
        {
            return log_if_enabled(LogLevels::fatal, fmt, args...);
        }


        // logger.info(msg) << ".." call style
        template <typename T>
        inline detail::LineLogger Logger::trace(const T& msg)
        {
            return log_if_enabled(LogLevels::trace, msg);
        }
        template <typename T>
        inline detail::LineLogger Logger::debug(const T& msg)
        {
            return log_if_enabled(LogLevels::debug, msg);
        }
        template <typename T>
        inline detail::LineLogger Logger::info(const T& msg)
        {
            return log_if_enabled(LogLevels::info, msg);
        }
        template <typename T>
        inline detail::LineLogger Logger::warn(const T& msg)
        {
            return log_if_enabled(LogLevels::warn, msg);
        }
        template <typename T>
        inline detail::LineLogger Logger::error(const T& msg)
        {
            return log_if_enabled(LogLevels::error, msg);
        }
        template <typename T>
        inline detail::LineLogger Logger::fatal(const T& msg)
        {
            return log_if_enabled(LogLevels::fatal, msg);
        }

        // \endcond

        LoggerPtr get_logger(std::string name, bool createIfNotExists = true);

        SinkPtr new_stdout_sink();

        SinkPtr new_stderr_sink();

        SinkPtr get_sink(std::string name);

        void dump_loggers(std::ostream &out = std::cout);

        SinkPtr new_ostream_sink(std::ostream &stream, std::string name, bool forceFlush = false);

        SinkPtr new_simple_file_sink(std::string filename, bool truncate = false);

        SinkPtr new_rotate_file_sink(std::string filename, std::size_t maxSizeInByte = 4194304, bool backupOld = false);

        void lock_loggers();

        void unlock_loggers();

        void drop_logger(std::string name);

        void drop_all_loggers();

        void drop_sink(std::string name);

        // \cond
        namespace detail
        {
            void sink_list_revise(std::vector<std::string> &list, std::map<std::string, std::string> &map);

            void config_loggers_from_section(cfg::CfgLevel::section_map_t &section, std::map<std::string, std::string> &map);

            LoggerPtr get_hidden_logger();

            std::map<std::string, std::string> config_sinks_from_section(cfg::CfgLevel::section_map_t &section);


            void zupply_internal_warn(std::string msg);

            void zupply_internal_error(std::string msg);

            void config_from_parser(cfg::CfgParser& parser);
        } // namespace detail
        // \endcond

        void config_from_file(std::string cfgFilename);

        void config_from_stringstream(std::stringstream& ss);
    } // namespace log

    // \cond

    template<typename _Tp> static inline _Tp saturate_cast(unsigned char v)    { return _Tp(v); }
    template<typename _Tp> static inline _Tp saturate_cast(char v)    { return _Tp(v); }
    template<typename _Tp> static inline _Tp saturate_cast(unsigned short v)   { return _Tp(v); }
    template<typename _Tp> static inline _Tp saturate_cast(short v)    { return _Tp(v); }
    template<typename _Tp> static inline _Tp saturate_cast(unsigned v) { return _Tp(v); }
    template<typename _Tp> static inline _Tp saturate_cast(int v)      { return _Tp(v); }
    template<typename _Tp> static inline _Tp saturate_cast(float v)    { return _Tp(v); }
    template<typename _Tp> static inline _Tp saturate_cast(double v)   { return _Tp(v); }

    template<> inline unsigned char saturate_cast<unsigned char>(char v)        { return (unsigned char)(std::max)((int)v, 0); }
    template<> inline unsigned char saturate_cast<unsigned char>(unsigned char v)       { return (unsigned char)(std::min)((unsigned)v, (unsigned)UCHAR_MAX); }
    template<> inline unsigned char saturate_cast<unsigned char>(int v)          { return (unsigned char)((unsigned)v <= UCHAR_MAX ? v : v > 0 ? UCHAR_MAX : 0); }
    template<> inline unsigned char saturate_cast<unsigned char>(short v)        { return saturate_cast<unsigned char>((int)v); }
    template<> inline unsigned char saturate_cast<unsigned char>(unsigned v)     { return (unsigned char)(std::min)(v, (unsigned)UCHAR_MAX); }
    template<> inline unsigned char saturate_cast<unsigned char>(float v)        { int iv = math::round(v); return saturate_cast<unsigned char>(iv); }
    template<> inline unsigned char saturate_cast<unsigned char>(double v)       { int iv = math::round(v); return saturate_cast<unsigned char>(iv); }

    template<> inline char saturate_cast<char>(unsigned char v)        { return (char)(std::min)((int)v, SCHAR_MAX); }
    template<> inline char saturate_cast<char>(unsigned short v)       { return (char)(std::min)((unsigned)v, (unsigned)SCHAR_MAX); }
    template<> inline char saturate_cast<char>(int v)          { return (char)((unsigned)(v - SCHAR_MIN) <= (unsigned)UCHAR_MAX ? v : v > 0 ? SCHAR_MAX : SCHAR_MIN); }
    template<> inline char saturate_cast<char>(short v)        { return saturate_cast<char>((int)v); }
    template<> inline char saturate_cast<char>(unsigned int v)     { return (char)(std::min)(v, (unsigned)SCHAR_MAX); }
    template<> inline char saturate_cast<char>(float v)        { int iv = math::round(v); return saturate_cast<char>(iv); }
    template<> inline char saturate_cast<char>(double v)       { int iv = math::round(v); return saturate_cast<char>(iv); }

    template<> inline unsigned short saturate_cast<unsigned short>(char v)      { return (unsigned short)(std::max)((int)v, 0); }
    template<> inline unsigned short saturate_cast<unsigned short>(short v)      { return (unsigned short)(std::max)((int)v, 0); }
    template<> inline unsigned short saturate_cast<unsigned short>(int v)        { return (unsigned short)((unsigned)v <= (unsigned)USHRT_MAX ? v : v > 0 ? USHRT_MAX : 0); }
    template<> inline unsigned short saturate_cast<unsigned short>(unsigned v)   { return (unsigned short)(std::min)(v, (unsigned)USHRT_MAX); }
    template<> inline unsigned short saturate_cast<unsigned short>(float v)      { int iv = math::round(v); return saturate_cast<unsigned short>(iv); }
    template<> inline unsigned short saturate_cast<unsigned short>(double v)     { int iv = math::round(v); return saturate_cast<unsigned short>(iv); }

    template<> inline short saturate_cast<short>(unsigned short v)       { return (short)(std::min)((int)v, SHRT_MAX); }
    template<> inline short saturate_cast<short>(int v)          { return (short)((unsigned)(v - SHRT_MIN) <= (unsigned)USHRT_MAX ? v : v > 0 ? SHRT_MAX : SHRT_MIN); }
    template<> inline short saturate_cast<short>(unsigned v)     { return (short)(std::min)(v, (unsigned)SHRT_MAX); }
    template<> inline short saturate_cast<short>(float v)        { int iv = math::round(v); return saturate_cast<short>(iv); }
    template<> inline short saturate_cast<short>(double v)       { int iv = math::round(v); return saturate_cast<short>(iv); }

    template<> inline int saturate_cast<int>(float v)            { return math::round(v); }
    template<> inline int saturate_cast<int>(double v)           { return math::round(v); }

    // we intentionally do not clip negative numbers, to make -1 become 0xffffffff etc.
    template<> inline unsigned saturate_cast<unsigned>(float v)  { return (unsigned)math::round(v); }
    template<> inline unsigned saturate_cast<unsigned>(double v) { return (unsigned)math::round(v); }

    template<typename _Tp> inline
        Size_<_Tp>::Size_()
        : width(0), height(0) {}

    template<typename _Tp> inline
        Size_<_Tp>::Size_(_Tp _width, _Tp _height)
        : width(_width), height(_height) {}

    template<typename _Tp> inline
        Size_<_Tp>::Size_(const Size_& sz)
        : width(sz.width), height(sz.height) {}

    template<typename _Tp> template<typename _Tp2> inline
        Size_<_Tp>::operator Size_<_Tp2>() const
    {
            return Size_<_Tp2>(saturate_cast<_Tp2>(width), saturate_cast<_Tp2>(height));
        }

    template<typename _Tp> inline
        Size_<_Tp>& Size_<_Tp>::operator = (const Size_<_Tp>& sz)
    {
            width = sz.width; height = sz.height;
            return *this;
        }

    template<typename _Tp> inline
        bool Size_<_Tp>::operator == (const Size_<_Tp>& sz)
    {
            return (width == sz.width) && (height == sz.height);
        }

    template<typename _Tp> inline
        bool Size_<_Tp>::operator != (const Size_<_Tp>& sz)
    {
            return (width != sz.width) || (height != sz.height);
        }

    template<typename _Tp> inline
        _Tp Size_<_Tp>::area() const
    {
            return width * height;
        }

    template<typename _Tp> static inline
        Size_<_Tp>& operator *= (Size_<_Tp>& a, _Tp b)
    {
            a.width *= b;
            a.height *= b;
            return a;
        }

    template<typename _Tp> static inline
        Size_<_Tp> operator * (const Size_<_Tp>& a, _Tp b)
    {
            Size_<_Tp> tmp(a);
            tmp *= b;
            return tmp;
        }

    template<typename _Tp> static inline
        Size_<_Tp>& operator /= (Size_<_Tp>& a, _Tp b)
    {
            a.width /= b;
            a.height /= b;
            return a;
        }

    template<typename _Tp> static inline
        Size_<_Tp> operator / (const Size_<_Tp>& a, _Tp b)
    {
            Size_<_Tp> tmp(a);
            tmp /= b;
            return tmp;
        }

    template<typename _Tp> static inline
        Size_<_Tp>& operator += (Size_<_Tp>& a, const Size_<_Tp>& b)
    {
            a.width += b.width;
            a.height += b.height;
            return a;
        }

    template<typename _Tp> static inline
        Size_<_Tp> operator + (const Size_<_Tp>& a, const Size_<_Tp>& b)
    {
            Size_<_Tp> tmp(a);
            tmp += b;
            return tmp;
        }

    template<typename _Tp> static inline
        Size_<_Tp>& operator -= (Size_<_Tp>& a, const Size_<_Tp>& b)
    {
            a.width -= b.width;
            a.height -= b.height;
            return a;
        }

    template<typename _Tp> static inline
        Size_<_Tp> operator - (const Size_<_Tp>& a, const Size_<_Tp>& b)
    {
            Size_<_Tp> tmp(a);
            tmp -= b;
            return tmp;
        }

    template<typename _Tp> static inline
        bool operator == (const Size_<_Tp>& a, const Size_<_Tp>& b)
    {
            return a.width == b.width && a.height == b.height;
        }

    template<typename _Tp> static inline
        bool operator != (const Size_<_Tp>& a, const Size_<_Tp>& b)
    {
            return !(a == b);
        }

    template<typename _Tp> inline
        Point_<_Tp>::Point_()
        : x(0), y(0) {}

    template<typename _Tp> inline
        Point_<_Tp>::Point_(_Tp _x, _Tp _y)
        : x(_x), y(_y) {}

    template<typename _Tp> inline
        Point_<_Tp>::Point_(const Point_& pt)
        : x(pt.x), y(pt.y) {}

    template<typename _Tp> inline
        Point_<_Tp>& Point_<_Tp>::operator = (const Point_& pt)
    {
            x = pt.x; y = pt.y;
            return *this;
        }

    template<typename _Tp> template<typename _Tp2> inline
        Point_<_Tp>::operator Point_<_Tp2>() const
    {
            return Point_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y));
        }

    template<typename _Tp> static inline
        Point_<_Tp>& operator += (Point_<_Tp>& a, const Point_<_Tp>& b)
    {
            a.x += b.x;
            a.y += b.y;
            return a;
        }

    template<typename _Tp> static inline
        Point_<_Tp>& operator -= (Point_<_Tp>& a, const Point_<_Tp>& b)
    {
            a.x -= b.x;
            a.y -= b.y;
            return a;
        }

    template<typename _Tp> static inline
        Point_<_Tp>& operator *= (Point_<_Tp>& a, int b)
    {
            a.x = saturate_cast<_Tp>(a.x * b);
            a.y = saturate_cast<_Tp>(a.y * b);
            return a;
        }

    template<typename _Tp> static inline
        Point_<_Tp>& operator *= (Point_<_Tp>& a, float b)
    {
            a.x = saturate_cast<_Tp>(a.x * b);
            a.y = saturate_cast<_Tp>(a.y * b);
            return a;
        }

    template<typename _Tp> static inline
        Point_<_Tp>& operator *= (Point_<_Tp>& a, double b)
    {
            a.x = saturate_cast<_Tp>(a.x * b);
            a.y = saturate_cast<_Tp>(a.y * b);
            return a;
        }

    template<typename _Tp> static inline
        Point_<_Tp>& operator /= (Point_<_Tp>& a, int b)
    {
            a.x = saturate_cast<_Tp>(a.x / b);
            a.y = saturate_cast<_Tp>(a.y / b);
            return a;
        }

    template<typename _Tp> static inline
        Point_<_Tp>& operator /= (Point_<_Tp>& a, float b)
    {
            a.x = saturate_cast<_Tp>(a.x / b);
            a.y = saturate_cast<_Tp>(a.y / b);
            return a;
        }

    template<typename _Tp> static inline
        Point_<_Tp>& operator /= (Point_<_Tp>& a, double b)
    {
            a.x = saturate_cast<_Tp>(a.x / b);
            a.y = saturate_cast<_Tp>(a.y / b);
            return a;
        }

    template<typename _Tp> static inline
        bool operator == (const Point_<_Tp>& a, const Point_<_Tp>& b)
    {
            return a.x == b.x && a.y == b.y;
        }

    template<typename _Tp> static inline
        bool operator != (const Point_<_Tp>& a, const Point_<_Tp>& b)
    {
            return a.x != b.x || a.y != b.y;
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator + (const Point_<_Tp>& a, const Point_<_Tp>& b)
    {
            return Point_<_Tp>(saturate_cast<_Tp>(a.x + b.x), saturate_cast<_Tp>(a.y + b.y));
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator - (const Point_<_Tp>& a, const Point_<_Tp>& b)
    {
            return Point_<_Tp>(saturate_cast<_Tp>(a.x - b.x), saturate_cast<_Tp>(a.y - b.y));
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator - (const Point_<_Tp>& a)
    {
            return Point_<_Tp>(saturate_cast<_Tp>(-a.x), saturate_cast<_Tp>(-a.y));
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator * (const Point_<_Tp>& a, int b)
    {
            return Point_<_Tp>(saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b));
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator * (int a, const Point_<_Tp>& b)
    {
            return Point_<_Tp>(saturate_cast<_Tp>(b.x*a), saturate_cast<_Tp>(b.y*a));
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator * (const Point_<_Tp>& a, float b)
    {
            return Point_<_Tp>(saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b));
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator * (float a, const Point_<_Tp>& b)
    {
            return Point_<_Tp>(saturate_cast<_Tp>(b.x*a), saturate_cast<_Tp>(b.y*a));
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator * (const Point_<_Tp>& a, double b)
    {
            return Point_<_Tp>(saturate_cast<_Tp>(a.x*b), saturate_cast<_Tp>(a.y*b));
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator * (double a, const Point_<_Tp>& b)
    {
            return Point_<_Tp>(saturate_cast<_Tp>(b.x*a), saturate_cast<_Tp>(b.y*a));
        }


    template<typename _Tp> static inline
        Point_<_Tp> operator / (const Point_<_Tp>& a, int b)
    {
            Point_<_Tp> tmp(a);
            tmp /= b;
            return tmp;
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator / (const Point_<_Tp>& a, float b)
    {
            Point_<_Tp> tmp(a);
            tmp /= b;
            return tmp;
        }

    template<typename _Tp> static inline
        Point_<_Tp> operator / (const Point_<_Tp>& a, double b)
    {
            Point_<_Tp> tmp(a);
            tmp /= b;
            return tmp;
        }

    template<typename _Tp> inline
        _Tp Point_<_Tp>::dot(const Point_& pt) const
    {
            return saturate_cast<_Tp>(x*pt.x + y*pt.y);
        }

    template<typename _Tp> inline
        double Point_<_Tp>::ddot(const Point_& pt) const
    {
            return (double)x*pt.x + (double)y*pt.y;
        }

    template<typename _Tp> inline
        double Point_<_Tp>::cross(const Point_& pt) const
    {
            return (double)x*pt.y - (double)y*pt.x;
        }

    template<typename _Tp> inline bool
        Point_<_Tp>::inside(const Rect_<_Tp>& r) const
    {
            return r.contains(*this);
        }


    template<typename _Tp> inline
        Rect_<_Tp>::Rect_()
        : x(0), y(0), width(0), height(0) {}

    template<typename _Tp> inline
        Rect_<_Tp>::Rect_(_Tp _x, _Tp _y, _Tp _width, _Tp _height)
        : x(_x), y(_y), width(_width), height(_height) {}

    template<typename _Tp> inline
        Rect_<_Tp>::Rect_(const Rect_<_Tp>& r)
        : x(r.x), y(r.y), width(r.width), height(r.height) {}

    template<typename _Tp> inline
        Rect_<_Tp>::Rect_(const Point_<_Tp>& org, const Size_<_Tp>& sz)
        : x(org.x), y(org.y), width(sz.width), height(sz.height) {}

    template<typename _Tp> inline
        Rect_<_Tp>::Rect_(const Point_<_Tp>& pt1, const Point_<_Tp>& pt2)
    {
            x = (std::min)(pt1.x, pt2.x);
            y = (std::min)(pt1.y, pt2.y);
            width = (std::max)(pt1.x, pt2.x) - x;
            height = (std::max)(pt1.y, pt2.y) - y;
        }

    template<typename _Tp> inline
        Rect_<_Tp>& Rect_<_Tp>::operator = (const Rect_<_Tp>& r)
    {
            x = r.x;
            y = r.y;
            width = r.width;
            height = r.height;
            return *this;
        }

    template<typename _Tp> inline
        Point_<_Tp> Rect_<_Tp>::tl() const
    {
            return Point_<_Tp>(x, y);
        }

    template<typename _Tp> inline
        Point_<_Tp> Rect_<_Tp>::br() const
    {
            return Point_<_Tp>(x + width, y + height);
        }

    template<typename _Tp> inline
        Size_<_Tp> Rect_<_Tp>::size() const
    {
            return Size_<_Tp>(width, height);
        }

    template<typename _Tp> inline
        _Tp Rect_<_Tp>::area() const
    {
            return width * height;
        }

    template<typename _Tp> template<typename _Tp2> inline
        Rect_<_Tp>::operator Rect_<_Tp2>() const
    {
            return Rect_<_Tp2>(saturate_cast<_Tp2>(x), saturate_cast<_Tp2>(y), saturate_cast<_Tp2>(width), saturate_cast<_Tp2>(height));
        }

    template<typename _Tp> inline
        bool Rect_<_Tp>::contains(const Point_<_Tp>& pt) const
    {
            return x <= pt.x && pt.x < x + width && y <= pt.y && pt.y < y + height;
        }


    template<typename _Tp> static inline
        Rect_<_Tp>& operator += (Rect_<_Tp>& a, const Point_<_Tp>& b)
    {
            a.x += b.x;
            a.y += b.y;
            return a;
        }

    template<typename _Tp> static inline
        Rect_<_Tp>& operator -= (Rect_<_Tp>& a, const Point_<_Tp>& b)
    {
            a.x -= b.x;
            a.y -= b.y;
            return a;
        }

    template<typename _Tp> static inline
        Rect_<_Tp>& operator += (Rect_<_Tp>& a, const Size_<_Tp>& b)
    {
            a.width += b.width;
            a.height += b.height;
            return a;
        }

    template<typename _Tp> static inline
        Rect_<_Tp>& operator -= (Rect_<_Tp>& a, const Size_<_Tp>& b)
    {
            a.width -= b.width;
            a.height -= b.height;
            return a;
        }

    template<typename _Tp> static inline
        Rect_<_Tp>& operator &= (Rect_<_Tp>& a, const Rect_<_Tp>& b)
    {
            _Tp x1 = (std::max)(a.x, b.x);
            _Tp y1 = (std::max)(a.y, b.y);
            a.width = (std::min)(a.x + a.width, b.x + b.width) - x1;
            a.height = (std::min)(a.y + a.height, b.y + b.height) - y1;
            a.x = x1;
            a.y = y1;
            if (a.width <= 0 || a.height <= 0)
                a = Rect();
            return a;
        }

    template<typename _Tp> static inline
        Rect_<_Tp>& operator |= (Rect_<_Tp>& a, const Rect_<_Tp>& b)
    {
            _Tp x1 = (std::min)(a.x, b.x);
            _Tp y1 = (std::min)(a.y, b.y);
            a.width = (std::max)(a.x + a.width, b.x + b.width) - x1;
            a.height = (std::max)(a.y + a.height, b.y + b.height) - y1;
            a.x = x1;
            a.y = y1;
            return a;
        }

    template<typename _Tp> static inline
        bool operator == (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
    {
            return a.x == b.x && a.y == b.y && a.width == b.width && a.height == b.height;
        }

    template<typename _Tp> static inline
        bool operator != (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
    {
            return a.x != b.x || a.y != b.y || a.width != b.width || a.height != b.height;
        }

    template<typename _Tp> static inline
        Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Point_<_Tp>& b)
    {
            return Rect_<_Tp>(a.x + b.x, a.y + b.y, a.width, a.height);
        }

    template<typename _Tp> static inline
        Rect_<_Tp> operator - (const Rect_<_Tp>& a, const Point_<_Tp>& b)
    {
            return Rect_<_Tp>(a.x - b.x, a.y - b.y, a.width, a.height);
        }

    template<typename _Tp> static inline
        Rect_<_Tp> operator + (const Rect_<_Tp>& a, const Size_<_Tp>& b)
    {
            return Rect_<_Tp>(a.x, a.y, a.width + b.width, a.height + b.height);
        }

    template<typename _Tp> static inline
        Rect_<_Tp> operator & (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
    {
            Rect_<_Tp> c = a;
            return c &= b;
        }

    template<typename _Tp> static inline
        Rect_<_Tp> operator | (const Rect_<_Tp>& a, const Rect_<_Tp>& b)
    {
            Rect_<_Tp> c = a;
            return c |= b;
        }

    namespace detail
    {
        template<typename _Tp> inline
            ImageBase<_Tp>::ImageBase()
            :rows_(0), cols_(0), channels_(0), data_(nullptr)
        {
            }

        template<typename _Tp> inline
            ImageBase<_Tp>::ImageBase(int rows, int cols, int channels)
        {
                create(rows, cols, channels);
            }

        template<typename _Tp> inline
            ImageBase<_Tp>::ImageBase(const ImageBase& other)
        {
                rows_ = other.rows_;
                cols_ = other.cols_;
                channels_ = other.channels_;
                data_ = other.data_;    // shallow copy
            }

        template<typename _Tp> template<typename _Tp2> inline
            ImageBase<_Tp>::operator ImageBase<_Tp2>() const
        {
                ImageBase<_Tp2> tmp(rows_, cols_, channels_);
                _Tp2* p = tmp.ptr(0);
                _Tp* p_ = ptr(0);
                for (long i = 0; i < rows_ * cols_ * channels_; ++i)
                {
                    *p = saturate_cast<_Tp>(*p_);
                    ++p;
                    ++p_;
                }
                return tmp;
            }

        template<typename _Tp> inline
            ImageBase<_Tp>::ImageBase(ImageBase&& other)
        {
                rows_ = other.rows_;
                cols_ = other.cols_;
                channels_ = other.channels_;
                data_ = other.data_;    // shallow copy
                other.release();
            }

        template<typename _Tp> inline
            ImageBase<_Tp>::~ImageBase()
        {
                release();
            }

        template<typename _Tp> inline
            void ImageBase<_Tp>::create(int rows, int cols, int channels)
        {
                assert(rows > 0 && cols > 0 && channels > 0);
                rows_ = rows;
                cols_ = cols;
                channels_ = channels;
                data_ = std::make_shared<std::vector<_Tp>>(rows * cols * channels);
            }

        template<typename _Tp> inline
            void ImageBase<_Tp>::release()
        {
                rows_ = 0;
                cols_ = 0;
                channels_ = 0;
                data_ = nullptr;
            }

        template<typename _Tp> inline
            ImageBase<_Tp>& ImageBase<_Tp>::operator= (const ImageBase<_Tp>& other)
        {
                rows_ = other.rows_;
                cols_ = other.cols_;
                channels_ = other.channels_;
                data_ = other.data_;    // shallow copy
                return *this;
            }

        template<typename _Tp> inline
            ImageBase<_Tp>& ImageBase<_Tp>::operator= (ImageBase<_Tp>&& other)
        {
                rows_ = other.rows_;
                cols_ = other.cols_;
                channels_ = other.channels_;
                data_ = other.data_;    // shallow copy
                other.release();
                return *this;
            }

        template<typename _Tp> inline
            _Tp& ImageBase<_Tp>::operator() (int row, int col, int channel)
        {
                detach();
                long pos = row * cols_ * channels_ + col * channels_ + channel;
                range_check(row, col, channel);
                return (*data_)[pos];
            }

        template<typename _Tp> inline
            const _Tp& ImageBase<_Tp>::operator() (int row, int col, int channel) const
        {
                detach();
                long pos = row * cols_ * channels_ + col * channels_ + channel;
                range_check(row, col, channel);
                return (*data_)[pos];
            }

        template<typename _Tp> inline
            bool ImageBase<_Tp>::empty() const
        {
                return (rows_ < 1 || cols_ < 1 || channels_ < 1 || (!data_));
            }

        template<typename _Tp> inline
            int ImageBase<_Tp>::rows() const
        {
                return rows_;
            }

        template<typename _Tp> inline
            int ImageBase<_Tp>::cols() const
        {
                return cols_;
            }

        template<typename _Tp> inline
            int ImageBase<_Tp>::channels() const
        {
                return channels_;
            }

        template<typename _Tp> inline
            void ImageBase<_Tp>::range_check(long long pos) const
        {
                assert(pos >= 0);
                if (empty()) throw RuntimeException("Accessing emtpy image!");
                if (pos >= rows_ * cols_ * channels_) throw RuntimeException("Access out of range!");
            }

        template<typename _Tp> inline
            void ImageBase<_Tp>::range_check(int row, int col, int channel) const
        {
                assert(row >= 0 && col >= 0 && channel >= 0);
                if (empty()) throw RuntimeException("Accessing emtpy image!");
                if (row >= rows_ || col >= cols_ || channel >= channels_) throw RuntimeException("Access out of range!");
            }

        template<typename _Tp> inline
            _Tp ImageBase<_Tp>::at(int row, int col, int channel) const
        {
                range_check(row, col, channel);
                long pos = row * cols_ * channels_ + col * channels_ + channel;
                return (*data_)[pos];
            }

        template<typename _Tp> inline
            _Tp* ImageBase<_Tp>::ptr(int offset) const
        {
                range_check(offset);
                return (*data_).data() + offset;
            }

        template<typename _Tp> inline
            _Tp* ImageBase<_Tp>::ptr(int row, int col, int channel) const
        {
                range_check(row, col, channel);
                long pos = row * cols_ * channels_ + col * channels_ + channel;
                return (*data_).data() + pos;
            }

        template<typename _Tp> inline
            void ImageBase<_Tp>::import(_Tp* data, int rows, int cols, int channels)
        {
                assert(rows > 0 && cols > 0 && channels > 0 && "import size should be positive");
                create(rows, cols, channels);
                std::memcpy((*data_).data(), data, sizeof(_Tp)* rows * cols * channels);
            }

        template<typename _Tp> inline
            void ImageBase<_Tp>::import(std::vector<_Tp> data, int rows, int cols, int channels)
        {
                assert(rows > 0 && cols > 0 && channels > 0 && data.size() >= rows * cols * channels);
                create(rows, cols, channels);
                std::memcpy((*data_).data(), data.data(), sizeof(_Tp)* rows * cols * channels);
            }

        template<typename _Tp> inline
            std::vector<_Tp> ImageBase<_Tp>::export_raw() const
        {
                return (*data_);
            }

        template<typename _Tp> template<typename _Tp2> inline
            std::vector<_Tp2>& ImageBase<_Tp>::export_raw(std::vector<_Tp2>& out) const
        {
                out.resize(rows_ * cols_ * channels_);
                auto p = out.begin();
                for (auto i = (*data_).begin(); i != (*data_).end(); ++i, ++p)
                {
                    *p = saturate_cast<_Tp2>(*i);
                }
                return out;
            }

        template<typename _Tp> inline
            void ImageBase<_Tp>::crop(int r0, int c0, int r1, int c1)
        {
                assert(r0 >= 0 && c0 >= 0 && r1 >= 0 && c1 >= 0 && "crop region should be positive!");
                assert(r0 < rows_ && r1 < rows_ && c0 < cols_ && c1 < cols_ && "crop point should in image!");
                assert(r0 != r1 && (c0 != c1) && "need a rectangle region!");

                int width = std::abs(c0 - c1);
                int height = std::abs(r0 - r1);
                int i0 = (std::min)(r0, r1);
                int i1 = (std::max)(r0, r1);
                int j0 = (std::min)(c0, c1);
                int j1 = (std::max)(c0, c1);
                detach();
                ImageBase<_Tp> tmp(height, width, channels_);
                
                // temporary solution, not optimized
                _Tp* pOld = ptr(i0, j0, 0);
                _Tp* pNew = tmp.ptr(0);
                int step = cols_ * channels_;
                int bulkSize = width * channels_;
                for (auto r = 0; r < height; ++r)
                {
                    // copy entire row
                    std::memcpy(pNew, pOld, sizeof(_Tp)* bulkSize);
                    pOld += step;
                    pNew += bulkSize;
                }
                std::swap(*this, tmp);
            }

        template<typename _Tp> inline
            void ImageBase<_Tp>::crop(Point p0, Point p1)
        {
                crop(p0.y, p0.x, p1.y, p1.x);
            }

        template<typename _Tp> inline
            void ImageBase<_Tp>::crop(Rect rect)
        {
                crop(rect.y, rect.x, rect.y + rect.height, rect.y + rect.width);
            }

        template<typename _Tp> inline
            void ImageBase<_Tp>::detach()
        {
                if (data_.use_count() < 2) return;
                // detach the current resource from shared
                std::shared_ptr<std::vector<_Tp>> tmp = std::make_shared<std::vector<_Tp>>();
                *tmp = *data_; // deep copy
                data_ = tmp;
            }
    } // namespace zz::detail

    // \endcond

} // namespace zz

#endif //END _ZUPPLY_ZUPPLY_HPP_