edlstring.h

Go to the documentation of this file.

/*
 * Copyright (C) 2007-2025 Global Graphics Software Ltd. All rights reserved.
 */

 
#ifndef EDLSTRING_H
#define EDLSTRING_H
 
#include <string>
#include <sstream>
#include <limits>
#ifdef ANDROID
#include <ctype.h>
#endif
#include <edl/platform.h>
#include <edl/edltypes.h>
#include <edl/edlvector.h>
 
_BEGIN_EDL_NAMESPACE
 
#if defined(_WIN32) && !defined(SWIG_BINDINGS)
#   define  USE_EDL_ALLOCATOR
#endif
 
#ifdef USE_EDL_ALLOCATOR
 
// An STL Allocator, used for strings to allow
// strings to be passed between DLLs that use
// statically-linked runtimes.
 
EDL_API void *edlStringAlloc(size_t);
EDL_API void  edlStringFree(void*);
template <class T>
class CEDLStringAllocator
{
  public:
    inline CEDLStringAllocator()
    {
        allocFunc = edlStringAlloc;
        freeFunc = edlStringFree;
    }
    CEDLStringAllocator(CEDLStringAllocator const &r)
    {
        allocFunc = r.allocFunc;
        freeFunc = r.freeFunc;
    }
    template <class U>
    inline explicit CEDLStringAllocator(CEDLStringAllocator<U> const &r)
    {
        allocFunc = r.allocFunc;
        freeFunc = r.freeFunc;
    }
    inline ~CEDLStringAllocator() {}
 
  public:
    void *(*allocFunc)(size_t);
    void (*freeFunc)(void*);
 
  public:
    typedef T              value_type;
    typedef T*             pointer;
    typedef const T*       const_pointer;
    typedef T&             reference;
    typedef const T&       const_reference;
    typedef std::size_t    size_type;
    typedef std::ptrdiff_t difference_type;
 
    template <class U>
    struct rebind
    {
        typedef CEDLStringAllocator<U> other;
    };
 
    inline pointer address (reference v) const { return &v; }
    const_pointer address (const_reference v) const { return &v; }
    size_type max_size () const
    {
#undef max
        return std::numeric_limits<std::size_t>::max() / sizeof(T);
    }
 
    pointer allocate (size_type n, const void * = 0)
    {
        pointer p = (pointer) allocFunc(n * sizeof(T));
        if (!p)
            throw std::bad_alloc();
        return p;
    }
    void deallocate (pointer p, size_type)
    {
        freeFunc(p);
    }
 
    void construct (pointer p, const T& v)
    {
        new ((void*)p) T(v);
    }
 
    void destroy (pointer p)
    {
        p->~T();
    }
};
 
template <typename T, typename U>
bool operator== (CEDLStringAllocator<T> const &l, CEDLStringAllocator<U> const &r)
{
    return (l.freeFunc == r.freeFunc);
}
 
template<typename T, typename U>
bool operator!= (CEDLStringAllocator<T> const &l, CEDLStringAllocator<U> const &r)
{
    return (l.freeFunc != r.freeFunc);
}
 
#endif
 
 
// Basic EDLString types, be careful about the make assumptions about the size of wchar_t
// on Windows it's 2 bytes, on Linux and OSX it's 4 bytes
 
#ifdef _WIN32
typedef wchar_t     u16char;
typedef char32_t    u32char;
#elif defined(ANDROID)
typedef uint16_t    u16char;
typedef wchar_t     u32char;
#else
typedef char16_t    u16char;
typedef wchar_t     u32char;
#endif
 
 
 
#if defined(USE_EDL_ALLOCATOR) && defined(_WIN32)
 
 
typedef std::basic_string<char,             std::char_traits<char>,    CEDLStringAllocator<char>    >       EDLSysString;
typedef std::basic_istringstream<char,      std::char_traits<char>,    CEDLStringAllocator<char>    >       EDLSysStringIStream;
typedef std::basic_ostringstream<char,      std::char_traits<char>,    CEDLStringAllocator<char>    >       EDLSysStringOStream;
 
typedef std::basic_string<u16char,          std::char_traits<u16char>, CEDLStringAllocator<u16char> >       EDLU16String;
typedef std::basic_string<u32char,          std::char_traits<u32char>, CEDLStringAllocator<u32char> >       EDLU32String;
 
typedef std::basic_string<wchar_t,          std::char_traits<wchar_t>, CEDLStringAllocator<wchar_t> >       EDLString;
typedef std::basic_istringstream<wchar_t,   std::char_traits<wchar_t>, CEDLStringAllocator<wchar_t> >       EDLStringIStream;
typedef std::basic_ostringstream<wchar_t,   std::char_traits<wchar_t>, CEDLStringAllocator<wchar_t> >       EDLStringOStream;
 
#else
 
typedef std::string                             EDLSysString;
typedef std::istringstream                      EDLSysStringIStream;
typedef std::ostringstream                      EDLSysStringOStream;
 
typedef std::basic_string<u16char>              EDLU16String;
typedef std::basic_string<u32char>              EDLU32String;
 
typedef std::wstring                            EDLString;
typedef std::wistringstream                     EDLStringIStream;
typedef std::wostringstream                     EDLStringOStream;
 
#endif
 
typedef EDLSysString                        EDLRawString;
 
typedef CEDLVector<EDLString>               CEDLStringVect;
typedef CEDLVector<EDLSysString>            CEDLSysStringVect;
typedef CEDLVector<EDLRawString>            CEDLRawStringVect;
 
 
inline bool equal(const EDLSysString &str1,const EDLSysString &str2) { return (str1 == str2); }
uint32 hashValue(const EDLSysString &str);
uint32 hashValue(const char *pStr, uint32 lenStr);

inline uint8 sxtob(char c)
{
    return (uint8) ((c >= '0' && c <= '9') ? (c - '0') : ((c >= 'a' && c <= 'f') ? (c - 'a' + 10) : (c - 'A' + 10)));
}

 inline bool edlstringEqualsIgnoreCaseCnt(const EDLString &str1,const EDLString &str2, size_t len)
{
    wchar_t c1;
    wchar_t c2;
    size_t  minLen = (str1.size() < str2.size()) ? str1.size() : str2.size();
 
    if (minLen < len)
        return false;
 
    for (size_t i = 0; i < len; i++)
    {
        c1 = (wchar_t) ::tolower(str1.at(i));
        c2 = (wchar_t) ::tolower(str2.at(i));
 
        if (c1 != c2)
            return false;
    }
 
    return true;
}

inline size_t edlstringFind(const EDLString &str, EDLString &searchStr)
{
    return str.find(searchStr);
}

 inline void edlstringSubstr(const EDLString &str, EDLString& result, size_t start, size_t end)
{
    result = str.substr(start, end);
}
 

 
EDL_API EDLString EDLSysStringToEDLString(const EDLSysString &edlSysString);

 
EDL_API EDLSysString EDLStringToEDLSysString(const EDLString &edlString);
 
_END_EDL_NAMESPACE
 
#endif /* __EDLSTRING_H__ */