string_intf.h

Go to the documentation of this file.

#pragma once
#include <adtf_utils.h>
#include <string>
#include <string_view>
#include <optional>
#include <cstring>
 
#include "adtf_base_type_traits.h"
 
namespace adtf
{
namespace base
{
namespace ant
{
class IString
{
public:
    static constexpr size_t InvalidPos = g_npos;
    virtual tResult Set(const char* strValue) = 0;
    virtual const char* Get() const = 0;
    virtual size_t GetLength() const = 0;
};

template<typename T>
struct adtf_string_forward
{
    static constexpr bool is_mutable = false;
    inline static const char* GetConstChar(const T* const pValue)
    {
        static_assert(penguin::detail::always_false<T>,
                      "Unsupported type T! See documentation which types are supported."
                      "adtf_string<T> only supports std::string and adtf_util::cString types unless you specialize the "
                      "adtf_string_forward<T> for the type T!");
        return nullptr;
    }

    inline static size_t GetCurrentLength(const T* const pValue)
    {
        static_assert(penguin::detail::always_false<T>,
                      "Unsupported type T! See documentation which types are supported."
                      "adtf_string<T> only supports std::string and adtf_util::cString types unless you specialize the "
                      "adtf_string_forward<T> for the type T!");
 
        return size_t(0);
    }

    inline static tResult SetValue(T* const pValue, const char* strValue)
    {
        static_assert(penguin::detail::always_false<T>,
                      "Unsupported type T! See documentation which types are supported."
                      "adtf_string<T> only supports std::string and adtf_util::cString types unless you specialize the "
                      "adtf_string_forward<T> for the type T!");
        return ERR_NOT_IMPL;
    }
};

template<>
struct adtf_string_forward<std::string>
{
    static constexpr bool is_mutable = true;

    static const char* GetConstChar(const std::string* const pValue)
    {
        return pValue->c_str();
    }

    static size_t GetCurrentLength(const std::string* const pValue)
    {
        return static_cast<size_t>(pValue->length());
    }

    static tResult SetValue(std::string* const pValue, const char* strValue /* strValue */)
    {
        pValue->assign(strValue);
        RETURN_NOERROR;
    }
};

template<>
struct adtf_string_forward<const std::string> : adtf_string_forward<std::string>
{
    static constexpr bool is_mutable = false;

    static tResult SetValue(const std::string* const /* pValue */, const char* /* strValue */)
    {
        RETURN_ERROR(ERR_ACCESS_DENIED);
    }
};

template<>
struct adtf_string_forward<std::string_view>
{
    static constexpr bool is_mutable = false;

    static const char* GetConstChar(const std::string* const pValue)
    {
        return pValue->c_str();
    }

    static size_t GetCurrentLength(const std::string* const pValue)
    {
        return static_cast<size_t>(pValue->length());
    }

    static tResult SetValue(std::string_view* const /* pValue */, const char* /* strValue */)
    {
        RETURN_ERROR(ERR_ACCESS_DENIED);
    }
};

template<>
struct adtf_string_forward<const std::string_view> : adtf_string_forward<std::string_view>
{
    static tResult SetValue(const std::string_view* const /* pValue */, const char* /* strValue */)
    {
        RETURN_ERROR(ERR_ACCESS_DENIED);
    }
};

template<>
struct adtf_string_forward<adtf::util::cString>
{
    static constexpr bool is_mutable = true;
 
    static const char* GetConstChar(const adtf_util::cString* const pValue)
    {
        return pValue->GetPtr();
    }
    static size_t GetCurrentLength(const adtf_util::cString* const pValue)
    {
        return static_cast<size_t>(pValue->GetLength());
    }
    static tResult SetValue(adtf_util::cString* const pValue, const char* strValue /* strValue */)
    {
        pValue->Set(strValue);
        RETURN_NOERROR;
    }
};

template<>
struct adtf_string_forward<const adtf::util::cString> : adtf_string_forward<adtf::util::cString>
{
    static constexpr bool is_mutable = false;

