xsstring.h

Go to the documentation of this file.

 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
 
//  Copyright (c) 2003-2021 Xsens Technologies B.V. or subsidiaries worldwide.
//  All rights reserved.
//  
//  Redistribution and use in source and binary forms, with or without modification,
//  are permitted provided that the following conditions are met:
//  
//  1.  Redistributions of source code must retain the above copyright notice,
//      this list of conditions, and the following disclaimer.
//  
//  2.  Redistributions in binary form must reproduce the above copyright notice,
//      this list of conditions, and the following disclaimer in the documentation
//      and/or other materials provided with the distribution.
//  
//  3.  Neither the names of the copyright holders nor the names of their contributors
//      may be used to endorse or promote products derived from this software without
//      specific prior written permission.
//  
//  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
//  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
//  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
//  THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
//  SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
//  OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
//  HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY OR
//  TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
//  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.THE LAWS OF THE NETHERLANDS 
//  SHALL BE EXCLUSIVELY APPLICABLE AND ANY DISPUTES SHALL BE FINALLY SETTLED UNDER THE RULES 
//  OF ARBITRATION OF THE INTERNATIONAL CHAMBER OF COMMERCE IN THE HAGUE BY ONE OR MORE 
//  ARBITRATORS APPOINTED IN ACCORDANCE WITH SAID RULES.
//  
 
#ifndef XSSTRING_H
#define XSSTRING_H
 
#include "xstypesconfig.h"
#include "xsarray.h"
#ifndef XSENS_NO_WCHAR
        #include <wchar.h>
#endif // XSENS_NO_WCHAR
#include <string.h>
 
#ifdef __cplusplus
#include <string>
#include <cstdlib>
#include <cstdio>
extern "C" {
#endif
 
extern XsArrayDescriptor const XSTYPES_DLL_API g_xsStringDescriptor;
 
#ifndef __cplusplus
#define XsString_INITIALIZER    XSARRAY_INITIALIZER(&g_xsStringDescriptor)
XSARRAY_STRUCT(XsString, char);
typedef struct XsString XsString;
// obsolete:
#define XSSTRING_INITIALIZER    XsString_INITIALIZER
#else
struct XsString;
#endif
 
XSTYPES_DLL_API void XsString_construct(XsString* thisPtr);
XSTYPES_DLL_API void XsString_destruct(XsString* thisPtr);
XSTYPES_DLL_API void XsString_assign(XsString* thisPtr, XsSize count, const char* src);
XSTYPES_DLL_API void XsString_assignCharArray(XsString* thisPtr, const char* src);
XSTYPES_DLL_API void XsString_resize(XsString* thisPtr, XsSize count);
XSTYPES_DLL_API void XsString_append(XsString* thisPtr, XsString const* other);
XSTYPES_DLL_API void XsString_erase(XsString* thisPtr, XsSize index, XsSize count);
XSTYPES_DLL_API void XsString_push_back(XsString* thisPtr, char c);
XSTYPES_DLL_API XsSize XsString_utf8Len(XsString const* thisPtr);
XSTYPES_DLL_API int XsString_endsWith(XsString const* thisPtr, XsString const* other, int caseSensitive);
XSTYPES_DLL_API int XsString_startsWith(XsString const* thisPtr, XsString const* other, int caseSensitive);
XSTYPES_DLL_API int XsString_contains(XsString const* thisPtr, XsString const* other, int caseSensitive, XsSize* offset);
XSTYPES_DLL_API int XsString_empty(XsString const* thisPtr);
XSTYPES_DLL_API void XsString_sort(XsString* thisPtr);
XSTYPES_DLL_API void XsString_reverse(XsString* thisPtr);
XSTYPES_DLL_API ptrdiff_t XsString_findSubStr(XsString const* thisPtr, XsString const* needle);
XSTYPES_DLL_API void XsString_mid(XsString* thisPtr, XsString const* source, XsSize start, XsSize count);
XSTYPES_DLL_API void XsString_replaceAll(XsString* thisPtr, XsString const* src, XsString const* dst);
XSTYPES_DLL_API void XsString_trimmed(XsString* thisPtr, XsString const* source);
 
#ifndef XSENS_NO_WCHAR
XSTYPES_DLL_API XsSize XsString_copyToWCharArray(const XsString* thisPtr, wchar_t* dest, XsSize size);
XSTYPES_DLL_API wchar_t XsString_utf8At(const XsString* thisPtr, XsSize index);
XSTYPES_DLL_API void XsString_assignWCharArray(XsString* thisPtr, const wchar_t* src);
XSTYPES_DLL_API void XsString_push_backWChar(XsString* thisPtr, wchar_t c);
#endif // XSENS_NO_WCHAR
 
#ifndef __cplusplus
// obsolete:
#define XsString_copy(thisPtr, copy)    XsArray_copy(copy, thisPtr)
#define XsString_swap(a, b)                             XsArray_swap(a, b)
#endif
#ifdef __cplusplus
} // extern "C"
#endif
 
