source: NonGTP/FCollada/FUtils/FUStringConversion.h @ 964

/*
        Copyright (C) 2005-2006 Feeling Software Inc.
        MIT License: http://www.opensource.org/licenses/mit-license.php
*/
/*
        Based on the FS Import classes:
        Copyright (C) 2005-2006 Feeling Software Inc
        Copyright (C) 2005-2006 Autodesk Media Entertainment
        MIT License: http://www.opensource.org/licenses/mit-license.php
*/

/**
        @file FUStringConversion.h
        This file contains the FUStringConversion class.
*/

#ifndef _FCU_STRING_CONVERSION_
#define _FCU_STRING_CONVERSION_

class FUDateTime;

/**
        Common string conversion.

        This static class contains the parsing function for Unicode and 8-bit/UTF-8
        strings into common data types: integers, booleans, floating-point values,
        vectors, matrices, date-time, etc. and dynamically-sized array of these types.

        This class can also convert common data types into an 8-bit or a Unicode string and 
        it contains conversion functions to convert string between 8-bit and Unicode.

        @ingroup FUtils
*/
class FCOLLADA_EXPORT FUStringConversion
{
private: FUStringConversion() {}
public:
        /** Converts a 8-bit string to a Unicode string.
                @param value The 8-bit string.
                @return The converted Unicode string. */
        static fstring ToFString(const char* value);
        inline static fstring ToFString(const string& value) { return ToFString(value.c_str()); } /**< See above. */

        /** Converts an Unicode string to a 8-bit string.
                @param value The Unicode string.
                @return The converted 8-bit string. */
        static string ToString(const fchar* value);
        inline static string ToString(const fstring& value) { return ToString(value.c_str()); } /**< See above. */

        /** Parses a string into a boolean value.
                @param value The string.
                @return The parsed boolean value. */
        static bool ToBoolean(const char* value);
        inline static bool ToBoolean(const string& value) { return ToBoolean(value.c_str()); } /**< See above. */
#ifdef UNICODE
        static bool ToBoolean(const fchar* value); /**< See above. */
        inline static bool ToBoolean(const fstring& value) { return ToBoolean(value.c_str()); } /**< See above. */
#endif

        /** Parses a string into a floating-point value.
                @param value The string. For the string pointer versions of this function,
                        the pointer will point to the last processed characters after the parsing.
                @return The parsed floating-point value. */
        static float ToFloat(const char** value);
        inline static float ToFloat(const char* value) { return ToFloat(&value); } /**< See above. */
        inline static float ToFloat(const string& value) { return ToFloat(value.c_str()); } /**< See above. */
#ifdef UNICODE
        static float ToFloat(const fchar** value); /**< See above. */
        inline static float ToFloat(const fstring& value) { return ToFloat(value.c_str()); } /**< See above. */
        inline static float ToFloat(const fchar* value) { return ToFloat(&value); } /**< See above. */
#endif

        /** Parses a string into a signed integer.
                @param value The string. For the string pointer versions of this function,
                        the pointer will point to the last processed characters after the parsing.
                @return The parsed signed integer. */
        static int32 ToInt32(const char** value);
        inline static int32 ToInt32(const char* value) { return ToInt32(&value); } /**< See above. */
        inline static int32 ToInt32(const string& value) { return ToInt32(value.c_str()); } /**< See above. */
#ifdef UNICODE
        static int32 ToInt32(const fchar** value); /**< See above. */
        inline static int32 ToInt32(const fchar* value) { return ToInt32(&value); } /**< See above. */
        inline static int32 ToInt32(const fstring& value) { return ToInt32(value.c_str()); } /**< See above. */
#endif

        /** Parses a string into an unsigned integer.
                @param value The string. For the string pointer versions of this function,
                        the pointer will point to the last processed characters after the parsing.
                @return The parsed unsigned integer. */
        static uint32 ToUInt32(const char** value);
        inline static uint32 ToUInt32(const char* value) { return ToUInt32(&value); } /**< See above. */
        inline static uint32 ToUInt32(const string& value) { return ToUInt32(value.c_str()); } /**< See above. */
#ifdef UNICODE
        static uint32 ToUInt32(const fchar** value); /**< See above. */
        inline static uint32 ToUInt32(const fchar* value) { return ToUInt32(&value); } /**< See above. */
        inline static uint32 ToUInt32(const fstring& value) { return ToUInt32(value.c_str()); } /**< See above. */
#endif

