RscString.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/Base/Core/Arp.hpp"
#include "Arp/Base/Core/SecureString.hpp"
#include "Arp/Base/Rsc/Commons/RscStringBase.hpp"
#include "Arp/Base/Commons/Exceptions/ArgumentException.hpp"
#include <cstring>
#include <array>
 
namespace Arp::Base::Rsc::Commons
{
 
template<int N>
class RscString : public RscStringBase
{
public: // construction
    RscString(void);
    RscString(const char* pChars);      // no explicit here, implicit conversion is desired
    RscString(const char8u* pChars);    // no explicit here, implicit conversion is desired
    RscString(const String& arg);       // no explicit here, implicit conversion is desired
 
    // canonical construction/assignment/destruction
    RscString(const RscString& arg);
    RscString(RscString&& arg)noexcept;
    RscString& operator=(const RscString& arg);
    RscString& operator=(RscString&& arg)noexcept;
    ~RscString(void);
 
public: // operators
    RscString& operator=(const char* pChars);
    RscString& operator=(const char8u* pChars);
    RscString& operator=(const String& str);
 
public: // global friend operators (shall be defined implicit inline due to EXPORT on Windows)
 
    friend std::ostream& operator<<(std::ostream& os, const RscString& str)
    {
        os << str.CStr();
        return os;
    }
 
    friend std::istream& operator>>(std::istream& is, RscString& str)
    {
        std::string s;
        is >> s;
        str = s;
        return is;
    }
 
public: // static getter operations
    static constexpr size_t  GetMaxLength(void);
 
protected: // operations
    explicit RscString(RscType stringType);
 
private: // static fields
    const static size_t maxLength = N;
    const static size_t bufferSize = maxLength + 1;
 
private: // fields
    std::array<char, bufferSize> buffer{}; // default initialized by zeros
};
 
// inline methods of class RscString<N>
 
template<int N>
inline RscString<N>::RscString()
    : RscStringBase(RscType::String)
{
    RscStringBase::SetBufferInfo(this->buffer.data(), bufferSize);
}
 
template<int N>
inline RscString<N>::RscString(RscType stringType)
    : RscStringBase(stringType)
{
    RscStringBase::SetBufferInfo(this->buffer.data(), bufferSize);
}
 
template<int N>
inline RscString<N>::RscString(const RscString& arg)
    : RscStringBase(arg)
    , buffer(arg.buffer)
{
    RscStringBase::SetBufferInfo(this->buffer.data(), bufferSize, arg.GetLength());
}
 
template<int N>
inline RscString<N>::RscString(RscString&& arg)noexcept
    : RscStringBase(arg)
    , buffer(arg.buffer)
{
    RscStringBase::SetBufferInfo(this->buffer.data(), bufferSize, arg.GetLength());
}
 
template<int N>
inline RscString<N>& RscString<N>::operator=(const RscString& arg)
{
    this->buffer = arg.buffer;
    RscStringBase::SetStringType(this->GetStringType());
    RscStringBase::SetBufferInfo(this->buffer.data(), bufferSize, arg.GetLength());
    return *this;
}
 
template<int N>
inline RscString<N>& RscString<N>::operator=(RscString&& arg)noexcept
{
    this->buffer = arg.buffer;
    RscStringBase::SetStringType(this->GetStringType());
    RscStringBase::SetBufferInfo(this->buffer.data(), bufferSize, arg.GetLength());
    return *this;
}
 
template<int N>
inline RscString<N>::~RscString(void) = default;
 
template<int N>
inline RscString<N>::RscString(const char* pChars)
    : RscStringBase(RscType::String)
{
    RscStringBase::SetBufferInfo(this->buffer.data(), bufferSize, pChars);
}
 
template<int N>
inline RscString<N>::RscString(const char8u* pChars)
    : RscString(reinterpret_cast<const char*>(pChars))
{
}
 
template<int N>
inline RscString<N>::RscString(const String& arg)
    : RscStringBase(RscType::String)
{
    RscStringBase::SetBufferInfo(this->buffer.data(), bufferSize, arg.CStr());
}
 
template<int N>
inline constexpr size_t RscString<N>::GetMaxLength()
{
    return maxLength;
}
 
template<int N>
inline RscString<N>& RscString<N>::operator=(const char* pChars)
{
    this->Assign(pChars);
    return *this;
}
 
template<int N>
inline RscString<N>& RscString<N>::operator=(const char8u* pChars)
{
    this->Assign(reinterpret_cast<const char*>(pChars));
    return *this;
}
 
template<int N>
inline RscString<N>& RscString<N>::operator=(const String& str)
{
    this->Assign(str.CStr(), str.Length());
    return *this;
}
 
} // end of namespace Arp::Base::Rsc::Commons
 
// template specialization of RscString<N> formatter
template<int N>
struct fmt::formatter<Arp::Base::Rsc::Commons::RscString<N>> : public fmt::ostream_formatter {};