#ifdef __cplusplus
/*  We need some special template implementations for strings to keep them 0-terminated
*/
// this typedef is not _always_ interpreted correctly by doxygen, hence the occasional function where we're NOT using it.
typedef XsArrayImpl<char, g_xsStringDescriptor, XsString> XsStringType;
 
template<> inline XsSize XsStringType::size() const noexcept
{
        return m_size ? m_size - 1 : 0;
}
 
template<> inline void XsStringType::reserve(XsSize count)
{
        if (count)
                XsArray_reserve(this, count + 1);
        else
                XsArray_reserve(this, 0);
}
 
template<> inline XsSize XsStringType::reserved() const
{
        return m_reserved ? m_reserved - 1 : 0;
}
 
template<> inline void XsStringType::erase(XsSize index, XsSize count)
{
        XsString_erase((XsString*) this, index, count);
}
 
template<> inline void XsArrayImpl<char, g_xsStringDescriptor, XsString>::insert(char const* items, XsSize index, XsSize count)
{
        if (size())
        {
                if (index >= size())
                        index = size();
                XsArray_insert(this, index, count, items);
        }
        else
                XsString_assign((XsString*) this, count, items);
}
 
template<> inline void XsArrayImpl<char, g_xsStringDescriptor, XsString>::assign(XsSize count, char const* src)
{
        XsString_assign((XsString*) this, count, src);
}
 
template<> inline void XsArrayImpl<char, g_xsStringDescriptor, XsString>::resize(XsSize count)
{
        XsString_resize((XsString*) this, count);
}
 
template<> inline void XsArrayImpl<char, g_xsStringDescriptor, XsString>::setSize(XsSize count)
{
        if (count != size())
                XsString_assign((XsString*) this, count, 0);
}
 
template<> inline void XsArrayImpl<char, g_xsStringDescriptor, XsString>::append(const XsStringType& other)
{
        XsString_append((XsString*) this, (XsString const*) &other);
}
 
struct XsString : public XsStringType
{
        inline explicit XsString(XsSize sz = 0, char const* src = 0)
                : XsStringType()
        {
                if (sz || src)
                        XsString_assign(this, sz, src);
        }
 
#ifndef SWIG
        inline XsString(const XsStringType& other)
                : XsStringType(other)
        {
        }
#else
        inline XsString(const XsString& other)
                : XsStringType(other)
        {
        }
#endif
 
        inline explicit XsString(char* ref, XsSize sz, XsDataFlags flags /* = XSDF_None */)
                : XsStringType(ref, sz + 1, flags)
        {
        }
#ifndef XSENS_NOITERATOR
        template <typename Iterator>
        inline explicit XsString(Iterator const& beginIt, Iterator const& endIt)
                : XsStringType(beginIt, endIt)
        {
        }
#endif
 
        inline XsString(char const* src)
                : XsStringType()
        {
                if (src && src[0])
                        XsString_assignCharArray(this, src);
        }
 
#ifndef XSENS_NO_WCHAR
        inline XsString(wchar_t const* src)
                : XsStringType()
        {
                if (src && src[0])
                        XsString_assignWCharArray(this, src);
        }
#endif
 
#ifndef XSENS_NO_STL
        inline XsString(std::string const& src)
                : XsStringType()
        {
                if (!src.empty())
                        XsString_assign(this, (XsSize)src.size() + 1, src.c_str());
        }
 
        inline XsString(std::wstring const& src)
                : XsStringType()
        {
                if (!src.empty())
                        XsString_assignWCharArray(this, src.c_str());
        }
#endif // XSENS_NO_STL
 
        inline char* c_str()
        {
                static const char nullChar = 0;
                if (empty())
                        return const_cast<char*>(&nullChar);
#ifdef XSENS_NO_EXCEPTION
                try
                {
                        return begin().operator ->();
                }
                catch (...)
                {
                        return const_cast<char*>(&nullChar);
                }
#else
                return begin().operator->();
#endif
        }
 
        inline char const* c_str() const
        {
                static const char nullChar = 0;
                if (empty())
                        return &nullChar;
#ifdef XSENS_NO_EXCEPTION
                try
                {
                        return begin().operator ->();
                }
                catch (...)
                {
                        return &nullChar;
                }
#else
                return begin().operator->();
#endif
        }
 
#ifndef XSENS_NO_STL
        inline std::string toStdString() const
        {
                if (empty())
                        return std::string();
                return std::string((char const*)begin().operator ->());
        }
#endif // XSENS_NO_STL
 
        XsString operator + (XsString const& other) const
        {
                XsString tmp;
                tmp.reserve(size() + other.size());
                tmp.append(*this);
                tmp.append(other);
                return tmp;
        }
 
#ifndef XSENS_NO_STL
        std::wstring toStdWString() const
        {
                if (empty())
                        return std::wstring();
                size_t s = XsString_copyToWCharArray(this, NULL, 0);
                std::wstring w;
                w.resize(s - 1);
                (void) XsString_copyToWCharArray(this, &w[0], (XsSize)s);
                return w;
        }
#endif // XSENS_NO_STL
 
