String.h

Go to the documentation of this file.

//
// Copyright 2015 - 2025 (C). Alex Robenko. All rights reserved.
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
 
#pragma once
 
#include <vector>
 
#include "comms/CompileControl.h"
 
#if COMMS_HAS_CPP17_STRING_VIEW
#include <string_view>
#endif // #if COMMS_HAS_CPP17_STRING_VIEW
 
#include "comms/ErrorStatus.h"
#include "comms/options.h"
#include "comms/util/StaticString.h"
#include "comms/util/StringView.h"
#include "comms/util/detect.h"
#include "comms/util/type_traits.h"
#include "comms/field/basic/String.h"
#include "comms/field/details/AdaptBasicField.h"
#include "comms/field/details/OptionsParser.h"
#include "comms/details/tag.h"
 
namespace comms
{
 
namespace field
{
 
namespace details
{
 
template <bool THasOrigDataViewStorage>
struct StringOrigDataViewStorageType;
 
template <>
struct StringOrigDataViewStorageType<true>
{
#if COMMS_HAS_CPP17_STRING_VIEW
    using Type = std::string_view;
#else // #if COMMS_HAS_CPP17_STRING_VIEW
    using Type = comms::util::StringView;
#endif // #if COMMS_HAS_CPP17_STRING_VIEW
};
 
template <>
struct StringOrigDataViewStorageType<false>
{
    using Type = std::string;
};
 
template <bool THasSequenceFixedSizeUseFixedSizeStorage>
struct StringFixedSizeUseFixedSizeStorageType;
 
template <>
struct StringFixedSizeUseFixedSizeStorageType<true>
{
    template <typename TOpt>
    using Type = comms::util::StaticString<TOpt::SequenceFixedSize>;
};
 
template <>
struct StringFixedSizeUseFixedSizeStorageType<false>
{
    template <typename TOpt>
    using Type = typename StringOrigDataViewStorageType<TOpt::HasOrigDataView>::Type;
};
 
template <bool THasFixedSizeStorage>
struct StringFixedSizeStorageType;
 
template <>
struct StringFixedSizeStorageType<true>
{
    template <typename TOpt>
    using Type = comms::util::StaticString<TOpt::FixedSizeStorage>;
};
 
template <>
struct StringFixedSizeStorageType<false>
{
    template <typename TOpt>
    using Type = typename StringFixedSizeUseFixedSizeStorageType<TOpt::HasSequenceFixedSizeUseFixedSizeStorage>
        ::template Type<TOpt>;
};
 
template <bool THasCustomStorage>
struct StringCustomStringStorageType;
 
template <>
struct StringCustomStringStorageType<true>
{
    template <typename TOpt>
    using Type = typename TOpt::CustomStorageType;
};
 
template <>
struct StringCustomStringStorageType<false>
{
    template <typename TOpt>
    using Type =
        typename StringFixedSizeStorageType<TOpt::HasFixedSizeStorage>::template Type<TOpt>;
};
 
template <typename TOpt>
using StringStorageTypeT =
    typename StringCustomStringStorageType<TOpt::HasCustomStorageType>::template Type<TOpt>;
 
template <typename TFieldBase, typename... TOptions>
using StringBase =
    AdaptBasicFieldT<
        basic::String<TFieldBase, StringStorageTypeT<OptionsParser<TOptions...> > >,
        TOptions...
    >;
 
} // namespace details
 
template <typename TFieldBase, typename... TOptions>
class String : public details::StringBase<TFieldBase, TOptions...>
{
    using BaseImpl = details::StringBase<TFieldBase, TOptions...>;
public:
    using FieldBase = TFieldBase;
 
    using Endian = typename BaseImpl::Endian;
 
    using VersionType = typename BaseImpl::VersionType;
 
    using ParsedOptions = details::OptionsParser<TOptions...>;
 
    using CommsTag = typename BaseImpl::CommsTag;
 
    using ValueType = typename BaseImpl::ValueType;
 
    using FieldType = typename ParsedOptions::FieldType;    
 
    using SizeFieldPrefix = typename ParsedOptions::SequenceSizeFieldPrefix;
 
    using SerLengthFieldPrefix = typename ParsedOptions::SequenceSerLengthFieldPrefix;    
 
    using TerminationFieldSuffix = typename ParsedOptions::SequenceTerminationFieldSuffix;    
 
    using TrailingFieldSuffix = typename ParsedOptions::SequenceTrailingFieldSuffix;         
 
    String() = default;
 
    explicit String(const ValueType& val)
      : BaseImpl(val)
    {
    }
 
    explicit String(ValueType&& val)
      : BaseImpl(std::move(val))
    {
    }
 
    explicit String(const char* str)
    {
        setValue(str);
    }
 
    String(const String&) = default;
 
    String(String&&) = default;
 
    ~String() noexcept = default;
 
    String& operator=(const String&) = default;
 
    String& operator=(String&&) = default;
 
