String.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Detail/BasicString.hxx"
#include "Arp/Base/Core/Detail/BasicString.inl"
#include "Arp/Base/Core/Detail/Arp.Base.Core.hpp"
 
#define ARP_BUILD_STRING_IMPL_INLINE
 
#ifdef ARP_BUILD_STRING_IMPL_INLINE
    #define ARP_STRING_INLINE       inline
    #define ARP_STRING_EXPORT       inline
    #define ARP_STRING_EXPORT_DECL
#else
    #define ARP_STRING_INLINE
    #define ARP_STRING_EXPORT       ARP_EXPORT
    #define ARP_STRING_EXPORT_DECL  ARP_EXPORT
#endif
 
namespace Arp { namespace Base { namespace Core
{
 
class ARP_BASE_CORE_EXPORT String
{
public: // usings
    using CharType = char;                                                          
    using Allocator = std::allocator<CharType>;                                     
    using AllocatorTraits = std::allocator_traits<Allocator>;                       
    using Char8uType = Arp::Base::Core::char8u;                                     
    using BaseString = BasicString<CharType, Allocator>;                            
    using StdString = BaseString::StdString;                                        
    using Reference = typename BaseString::reference;                               
    using ConstReference = typename BaseString::const_reference;                    
    using Iterator = typename BaseString::iterator;                                 
    using ConstIterator = typename BaseString::const_iterator;                      
    using ReverseIterator = typename BaseString::reverse_iterator;                  
    using ConstReverseIterator = typename BaseString::const_reverse_iterator;       
    using ThreeWayCompareResult = decltype(StdString() <=> StdString());            
    using Tokens = std::vector<String>;                                             
    using Bytes = std::vector<byte>;
 
public: // container policy usings
    using allocator_type = Allocator;                                           
    using value_type = CharType;                                                
    using size_type = typename BaseString::size_type;                           
    using difference_type = typename BaseString::difference_type;               
    using reference = typename BaseString::reference;                           
    using const_reference = typename BaseString::const_reference;               
    using pointer = typename AllocatorTraits::pointer;                          
    using const_pointer = typename AllocatorTraits::const_pointer;              
    using iterator = typename BaseString::iterator;                             
    using const_iterator = typename BaseString::const_iterator;                 
    using reverse_iterator = typename BaseString::reverse_iterator;             
    using const_reverse_iterator = typename BaseString::const_reverse_iterator; 
 
public: // construction/destruction
    String(void);
    String(const String& arg);
    String(String&& arg)noexcept;
    String& operator=(const String& arg);
    String& operator=(String&& arg)noexcept;
    ~String(void);
 
    String(const BaseString& arg);
    String(BaseString&& arg);
    String(const StdString& arg);
    String(StdString&& arg);
    String(const String& arg, size_type offset, size_type count = NPos);
    String(const CharType* pChars, size_type count);
    String(const CharType* pChars);
    String(const Char8uType* pChars);
    String(size_type count, CharType c);
    String(std::initializer_list<CharType> arg);
    String(Iterator first, Iterator last);
    String(ConstIterator first, ConstIterator last);
    explicit String(const Bytes& bytes);
 
public: // static properties
    static const size_type  NPos = size_type(-1);
    static const String     Empty;
    static const String     NewLine;
 
public: // implicit cast operators (Arp extension)
    operator const CharType*(void)const;
    operator const StdString& (void)const;
 
public: // assignment operator
    String& operator=(std::initializer_list<CharType> right);
    String& operator=(const CharType* right);
    String& operator=(CharType c);
 
public: // append operator
    String& operator+=(std::initializer_list<CharType> right);
    String& operator+=(const String& right);
    String& operator+=(const CharType* right);
    String& operator+=(CharType c);
 
public: // assign operations
    String&     Assign(const String& arg);
    String&     Assign(String&& arg);
    String&     Assign(const StdString& arg);
    String&     Assign(StdString&& arg);
    String&     Assign(std::initializer_list<CharType> arg);
    String&     Assign(const String& arg, size_type offset, size_type count = NPos);
 
