Creates type safe SQL classes

Author: David-Maisonave

CommonFunction.cpp

@@ -0,0 +1,72 @@
+/*
+	Copyright (C) 2021  David Maisonave
+	The RegexAssistant source code is free software. You can redistribute it and/or modify it under the terms of the GNU General Public License.
+	This program is distributed in the hope that it will be useful,	but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+*/
+#include "pch.h"
+#include <windows.h>
+#include "CommonFunctions.h"
+
+#ifndef EXCLUDE_BOOST_CODE
+#include <boost\algorithm\string\replace.hpp>
+#endif //!EXCLUDE_BOOST_CODE
+
+
+namespace Common
+{
+	std::wstring ToWString(std::string str )	
+	{
+		if ( str.empty() ) return std::wstring();
+		int size_needed = MultiByteToWideChar( CP_UTF8, 0, &str[0], (int)str.size(), NULL, 0 );
+		std::wstring wstrTo( size_needed, 0 );
+		MultiByteToWideChar( CP_UTF8, 0, &str[0], (int)str.size(), &wstrTo[0], size_needed );
+		return wstrTo;
+	}
+
+	std::string ToString(std::wstring wstr )	
+	{
+		if ( wstr.empty() ) return std::string();
+		int size_needed = WideCharToMultiByte( CP_UTF8, 0, &wstr[0], (int)wstr.size(), NULL, 0, NULL, NULL );
+		std::string strTo( size_needed, 0 );
+		WideCharToMultiByte( CP_UTF8, 0, &wstr[0], (int)wstr.size(), &strTo[0], size_needed, NULL, NULL );
+		return strTo;
+	}
+
+#ifndef EXCLUDE_BOOST_CODE
+	void ReplaceAll( std::string &src, const std::string &searchStr, const std::string &ReplacementStr )
+	{
+		boost::replace_all( src, searchStr, ReplacementStr );
+	}
+
+	std::string Replace( std::string &src, const std::string &searchStr, const std::string &ReplacementStr )
+	{
+		ReplaceAll( src, searchStr, ReplacementStr );
+		return src;
+	}
+
+	std::string ReplaceInCopy(const std::string &org, const std::string &searchStr, const std::string &ReplacementStr)
+	{
+		std::string str = org;
+		ReplaceAll(str, searchStr, ReplacementStr);
+		return str;
+	}
+#endif //!EXCLUDE_BOOST_CODE
+
+#ifdef _AFX
+	void TraceDiagnosticInfo( std::string msg )
+	{// AfxTrace has a max buffer size of 512 bytes, which is 256 wchar_t's.  Need to make sure the diagnostic info doesn't overrun the buffer by sending it MaxSectionSize characters at a time
+		const int MaxSectionSize = 100;
+		const int strsize = static_cast<int>(msg.size());
+		if ( strsize > MaxSectionSize )
+		{
+#ifndef EXCLUDE_BOOST_CODE
+			Common::Replace( msg, "\n", " " );
+			Common::Replace( msg, "\r", " " );
+#endif //!EXCLUDE_BOOST_CODE
+		}
+		for ( int i = 0; (i * MaxSectionSize) < strsize; ++i )
+			AfxTrace( i ? L"\t\t\t\t%S\n" : L"Exception Info:\t%S\n", msg.substr( i * MaxSectionSize, (i + 1) * MaxSectionSize ).c_str() );
+	}
+#endif //_AFX
+}
+

CommonFunctions.h

