Files
externals/linux/include/ActivMiddleware/ActivBase/StringConversion.h
T

625 lines
16 KiB
C++

/**
* @file ActivMiddleware/ActivBase/StringConversion.h
*
* @brief Header file for the StringConversion
*/
#if (!defined ACTIV_BASE_STRING_CONVERSION_H)
#define ACTIV_BASE_STRING_CONVERSION_H
#include "ActivMiddleware/ActivBase/External.h"
#include "ActivMiddleware/CxxYZ/type_traits.h"
#include ACTIV_BOOST_INCLUDE(config.hpp)
#include ACTIV_BOOST_INCLUDE(utility/string_view.hpp)
#if (!defined ACTIV_BOOST_NO_CXX17_HDR_STRING_VIEW)
#include <string_view>
#endif
#if (defined __GLIBCXX__)
#include <ext/vstring_fwd.h>
#include <ext/vstring.h>
#endif
//! Activ namespace.
namespace Activ
{
class IFieldType;
class MessageValidator;
template<typename S>
struct IsStringType : public MakeBoolConstant<
#if (!defined ACTIV_BOOST_NO_CXX17_HDR_STRING_VIEW)
CxxYZ::is_same<std::string_view, typename CxxYZ::decay<S>::type>::value ||
#endif
#if (defined __GLIBCXX__)
CxxYZ::is_same<__gnu_cxx::__vstring, typename CxxYZ::decay<S>::type>::value ||
#endif
CxxYZ::is_same<Boost::string_view, typename CxxYZ::decay<S>::type>::value ||
CxxYZ::is_same<std::string, typename CxxYZ::decay<S>::type>::value ||
CxxYZ::is_same<Boost::container::string, typename CxxYZ::decay<S>::type>::value>
{
};
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename T>
struct IsCharType : public MakeBoolConstant<
CxxYZ::is_integral<T>::value &&
(1 == sizeof(T))>
{
};
// ---------------------------------------------------------------------------------------------------------------------------------
template<typename T>
String TypeToString(const T &value);
// ---------------------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------------------
namespace Detail
{
/**
* @brief Convert a value of an arbitrary non-container type to a string.
*
* @param value
*
* @return The value as a string.
*/
template<typename T>
inline typename CxxYZ::enable_if<
!(
has_type_iterator<T>::value ||
has_member_function_ToString<const T, const String>::value ||
has_member_function_ToString<const T, const String &>::value ||
has_member_function_ToString<const T, String>::value
), String>::type
TypeToStringImpl(const T &value)
{
// Leave up to the user to figure out if they want the char or the integer appended.
ACTIV_BOOST_STATIC_ASSERT((!CxxYZ::is_same<char, T>::value));
try
{
return Boost::lexical_cast<String>(value);
}
catch (const Boost::bad_lexical_cast &)
{
return String("");
}
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a value to a string where T has a ToString function.
*
* @param value
*
* @return The value as a string.
*/
template<typename T>
inline typename CxxYZ::enable_if<
has_member_function_ToString<const T, const String>::value ||
has_member_function_ToString<const T, const String &>::value ||
has_member_function_ToString<const T, String>::value
, String>::type
TypeToStringImpl(const T &value)
{
return value.ToString();
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline String TypeToStringImpl(const int8_t &value)
{
// Otherwise value gets converted to an ascii char.
return TypeToString(static_cast<int32_t>(value));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline String TypeToStringImpl(const uint8_t &value)
{
// Otherwise value gets converted to an ascii char.
return TypeToString(static_cast<uint32_t>(value));
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline String TypeToStringImpl(const String &value)
{
// Simple case.
return value;
}
// ---------------------------------------------------------------------------------------------------------------------------------
inline String TypeToStringImpl(const char * const pStr)
{
return (ACTIV_UNLIKELY(ACTIV_NULLPTR == pStr)) ? String() : String(pStr);
}
// ---------------------------------------------------------------------------------------------------------------------------------
ACTIV_BASE_API String TypeToStringImpl(const double value);
// ---------------------------------------------------------------------------------------------------------------------------------
ACTIV_BASE_API String TypeToStringImpl(const float value);
// ---------------------------------------------------------------------------------------------------------------------------------
#if (defined ACTIV_USING_ALTERNATIVE_STRING)
inline String TypeToStringImpl(const std::string &value)
{
return String(value.data(), value.length());
}
#endif // (defined ACTIV_USING_ALTERNATIVE_STRING)
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a std::pair to a string.
*
* @param value
*
* @return The pair as a string of the form "key=value".
*/
template<typename K, typename V>
String TypeToStringImpl(const std::pair<K, V> &value)
{
String output;
output.append(TypeToString(value.first));
output.append(1, '=');
output.append(TypeToString(value.second));
return output;
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a container to a string.
*
* @param values container with signed integral values
*
* @return The container as a string.
*/
template<typename C>
inline typename CxxYZ::enable_if<(
has_type_iterator<C>::value &&
!CxxYZ::is_unsigned<typename C::value_type>::value
), String>::type
TypeToStringImpl(const C &values)
{
String output;
ACTIV_FOREACH(const typename C::value_type &value, values)
{
if (!output.empty())
output.append(1, ',');
output.append(TypeToString(value));
}
return output;
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert an unsigned integral container to a string of the form "1,2-5,7,10".
*
* @param values container with unsigned integral values
*
* @return The container as a string.
*/
template<typename C>
inline typename CxxYZ::enable_if<(
has_type_iterator<C>::value &&
CxxYZ::is_unsigned<typename C::value_type>::value
), String>::type
TypeToStringImpl(const C &values)
{
typedef typename C::value_type IntegerType;
typedef typename C::const_iterator ConstIterator;
String output;
if (!values.empty())
{
ConstIterator iter = values.begin();
ConstIterator iterEnd = values.end();
do
{
if (!output.empty())
output.append(1, ',');
output.append(TypeToString(*iter));
const IntegerType startValue = *iter;
IntegerType endValue = startValue;
while (iterEnd != ++iter)
{
if (*iter != (endValue + 1))
break;
endValue = *iter;
}
if (startValue != endValue)
{
output.append(1, (endValue == (startValue + 1)) ? ',' : '-');
output.append(TypeToString(endValue));
}
}
while (iter != iterEnd);
}
return output;
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a Boost::dynamic_bitset<> container to a string of the form "1,2-5,7,10" where the numbers
* represent the set bit indexes.
*
* @param value
*
* @return The container as a string.
*/
template<typename B, typename A>
inline String TypeToStringImpl(const Boost::dynamic_bitset<B, A> &value)
{
String output;
if (!value.empty())
{
size_t i = 0;
do
{
if (value.test(i))
{
if (!output.empty())
output.append(1, ',');
output.append(TypeToString(i));
const size_t startValue = i;
size_t endValue = startValue;
while (++i < value.size())
{
if (!value.test(i))
break;
endValue = i;
}
if (startValue != endValue)
{
output.append(1, (endValue == (startValue + 1)) ? ',' : '-');
output.append(TypeToString(endValue));
}
}
else
{
++i;
}
}
while (i < value.size());
}
return output;
}
} // namespace Detail
// ---------------------------------------------------------------------------------------------------------------------------------
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert an arbitrarily typed value to a string.
*
* @param value
*
* @return The value as a string.
*/
template<typename T>
inline String TypeToString(const T &value)
{
return Activ::Detail::TypeToStringImpl(value);
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a char buffer to a non-integral, non-char type..
*
* @param pStr the pointer to the start of the buffer to convert.
* @param length the length of the buffer to convert.
* @param target to receive the value.
*
* @return true if conversion was successful.
*/
template <typename T>
inline typename CxxYZ::enable_if<
!IsIntegral<T>::value &&
!has_member_function_FromString<StatusCode (T::*) (MessageValidator &)>::value,
bool>::type
StringToType(const char * const pStr, const size_t length, T &target)
{
try
{
target = Boost::lexical_cast<T>(pStr, length);
}
catch (Boost::bad_lexical_cast &)
{
return false;
}
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a char buffer to an arbitrary non-container, non-unsigned and non-floating point type.
*
* @param pStr the pointer to the start of the buffer to convert.
* @param length the length of the buffer to convert.
* @param t to receive the value.
*
* @return true if conversion was successful.
*/
template <typename T>
inline typename CxxYZ::enable_if<(
IsIntegral<T>::value &&
!IsCharType<T>::value
), bool>::type
StringToType(const char * const pStr, const size_t length, T &t)
{
if (ACTIV_UNLIKELY((ACTIV_NULLPTR == pStr) || (0 == length)))
return false;
if (IsUnsigned<T>::value && ACTIV_UNLIKELY(!::isdigit(pStr[0])))
return false;
try
{
t = Boost::lexical_cast<T>(pStr, length);
}
catch (Boost::bad_lexical_cast &)
{
return false;
}
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a char buffer to a 1 bytes length integer.
*
* @param pStr the pointer to the start of the buffer to convert.
* @param length the length of the buffer to convert.
* @param target to receive the value.
*
* @return true if conversion was successful.
*/
template <typename T>
inline typename CxxYZ::enable_if<
IsCharType<T>::value,
bool>::type
StringToType(const char * const pStr, const size_t length, T &target)
{
typename LengthToIntegralType<2, CxxYZ::is_signed<T>::value>::Type tmp;
if (!StringToType(pStr, length, tmp))
return false;
if (!InRangeOfIntegralType<T>()(tmp))
return false;
target = static_cast<T>(tmp);
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
ACTIV_BASE_API bool StringToType(const char * const pStr, const size_t length, IFieldType &target);
// ---------------------------------------------------------------------------------------------------------------------------------
ACTIV_BASE_API bool StringToType(const char * const pStr, const size_t length, double &target);
// ---------------------------------------------------------------------------------------------------------------------------------
ACTIV_BASE_API bool StringToType(const char * const pStr, const size_t length, float &target);
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a char buffer to an arbitrary type.
* @brief Wrapper ensuring compatibility with existing call which worked thanks to implicit conversion to Activ::String
*
* @param pStr the pointer to the start of the buffer to convert.
* @param t to receive the value.
*
* @return true if conversion was successful.
*/
template <typename T>
inline bool StringToType(const char * pStr, T &t)
{
return StringToType(pStr, strlen(pStr), t);
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Wrapper to set of methods converting a string-like type to an arbitrary non-container type
*
* @param str the string to convert.
* @param t to receive the value.
*
* @return true if conversion was successful.
*/
template <typename S, typename T>
inline typename CxxYZ::enable_if<(
!has_type_iterator<T>::value &&
IsStringType<S>::value
), bool>::type
StringToType(const S &str, T &t)
{
return StringToType(str.data(), str.length(), t);
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a string-like type to a String.
*
* @param str the string-like object to convert.
* @param target to receive the value.
*
* @return true if conversion was successful.
*/
template <typename S>
inline typename CxxYZ::enable_if<
IsStringType<S>::value
, bool>::type
StringToType(const S &str, String &target)
{
target = String(str.data(), str.length());
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a string-like type to a container of an arbitrary type.
*
* @param str the string to convert.
* @param target to receive the value.
*
* @return true if conversion was successful.
*/
template<typename S, typename C>
inline typename CxxYZ::enable_if<(
IsStringType<S>::value &&
has_type_iterator<C>::value &&
!CxxYZ::is_unsigned<typename C::value_type>::value
), bool>::type
StringToType(const S &str, C &target)
{
std::vector<String> stringList;
Boost::algorithm::split(stringList, str, Boost::is_any_of(","), Boost::token_compress_on);
ACTIV_FOREACH(const String &string, stringList)
{
typename C::value_type value;
if (!StringToType(string, value))
return false;
target.insert(target.end(), value);
}
return true;
}
// ---------------------------------------------------------------------------------------------------------------------------------
/**
* @brief Convert a string-like type of the form "1,2-5,7,10" to a container of an unsigned integrals.
*
* @param str the string to convert.
* @param target to receive the value.
*
* @return true if conversion was successful.
*/
template<typename S, typename C>
inline typename CxxYZ::enable_if<(
IsStringType<S>::value &&
has_type_iterator<C>::value &&
CxxYZ::is_unsigned<typename C::value_type>::value
), bool>::type
StringToType(const S &str, C &target)
{
typedef typename C::value_type TYPE;
std::vector<String> stringList;
if (!StringToType(str, stringList))
return false;
ACTIV_FOREACH(const String &token, stringList)
{
if (token.empty())
continue;
// Could be a range of values (N-M).
// N or M may be negative so skip the first char, the next occurence must be the range separator.
const size_t rangeSeparatorPosition = token.find('-', 1);
if (String::npos != rangeSeparatorPosition)
{
TYPE startValue;
if (!StringToType(token.substr(0, rangeSeparatorPosition), startValue))
return false;
TYPE endValue;
if (!StringToType(token.substr(rangeSeparatorPosition + 1), endValue))
return false;
// Convert a descending range to ascending.
if (startValue <= endValue)
{
for (; startValue <= endValue; ++startValue)
target.insert(target.end(), startValue);
}
else
{
for (; startValue >= endValue; --startValue)
target.insert(target.end(), startValue);
}
}
else
{
TYPE value;
if (!StringToType(token, value))
return false;
target.insert(target.end(), value);
}
}
return true;
}
} // namespace Activ
#endif // (defined ACTIV_BASE_STRING_CONVERSION_H)