Zakero_Base.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2010-2019 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 <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_MACRO_HAS_VALUE(define_) \
        ~(~define_ + 0) == 0 && ~(~define_ + 1) == 1
 
#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()                                           \
 
// }}}
 
namespace zakero
{
        enum struct Storage : uint64_t
        {       Byte     = 0x0000'0000'0000'0001 ///< 1 byte
        ,       Kilobyte = 0x0000'0000'0000'0400 
        ,       Megabyte = 0x0000'0000'0010'0000 ///< 1024 kilobytes
        ,       Gigabyte = 0x0000'0000'4000'0000 
        ,       Terabyte = 0x0000'0100'0000'0000 ///< 1024 gigabytes
        ,       Petabyte = 0x0004'0000'0000'0000 
        ,       Exabyte  = 0x1000'0000'0000'0000 ///< 1024 petabytes
        };
 
 
        /*
         * 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 ///< The size to convert
                , const zakero::Storage        from ///< The source unit
                , const zakero::Storage        to   ///< The destination unit
                ) noexcept
        {
                return size * static_cast<uint64_t>(from) / static_cast<uint64_t>(to);
        }
 
 
        [[nodiscard]]
        inline double convert(const double size ///< The size to convert
                , const zakero::Storage    from ///< The source unit
                , const zakero::Storage    to   ///< The destination unit
                ) noexcept
        {
                return size * static_cast<uint64_t>(from) / static_cast<uint64_t>(to);
        }
 
 
        template <class Type ///< The vector type
                >
        [[nodiscard]]
        inline bool vectorContains(const std::vector<Type>& vector ///< The vector to search
                , const Type&                               value  ///< The value to look for
                ) noexcept
        {
                return (std::find(std::begin(vector), std::end(vector), value) != std::end(vector));
        }
 
 
        template <class InputIter ///< The iterator type
                , class Type      ///< The vector type
                >
        [[nodiscard]]
        inline bool vectorContains(InputIter first ///< Start searching here
                , InputIter                  last  ///< Stop seaching here
                , const Type&                value ///< The value to look for
                ) noexcept
        {
                return (std::find(first, last, value) != last);
        }
 
 
        template <class Type ///< The vector type
                >
        inline auto vectorErase(std::vector<Type>& vector ///< The vector to search
                , const Type&                      value  ///< The value to look for
                ) noexcept
        {
                return vector.erase(std::remove(std::begin(vector), std::end(vector), value), std::end(vector));
        }
 
 
        std::string to_string(const std::error_code& error ///< The value
                ) noexcept
        {
                std::string str = std::string(error.category().name())
                        + "," + std::to_string(error.value())
                        + "," + std::string(error.message())
                        ;
 
                return str;
        }
 
#if 0 // Future?
        using VectorString = std::vector<std::string>;
 
        [[nodiscard]]
        std::string to_string(const Yetani::VectorString&) noexcept;
 
        [[nodiscard]]
        std::string to_string(const Yetani::VectorString& vector ///< The value
                ) noexcept
        {
                if(vector.empty())
                {
                        return "[]";
                }
 
                std::string string = "";
                std::string delim  = "[ \"";
 
                for(const auto& str : vector)
                {
                        string += delim + str;
 
                        delim = "\", \"";
                }
 
                string += "\" ]";
 
                return string;
        }
#endif
}
 
#endif // zakero_Base_h