        /** Parses a string into an unsigned integer. The string is assumed to have
                an unsigned integer in hexadecimal format.
                @param value The string. For the string pointer versions of this function,
                        the pointer will point to the last processed characters after the parsing.
                @param count The maxmimum number of characters to parse.
                        For example, a count of 2 will read in an 8-bit character.
                @return The parsed unsigned integer. */
        static uint32 HexToUInt32(const char** value, uint32 count=UINT_MAX);
        inline static uint32 HexToUInt32(const char* value, uint32 count=UINT_MAX) { return HexToUInt32(&value, count); } /**< See above. */
        inline static uint32 HexToUInt32(const string& value, uint32 count=UINT_MAX) { return HexToUInt32(value.c_str(), count); } /**< See above. */
#ifdef UNICODE
        static uint32 HexToUInt32(const fchar** value, uint32 count=UINT_MAX); /**< See above. */
        inline static uint32 HexToUInt32(const fchar* value, uint32 count=UINT_MAX) { return HexToUInt32(&value, count); } /**< See above. */
        inline static uint32 HexToUInt32(const fstring& value, uint32 count=UINT_MAX) { return HexToUInt32(value.c_str(), count); } /**< See above. */
#endif

        /** Parses a string into a 3D vector.
                @param value The string. For the string pointer versions of this function,
                        the pointer will point to the last processed characters after the parsing.
                @param lengthFactor An optional factor that will scale the 3D vector.
                @return The parsed 3D vector. */
        static FMVector3 ToPoint(const char** value, float lengthFactor=1.0f);
        inline static FMVector3 ToPoint(const char* value, float lengthFactor=1.0f) { return ToPoint(&value, lengthFactor); } /**< See above. */
        inline static FMVector3 ToPoint(const string& value, float lengthFactor=1.0f) { return ToPoint(value.c_str(), lengthFactor); } /**< See above. */
#ifdef UNICODE
        static FMVector3 ToPoint(const fchar** value, float lengthFactor=1.0f); /**< See above. */
        inline static FMVector3 ToPoint(const fchar* value, float lengthFactor=1.0f) { return ToPoint(&value, lengthFactor); } /**< See above. */
        inline static FMVector3 ToPoint(const fstring& value, float lengthFactor=1.0f) { return ToPoint(value.c_str(), lengthFactor); } /**< See above. */
#endif

        /** Parses a string into a 4x4 matrix.
                @param value The string. For the string pointer versions of this function,
                        the pointer will point to the last processed characters after the parsing.
                @param mx The matrix to be filled in.
                @param lengthFactor An optional factor that will scale the translation column
                        of the matrix. */
        static void ToMatrix(const char** value, FMMatrix44& mx, float lengthFactor=1.0f);
        inline static void ToMatrix(const char* value, FMMatrix44& mx, float lengthFactor=1.0f) { return ToMatrix(&value, mx, lengthFactor); } /**< See above. */
        inline static void ToMatrix(const string& value, FMMatrix44& mx, float lengthFactor=1.0f) { return ToMatrix(value.c_str(), mx, lengthFactor); } /**< See above. */
#ifdef UNICODE
        static void ToMatrix(const fchar** value, FMMatrix44& mx, float lengthFactor=1.0f); /**< See above. */
        inline static void ToMatrix(const fchar* value, FMMatrix44& mx, float lengthFactor=1.0f) { return ToMatrix(&value, mx, lengthFactor); } /**< See above. */
        inline static void ToMatrix(const fstring& value, FMMatrix44& mx, float lengthFactor=1.0f) { return ToMatrix(value.c_str(), mx, lengthFactor); } /**< See above. */
#endif

        /** Parses a string into a datetime structure.
                @param value The string.
                @param dateTime The datetime structure to fill in. */
        static void ToDateTime(const char* value, FUDateTime& dateTime);
        inline static void ToDateTime(const string& value, FUDateTime& dateTime) { return ToDateTime(value.c_str(), dateTime); } /**< See above. */
#ifdef UNICODE
        static void ToDateTime(const fchar* value, FUDateTime& dateTime); /**< See above. */
        inline static void ToDateTime(const fstring& value, FUDateTime& dateTime) { return ToDateTime(value.c_str(), dateTime); } /**< See above. */
#endif

#ifdef HAS_VECTORTYPES

