BasicString.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Detail/PrimitiveTypes.hpp"
#include <string>
#include <memory>
#include <iosfwd>
#include <vector>
#include <functional>
#include <initializer_list>
#include <span>
 
#ifndef ARP_INSIDE_ARP_BASE_CORE_ARP_H
    #error Never include 'BasicString.hxx' directly, just include 'Arp.hpp'
#endif
 
namespace Arp { namespace Base { namespace Core
{
 
template<class C, class A = std::allocator<C>>
class BasicString
{
public: // usings
    using Allocator             = A;                                                                   
    using AllocatorTraits       = std::allocator_traits<Allocator>;                                    
    using CharType              = C;                                                                   
    using Char8uType            = Arp::Base::Core::char8u;                                             
    using SelfType              = BasicString<CharType, Allocator>;                                    
    using StdString            = std::basic_string<CharType, std::char_traits<CharType>, Allocator>;   
    using Reference             = typename StdString::reference;                                       
    using ConstReference        = typename StdString::const_reference;                                 
    using Iterator              = typename StdString::iterator;                                        
    using ConstIterator         = typename StdString::const_iterator;                                  
    using ReverseIterator       = typename StdString::reverse_iterator;                                
    using ConstReverseIterator  = typename StdString::const_reverse_iterator;                          
    using Tokens                = std::vector<SelfType>;                                               
    using AppendToken           = std::function < void(SelfType&&) >;
    using Bytes                 = std::vector<byte>;
 
public: // container policy usings
    using allocator_type            = Allocator;                                   
    using value_type                = CharType;                                    
    using size_type                 = typename StdString::size_type;               
    using difference_type           = typename StdString::difference_type;         
    using reference                 = typename StdString::reference;               
    using const_reference           = typename StdString::const_reference;         
    using pointer                   = typename AllocatorTraits::pointer;           
    using const_pointer             = typename AllocatorTraits::const_pointer;     
    using iterator                  = typename StdString::iterator;                
    using const_iterator            = typename StdString::const_iterator;          
    using reverse_iterator          = typename StdString::reverse_iterator;        
    using const_reverse_iterator    = typename StdString::const_reverse_iterator;  
 
public: // construction/destruction
    BasicString(void);
    BasicString(const SelfType& arg);
    BasicString(SelfType&& arg)noexcept;
    SelfType& operator=(const SelfType& arg);
    SelfType& operator=(SelfType&& arg)noexcept;
    ~BasicString(void);
 
    explicit BasicString(const Allocator& alloc);
    explicit BasicString(const Bytes& bytes, const Allocator& alloc = Allocator());
    BasicString(const StdString& arg);
    BasicString(StdString&& arg)noexcept;
    BasicString(const SelfType& arg, const Allocator& alloc);
    BasicString(const SelfType& arg, size_type offset, size_type count = NPos);
    BasicString(const SelfType& arg, size_type offset, size_type count, const Allocator& alloc);
    BasicString(const CharType* pChars, size_type count);
    BasicString(const CharType* pChars, size_type count, const Allocator& alloc);
    BasicString(const CharType* pChars);
    BasicString(const Char8uType* pChars);
    BasicString(const CharType* pChars, const Allocator& alloc);
    BasicString(size_type count, CharType c);
    BasicString(size_type count, CharType c, const Allocator& alloc);
    BasicString(SelfType&& arg, const Allocator& alloc);
    BasicString(std::initializer_list<CharType> arg, const Allocator& alloc = Allocator());
    BasicString(Iterator first, Iterator last, const Allocator& alloc = Allocator());
    BasicString(ConstIterator first, ConstIterator last, const Allocator& alloc = Allocator());
 
public: // static fields
    static const size_type  NPos = size_type(-1);
    static const SelfType   Empty;
    static const SelfType   NewLine;
 
public: // replace_all operations
    SelfType& ReplaceAll(const SelfType& pattern, const SelfType& replacement);
 
public: // Misc operations
    Allocator           GetAllocator(void)const;
    StdString&          GetStdString(void);
    const StdString&    GetStdString(void)const;
 
public: // Trim operations
    SelfType    TrimLeft(void)const;
    SelfType    TrimLeft(CharType trim)const;
    SelfType    TrimRight(void)const;
    SelfType    TrimRight(CharType trim)const;
    SelfType    Trim(void)const;
    SelfType    Trim(CharType trim)const;
 
public: // Split operations
    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 SelfType& delimiter, bool trimTokens = true, bool removeEmptyTokens = true)const;
    void    Split(CharType delimiter, bool trimTokens, bool removeEmptyTokens, AppendToken appendToken)const;
    void    Split(std::span<const CharType> delimiters, bool trimTokens, bool removeEmptyTokens, AppendToken appendToken)const;
    void    SplitByWord(const SelfType& delimiter, bool trimTokens, bool removeEmptyTokens, AppendToken appendToken)const;
 
public: // Format operations
    template<typename... Args>  static SelfType Format(const SelfType& format, const Args& ... args);
    template<typename... Args>  static SelfType Format(const char* format, const Args& ... args);
    template<typename... Args>  static SelfType FormatPrintf(const char* format, const Args& ... args);
 
private: // fields
    StdString  stdString;
};
 
// initializing of static fields
template<class C, class A>
const BasicString<C, A> BasicString<C, A>::Empty;
 
template <class C, class A>
const BasicString<C, A> BasicString<C, A>::NewLine("\n");
 
}}} // end of namespace Arp::Base::Core