Zakero_Base.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 Andrew Moore
 * 
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */
 
#ifndef zakero_Base_h
#define zakero_Base_h
 
/******************************************************************************
 * Includes
 */
 
#include <chrono>
#include <locale>
#include <string>
#include <vector>
 
 
/******************************************************************************
 * Macros
 */
 
// {{{ Macros
 
#define ZAKERO_CONCAT_(thing_1_, thing_2_) thing_1_ ## thing_2_
 
#define ZAKERO_CONCAT(thing_1_, thing_2_) ZAKERO_CONCAT_(thing_1_, thing_2_)
 
 
#define ZAKERO_DELETE(ptr_) \
{                                    \
        auto*& var##__LINE__ = ptr_; \
        delete var##__LINE__;        \
        var##__LINE__ = nullptr;     \
}                                    \
 
 
#define ZAKERO_FREE(ptr_) \
{                                    \
        auto*& var##__LINE__ = ptr_; \
        free(var##__LINE__);         \
        var##__LINE__ = nullptr;     \
}                                    \
 
 
#define ZAKERO_MACRO_HAS_VALUE(define_) \
        ~(~define_ + 0) == 0 && ~(~define_ + 1) == 1
 
#ifdef __linux__
#       include <sys/types.h>
#       include <unistd.h>
#       define ZAKERO_PID getpid()
#else
#       define ZAKERO_PID (pid_t)-1
#endif
 
#define ZAKERO_STEADY_TIME_NOW(unit_) \
        std::chrono::duration_cast<std::chrono::unit_>(             \
                std::chrono::steady_clock::now().time_since_epoch() \
                ).count()                                           \
 
#define ZAKERO_SYSTEM_TIME_NOW(unit_) \
std::chrono::duration_cast<std::chrono::unit_>(             \
        std::chrono::steady_clock::now().time_since_epoch() \
        ).count()                                           \
 
 
#define ZAKERO_UNUSED(var_) \
        (void)(var_);
 
// }}}
 
namespace zakero
{
        enum struct Storage : uint64_t
        {       Byte     = 0x0000'0000'0000'0001 
        ,       Kilobyte = 0x0000'0000'0000'0400 
        ,       Megabyte = 0x0000'0000'0010'0000 
        ,       Gigabyte = 0x0000'0000'4000'0000 
        ,       Terabyte = 0x0000'0100'0000'0000 
        ,       Petabyte = 0x0004'0000'0000'0000 
        ,       Exabyte  = 0x1000'0000'0000'0000 
        };
 
 
        /*
         * Doxygen Bug: For some reason doxygen can not parse aliases 
         * only/specifically in this file and in this namespace.
         */
 
        [[nodiscard]]
        inline uint64_t convert(const uint64_t size 
                , const zakero::Storage        from 
                , const zakero::Storage        to   
                ) noexcept
        {
                return size * static_cast<uint64_t>(from) / static_cast<uint64_t>(to);
        }
 
 
        [[nodiscard]]
        inline double convert(const double size 
                , const zakero::Storage    from 
                , const zakero::Storage    to   
                ) noexcept
        {
                return size * static_cast<uint64_t>(from) / static_cast<uint64_t>(to);
        }
 
 
        [[nodiscard]]
        inline bool equalish(const float a     
                , const float            b     
                , const float            delta 
                ) noexcept
        {
                return (std::abs(a - b) < delta);
        }
 
 
        [[nodiscard]]
        inline std::string tolower(std::string str 
                ) noexcept
        {
                std::locale locale;
 
                for(auto& c : str)
                {
                        c = std::tolower(c, locale);
                }
 
                return str;
        }
 
 
        template <class Type 
                >
        [[nodiscard]]
        inline bool vectorContains(const std::vector<Type>& vector 
                , const Type&                               value  
                ) noexcept
        {
                return (std::find(std::begin(vector), std::end(vector), value) != std::end(vector));
        }
 
 
        template <class InputIter 
                , class Type      
                >
        [[nodiscard]]
        inline bool vectorContains(InputIter first 
                , InputIter                  last  
                , const Type&                value 
                ) noexcept
        {
                return (std::find(first, last, value) != last);
        }
 
 
        template <class Type 
                >
        inline auto vectorErase(std::vector<Type>& vector 
                , const Type&                      value  
                ) noexcept
        {
                return vector.erase(std::remove(std::begin(vector), std::end(vector), value), std::end(vector));
        }
 
 
        [[nodiscard]]
        inline bool stob(const std::string_view str 
                ) noexcept
        {
                static std::vector<std::string> v =
                {       "enable"
                ,       "enabled"
                ,       "true"
                ,       "t"
                ,       "yes"
                ,       "y"
                ,       "1"
                };
 
                return (vectorContains(v, tolower(std::string(str))));
        }
 
 
        [[nodiscard]]
        inline std::string to_string(const bool value 
                ) noexcept
        {
                if(value)
                {
                        return std::string("true");
                }
 
                return std::string("false");
        }
 
 
        [[nodiscard]]
        inline std::string to_string(std::chrono::nanoseconds nanoseconds 
                ) noexcept
        {
                typedef std::chrono::duration<int64_t, std::ratio<86400>> duration_days;
 
                const auto days = std::chrono::duration_cast<duration_days>(nanoseconds);
                nanoseconds -= days;
 
                const auto hours = std::chrono::duration_cast<std::chrono::hours>(nanoseconds);
                nanoseconds -= hours;
 
                const auto minutes = std::chrono::duration_cast<std::chrono::minutes>(nanoseconds);
                nanoseconds -= minutes;
 
                const auto seconds = std::chrono::duration_cast<std::chrono::seconds>(nanoseconds);
                nanoseconds -= seconds;
 
                return    "{ \"days\": "        + std::to_string((int64_t)days.count())
                        + ", \"hours\": "       + std::to_string((int64_t)hours.count())
                        + ", \"minutes\": "     + std::to_string((int64_t)minutes.count())
                        + ", \"seconds\": "     + std::to_string((int64_t)seconds.count())
                        + ", \"nanoseconds\": " + std::to_string((int64_t)nanoseconds.count())
                        + " }";
        }
 
 
        [[nodiscard]]
        inline std::string to_string(const std::error_code& error 
                ) noexcept
        {
                return std::string()
                        + "{ \"category\": \"" + error.category().name() + "\""
                        + ", \"value\": "      + std::to_string(error.value())
                        + ", \"message\": \""  + error.message() + "\""
                        + " }";
        }
} // namespace zakero
 
 
[[nodiscard]]
inline std::ostream& operator<<(std::ostream& stream 
        , const std::error_code&              error  
        ) noexcept
{
        stream
                << "{ \"category\": \"" << error.category().name() << "\""
                << ", \"value\": "      << std::to_string(error.value())
                << ", \"message\": \""  << error.message() << "\""
                << " }"
                ;
 
        return stream;
}
 
#endif // zakero_Base_h