Deliver/include/Log4CPP8.0/Common.Include/Utility.SHA.hpp

#pragma once

#include <string>

#include <vector>
#include <list>


#ifndef _SHA_EXPORTS
#define _SHA_API	_declspec(dllimport)
#else
#define _SHA_API	_declspec(dllexport)
#endif



#ifndef _SHA_EXPORTS

#ifdef _WIN64

#ifdef _DEBUG
#pragma comment (lib, "ECOM.Utility.SHA64D.lib") 
#else
#pragma comment (lib, "ECOM.Utility.SHA64.lib") 
#endif

#else	//	X86

#ifdef _DEBUG
#pragma comment (lib, "ECOM.Utility.SHAD.lib") 
#else
#pragma comment (lib, "ECOM.Utility.SHA.lib") 
#endif

#endif

#endif  //  _SHA_EXPORTS



namespace ECOM::Utility
{

	//-----------------------------------------------------------------------------
	//		SHA224
	//-----------------------------------------------------------------------------

	class  _SHA_API  SHA224
	{
	public:
		using tStringType = std::string;
		using tStringView = std::string_view;

		SHA224 () = delete;

	public:
		union tHash224
		{
			static constexpr auto NbOf8  = 28;
			static constexpr auto NbOf32 = 7;
			static constexpr auto NbOf64 = 3;

			BYTE   Hash8  [NbOf8];
			DWORD  Hash32 [NbOf32];
			UINT64 Hash64 [NbOf64];

			bool operator == (const tHash224 & with)
			{
				return (
					Hash64 [0] == with.Hash64 [0] &&
					Hash64 [1] == with.Hash64 [1] &&
					Hash64 [2] == with.Hash64 [2]);
			}

		} Hash224;


		static tHash224    From (const tStringType &);
		static tHash224    From (const tStringView);

		static tHash224    From (std::initializer_list <tStringType> lst);
		static tHash224    From (std::initializer_list <tStringView> lst);

		static tHash224    From (const std::vector <tStringType> & lst);
		static tHash224    From (const std::vector <tStringView> & lst);

		static tHash224    From (const std::list <tStringType> & lst);
		static tHash224    From (const std::list <tStringView> & lst);

		static tStringType ToHexString (char ch, const tStringType &);
		static tStringType ToHexString (char ch, const tStringView);

		static tStringType ToHexString (char ch, std::initializer_list <tStringType> lst);
		static tStringType ToHexString (char ch, std::initializer_list <tStringView> lst);

		static tStringType ToHexString (char ch, const std::vector <tStringType> & lst);
		static tStringType ToHexString (char ch, const std::vector <tStringView> & lst);

		static tStringType ToHexString (char ch, const std::list <tStringType> & lst);
		static tStringType ToHexString (char ch, const std::list <tStringView> & lst);
	};



	//-----------------------------------------------------------------------------
	//		SHA256
	//-----------------------------------------------------------------------------

	class  _SHA_API  SHA256
	{
	public:
		using tStringType = std::string;
		using tStringView = std::string_view;

		SHA256 () = delete;

	public:
		union tHash256
		{
			static constexpr auto NbOf8  = 32;
			static constexpr auto NbOf32 = 8;
			static constexpr auto NbOf64 = 4;

			BYTE   Hash8  [NbOf8];
			DWORD  Hash32 [NbOf32];
			UINT64 Hash64 [NbOf64];

			bool operator == (const tHash256 & with)
			{
				return (
					Hash64 [0] == with.Hash64 [0] &&
					Hash64 [1] == with.Hash64 [1] &&
					Hash64 [2] == with.Hash64 [2] &&
					Hash64 [3] == with.Hash64 [3]);
			}

		} Hash256;


		static tHash256    From (const tStringType &);
		static tHash256    From (const tStringView);

		static tHash256    From (std::initializer_list <tStringType> lst);
		static tHash256    From (std::initializer_list <tStringView> lst);

		static tHash256    From (const std::vector <tStringType> & lst);
		static tHash256    From (const std::vector <tStringView> & lst);

		static tHash256    From (const std::list <tStringType> & lst);
		static tHash256    From (const std::list <tStringView> & lst);

		static tStringType ToHexString (char ch, const tStringType &);
		static tStringType ToHexString (char ch, const tStringView);

		static tStringType ToHexString (char ch, std::initializer_list <tStringType> lst);
		static tStringType ToHexString (char ch, std::initializer_list <tStringView> lst);

		static tStringType ToHexString (char ch, const std::vector <tStringType> & lst);
		static tStringType ToHexString (char ch, const std::vector <tStringView> & lst);

