string_intf.h

Go to the documentation of this file.

 
#pragma once
#include <adtf_utils.h>
#include <string>
#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
    {
        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 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)
        {
            pValue->assign(strValue);
            RETURN_NOERROR;
        }
    };
 
    template <>
    struct adtf_string_forward<adtf::util::cString>
    {
        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)
        {
            pValue->Set(strValue);
            RETURN_NOERROR;
        }
    };
 
    template <>
    struct adtf_string_forward<adtf::util::cFilename>: public adtf_string_forward<adtf::util::cString>
    {
    };
 
    template <>
    struct adtf_string_forward < const char >
    {
        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 (strValue != nullptr)
            {
                return base_type::SetValue(m_pAssignValue, strValue);
            }
            else
            {
                RETURN_ERROR(ERR_POINTER);
            }
        }
        const char* Get() const override
        {
            const tChar* 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;
};
 
}
 
using ant::adtf_string_forward;
using ant::adtf_string;
using ant::IString;
using spider::cStringRedirect;
 
} //namespace base
} // namespace adtf
 
#define adtf_string_intf( __string__) ::adtf::base::adtf_string<typename std::remove_reference<decltype(__string__)>::type>(& (__string__))
 
#define adtf_char_intf( __const_char_ptr__) ::adtf::base::adtf_string<const char>(__const_char_ptr__)