CArcPacketFactory.h

// +------------------------------------------------------------------------------------------------------------------+
// |  FILE:  CArcPacketFactory.h  ( GenIV )                                                                           |
// +------------------------------------------------------------------------------------------------------------------+
// |  PURPOSE: This file defines the ARC device/controller packet factory. All types of packets instances are         |
// |           created using this class. Implemented as a singleton class.                                            |
// |                                                                                                                  |
// |  AUTHOR:  Scott Streit         DATE: March 26, 2014                                                              |
// |                                                                                                                  |
// |  Copyright 2014 Astronomical Research Cameras, Inc. All rights reserved.                                         |
// +------------------------------------------------------------------------------------------------------------------+
#pragma once
 
#ifdef _WINDOWS
    #pragma warning( disable: 4251 )
#endif
 
#include <type_traits>
#include <cstdint>
#include <memory>
#include <any>
 
#include <CArcPacket.h>
#include <CArcStatusPacket.h>
#include <CArcDLoadPacket.h>
#include <CArcCommandPacket.h>
#include <CArcAlertPacket.h>
#include <CArcImagePacket.h>
#include <CArcDeviceDllMain.h>
#include <ArcConcepts.h>
 
 
 
namespace arc
{
    namespace gen4
    {
 
        class GEN4_CARCDEVICE_API CArcPacketFactory
        {
            public:
 
                static CArcPacketFactory& getInstance( void ) noexcept;
 
                inline std::unique_ptr<CArcCommandPacket> cmdPacket( const std::uint8_t uiId = 0 ) const
                {
                    return std::unique_ptr<CArcCommandPacket>( newCmdPacket( uiId ) );
                }
 
                inline std::unique_ptr<CArcCommandPacket> cmdPacket( const std::vector<std::uint32_t>& vCmdList, const std::uint8_t uiId = 0 ) const
                {
                    return std::unique_ptr<CArcCommandPacket>( newCmdPacket( vCmdList, uiId ) );
                }
 
                inline std::unique_ptr<CArcCommandPacket> cmdPacket( const std::vector<std::any>& vCmdList, const std::uint8_t uiId = 0 ) const
                {
                    return std::unique_ptr<CArcCommandPacket>( newCmdPacket( vCmdList, uiId ) );
                }
 
                inline std::unique_ptr<CArcCommandPacket> cmdPacket( const std::uint32_t uiCmd ) const
                {
                    return std::unique_ptr<CArcCommandPacket>( newCmdPacket( std::vector{ uiCmd } ) );
                }
 
                template<uint32Type... CommandList> inline
                std::unique_ptr<CArcCommandPacket> cmdPacket( CommandList... uiCmdList ) const
                {
                    return std::unique_ptr<CArcCommandPacket>( newCmdPacket( std::forward<CommandList>( uiCmdList )... ) );
                }
 
                template<uint32Type... Args> inline
                std::unique_ptr<CArcCommandPacket> cmdPacket( const arc::gen4::cmds_e tCmd, const Args... uiArgs ) const
                {
                    return std::unique_ptr<CArcCommandPacket>( newCmdPacket( tCmd, std::forward<Args>( uiArgs )... ) );
                }
 
                inline std::unique_ptr<CArcDLoadPacket> dloadPacket( void ) const
                {
                    return std::unique_ptr<CArcDLoadPacket>( newDLoadPacket() );
                }
 
                inline std::unique_ptr<CArcStatusPacket> statusPacket( void ) const
                {
                    return std::unique_ptr<CArcStatusPacket>( newStatusPacket() );
                }
 
                inline std::unique_ptr<CArcAlertPacket> alertPacket( void ) const
                {
                    return std::unique_ptr<CArcAlertPacket>( newAlertPacket() );
                }
 
                inline std::unique_ptr<CArcImagePacket> imagePacket( void ) const
                {
                    return std::unique_ptr<CArcImagePacket>( newImagePacket() );
                }
 
            private:
 
                CArcPacketFactory( void ) = default;
 
                CArcCommandPacket* newCmdPacket( const std::uint8_t uiId = 0 ) const;
 
                CArcCommandPacket* newCmdPacket( const std::vector<std::uint32_t>& vCmdList, const std::uint8_t uiId = 0 ) const;
 
                CArcCommandPacket* newCmdPacket( const std::vector<std::any>& vCmdList, const std::uint8_t uiId = 0 ) const;
 
                CArcCommandPacket* newCmdPacket( const std::uint32_t uiCmd, const std::uint8_t uiId = 0 ) const;
 
                template<uint32Type... CommandList> inline
                CArcCommandPacket* newCmdPacket( CommandList... uiCmdList ) const
                {
                    auto pCommandPacket = new CArcCommandPacket();
 
                    pCommandPacket->add( std::forward<CommandList>( uiCmdList )... );
 
                    return pCommandPacket;
                }
 
                template<uint32Type... Args> inline
                CArcCommandPacket* newCmdPacket( arc::gen4::cmds_e tCmd, Args... uiArgs ) const
                {
                    auto pCommandPacket = new CArcCommandPacket( tCmd );
 
                    pCommandPacket->add( std::forward<Args>( uiArgs )... );
 
                    return pCommandPacket;
                }
 
                CArcDLoadPacket* newDLoadPacket( void ) const;
 
                CArcStatusPacket* newStatusPacket( void ) const;
 
                CArcAlertPacket* newAlertPacket( void ) const;
 
                CArcImagePacket* newImagePacket( void ) const;
 
            };
 
    }       // end gen4 namespace
}           // end arc namespace