util.h

/*
 * Copyright (c) 2015, 2024, Oracle and/or its affiliates.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License, version 2.0, as
 * published by the Free Software Foundation.
 *
 * This program is designed to work with certain software (including
 * but not limited to OpenSSL) that is licensed under separate terms, as
 * designated in a particular file or component or in included license
 * documentation. The authors of MySQL hereby grant you an additional
 * permission to link the program and your derivative works with the
 * separately licensed software that they have either included with
 * the program or referenced in the documentation.
 *
 * Without limiting anything contained in the foregoing, this file,
 * which is part of Connector/C++, is also subject to the
 * Universal FOSS Exception, version 1.0, a copy of which can be found at
 * https://oss.oracle.com/licenses/universal-foss-exception.
 *
 * 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, version 2.0, for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/

#ifndef MYSQLX_COMMON_UTIL_H
#defineMYSQLX_COMMON_UTIL_H

#include"api.h"
#include<limits>

/*
 Macros used to disable warnings for fragments of code.
*/

#if defined _MSC_VER


#definePRAGMA(X) __pragma(X)
#defineDISABLE_WARNING(W) PRAGMA(warning (disable:W))

#defineDIAGNOSTIC_PUSHPRAGMA(warning (push))
#defineDIAGNOSTIC_POPPRAGMA(warning (pop))

#elif defined __GNUC__ || defined __clang__

#definePRAGMA(X) _Pragma(#X)
#defineDISABLE_WARNING(W) PRAGMA(GCC diagnostic ignored #W)

#if defined __clang__ || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#defineDIAGNOSTIC_PUSHPRAGMA(GCC diagnostic push)
#defineDIAGNOSTIC_POPPRAGMA(GCC diagnostic pop)
#else
#defineDIAGNOSTIC_PUSH
#defineDIAGNOSTIC_POP
#endif

#else

#definePRAGMA(X)
#defineDISABLE_WARNING(W)

#defineDIAGNOSTIC_PUSH
#defineDIAGNOSTIC_POP

#endif


/*
 Macros to disable compile warnings in system headers. Put
 PUSH_SYS_WARNINGS/POP_SYS_WARNINGS around sytem header includes.
*/

#if defined _MSC_VER

/*
 Warning 4350 is triggered by std::shared_ptr<> implementation
 - see https://msdn.microsoft.com/en-us/library/0eestyah.aspx

 Warning 4365 conversion from 'type_1' to 'type_2', signed/unsigned mismatch
 - see https://msdn.microsoft.com/en-us/library/ms173683.aspx

 Warning 4774 format string expected in argument <position> is not a
 string literal
*/

#definePUSH_SYS_WARNINGS \
PRAGMA(warning (push,2)) \
 DISABLE_WARNING(4350) \
 DISABLE_WARNING(4738) \
 DISABLE_WARNING(4548) \
 DISABLE_WARNING(4365) \
 DISABLE_WARNING(4774) \
 DISABLE_WARNING(4244)

#else

#definePUSH_SYS_WARNINGS DIAGNOSTIC_PUSH

#endif

#definePOP_SYS_WARNINGS DIAGNOSTIC_POP

PUSH_SYS_WARNINGS

#include<string>
#include<stdexcept>
#include<ostream>
#include<memory>
#include<forward_list>
#include<string.h>// for memcpy
#include<utility>// std::move etc
#include<algorithm>
#include<functional>
#include<type_traits>

POP_SYS_WARNINGS

/*
 Macro to be used to disable "implicit fallthrough" gcc warning
 <https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html>
*/

#ifndef FALLTHROUGH
# ifdef __GNUC__
# if __GNUC__ < 7
# defineFALLTHROUGH// fallthrough
# else
# if __cplusplus >= 201703L
# defineFALLTHROUGH [[fallthrough]] // C++17
# elif __cplusplus >= 201103L
# defineFALLTHROUGH [[gnu::fallthrough]] // C++11 and C++14
# else
# defineFALLTHROUGH__attribute__((fallthrough))
# endif
# endif
# else
# defineFALLTHROUGH// fallthrough
# endif
#endif//FALLTHROUGH

/*
 Note: we add throw statement to the definition of THROW() so that compiler won't
 complain if it is used in contexts where, e.g., a value should be returned from
 a function.
*/

#undef THROW

#ifdef THROW_AS_ASSERT

#defineTHROW(MSG) do { assert(false && (MSG)); throw (MSG); } while(false)

#else

#defineTHROW(MSG) do { throw_error(MSG); throw (MSG); } while(false)

#endif


/*
 Macros used to disable warnings for fragments of code.
*/

#undef PRAGMA
#undef DISABLE_WARNING
#undef DIAGNOSTIC_PUSH
#undef DIAGNOSTIC_POP

#if defined _MSC_VER

#definePRAGMA(X) __pragma(X)
#defineDISABLE_WARNING(W) PRAGMA(warning(disable : W))

#defineDIAGNOSTIC_PUSHPRAGMA(warning(push))
#defineDIAGNOSTIC_POPPRAGMA(warning(pop))

#elif defined __GNUC__ || defined __clang__

#definePRAGMA(X) _Pragma(#X)
#defineDISABLE_WARNING(W) PRAGMA(GCC diagnostic ignored #W)

