CArcBase.h

// +------------------------------------------------------------------------------------------------------------------+
// |  FILE:  ArcBase.h  ( GenIV )                                                                                     |
// +------------------------------------------------------------------------------------------------------------------+
// |  PURPOSE: This file defines the ARC base class.                                                                  |
// |                                                                                                                  |
// |  AUTHOR:  Scott Streit         DATE: Sept 25, 2014                                                               |
// |                                                                                                                  |
// |  Copyright 2013 Astronomical Research Cameras, Inc. All rights reserved.                                         |
// +------------------------------------------------------------------------------------------------------------------+
#pragma once
 
#ifdef _WINDOWS
    #include <windows.h>
#else
    #include <cstring>
#endif
 
#ifdef __cpp_lib_format
    #include <format>
#endif
 
#include <type_traits>
#include <filesystem>
#include <stdexcept>
#include <string>
#include <sstream>
#include <cstdint>
#include <cstdarg>
#include <chrono>
#include <thread>
#include <concepts>
#include <string_view>
#include <source_location>
 
#include <CArcBaseDllMain.h>
#include <CArcStringList.h>
 
using namespace std::string_literals;
using namespace std::string_view_literals;
 
 
 
namespace arc
{
    namespace gen4
    {
 
        // +----------------------------------------------------------------------------------------------------------+
        // |  throwArcGen4xxx functions                                                                               |
        // +----------------------------------------------------------------------------------------------------------+
        // |  Convenience to auto fill filename, method name and line number                                          |
        // +----------------------------------------------------------------------------------------------------------+
 
        template <typename... Args>
        struct throwFormat_t
        {
            throwFormat_t( const char* pszFormat, const std::source_location& tLocation = std::source_location::current() ) : m_format( pszFormat ), m_location( tLocation )
            {
            }
 
            throwFormat_t( const std::string& sFormat, const std::source_location& tLocation = std::source_location::current() ) : m_format( sFormat ), m_location( tLocation )
            {
            }
 
            throwFormat_t( std::string_view svFormat, const std::source_location& tLocation = std::source_location::current() ) : m_format( svFormat ), m_location( tLocation )
            {
            }
 
            std::string m_format;                   
            std::source_location m_location;        
        };
 
 
        template <typename... Args>
        void throwArcGen4Error( const throwFormat_t<> tFormat, [[ maybe_unused ]] Args&&... args )
        {
            auto sFile = std::filesystem::path( tFormat.m_location.file_name() ).filename().string();
 
            #ifdef __cpp_lib_format
 
                throw std::runtime_error( std::format( tFormat.m_format, std::forward<Args&&>( args )... ) +
                                          std::format( " at file: {}, func: {}, line: {}",
                                                        sFile,
                                                        tFormat.m_location.function_name(),
                                                        tFormat.m_location.line() ) );
 
            #else
 
                std::ostringstream oss;
 
                oss << tFormat.m_format << " at file: " << sFile << ", func: "
                    << tFormat.m_location.function_name() << ", line: "
                    << tFormat.m_location.line() << std::ends;
 
                throw std::runtime_error( oss.str() );
 
            #endif
        }
 
        
        template <typename... Args>
        void throwArcGen4InvalidArgument( const throwFormat_t<> tFormat, [[ maybe_unused ]] Args&&... args )
        {
            auto sFile = std::filesystem::path( tFormat.m_location.file_name() ).filename().string();
 
            #ifdef __cpp_lib_format
 
                throw std::invalid_argument( std::format( tFormat.m_format, std::forward<Args&&>( args )... ) +
                                             std::format( " at file: {}, func: {}, line: {}",
                                                            sFile,
                                                            tFormat.m_location.function_name(),
                                                            tFormat.m_location.line() ) );
 
            #else
 
                std::ostringstream oss;
 
                oss << tFormat.m_format << " at file: " << sFile << ", func: "
                    << tFormat.m_location.function_name() << ", line: "
                    << tFormat.m_location.line() << std::ends;
 
                throw std::invalid_argument( oss.str() );
 
            #endif
        }
 
 
        template <typename... Args>
        struct throwArcGen4OutOfRange
        {
            throwArcGen4OutOfRange( const std::uint32_t uiElement, const std::pair<std::uint32_t, std::uint32_t>&& tRange , const std::source_location& location = std::source_location::current() )
            {
                auto [uiMin, uiMax] { tRange };
 
                auto sFile = std::filesystem::path( location.file_name() ).filename().string();
 
                #ifdef __cpp_lib_format
 
                    throw std::out_of_range( std::format( "Element [ {} ] out of range [ {} - {} ]\nTrace: ( {} {}() line: {} )"sv, uiElement, uiMin, uiMax, sFile, location.function_name(), location.line() ) );
 
                #else
 
                    std::ostringstream oss;
                    
                    oss << "Element [ " << uiElement << " ] out of range [ " << uiMin << " - " << uiMax << " ]\nTrace: ( " << sFile << " " << location.function_name() << "() line: " << location.line() << " )" << std::ends;
 
                    throw std::out_of_range( oss.str() );
 
                #endif
            }
        };
 
 
        template <typename... Args>
        void throwArcGen4LengthError( throwFormat_t<> tFormat, [[ maybe_unused ]] Args&&... args )
        {
            auto sFile = std::filesystem::path( tFormat.m_location.file_name() ).filename().string();
 
            #ifdef __cpp_lib_format
 
                throw std::length_error( std::format( tFormat.m_format, std::forward<Args&&>( args )... ) +
                                         std::format( " at file: {}, func: {}, line: {}",
                                                        sFile,
                                                        tFormat.m_location.function_name(),
                                                        tFormat.m_location.line() ) );
 
            #else
 
                std::ostringstream oss;
 
                oss << tFormat.m_format << " at file: " << sFile << ", func: "
                    << tFormat.m_location.function_name() << ", line: "
                    << tFormat.m_location.line() << std::ends;
 
                throw std::length_error( oss.str() );
 
            #endif
        }
 
 
 