		static tStringType ToHexString (char ch, const std::list <tStringType> & lst);
		static tStringType ToHexString (char ch, const std::list <tStringView> & lst);
	};





	//-----------------------------------------------------------------------------
	//		SHA384
	//-----------------------------------------------------------------------------

	class  _SHA_API  SHA384
	{
	public:
		using tStringType = std::string;
		using tStringView = std::string_view;

		SHA384 () = delete;

	public:
		union tHash384
		{
			static constexpr auto NbOf8  = 48;
			static constexpr auto NbOf32 = 12;
			static constexpr auto NbOf64 = 6;

			BYTE   Hash8  [NbOf8];
			DWORD  Hash32 [NbOf32];
			UINT64 Hash64 [NbOf64];

			bool operator == (const tHash384 & with)
			{
				return (
					Hash64 [0] == with.Hash64 [0] &&
					Hash64 [1] == with.Hash64 [1] &&
					Hash64 [2] == with.Hash64 [2] &&
					Hash64 [3] == with.Hash64 [3] &&
					Hash64 [4] == with.Hash64 [4] &&
					Hash64 [5] == with.Hash64 [5]);
			}

		} Hash384;


		static tHash384    From (const tStringType &);
		static tHash384    From (const tStringView);

		static tHash384    From (std::initializer_list <tStringType> lst);
		static tHash384    From (std::initializer_list <tStringView> lst);

		static tHash384    From (const std::vector <tStringType> & lst);
		static tHash384    From (const std::vector <tStringView> & lst);

		static tHash384    From (const std::list <tStringType> & lst);
		static tHash384    From (const std::list <tStringView> & lst);

		static tStringType ToHexString (char ch, const tStringType &);
		static tStringType ToHexString (char ch, const tStringView);

		static tStringType ToHexString (char ch, std::initializer_list <tStringType> lst);
		static tStringType ToHexString (char ch, std::initializer_list <tStringView> lst);

		static tStringType ToHexString (char ch, const std::vector <tStringType> & lst);
		static tStringType ToHexString (char ch, const std::vector <tStringView> & lst);

		static tStringType ToHexString (char ch, const std::list <tStringType> & lst);
		static tStringType ToHexString (char ch, const std::list <tStringView> & lst);
	};



	//-----------------------------------------------------------------------------
	//		SHA512
	//-----------------------------------------------------------------------------

	class  _SHA_API  SHA512
	{
	public:
		using tStringType = std::string;
		using tStringView = std::string_view;

		SHA512 () = delete;

	public:
		union tHash512
		{
			static constexpr auto NbOf8  = 32 * 2;
			static constexpr auto NbOf32 = 8 * 2;
			static constexpr auto NbOf64 = 4 * 2;

			BYTE   Hash8  [NbOf8];
			DWORD  Hash32 [NbOf32];
			UINT64 Hash64 [NbOf64];

			bool operator == (const tHash512 & with)
			{
				return (
					Hash64 [0] == with.Hash64 [0] &&
					Hash64 [1] == with.Hash64 [1] &&
					Hash64 [2] == with.Hash64 [2] &&
					Hash64 [3] == with.Hash64 [3] &&
					Hash64 [4] == with.Hash64 [4] &&
					Hash64 [5] == with.Hash64 [5] &&
					Hash64 [6] == with.Hash64 [6] &&
					Hash64 [7] == with.Hash64 [7]);
			}

		} Hash512;


		static tHash512    From (const tStringType &);
		static tHash512    From (const tStringView);
		static tHash512    From (std::initializer_list <tStringType> lst);
		static tHash512    From (std::initializer_list <tStringView> lst);

		static tHash512    From (const std::vector <tStringType> & lst);
		static tHash512    From (const std::vector <tStringView> & lst);
		static tHash512    From (const std::list <tStringType> & lst);
		static tHash512    From (const std::list <tStringView> & lst);

		static tStringType ToHexString (char ch, const tStringType &);
		static tStringType ToHexString (char ch, const tStringView);
		static tStringType ToHexString (char ch, std::initializer_list <tStringType> lst);
		static tStringType ToHexString (char ch, std::initializer_list <tStringView> lst);

		static tStringType ToHexString (char ch, const std::vector <tStringType> & lst);
		static tStringType ToHexString (char ch, const std::vector <tStringView> & lst);
		static tStringType ToHexString (char ch, const std::list <tStringType> & lst);
		static tStringType ToHexString (char ch, const std::list <tStringView> & lst);
	};


}