#if defined __clang__ || __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)
#defineDIAGNOSTIC_PUSHPRAGMA(GCC diagnostic push)
#defineDIAGNOSTIC_POPPRAGMA(GCC diagnostic pop)
#else
#defineDIAGNOSTIC_PUSH
#defineDIAGNOSTIC_POP
#endif

#else

#definePRAGMA(X)
#defineDISABLE_WARNING(W)

#defineDIAGNOSTIC_PUSH
#defineDIAGNOSTIC_POP

#endif


/*
 On Windows, MSVC issues warnings if public API class definition uses
 another class which is not exported as public API (either as a base class
 or type of member). This is indeed dangerous because client code might get
 the class definition wrong if the non-exported component is not available or
 (worse) is defined in a different way than the same component during connector
 build time.

 We can not completely avoid these warnings because for some API classes we
 use standard C++ library classes as components. For example, we use
 std::shared_ptr<> a lot. We can not modify standard library headers to export
 these classes. As is the common practice, we ignore this issue assuming that
 the code that uses our connector is built with the same C++ runtime
 implementation as the one used to build the connector. To silence the warnings,
 uses of standard library classes in our public API classes should be surrounded
 with DLL_WARNINGS_PUSH/POP macros.
*/

#if defined _MSC_VER

#defineDLL_WARNINGS_PUSH DIAGNOSTIC_PUSH \
DISABLE_WARNING(4251) \
 DISABLE_WARNING(4275)
#defineDLL_WARNINGS_POP DIAGNOSTIC_POP

#else

#defineDLL_WARNINGS_PUSH
#defineDLL_WARNINGS_POP

#endif


/*
 A dirty trick to help Doxygen to process 'enum class' declarations, which
 are not fully supported. Thus we replace them by plain 'enum' when processing
 sources by Doxygen.
*/

#ifdef DOXYGEN
#defineenum_classenum
#else
#defineenum_classenumclass
#endif


/*
 Macro to put at the end of other macros that define lists of items. This is
 another dirty trick for Doxygen to hide from it a documentation of the last
 item in the list. Otherwise, in a situation like this:

 #define ITEM_LIST(X) \
 X(item1) \
 ...
 X(itemN) /##< Doc for last item #/

 Doxegen treats the documentation of the last item as documentation for
 the whole ITEM_LIST() macro. This does not happen if END_LIST is added at
 the end:

 #define ITEM_LIST(X) \
 X(item1) \
 ...
 X(itemN) /##< Doc for last item #/ \
 END_LIST
*/

#defineEND_LIST


#ifdef __cplusplus

namespacemysqlx {
MYSQLX_ABI_BEGIN(2,0)

namespacecommon {

/*
 Convenience for checking numeric limits (to be used when doing numeric
 casts).

 TODO: Maybe more templates are needed for the case where T is a float/double
 type and U is an integer type or vice versa.
*/

template <
typename T, typename U,
typename std::enable_if<std::is_unsigned<U>::value>::type* = nullptr
>
inline
boolcheck_num_limits(U val)
{
using UT = typename std::make_unsigned<T>::type;
return !(val > (UT)std::numeric_limits<T>::max());
}

template <
typename T, typename U,
typename std::enable_if<std::is_unsigned<T>::value>::type* = nullptr,
typename std::enable_if<!std::is_unsigned<U>::value>::type* = nullptr
>
inline
boolcheck_num_limits(U val)
{
return !(val < 0) && !(val > std::numeric_limits<T>::max());
}

template <
typename T, typename U,
typename std::enable_if<!std::is_unsigned<T>::value>::type* = nullptr,
typename std::enable_if<!std::is_unsigned<U>::value>::type* = nullptr
>
inline
boolcheck_num_limits(U val)
{
return
 !((val > std::numeric_limits<T>::max())
 || (val < std::numeric_limits<T>::lowest()));
}

#defineASSERT_NUM_LIMITS(T,V) assert(::mysqlx::common::check_num_limits<T>(V))



inline
std::string to_upper(const std::string &val)
{
using std::transform;

 std::string uc_val;
 uc_val.resize(val.size());
transform(val.begin(), val.end(), uc_val.begin(), ::toupper);
return uc_val;
}

inline
std::string to_lower(const std::string &val)
{
using std::transform;

 std::string uc_val;
 uc_val.resize(val.size());
transform(val.begin(), val.end(), uc_val.begin(), ::tolower);
return uc_val;
}

} // common


namespacecommon {

#ifdef USE_NATIVE_BYTE
using ::byte;
#else
typedefunsignedchar byte;
#endif

classnocopy
 {
public:
nocopy(const nocopy&) = delete;
 nocopy& operator=(const nocopy&) = delete;
protected:
nocopy() {}
 };


classPrintable
 {
virtualvoidprint(std::ostream&) const = 0;
friend std::ostream& operator<<(std::ostream&, const Printable&);
 };

inline
 std::ostream& operator<<(std::ostream &out, const Printable &obj)
 {
 obj.print(out);
return out;
 }


} // common


namespacecommon {

using std::find_if;

/*
 Remove from a container all elements that satisfy the given predicate.
*/

template <classCONT, classPRED>
voidremove_from(CONT &cont, PRED pred)
{
using It = typename CONT::iterator;
 It end = std::remove_if(cont.begin(), cont.end(), pred);
 cont.erase(end, cont.end());
}


} // common
MYSQLX_ABI_END(2,0)
} // mysqlx

#endif// __cplusplus

#endif