        // +----------------------------------------------------------------------------------------------------------+
        // |  CArcBase Class                                                                                          |
        // +----------------------------------------------------------------------------------------------------------+
 
        class GEN4_CARCBASE_API CArcBase
        {
            public:
 
                static const std::string version( void );
 
 
                static void zeroMemory( void* pDest, std::size_t uiSize );
 
 
                static void copyMemory( void* pDest, void* pSrc, std::size_t uiSize );
 
 
                template<typename T> static std::tuple<T*,T*> copyAndIncrement( void* pDest, void* pSrc, const std::size_t uiSize )
                {
                    T* pInserter = reinterpret_cast<T*>( pDest );
                    T* pReader   = reinterpret_cast<T*>( pSrc );
 
                    if ( std::is_integral_v<T> )
                    {
                        if ( pInserter != nullptr && pReader != nullptr )
                        {
                            for ( std::remove_const_t<decltype( uiSize )> i = 0; i < uiSize; i++, pInserter++, pReader++ )
                            {
                                *pInserter = *pReader;
                            }
                        }
 
                        else
                        {
                            throwArcGen4InvalidArgument( "Source and/or destination pointer(s) cannot be NULL!"sv );
                        }
                    }
                
                    else
                    {
                        throwArcGen4InvalidArgument( "Must be integral type!"sv );
                    }
 
                    return { pInserter, pReader };
                }
 
 
                template<typename ErrCode>
                static const std::string getSystemErrorMessage( ErrCode iErrCode ) requires std::is_integral_v<ErrCode>
                {
                    #ifdef _WINDOWS
 
                        std::ostringstream  oss;
                        std::string         sMsg;
 
                        LPTSTR lpBuffer;
 
                        FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
                                        NULL,
                                        ( DWORD )iErrCode,
                                        MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ),
                                        ( LPTSTR )&lpBuffer,
                                        0,
                                        NULL );
 
                        char szBuffer[ 1024 ] = { '\0' };
 
                        std::int32_t iBytes = WideCharToMultiByte( CP_ACP, 0, reinterpret_cast< LPWSTR >( lpBuffer ), -1, szBuffer, sizeof( szBuffer ), NULL, NULL );
 
                        if ( iBytes > 0 )
                        {
                            oss << szBuffer;
                        }
 
                        LocalFree( lpBuffer );
 
                    #else
 
                        std::ostringstream  oss;
                        std::string         sMsg;
 
                        if ( iErrCode != -1 )
                        {
                            oss << "( errno: " << iErrCode << " ) - " << strerror( iErrCode );
                        }
 