        using XsStringType::operator ==;
        using XsStringType::operator !=;
#ifndef XSENS_NOITERATOR
        using XsStringType::operator <<;
#endif
 
        inline bool operator == (char const* str) const
        {
                if (!str)
                        return empty();
                return !strcmp(c_str(), str);
        }
 
        inline bool operator == (XsString const& str) const
        {
                return XsStringType::operator ==(str);
        }
 
        inline bool operator != (char const* str) const
        {
                return !(*this == str);
        }
 
        inline bool operator != (XsString const& str) const
        {
                return !(*this == str);
        }
 
        inline XsString& operator << (char const* str)
        {
                if (str && str[0])
                {
                        XsString const ref(const_cast<char*>(str), (XsSize)strlen(str), XSDF_None);
                        append(ref);
                }
                return *this;
        }
 
        inline XsString& operator << (int i)
        {
                char buffer[32];
                XSENS_MSC_WARNING_SUPPRESS(4996)
                append(XsString(buffer, (XsSize)(ptrdiff_t) std::sprintf(buffer, "%d", i), XSDF_None));
                return *this;
        }
 
        inline XsString& operator << (XsString const& s)
        {
                append(s);
                return *this;
        }
 
        inline bool operator < (const XsString& str) const
        {
#ifdef XSENS_NO_STL
                return (strcmp(c_str(), str.c_str()) < 0);
#else
                return (this->toStdString() < str.toStdString());
#endif
        }
 
        inline bool operator > (const XsString& str) const
        {
#ifdef XSENS_NO_STL
                return (strcmp(c_str(), str.c_str()) > 0);
#else
                return (this->toStdString() > str.toStdString());
#endif
        }
 
#ifndef SWIG
 
        friend inline void swap(XsString& first, XsString& second)
        {
                first.swap(second);
        }
#endif
 
        inline XsString& push_back(char c)
        {
                XsString_push_back(this, c);
                return *this;
        }
 
        inline bool empty() const
        {
                return !!XsString_empty(this);
        }
 
#ifndef SWIG
        using XsStringType::append;
#else
        void append(XsString const& other)
        {
                XsStringType::append(other);
        }
#endif
 
        inline void append(char const* other)
        {
                if (other)
                {
                        XsString tmp(other);
                        XsString_append(this, &tmp);
                }
        }
 
#ifndef XSENS_NO_WCHAR
        inline void append(wchar_t const* other)
        {
                if (other)
                {
                        XsString tmp(other);
                        XsString_append(this, &tmp);
                }
        }
#endif
 
        inline XsSize utf8Len() const
        {
                return XsString_utf8Len(this);
        }
 
        inline bool endsWith(XsString const& other, bool caseSensitive = false) const
        {
                return 0 != XsString_endsWith(this, &other, caseSensitive ? 1 : 0);
        }
 
        inline bool startsWith(XsString const& other, bool caseSensitive = false) const
        {
                return 0 != XsString_startsWith(this, &other, caseSensitive ? 1 : 0);
        }
 
        inline bool contains(XsString const& other, bool caseSensitive = false, XsSize* offset = 0) const
        {
                return 0 != XsString_contains(this, &other, caseSensitive ? 1 : 0, offset);
        }
 
#ifndef XSENS_NO_WCHAR
 
        inline wchar_t utf8At(XsSize index) const
        {
                return XsString_utf8At(this, index);
        }
 
        inline XsString& push_back(wchar_t c)
        {
                XsString_push_backWChar(this, c);
                return *this;
        }
#endif
 
        inline void sort()
        {
                XsString_sort(this);
        }
 
        inline void reverse()
        {
                XsString_reverse(this);
        }
 
        inline ptrdiff_t findSubStr(XsString const& needle) const
        {
                return XsString_findSubStr(this, &needle);
        }
 
        inline XsString mid(XsSize start, XsSize count) const
        {
                XsString rv;
                XsString_mid(&rv, this, start, count);
                return rv;
        }
 
        inline void replaceAll(XsString const& src, XsString const& dst)
        {
                XsString_replaceAll(this, &src, &dst);
        }
 
        inline XsString replacedAll(XsString const& src, XsString const& dst) const
        {
                XsString rv(*this);
                XsString_replaceAll(&rv, &src, &dst);
                return rv;
        }
 
        inline void trim()
        {
                XsString rv;
                XsString_trimmed(&rv, this);
                swap(rv);
        }
 
        inline XsString trimmed() const
        {
                XsString rv;
                XsString_trimmed(&rv, this);
                return rv;
        }
 
        inline char last() const
        {
                if (size())
                        return at(size() - 1);
                return 0;
        }
 
};
 
#ifndef XSENS_NO_STL
namespace std
{
template<typename _CharT, typename _Traits>
basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& o, XsString const& xs)
{
        return (o << xs.toStdString());
}
}
#endif
 
#endif
#endif