    static constexpr bool hasFailOnInvalid()
    {
        return ParsedOptions::HasFailOnInvalid;
    }
 
    static constexpr bool hasIgnoreInvalid()
    {
        return ParsedOptions::HasIgnoreInvalid;
    }
 
    static constexpr bool hasEmptySerialization()
    {
        return ParsedOptions::HasEmptySerialization;
    }    
 
    static constexpr bool hasFieldType()
    {
        return ParsedOptions::HasFieldType;
    }    
 
    static constexpr bool hasSizeFieldPrefix()
    {
        return ParsedOptions::HasSequenceSizeFieldPrefix;
    }
 
    static constexpr bool hasSerLengthFieldPrefix()
    {
        return ParsedOptions::HasSequenceSerLengthFieldPrefix;
    }    
 
    static constexpr bool hasTerminationFieldSuffix()
    {
        return ParsedOptions::HasSequenceTerminationFieldSuffix;
    }      
 
    static constexpr bool hasTrailingFieldSuffix()
    {
        return ParsedOptions::HasSequenceTrailingFieldSuffix;
    }    
 
    static constexpr bool hasFixedSize()
    {
        return ParsedOptions::HasSequenceFixedSize;
    }   
 
    static constexpr bool hasFixedValue()
    {
        return ParsedOptions::HasFixedValue;
    }  
 
    static constexpr bool hasName()
    {
        return ParsedOptions::HasName;
    } 
 
    static constexpr std::size_t fixedSize()
    {
        return ParsedOptions::SequenceFixedSize;
    }                 
 
    template <typename TIter>
    ErrorStatus read(TIter& iter, std::size_t len)
    {
        auto es = BaseImpl::read(iter, len);
        using TagTmp = 
            typename comms::util::LazyShallowConditional<
                ParsedOptions::HasSequenceFixedSize
            >::template Type<
                AdjustmentNeededTag,
                NoAdjustmentTag
            >;
 
        adjustValue(TagTmp());
        return es;
    }
 
    static constexpr bool hasReadNoStatus()
    {
        return BaseImpl::hasReadNoStatus();
    }
 
    template <typename TIter>
    void readNoStatus(TIter& iter)
    {
        BaseImpl::readNoStatus(iter);
        using TagTmp = 
            typename comms::util::LazyShallowConditional<
                ParsedOptions::HasSequenceFixedSize
            >::template Type<
                AdjustmentNeededTag,
                NoAdjustmentTag
            >;
 
        adjustValue(TagTmp());
    }
 
    ValueType& value()
    {
        return BaseImpl::value();
    }
 
    const ValueType& value() const
    {
        return BaseImpl::value();
    }
 
    const ValueType& getValue() const
    {
        return BaseImpl::getValue();
    }
 
    template <typename U>
    void setValue(U&& val)
    {
        BaseImpl::setValue(std::forward<U>(val));
    }          
 
    std::size_t length() const
    {
        return BaseImpl::length();
    }
 
    bool valid() const
    {
        return BaseImpl::valid();
    }
 
    bool refresh()
    {
        return BaseImpl::refresh();
    }
 
    bool canWrite() const
    {
        return BaseImpl::canWrite();
    }
 
    template <typename TIter>
    ErrorStatus write(TIter& iter, std::size_t len) const
    {
        return BaseImpl::write(iter, len);
    }
 
    static constexpr bool hasWriteNoStatus()
    {
        return BaseImpl::hasWriteNoStatus();
    }
 
    template <typename TIter>
    void writeNoStatus(TIter& iter) const
    {
        BaseImpl::writeNoStatus(iter);
    }
 
    static constexpr std::size_t minLength()
    {
        return BaseImpl::minLength();
    }
 
    static constexpr std::size_t maxLength()
    {
        return BaseImpl::maxLength();
    }
 
    void forceReadElemCount(std::size_t count)
    {
        BaseImpl::forceReadElemCount(count);
    }
 
    void clearReadElemCount()
    {
        BaseImpl::clearReadElemCount();
    }
 
    void forceReadLength(std::size_t count)
    {
        return BaseImpl::forceReadLength(count);
    }
 
    void clearReadLengthForcing()
    {
        return BaseImpl::clearReadLengthForcing();
    }
 
    static constexpr bool isVersionDependent()
    {
        return ParsedOptions::HasCustomVersionUpdate || BaseImpl::isVersionDependent();
    }
 
    static constexpr bool hasNonDefaultRefresh()
    {
        return BaseImpl::hasNonDefaultRefresh();
    }
 
    VersionType getVersion() const
    {
        return BaseImpl::getVersion();
    }
 
    bool setVersion(VersionType version)
    {
        return BaseImpl::setVersion(version);
    }
 
protected:
    using BaseImpl::readData;
    using BaseImpl::writeData;
 
private:
    template <typename... TParams>
    using NoAdjustmentTag = comms::details::tag::Tag1<>;
 