    static tResult SetValue(const adtf_util::cString* const /* pValue */, const char* /* strValue */)
    {
        RETURN_ERROR(ERR_ACCESS_DENIED);
    }
};

template<>
struct adtf_string_forward<adtf::util::cFilename> : public adtf_string_forward<adtf::util::cString>
{
};

template<>
struct adtf_string_forward<const adtf::util::cFilename> : public adtf_string_forward<const adtf::util::cString>
{
};

template<>
struct adtf_string_forward<const char>
{
    static constexpr bool is_mutable = false;
 
    static const char* GetConstChar(const char* const pValue)
    {
        return pValue;
    }
    static size_t GetCurrentLength(const char* const pValue)
    {
        return static_cast<size_t>(adtf_util::cStringUtil::GetLength(pValue));
    }
    static tResult SetValue(const char* const /* pValue */, const char* /* strValue */)
    {
        RETURN_ERROR(ERR_ACCESS_DENIED);
    }
};

template<typename T>
class adtf_string : public IString, protected adtf_string_forward<T>
{
    typedef adtf_string<T> self_type;
    typedef T value_type;
    typedef adtf_string_forward<T> base_type;
 
private:
    value_type* m_pAssignValue;
    adtf_string() = delete;
    adtf_string(const adtf_string& strValue) = delete;
    adtf_string(adtf_string&& strValue) = delete;
    adtf_string& operator=(const adtf_string& strValue) = delete;
    adtf_string& operator=(adtf_string&& strValue) = delete;
 
public:
    explicit adtf_string(value_type* pstrAssignValue)
    {
        m_pAssignValue = pstrAssignValue;
    }

    ~adtf_string()
    {
        m_pAssignValue = nullptr;
    }
    tResult Set(const char* strValue) override
    {
        if constexpr (std::is_const_v<T>)
        {
            RETURN_ERROR(ERR_NOT_SUPPORTED);
        }
        else if (strValue != nullptr)
        {
            return base_type::SetValue(m_pAssignValue, strValue);
        }
        else
        {
            RETURN_ERROR(ERR_POINTER);
        }
    }
    const char* Get() const override
    {
        const char* strValue = "";
        if (m_pAssignValue != nullptr)
        {
            strValue = base_type::GetConstChar(m_pAssignValue);
        }
        return strValue;
    }
    size_t GetLength() const override
    {
        if (m_pAssignValue != nullptr)
        {
            return base_type::GetCurrentLength(m_pAssignValue);
        }
        return IString::InvalidPos;
    }
};
} // namespace ant
 
namespace spider
{

class cStringLengthProxy : public ant::IString
{
public:
    cStringLengthProxy(const char* strValue): m_strValue(strValue)
    {
    }
 
    tResult Set(const char* /* strValue */) override
    {
        RETURN_ERROR(ERR_NOT_SUPPORTED);
    }
 
    size_t GetLength() const override
    {
        if (!m_nSize)
        {
            m_nSize = std::strlen(m_strValue);
        }
 
        return *m_nSize;
    }
 
    const char* Get() const override
    {
        return m_strValue;
    }
 
private:
    const char* m_strValue;
    mutable std::optional<size_t> m_nSize;
};

class cStringRedirect : public ant::IString
{
public:
    cStringRedirect(std::function<tResult(const ant::IString&)> fnForward): m_fnForward(std::move(fnForward))
    {
    }
 
    tResult Set(const char* strValue) override
    {
        return m_fnForward(cStringLengthProxy(strValue));
    }
 
    size_t GetLength() const override
    {
        return 0;
    }
 
    const char* Get() const override
    {
        return nullptr;
    }
 
private:
    std::function<tResult(const ant::IString&)> m_fnForward;
};
 
} // namespace spider
 
using ant::adtf_string_forward;
using ant::adtf_string;
using ant::IString;
using spider::cStringRedirect;
 
} // namespace base
} // namespace adtf

#define adtf_string_intf(__string__)                                                                           \
    static_cast<std::conditional_t<                                                                            \
        ::adtf::base::adtf_string_forward<typename std::remove_reference_t<decltype(__string__)>>::is_mutable, \
        ::adtf::base::IString&&, const ::adtf::base::IString&&>>(                                              \
        ::adtf::base::adtf_string<typename std::remove_reference<decltype(__string__)>::type>(&(__string__)))

#define adtf_char_intf(__const_char_ptr__) \
    static_cast<const ::adtf::base::IString&&>(::adtf::base::adtf_string<const char>(__const_char_ptr__))