        /** Splits a string into multiple substrings.
                The separator used here are the white-spaces.
                @param value The string.
                @param array A list of strings that will be filled in. */
        static void ToFStringList(const fstring& value, FStringList& array);
        static void ToStringList(const string& value, StringList& array); /**< See above. */
#ifdef UNICODE
        static void ToStringList(const fchar* value, StringList& array); /**< See above. */
        inline static void ToStringList(const fstring& value, StringList& array) { return ToStringList(value.c_str(), array); } /**< See above. */
#endif

        /** Parses a string into a list of floating point values.
                @param value The string.
                @param array The list of floating point values to fill in. */
        static void ToFloatList(const char* value, FloatList& array);
        inline static void ToFloatList(const string& value, FloatList& array) { return ToFloatList(value.c_str(), array); } /**< See above. */
#ifdef UNICODE
        static void ToFloatList(const fchar* value, FloatList& array); /**< See above. */
        inline static void ToFloatList(const fstring& value, FloatList& array) { return ToFloatList(value.c_str(), array); } /**< See above. */
#endif

        /** Parses a string into a list of signed integers.
                @param value The string.
                @param array The list of signed integers to fill in. */
        static void ToInt32List(const char* value, Int32List& array);
        inline static void ToInt32List(const string& value, Int32List& array) { return ToInt32List(value.c_str(), array); } /**< See above. */
#ifdef UNICODE
        static void ToInt32List(const fchar* value, Int32List& array); /**< See above. */
        inline static void ToInt32List(const fstring& value, Int32List& array) { return ToInt32List(value.c_str(), array); } /**< See above. */
#endif

        /** Parses a string into a list of unsigned integers.
                @param value The string.
                @param array The list of unsigned integers to fill in. */
        static void ToUInt32List(const char* value, UInt32List& array);
        inline static void ToUInt32List(const string& value, UInt32List& array) { return ToUInt32List(value.c_str(), array); } /**< See above. */
#ifdef UNICODE
        static void ToUInt32List(const fchar* value, UInt32List& array); /**< See above. */
        inline static void ToUInt32List(const fstring& value, UInt32List& array) { return ToUInt32List(value.c_str(), array); } /**< See above. */
#endif

        /** Parses a string containing interleaved floating-point values.
                The values will be stored in multiple, independent lists.
                @param value The string containing interleaved floating-point values.
                @param arrays The lists of floating-point values to fill in. */
        static void ToInterleavedFloatList(const char* value, const vector<FloatList*>& arrays);
        inline static void ToInterleavedFloatList(const string& value, const vector<FloatList*>& arrays) { return ToInterleavedFloatList(value.c_str(), arrays); } /**< See above. */
#ifdef UNICODE
        static void ToInterleavedFloatList(const fchar* value, const vector<FloatList*>& arrays); /**< See above. */
        inline static void ToInterleavedFloatList(const fstring& value, const vector<FloatList*>& arrays) { return ToInterleavedFloatList(value.c_str(), arrays); } /**< See above. */
#endif

        /** Parses a string into a list of matrices.
                @param value The string.
                @param array The list of matrices to fill in.
                @param lengthFactor An optional factor that will scale the translation column
                        of the matrices. */
        static void ToMatrixList(const char* value, FMMatrix44List& array, float lengthFactor=1.0f);
        inline static void ToMatrixList(const string& value, FMMatrix44List& array, float lengthFactor=1.0f) { return ToMatrixList(value.c_str(), array, lengthFactor); } /**< See above. */
#ifdef UNICODE
        static void ToMatrixList(const fchar* value, FMMatrix44List& array, float lengthFactor=1.0f); /**< See above. */
        inline static void ToMatrixList(const fstring& value, FMMatrix44List& array, float lengthFactor=1.0f) { return ToMatrixList(value.c_str(), array, lengthFactor); } /**< See above. */
#endif

        /** Parses a string into a list of 3D points.
                @param value The string.
                @param array The list of 3D points to fill in.
                @param lengthFactor An optional factor that will scale the points. */
        static void ToPointList(const char* value, FMVector3List& array, float lengthFactor=1.0f);
        inline static void ToPointList(const string& value, FMVector3List& array, float lengthFactor=1.0f) { return ToPointList(value.c_str(), array, lengthFactor); } /**< See above. */
#ifdef UNICODE
        static void ToPointList(const fchar* value, FMVector3List& array, float lengthFactor=1.0f); /**< See above. */
        inline static void ToPointList(const fstring& value, FMVector3List& array, float lengthFactor=1.0f) { return ToPointList(value.c_str(), array, lengthFactor); } /**< See above. */
#endif

