StaticString.hxx

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/Plc/Commons/Gds/StaticStringBase.hpp"
#include <cstring>
namespace Arp { namespace Plc { namespace Commons { namespace Gds
{
 
template <uint16 Capacity = 80, class TChar = char8>
class StaticString : public StaticStringBase
{
public: // using
    using String = Arp::String;
 
public: // construction/destruction
    StaticString(const TChar* str = nullptr);
    StaticString(const StaticString& arg);
    StaticString& operator=(const StaticString<Capacity, TChar>& arg);
    template <uint16 M>
    StaticString& operator=(const StaticString<M, TChar>& arg);
    StaticString& operator=(const String& arg);
    StaticString& operator=(const TChar* arg);
    ~StaticString(void) = default;
 
public: // setter/getter operations
    uint16  GetLength(void)const;
    bool    IsEmpty(void)const;
 
public: // operations
    void    CopyTo(StaticString& other)const;
    String  ToString(void)const;
    void    Clear(void);
 
private: // operations
    void    Assign(const TChar* arg);
 
private: // static operations
    static uint16  GetLengthFrom(const TChar* arg);
 
private: // fields
    TChar   data[Capacity + 1];
};
 
// inline methods of class StaticString
 
template <uint16 N, class TChar>
inline StaticString<N, TChar>::StaticString(const TChar* str)
    : StaticStringBase(N)
{
    this->Clear();
    if(str != nullptr)
    {
        this->Assign(str);
    }
}
 
template <uint16 N, class TChar>
inline StaticString<N, TChar>::StaticString(const StaticString& arg)
{
    this->capacity = arg.capacity;
    this->length = arg.length;
    std::char_traits<TChar>::copy(this->data, reinterpret_cast<TChar*>(arg.GetData()), static_cast<size_t>(this->length) + 1);
}
 
template <uint16 N, class TChar>
inline void StaticString<N, TChar>::CopyTo(StaticString& other)const
{
    other.capacity = this->capacity;
    other.length = this->length;
    std::char_traits<TChar>::copy(reinterpret_cast<TChar*>(other.GetData()), this->data, static_cast<size_t>(this->length) + 1);
}
 
template <uint16 N, class TChar>
inline StaticString<N, TChar>& StaticString<N, TChar>::operator=(const StaticString& arg)
{
    this->Assign(reinterpret_cast<TChar*>(arg.GetData()));
    return *this;
}
 
template <uint16 N, class TChar>
template <uint16 M>
inline StaticString<N, TChar>& StaticString<N, TChar>::operator=(const StaticString<M, TChar>& arg)
{
    this->Assign(reinterpret_cast<TChar*>(arg.GetData()));
    return *this;
}
 
template <uint16 N, class TChar>
inline StaticString<N, TChar>& StaticString<N, TChar>::operator=(const TChar* arg)
{
    if (arg != nullptr)
    {
        this->Assign(arg);
    }
    return *this;
}
 
template <uint16 N, class TChar>
inline StaticString<N, TChar>& StaticString<N, TChar>::operator=(const String& arg)
{
    this->length = this->AssignStaticString(this->data, this->capacity, arg);
    return *this;
}
 
template <uint16 N, class TChar>
inline uint16 StaticString<N, TChar>::GetLength(void)const
{
    return this->length;
}
 
template <uint16 N, class TChar>
inline uint16 StaticString<N, TChar>::GetLengthFrom(const TChar* arg)
{
    return static_cast<uint16>(std::char_traits<TChar>::length(arg));
}
 
template <uint16 N, class TChar>
inline StaticString<N, TChar>::String StaticString<N, TChar>::ToString(void)const
{
    return this->ConvertStaticString(this->data).GetStdString();
}
 
template <uint16 N, class TChar>
inline bool StaticString<N, TChar>::IsEmpty(void)const
{
    if (this->GetLength() == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}
 
template <uint16 N, class TChar>
void StaticString<N, TChar>::Assign(const TChar* arg)
{
    uint16 currentLength = this->GetLengthFrom(arg);
    if (currentLength > this->capacity)
    {
        this->length = this->capacity;
    }
    else
    {
        this->length = currentLength;
    }
    std::memset(this->data, 0, sizeof(this->data));
    std::char_traits<TChar>::copy(this->data, arg, static_cast<size_t>(this->length));
}
 
template <uint16 N, class TChar>
inline void StaticString<N, TChar>::Clear(void)
{
    std::memset(this->data, 0, sizeof(this->data));
    this->length = 0;
}
 
}}}} // end of namespace Arp::Plc::Commons::Gds