    template <typename... TParams>
    using AdjustmentNeededTag = comms::details::tag::Tag2<>;
 
    template <typename... TParams>
    using HasResizeTag = comms::details::tag::Tag3<>;
 
    template <typename... TParams>
    using HasRemoveSuffixTag = comms::details::tag::Tag4<>;    
 
    template <typename... TParams>
    void adjustValue(NoAdjustmentTag<TParams...>)
    {
    }
 
    template <typename... TParams>
    void adjustValue(AdjustmentNeededTag<TParams...>)
    {
        std::size_t count = 0;
        for (auto iter = BaseImpl::value().begin(); iter != BaseImpl::value().end(); ++iter) {
            if (*iter == 0) {
                break;
            }
            ++count;
        }
 
        doResize(count);
    }
 
    void doResize(std::size_t count)
    {
        using TagTmp =
            typename comms::util::Conditional<
                comms::util::detect::hasResizeFunc<ValueType>()
            >::template Type<
                HasResizeTag<>,
                typename comms::util::Conditional<
                    comms::util::detect::hasRemoveSuffixFunc<ValueType>()
                >::template Type<
                    HasRemoveSuffixTag<>,
                    void
                >
            >;
 
        static_assert(!std::is_void<TagTmp>::value,
            "The string storage value type must have either resize() or remove_suffix() "
            "member functions");
        doResize(count, TagTmp());
    }
 
    template <typename... TParams>
    void doResize(std::size_t count, HasResizeTag<TParams...>)
    {
        BaseImpl::value().resize(count);
    }
 
    template <typename... TParams>
    void doResize(std::size_t count, HasRemoveSuffixTag<TParams...>)
    {
        BaseImpl::value().remove_suffix(BaseImpl::value().size() - count);
    }
 
    static_assert(!ParsedOptions::HasSerOffset,
        "comms::option::def::NumValueSerOffset option is not applicable to String field");
    static_assert(!ParsedOptions::HasFixedLengthLimit,
        "comms::option::def::FixedLength option is not applicable to String field");
    static_assert(!ParsedOptions::HasFixedBitLengthLimit,
        "comms::option::def::FixedBitLength option is not applicable to String field");
    static_assert(!ParsedOptions::HasVarLengthLimits,
        "comms::option::def::VarLength option is not applicable to String field");
    static_assert(!ParsedOptions::HasAvailableLengthLimit,
            "comms::option::def::AvailableLengthLimit option is not applicable to String field");
    static_assert(!ParsedOptions::HasScalingRatio,
        "comms::option::def::ScalingRatio option is not applicable to String field");
    static_assert(!ParsedOptions::HasUnits,
        "comms::option::def::Units option is not applicable to String field");
    static_assert(!ParsedOptions::HasMultiRangeValidation,
        "comms::option::def::ValidNumValueRange (or similar) option is not applicable to String field");
    static_assert(!ParsedOptions::HasSequenceElemSerLengthFieldPrefix,
        "comms::option::def::SequenceElemSerLengthFieldPrefix option is not applicable to String field");
    static_assert(!ParsedOptions::HasSequenceElemFixedSerLengthFieldPrefix,
        "comms::option::def::SequenceElemSerLengthFixedFieldPrefix option is not applicable to String field");
    static_assert(!ParsedOptions::HasVersionsRange,
        "comms::option::def::ExistsBetweenVersions (or similar) option is not applicable to String field");
    static_assert(!ParsedOptions::HasMissingOnReadFail,
            "comms::option::def::MissingOnReadFail option is not applicable to String field");           
    static_assert(!ParsedOptions::HasMissingOnInvalid,
            "comms::option::def::MissingOnInvalid option is not applicable to String field");  
};
 
template <typename TFieldBase, typename... TOptions>
bool operator==(
    const String<TFieldBase, TOptions...>& field1,
    const String<TFieldBase, TOptions...>& field2) noexcept
{
    return field1.value() == field2.value();
}
 
template <typename TFieldBase, typename... TOptions>
bool operator!=(
    const String<TFieldBase, TOptions...>& field1,
    const String<TFieldBase, TOptions...>& field2) noexcept
{
    return field1.value() != field2.value();
}
 
template <typename TFieldBase, typename... TOptions>
bool operator<(
    const String<TFieldBase, TOptions...>& field1,
    const String<TFieldBase, TOptions...>& field2) noexcept
{
    return field1.value() < field2.value();
}
 
template <typename T>
constexpr bool isString()
{
    return std::is_same<typename T::CommsTag, tag::String>::value;
}
 
template <typename TFieldBase, typename... TOptions>
inline
String<TFieldBase, TOptions...>&
toFieldBase(String<TFieldBase, TOptions...>& field)
{
    return field;
}
 
template <typename TFieldBase, typename... TOptions>
inline
const String<TFieldBase, TOptions...>&
toFieldBase(const String<TFieldBase, TOptions...>& field)
{
    return field;
}
 
}  // namespace field
 
}  // namespace comms