        /** Converts a list of floating-point values into a string.
                @param builder The string builder that will contain the list of values.
                        This string builder is not cleared of its contents and a space
                        character will be added if it is not empty.
                @param values The list of floating-point values to convert.
                @param lengthFactor An optional factor that will scale all the
                        floating-point values. */
        static void ToString(FUSStringBuilder& builder, const FloatList& values, float lengthFactor=1.0f);

        /** Converts a list of signed integers into a string.
                @param builder The string builder that will contain the list of values.
                        This string builder is not cleared of its contents and a space
                        character will be added if it is not empty.
                @param values The list of signed integers to convert. */
        static void ToString(FUSStringBuilder& builder, const Int32List& values);

        /** Converts a list of unsigned integers into a string.
                @param builder The string builder that will contain the list of values.
                        This string builder is not cleared of its contents and a space
                        character will be added if it is not empty.
                @param values The list of unsigned integers to convert. */
        static void ToString(FUSStringBuilder& builder, const UInt32List& values);

#endif // HAS_VECTORTYPES

        /** Converts a 4D vector into a string.
                @param p The 4D vector to convert.
                @param lengthFactor An optional factor that will scale the vector.
                @return The string containing the converted vector. */
        static string ToString(const FMVector4& p, float lengthFactor=1.0f);

        /** Converts a matrix into a string.
                @param value The matrix to convert.
                @param lengthFactor An optional factor that will scale the translation
                        column of the matrix.
                @return The string containing the converted matrix. */
        static string ToString(const FMMatrix44& value, float lengthFactor=1.0f);
        static fstring ToFString(const FMMatrix44& value, float lengthFactor=1.0f); /**< See above. */

        /** Converts a 3D vector into a string.
                @param value The 3D vector to convert.
                @param lengthFactor An optional factor that will scale the vector.
                @return The string containing the converted vector. */
        static string ToString(const FMVector3& value, float lengthFactor=1.0f);
        static fstring ToFString(const FMVector3& value, float lengthFactor=1.0f); /**< See above. */

        /** Converts a datetime structure into a string.
                @param dateTime The datetime structure to convert.
                @return The string containing the converted datetime structure. */
        static string ToString(const FUDateTime& dateTime);
        static fstring ToFString(const FUDateTime& dateTime); /**< See above. */

        /** Converts a primitive value into a string.
                This function is templatized to use the global string builders to
                convert most primitive value types, such as signed integers,
                unsigned integers and single floating-point values, into strings.
                @see FUStringBuilderT
                @param value A primitive value.
                @return The string containing the converted primitive value. */
        template <typename T> static string ToString(const T& value) { globalSBuilder.set(value); return globalSBuilder.ToString(); }
        template <typename T> static fstring ToFString(const T& value) { globalBuilder.set(value); return globalBuilder.ToString(); } /**< See above. */

        /** Converts a matrix into a string.
                @param builder The string builder that will contain the matrix.
                        This string builder is not cleared of its contents.
                @param value The matrix to convert.
                @param lengthFactor An optional factor that will scale the translation
                        column of the matrix. */
        static void ToString(FUSStringBuilder& builder, const FMMatrix44& value, float lengthFactor=1.0f);
        static void ToFString(FUStringBuilder& builder, const FMMatrix44& value, float lengthFactor=1.0f); /**< See above. */

        /** Converts a 3D vector into a string.
                @param builder The string builder that will contain the 3D vector.
                        This string builder is not cleared of its contents.
                @param value The 3D vector to convert.
                @param lengthFactor An optional factor that will scale the vector. */
        static void ToString(FUSStringBuilder& builder, const FMVector3& value, float lengthFactor=1.0f);
        static void ToFString(FUStringBuilder& builder, const FMVector3& value, float lengthFactor=1.0f); /**< See above. */

        /** Converts a 4D vector into a string.
                @param builder The string builder that will contain the 4D vector.
                        This string builder is not cleared of its contents.
                @param p The 4D vector to convert.
                @param lengthFactor An optional factor that will scale the vector. */
        static void ToString(FUSStringBuilder& builder, const FMVector4& p, float lengthFactor=1.0f);
};

#endif // _FCU_STRING_CONVERSION_