@@ -0,0 +1,193 @@
+/*
+	Copyright (C) 2021  David Maisonave
+	The RegexAssistant source code is free software. You can redistribute it and/or modify it under the terms of the GNU General Public License.
+	This program is distributed in the hope that it will be useful,	but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for more details.
+*/
+#pragma once
+#include <string>
+#include <memory>
+#include <mutex>
+#include <algorithm> 
+#include <cctype>
+#include <locale>
+
+namespace Common
+{
+	std::wstring ToWString(std::string src);
+	inline std::wstring ToWString( const std::wstring &src ) { return src; }
+	inline std::wstring ToWString( const wchar_t* src ) { return std::wstring( src ); }
+
+	std::string ToString( std::wstring src);
+	inline std::string ToString( const std::string &src ) { return src; }
+	inline std::string ToString( const wchar_t* src ) { return ToString( std::wstring(src) ); }
+
+	inline std::string ToString( int src ) { return std::to_string( src ); }
+	inline std::string ToString( long src ) { return std::to_string( src ); }
+	inline std::string ToString( long long src ) { return std::to_string( src ); }
+	inline std::string ToString( unsigned src ) { return std::to_string( src ); }
+	inline std::string ToString( unsigned long src ) { return std::to_string( src ); }
+	inline std::string ToString( unsigned long long src ) { return std::to_string( src ); }
+	inline std::string ToString( float src ) { return std::to_string( src ); }
+	inline std::string ToString( double src ) { return std::to_string( src ); }
+	inline std::string ToString( long double src ) { return std::to_string( src ); }
+
+	inline std::wstring ToWString( int src ) { return std::to_wstring( src ); }
+	inline std::wstring ToWString( long src ) { return std::to_wstring( src ); }
+	inline std::wstring ToWString( long long src ) { return std::to_wstring( src ); }
+	inline std::wstring ToWString( unsigned src ) { return std::to_wstring( src ); }
+	inline std::wstring ToWString( unsigned long src ) { return std::to_wstring( src ); }
+	inline std::wstring ToWString( unsigned long long src ) { return std::to_wstring( src ); }
+	inline std::wstring ToWString( float src ) { return std::to_wstring( src ); }
+	inline std::wstring ToWString( double src ) { return std::to_wstring( src ); }
+	inline std::wstring ToWString( long double src ) { return std::to_wstring( src ); }
+	
+	template<class T>
+	std::wstring ToStr( std::wstring dest, T src )
+	{
+		dest = std::to_wstring( src );
+		return dest;
+	}
+	template<class T>
+	std::string ToStr( std::string dest, T src )
+	{
+		dest = std::to_string( src );
+		return dest;
+	}
+
+	// trim from start (in place)
+	inline void ltrim(std::string &s) {
+		s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
+			return !std::isspace(ch);
+		}));
+	}
+
+	// trim from end (in place)
+	inline void rtrim(std::string &s) {
+		s.erase(std::find_if(s.rbegin(), s.rend(), [](unsigned char ch) {
+			return !std::isspace(ch);
+		}).base(), s.end());
+	}
+
+	// trim from both ends (in place)
+	inline void trim(std::string &s) {
+		ltrim(s);
+		rtrim(s);
+	}
+
+	// trim from start (copying)
+	inline std::string ltrim_copy(std::string s) {
+		ltrim(s);
+		return s;
+	}
+
+	// trim from end (copying)
+	inline std::string rtrim_copy(std::string s) {
+		rtrim(s);
+		return s;
+	}
+
+	// trim from both ends (copying)
+	inline std::string trim_copy(std::string s) {
+		trim(s);
+		return s;
+	}
+
+	// trim from end of string (right)
+	inline std::string& rtrim(std::string& s, const char* t_str)
+	{
+		s.erase(s.find_last_not_of(t_str) + 1);
+		return s;
+	}
+
+	// trim from beginning of string (left)
+	inline std::string& ltrim(std::string& s, const char* t_str)
+	{
+		s.erase(0, s.find_first_not_of(t_str));
+		return s;
+	}
+
+	// trim from both ends of string (right then left)
+	inline std::string& trim(std::string& s, const char* t_str)
+	{
+		return ltrim(rtrim(s, t_str), t_str);
+	}
+#ifdef _AFX
+	inline CString ToCString(const char * src) { return ToWString(src).c_str(); }
+	inline CString ToCString(const wchar_t * src) { return src; }
+
+	inline CString ToCString( int src ) { return std::to_wstring( src ).c_str(); }
+	inline CString ToCString( long src ) { return std::to_wstring( src ).c_str(); }
+	inline CString ToCString( long long src ) { return std::to_wstring( src ).c_str(); }
+	inline CString ToCString( unsigned src ) { return std::to_wstring( src ).c_str(); }
+	inline CString ToCString( unsigned long src ) { return std::to_wstring( src ).c_str(); }
+	inline CString ToCString( unsigned long long src ) { return std::to_wstring( src ).c_str(); }
+	inline CString ToCString( float src ) { return std::to_wstring( src ).c_str(); }
+	inline CString ToCString( double src ) { return std::to_wstring( src ).c_str(); }
+	inline CString ToCString( long double src ) { return std::to_wstring( src ).c_str(); }
+	inline size_t StrLen(const CString &str) { return static_cast <size_t>(str.GetLength()); }
+	inline DWORD StrDwLen( const CString &str ) { return static_cast<DWORD>(str.GetLength()); }
+	void TraceDiagnosticInfo( std::string msg );
+#endif //_AFX
+
+#ifndef EXCLUDE_BOOST_CODE
+	std::string ReplaceInCopy(const std::string &src, const std::string &searchStr, const std::string &ReplacementStr);
+	std::string Replace(std::string &src, const std::string &searchStr, const std::string &ReplacementStr);
+	void ReplaceAll( std::string &src, const std::string &searchStr, const std::string &ReplacementStr );
+#endif //!EXCLUDE_BOOST_CODE
+
+	template <class strType1, class strType2> bool MatchesNoCase(strType1 str1, strType2 str2)
+	{
+		std::wstring wstr1 = ToWString(str1);
+		std::wstring wstr2 = ToWString(str2);
+		return (0 == _wcsicmp(wstr1.c_str(), wstr2.c_str()));
+	}
+
+	inline size_t StrLen(const char * str) { return strlen(str); }
+	inline size_t StrLen(const wchar_t * str) { return wcslen(str); }
+
+#ifdef _WINBASE_
+#define GETLASTERROR__	GetLastError()
+#else
+#include <cstddef>
+#define GETLASTERROR__	GetErrNo()
+	int GetErrNo()
+	{
+		int Err = 0;
+		_get_errno(&Err);
+		return Err;
+	}
+	using DWORD = unsigned long;
+#endif
+
+	inline DWORD StrDwLen( const char * str ) { return static_cast<DWORD>(strlen( str )); }
+	inline DWORD StrDwLen( const wchar_t * str ) { return static_cast<DWORD>(wcslen( str )); }
+
+	class errno_exception
+	{
+		int m_errno;
+		std::string m_what;
+		std::exception *m_exception;
+		std::string m_name;
+	public:
+		errno_exception( const char *name, std::exception &Exception, int no = GETLASTERROR__, std::string s = "" ) :m_errno( no ), m_what( s.size() ? s : Exception.what() ), m_exception( &Exception ), m_name( name ) {}
+		errno_exception( const char *s = NULL, int no = GETLASTERROR__ ) :m_errno( no ), m_what( (s == NULL) ? "Unknown Exception" : s ), m_exception( NULL ), m_name( (s == NULL) ? "Unknown Exception" : "Exception" ) {}
+		errno_exception( std::string &s, int no = GETLASTERROR__ ) :m_errno( no ), m_what( s ), m_exception( NULL ), m_name( "Exception" ) {}
+		const char* what() { return (m_exception == NULL) ? m_what.c_str() : m_exception->what(); }
+		int code() { return m_errno; }
+		const char* name() { return m_name.c_str(); }
+	};
+
+	class auto_lock
+	{
+		std::mutex mtx;
+	public:
+		auto_lock(){ mtx.lock(); }
+		~auto_lock(){ mtx.unlock(); }
+	};
+
+
+}
+
+#define REPORT_ERR_AND_EXIT(exit_err_no, msg_format, ...) {CString msg; msg.Format(_T("Error:  " msg_format "  Performming early exit due to error."),__VA_ARGS__);AfxMessageBox(msg);exit(exit_err_no);}
+#define ERR_LOG(msg_format, ...	)	{Common::Logging logging(__FILE__, __LINE__, __FUNCTION__, Common::Verbosity::ERR, msg_format __VA_OPT__(,) __VA_ARGS__);}
+