                        //
                        // Remove and return characters '\r' or '\n' at the end of the string.
                        //
                        sMsg = oss.str();
 
                        if ( sMsg.back() == '\n' || sMsg.back() == '\r' )
                        {
                            sMsg.erase( sMsg.end() - 1, sMsg.end() );
                        }
 
                    #endif
 
                    //
                    // Remove and return characters '\r' or '\n' at the end of the string.
                    //
                    sMsg = oss.str();
 
                    if ( sMsg.back() == '\n' || sMsg.back() == '\r' )
                    {
                        sMsg.erase( sMsg.end() - 1, sMsg.end() );
                    }
 
                    return sMsg;
                }
 
 
                static const std::string getSystemErrorMessage( void );
 
 
                #ifdef _WINDOWS
                    static std::uint32_t getSystemError( void ) noexcept
                    {
                        return static_cast< std::uint32_t >( ::GetLastError() );
                    }
                #else
                    static std::int32_t getSystemError( void ) noexcept
                    {
                        return static_cast< std::int32_t >( errno );
                    }
                #endif
 
 
                static pStringList_t splitString( const std::string& sString, const char& zDelim = ' ' );
 
 
                 [[ deprecated( "Will be removed in a future release. Use std::format() instead." ) ]]
                 static std::string formatString( const char* pszFmt, ... );
 
 
                static const std::filesystem::path incrementFileName( const std::filesystem::path& tFilePath = "", const std::int32_t iStartValue = -1 );
 
 
                static std::filesystem::path getFileName( const std::string& sFilter = "Gen IV Microcontroller binary file\0*.bin\0All\0*.*\0"s ) noexcept;
 
 
                static std::string convertWideToAnsi( const wchar_t wzString[] ) noexcept;
 
 
                static std::string convertWideToAnsi( const std::wstring& wsString );
 
 
                static std::wstring convertAnsiToWide( const char* pszString );
 
 
                static std::string cmdToString( const std::uint32_t uiCmd );
 
 
                static std::string uintToString( const std::uint32_t uiValue ) noexcept;
 
 
                template <typename T> static std::string iterToString( T* begin, T* end, const char zSeperator = ' ' )
                {
                    std::ostringstream oss;
 
                    if ( begin == nullptr )
                    {
                        throwArcGen4Error( "Invalid \"begin\" parameter ( nullptr )."sv );
                    }
 
                    if ( end == nullptr )
                    {
                        throwArcGen4Error( "Invalid \"end\" parameter ( nullptr )."sv );
                    }
 
                    while ( begin != end )
                    {
                        oss << cmdToString( *begin++ ) << zSeperator;
                    }
 
                    return oss.str();
                }
 
 
                static std::unique_ptr<std::uint8_t[]> readFileBytes( const std::filesystem::path& tFilePath, std::uint32_t& uiFileLength );
 
 
                static std::string setDots( std::string_view svText, const std::size_t uiMaxLength, const char szDot = '.' );
 
 
                static std::string trim( const std::string& sText ) noexcept;
 
 
                static std::size_t replaceAll( std::string& sText, std::string_view svWhat, std::string_view svWith );
 
 
                static float uintToFloat( const std::uint32_t uiValue );
 
 
                static const std::chrono::time_point<std::chrono::high_resolution_clock> startCodeTime( void ) noexcept;
 
 
                template <typename T>
                static constexpr auto endCodeTime( const std::chrono::time_point<std::chrono::high_resolution_clock> tStartTimePoint ) noexcept
                {
                    return std::chrono::duration_cast< T >( std::chrono::high_resolution_clock::now() - tStartTimePoint ).count();
                }
 
 
                virtual ~CArcBase( void );
 
            protected:
 
                CArcBase( void ) = default;
 
                CArcBase( const CArcBase& ) = delete;
 
                CArcBase( CArcBase&& ) = delete;
 
                CArcBase& operator=( const CArcBase& ) = delete;
 
                CArcBase& operator=( CArcBase&& ) = delete;
 
                static const std::string m_sVersion;
 
            private:
 
                struct tFloatConverter
                {
 
                    std::uint64_t   uiValue;
                    float*          pfValue;
                };
 
            };
 
 
 
    }       // end gen4 namespace
}           // end arc namespace