    String&     Assign(const CharType* pChars, size_type count);
    String&     Assign(const CharType* pChars);
    String&     Assign(size_type count, CharType c);
    String&     Assign(Iterator first, Iterator last);
    String&     Assign(ConstIterator first, ConstIterator last);
    String&     Assign(const_pointer first, const_pointer last);
 
public: // append operations
    String&     Append(std::initializer_list<CharType> arg);
    String&     Append(const String& arg);
    String&     Append(const String& arg, size_type offset, size_type count = NPos);
    String&     Append(const CharType* pChars, size_type count);
    String&     Append(const CharType* pChars);
    String&     Append(size_type count, CharType c);
    String&     Append(Iterator first, Iterator last);
    String&     Append(ConstIterator first, ConstIterator last);
    String&     Append(const_pointer first, const_pointer last);
 
public: // insert operations
    String&     Insert(size_type offset, const String& arg);
    String&     Insert(size_type offset, const String& arg, size_type argOffset, size_type count = NPos);
    String&     Insert(size_type offset, const CharType* pChars, size_type count);
    String&     Insert(size_type offset, const CharType* pChars);
    String&     Insert(size_type offset, size_type count, CharType c);
    Iterator    Insert(ConstIterator where, CharType c);
    Iterator    Insert(ConstIterator where, size_type count, CharType c);
    Iterator    Insert(ConstIterator where, Iterator first, Iterator last);
    Iterator    Insert(ConstIterator where, ConstIterator first, ConstIterator last);
    Iterator    Insert(ConstIterator where, const_pointer first, const_pointer last);
    Iterator    Insert(ConstIterator where, std::initializer_list<CharType> chars);
 
public: // erase operations
    String&     Erase(size_type offset = 0);
    String&     Erase(size_type offset, size_type count);
    Iterator    Erase(ConstIterator where);
    Iterator    Erase(ConstIterator first, ConstIterator last);
 
public: // replace operation
    String&     Replace(ConstIterator first, ConstIterator last, std::initializer_list<CharType> chars);
    String&     Replace(size_type offset, size_type length, const String& arg);
    String&     Replace(size_type offset, size_type length, const String& arg, size_type offsetArg, size_type count = NPos);
    String&     Replace(size_type offset, size_type length, const CharType* pChars, size_type count);
    String&     Replace(size_type offset, size_type length, const CharType* pChars);
    String&     Replace(size_type offset, size_type length, size_type count, CharType c);
    String&     Replace(ConstIterator first, ConstIterator last, const String& arg);
    String&     Replace(ConstIterator first, ConstIterator last, const CharType* pChars, size_type count);
    String&     Replace(ConstIterator first, ConstIterator last, const CharType* pChars);
    String&     Replace(ConstIterator first, ConstIterator last, size_type count, CharType c);
    String&     Replace(ConstIterator first, ConstIterator last, Iterator first2, Iterator last2);
    String&     Replace(ConstIterator first, ConstIterator last, ConstIterator first2, ConstIterator last2);
    String&     Replace(ConstIterator first, ConstIterator last, const_pointer first2, const_pointer last2);
    String&     Replace(ConstIterator first, ConstIterator last, pointer first2, pointer last2);
 
public: // support of range based for loops
    Iterator        begin(void);
    ConstIterator   begin(void)const;
    Iterator        end(void);
    ConstIterator   end(void)const;
 
public: // container operations
    void                    ShrinkToFit(void);
    void                    PushBack(CharType c);
    void                    PopBack(void);
    Iterator                Begin(void);
    ConstIterator           Begin(void)const;
    Iterator                End(void);
    ConstIterator           End(void)const;
    ReverseIterator         ReverseBegin(void);
    ConstReverseIterator    ReverseBegin(void)const;
    ReverseIterator         ReverseEnd(void);
    ConstReverseIterator    ReverseEnd(void)const;
    ConstIterator           ConstBegin(void)const;
    ConstIterator           ConstEnd(void)const;
    ConstReverseIterator    ConstReverseBegin(void)const;
    ConstReverseIterator    ConstReverseEnd(void)const;
    Reference               Front(void);
    ConstReference          Front(void)const;
    Reference               Back(void);
    ConstReference          Back(void)const;
    Reference               At(size_type offset);
    ConstReference          At(size_type offset)const;
    Reference               operator[](size_type offset);
    ConstReference          operator[](size_type offset)const;
 
public: // Size/Length operations
    size_type   Length(void)const;
    size_type   Size(void)const;
    size_type   MaxSize(void)const;
    size_type   Capacity(void)const;
    bool        IsEmpty(void)const;
    void        Resize(size_type newSize);
    void        Resize(size_type newSize, CharType c);
    void        Reserve(size_type newCapacity = 0);
    void        Clear(void);
 
public: // Find operations
    size_type   Find(const String& pattern, size_type offset = 0)const;
    size_type   Find(const CharType* pChars, size_type offset, size_type count)const;
    size_type   Find(const CharType* pChars, size_type offset = 0)const;
    size_type   Find(CharType c, size_type offset = 0)const;
    size_type   ReverseFind(const String& pattern, size_type offset = NPos)const;
    size_type   ReverseFind(const CharType* pChars, size_type offset, size_type count)const;
    size_type   ReverseFind(const CharType* pChars, size_type offset = NPos)const;
    size_type   ReverseFind(CharType c, size_type offset = NPos)const;
    size_type   FindFirstOf(const String& chars, size_type offset = 0)const;
    size_type   FindFirstOf(const CharType* pChars, size_type offset, size_type count)const;
    size_type   FindFirstOf(const CharType* pChars, size_type offset = 0)const;
    size_type   FindFirstOf(CharType c, size_type offset = 0)const;
    size_type   FindLastOf(const String& chars, size_type offset = NPos)const;
    size_type   FindLastOf(const CharType* pChars, size_type offset, size_type count)const;
    size_type   FindLastOf(const CharType* pChars, size_type offset = NPos)const;
    size_type   FindLastOf(CharType c, size_type offset = NPos)const;
    size_type   FindFirstNotOf(const String& chars, size_type offset = 0)const;
    size_type   FindFirstNotOf(const CharType* pChars, size_type offset, size_type count)const;
    size_type   FindFirstNotOf(const CharType* pChars, size_type offset = 0)const;
    size_type   FindFirstNotOf(CharType c, size_type offset = 0)const;
    size_type   FindLastNotOf(const String& chars, size_type offset = NPos)const;
    size_type   FindLastNotOf(const CharType* pChars, size_type offset, size_type count)const;
    size_type   FindLastNotOf(const CharType* pChars, size_type offset = NPos)const;
    size_type   FindLastNotOf(CharType c, size_type offset = NPos)const;
 
public: // StartsWith/EndsWith operations
    bool    StartsWith(const CharType* pChars)const;
    bool    StartsWith(const String& pattern)const;
    bool    EndsWith(const CharType* pChars)const;
    bool    EndsWith(const String& pattern)const;
 
public: // Compare operations
    int Compare(const String& other)const;
    int Compare(size_type offset, size_type count, const String& other)const;
    int Compare(size_type offset, size_type count, const String& other, size_type offsetOther, size_type countOther = NPos)const;
    int Compare(const CharType* pOther)const;
    int Compare(size_type offset, size_type count, const CharType* pOther)const;
    int Compare(size_type offset, size_type count, const CharType* pOther, size_type countOther)const;
 
public: // Misc operations
    Allocator           GetAllocator(void)const;
    const CharType*     CStr(void)const;
    String              Substr(size_type offset = 0, size_type count = NPos)const;
    void                Swap(String& other);
 
public: // misc operations (Arp extension)
    Bytes               ToBytes(void)const;
    String&             ReplaceAll(const String& pattern, const String& replacement);
    const StdString&    GetStdString(void)const;
    StdString&          GetStdString(void);
 
public: // Arp Trim operations (Arp extension)
    String  TrimLeft(void)const;
    String  TrimLeft(CharType trim)const;
    String  TrimRight(void)const;
    String  TrimRight(CharType trim)const;
    String  Trim(void)const;
    String  Trim(CharType trim)const;
 
public: // Arp Split operations (Arp extension)
    Tokens Split(CharType delimiter, bool trimTokens = true, bool removeEmptyTokens = true)const;
    Tokens Split(std::span<const CharType> delimiters, bool trimTokens = true, bool removeEmptyTokens = true)const;
    Tokens SplitByWord(const String& delimiter, bool trimTokens = true, bool removeEmptyTokens = true)const;
 
public: // Arp Format operations (Arp extension)
    template<typename... Args>  static String Format(const String& format, const Args& ... args);
    template<typename... Args>  static String Format(const char* format, const Args& ... args);
    template<typename... Args>  static String FormatPrintf(const char* format, const Args& ... args);
 
public: // friend operators
    friend ARP_STRING_EXPORT_DECL   String operator+(const String& left, const String& right);
    friend ARP_STRING_EXPORT_DECL   String operator+(const String& left, const String::CharType* right);
    friend ARP_STRING_EXPORT_DECL   String operator+(const String& left, String::CharType right);
    friend ARP_STRING_EXPORT_DECL   String operator+(const String::CharType* left, const String& right);
    friend ARP_STRING_EXPORT_DECL   String operator+(String::CharType left, const String& right);
    friend ARP_STRING_EXPORT_DECL   String operator+(String&& left, String&& right);
    friend ARP_STRING_EXPORT_DECL   String operator+(String&& left, const String& right);
    friend ARP_STRING_EXPORT_DECL   String operator+(String&& left, const String::CharType* right);
    friend ARP_STRING_EXPORT_DECL   String operator+(String&& left, String::CharType right);
    friend ARP_STRING_EXPORT_DECL   String operator+(const String& left, String&& right);
    friend ARP_STRING_EXPORT_DECL   String operator+(const String::CharType* left, String&& right);
    friend ARP_STRING_EXPORT_DECL   String operator+(String::CharType left, String&& right);
 
public: // deprecated operations
    ARP_DEPRECATED("Use String::GetStdString() instead")
    const StdString& GetBaseString(void)const;
    ARP_DEPRECATED("Use String::StartsWith() instead")
    bool    StartWith(const CharType* pChars)const;
    ARP_DEPRECATED("Use String::StartsWith() instead")
    bool    StartWith(const String& pattern)const;
    ARP_DEPRECATED("Use String::EndsWith() instead")
    bool    EndWith(const CharType* pChars)const;
    ARP_DEPRECATED("Use String::EndsWith() instead")
    bool    EndWith(const String& pattern)const;
 
private: //methods
    StdString&          GetImpl(void);
    const StdString&    GetImpl(void)const;
 
private: // fields
    BaseString  baseString;
};
 
// declarations of global operators and functions of class String
 
ARP_STRING_EXPORT_DECL  std::ostream& operator<<(std::ostream& os, const String& right);
ARP_STRING_EXPORT_DECL  std::istream& operator>>(std::istream& is, String& right);
 
ARP_STRING_EXPORT_DECL  String operator+(const String& left, const String& right);
ARP_STRING_EXPORT_DECL  String operator+(const String::CharType* left, const String& right);
ARP_STRING_EXPORT_DECL  String operator+(String::CharType left, const String& right);
ARP_STRING_EXPORT_DECL  String operator+(const String& left, const String::CharType* right);
ARP_STRING_EXPORT_DECL  String operator+(const String& left, const String::CharType right);
ARP_STRING_EXPORT_DECL  String operator+(const String& left, String&& right);
ARP_STRING_EXPORT_DECL  String operator+(String&& left, const String& right);
ARP_STRING_EXPORT_DECL  String operator+(String&& left, String&& right);
ARP_STRING_EXPORT_DECL  String operator+(const String::CharType* left, String&& right);
ARP_STRING_EXPORT_DECL  String operator+(String::CharType left, String&& right);
ARP_STRING_EXPORT_DECL  String operator+(String&& left, const String::CharType* right);
ARP_STRING_EXPORT_DECL  String operator+(String&& left, const String::CharType right);
 
ARP_STRING_EXPORT_DECL  bool operator==(const String& left, const String& right);
ARP_STRING_EXPORT_DECL  bool operator==(const String::CharType* left, const String& right);
ARP_STRING_EXPORT_DECL  bool operator==(const String& left, const String::CharType* right);
ARP_STRING_EXPORT_DECL  bool operator!=(const String::CharType* left, const String& right);
ARP_STRING_EXPORT_DECL  bool operator!=(const String& left, const String::CharType* right);
ARP_STRING_EXPORT_DECL  bool operator< (const String::CharType* left, const String& right);
ARP_STRING_EXPORT_DECL  bool operator< (const String& left, const String::CharType* right);
ARP_STRING_EXPORT_DECL  bool operator> (const String::CharType* left, const String& right);
ARP_STRING_EXPORT_DECL  bool operator> (const String& left, const String::CharType* right);
ARP_STRING_EXPORT_DECL  bool operator<=(const String::CharType* left, const String& right);
ARP_STRING_EXPORT_DECL  bool operator<=(const String& left, const String::CharType* right);
ARP_STRING_EXPORT_DECL  bool operator>=(const String::CharType* left, const String& right);
ARP_STRING_EXPORT_DECL  bool operator>=(const String& left, const String::CharType* right);
ARP_STRING_EXPORT_DECL  String::ThreeWayCompareResult operator<=>(const String& left, const String& right);
 
ARP_STRING_EXPORT_DECL void swap(String& left, String& right)noexcept;
 
}}} // end of namespace Arp::Base::Core
 
// include of inline implementations
#include "Arp/Base/Core/Detail/String.inl"
 
#ifdef ARP_BUILD_STRING_IMPL_INLINE
    #include "Arp/Base/Core/Detail/String.ipp"
#endif // def ARP_BUILD_STRING_IMPL_INLINE