StaticString.hxx

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/Plc/Commons/Gds/StaticStringBase.hpp"
namespace Arp { namespace Plc { namespace Commons { namespace Gds
{

template <uint16 Capacity = 80>
class StaticString : public StaticStringBase
{
public: // typedefs
    typedef Arp::BasicString<char8> String;

public: // construction/destruction
    StaticString(const char8* str = "");
    StaticString(const StaticString& arg);
    StaticString& operator=(const StaticString& arg);
    template <uint16 M>
    StaticString& operator=(const StaticString<M>& arg);
    StaticString& operator=(const String& arg);
    StaticString& operator=(const char8* arg);
    ~StaticString(void) = default;

public: // operators

public: // setter/getter operations
    uint16  GetLength(void)const;

public: // operations
    String  ToString(void)const;

private: // methods
    bool    IsEmpty(void)const;

private: // fields
    char8   data[Capacity + 1];
};

// inline methods of class StaticString

template <uint16 N>
inline StaticString<N>::StaticString(const char8* str)
    : StaticStringBase(N)
{
    memset(this->data, 0, sizeof(this->data));
    strncpy(this->data, str, this->capacity);
    this->length = this->GetLength();
}

template <uint16 N>
inline StaticString<N>::StaticString(const StaticString& arg)
{
    this->capacity = arg.capacity;
    this->length = arg.length;
    strncpy(this->data, arg.data, this->capacity);
}

template <uint16 N>
inline StaticString<N>& StaticString<N>::operator=(const StaticString& arg)
{
    if (arg.IsEmpty() == false)
    {
        memcpy(this->data, arg.GetData(), this->capacity);
        this->length = arg.length;
    }
    return *this;
}

template <uint16 N>
template <uint16 M>
inline StaticString<N>& StaticString<N>::operator=(const StaticString<M>& arg)
{
    strncpy(this->data, arg.GetData(), this->capacity);
    this->length = this->GetLength();
    return *this;
}

template <uint16 N>
inline StaticString<N>& StaticString<N>::operator=(const char8* arg)
{
    size_t strLength = strlen(arg);
    if (strLength != 0)
    {
        memset(this->data, 0, sizeof(this->data));
        strncpy(this->data, arg, this->capacity);
        this->length = this->GetLength();
    }
    return *this;
}

template <uint16 N>
inline StaticString<N>& StaticString<N>::operator=(const String& arg)
{
    this->operator=(arg.CStr());
    return *this;
}

template <uint16 N>
inline uint16 StaticString<N>::GetLength(void)const
{
    return (uint16)(strlen(this->data));
}

template <uint16 N>
inline StaticString<>::String StaticString<N>::ToString(void)const
{
    return String(this->data);
}

template <uint16 N>
inline bool StaticString<N>::IsEmpty(void)const
{
    if (strlen(this->data) == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}

}}}} // end of namespace Arp::Plc::Commons::Gds