Bundle.h

Go to the documentation of this file.

//
// Copyright 2015 - 2024 (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 "comms/ErrorStatus.h"
#include "comms/options.h"
#include "comms/field/basic/Bundle.h"
#include "comms/field/details/AdaptBasicField.h"
 
namespace comms
{
 
namespace field
{
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
class Bundle : public 
    details::AdaptBasicFieldT<
        basic::Bundle<
            TFieldBase, 
            details::OptionsParser<TOptions...>::ForcedMembersVersionDependency,
            TMembers>, 
        TOptions...
    >
{
    using BaseImpl = 
        details::AdaptBasicFieldT<
            basic::Bundle<
                TFieldBase, 
                details::OptionsParser<TOptions...>::ForcedMembersVersionDependency,
                TMembers>, 
            TOptions...
        >;    
    static_assert(comms::util::IsTuple<TMembers>::Value,
        "TMembers is expected to be a tuple of std::tuple<...>");
 
    static_assert(
        1U <= std::tuple_size<TMembers>::value,
        "Number of members is expected to be at least 1.");
 
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;    
 
    Bundle() = default;
 
    explicit Bundle(const ValueType& val)
      : BaseImpl(val)
    {
    }
 
    explicit Bundle(ValueType&& val)
      : BaseImpl(std::move(val))
    {
    }
 
    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;
    }    
 
    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();
    }
 
    template <std::size_t TFromIdx>
    std::size_t lengthFrom() const
    {
        return BaseImpl::template lengthFrom<TFromIdx>();
    }
 
    template <std::size_t TUntilIdx>
    std::size_t lengthUntil() const
    {
        return BaseImpl::template lengthUntil<TUntilIdx>();
    }
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx>
    std::size_t lengthFromUntil() const
    {
        return BaseImpl::template lengthFromUntil<TFromIdx, TUntilIdx>();
    }
 
    static constexpr std::size_t minLength()
    {
        return BaseImpl::minLength();
    }
 
    template <std::size_t TFromIdx>
    static constexpr std::size_t minLengthFrom()
    {
        return BaseImpl::template minLengthFrom<TFromIdx>();
    }
 
    template <std::size_t TUntilIdx>
    static constexpr std::size_t minLengthUntil()
    {
        return BaseImpl::template minLengthUntil<TUntilIdx>();
    }
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx>
    static constexpr std::size_t minLengthFromUntil()
    {
        return BaseImpl::template minLengthFromUntil<TFromIdx, TUntilIdx>();
    }
 
    static constexpr std::size_t maxLength()
    {
        return BaseImpl::maxLength();
    }
 
    template <std::size_t TFromIdx>
    static constexpr std::size_t maxLengthFrom()
    {
        return BaseImpl::template maxLengthFrom<TFromIdx>();
    }
 
    template <std::size_t TUntilIdx>
    static constexpr std::size_t maxLengthUntil()
    {
        return BaseImpl::template maxLengthUntil<TUntilIdx>();
    }
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx>
    static constexpr std::size_t maxLengthFromUntil()
    {
        return BaseImpl::template maxLengthFromUntil<TFromIdx, TUntilIdx>();
    }
 
    template <typename TIter>
    ErrorStatus read(TIter& iter, std::size_t size)
    {
        return BaseImpl::read(iter, size);
    }
 
    template <std::size_t TFromIdx, typename TIter>
    ErrorStatus readFrom(TIter& iter, std::size_t len)
    {
        return BaseImpl::template readFrom<TFromIdx>(iter, len);
    }
 
    template <std::size_t TFromIdx, typename TIter>
    ErrorStatus readFromAndUpdateLen(TIter& iter, std::size_t& len)
    {
        return BaseImpl::template readFromAndUpdateLen<TFromIdx>(iter, len);
    }    
 
    template <std::size_t TUntilIdx, typename TIter>
    ErrorStatus readUntil(TIter& iter, std::size_t len)
    {
        return BaseImpl::template readUntil<TUntilIdx>(iter, len);
    }
 
    template <std::size_t TUntilIdx, typename TIter>
    ErrorStatus readUntilAndUpdateLen(TIter& iter, std::size_t& len)
    {
        return BaseImpl::template readUntilAndUpdateLen<TUntilIdx>(iter, len);
    }    
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    ErrorStatus readFromUntil(TIter& iter, std::size_t len)
    {
        return BaseImpl::template readFromUntil<TFromIdx, TUntilIdx>(iter, len);
    }
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    ErrorStatus readFromUntilAndUpdateLen(TIter& iter, std::size_t& len)
    {
        return BaseImpl::template readFromUntilAndUpdateLen<TFromIdx, TUntilIdx>(iter, len);
    }    
 
    static constexpr bool hasReadNoStatus()
    {
        return BaseImpl::hasReadNoStatus();
    }
 
    template <typename TIter>
    void readNoStatus(TIter& iter)
    {
        BaseImpl::readNoStatus(iter);
    }
 
    template <std::size_t TFromIdx, typename TIter>
    void readFromNoStatus(TIter& iter)
    {
        BaseImpl::template readFromNoStatus<TFromIdx>(iter);
    }
 
    template <std::size_t TUntilIdx, typename TIter>
    void readUntilNoStatus(TIter& iter)
    {
        BaseImpl::template readUntilNoStatus<TUntilIdx>(iter);
    }
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    void readFromUntilNoStatus(TIter& iter)
    {
        BaseImpl::template readFromUntilNoStatus<TFromIdx, TUntilIdx>(iter);
    }
 
    bool canWrite() const
    {
        return BaseImpl::canWrite();
    }
 
    template <typename TIter>
    ErrorStatus write(TIter& iter, std::size_t size) const
    {
        return BaseImpl::write(iter, size);
    }
 
    template <std::size_t TFromIdx, typename TIter>
    ErrorStatus writeFrom(TIter& iter, std::size_t size) const
    {
        return BaseImpl::template writeFrom<TFromIdx>(iter, size);
    }
 
    template <std::size_t TUntilIdx, typename TIter>
    ErrorStatus writeUntil(TIter& iter, std::size_t size) const
    {
        return BaseImpl::template writeUntil<TUntilIdx>(iter, size);
    }
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    ErrorStatus writeFromUntil(TIter& iter, std::size_t size) const
    {
        return BaseImpl::template writeFromUntil<TFromIdx, TUntilIdx>(iter, size);
    }
 
    static constexpr bool hasWriteNoStatus()
    {
        return BaseImpl::hasWriteNoStatus();
    }
 
    template <typename TIter>
    void writeNoStatus(TIter& iter) const
    {
        BaseImpl::writeNoStatus(iter);
    }
 
    template <std::size_t TFromIdx, typename TIter>
    void writeFromNoStatus(TIter& iter)
    {
        BaseImpl::template writeFromNoStatus<TFromIdx>(iter);
    }
 
    template <std::size_t TUntilIdx, typename TIter>
    void writeUntilNoStatus(TIter& iter)
    {
        BaseImpl::template writeUntilNoStatus<TUntilIdx>(iter);
    }
 
    template <std::size_t TFromIdx, std::size_t TUntilIdx, typename TIter>
    void writeFromUntilNoStatus(TIter& iter)
    {
        BaseImpl::template writeFromUntilNoStatus<TFromIdx, TUntilIdx>(iter);
    }
 
    bool valid() const
    {
        return BaseImpl::valid();
    }
 
    bool refresh()
    {
        return BaseImpl::refresh();
    }
 
    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:
    static_assert(!ParsedOptions::HasSerOffset,
        "comms::option::def::NumValueSerOffset option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasFixedLengthLimit,
        "comms::option::def::FixedLength option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasFixedBitLengthLimit,
        "comms::option::def::FixedBitLength option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasVarLengthLimits,
        "comms::option::def::VarLength option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasAvailableLengthLimit,
            "comms::option::def::AvailableLengthLimit option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceElemLengthForcing,
        "comms::option::def::SequenceElemLengthForcingEnabled option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceSizeForcing,
        "comms::option::def::SequenceSizeForcingEnabled option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceLengthForcing,
        "comms::option::def::SequenceLengthForcingEnabled option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceFixedSize,
        "comms::option::def::SequenceFixedSize option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceFixedSizeUseFixedSizeStorage,
        "comms::option::app::SequenceFixedSizeUseFixedSizeStorage option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceSizeFieldPrefix,
        "comms::option::def::SequenceSizeFieldPrefix option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceSerLengthFieldPrefix,
        "comms::option::def::SequenceSerLengthFieldPrefix option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceElemSerLengthFieldPrefix,
        "comms::option::def::SequenceElemSerLengthFieldPrefix option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceElemFixedSerLengthFieldPrefix,
        "comms::option::def::SequenceElemSerLengthFixedFieldPrefix option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceTrailingFieldSuffix,
        "comms::option::def::SequenceTrailingFieldSuffix option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasSequenceTerminationFieldSuffix,
        "comms::option::def::SequenceTerminationFieldSuffix option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasFixedSizeStorage,
        "comms::option::app::FixedSizeStorage option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasCustomStorageType,
        "comms::option::app::CustomStorageType option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasScalingRatio,
        "comms::option::def::ScalingRatio option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasUnits,
        "comms::option::def::Units option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasOrigDataView,
        "comms::option::app::OrigDataView option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasMultiRangeValidation,
        "comms::option::def::ValidNumValueRange (or similar) option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasVersionsRange,
        "comms::option::def::ExistsBetweenVersions (or similar) option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasInvalidByDefault,
        "comms::option::def::InvalidByDefault option is not applicable to Bundle field");
    static_assert(!ParsedOptions::HasMissingOnReadFail,
            "comms::option::def::MissingOnReadFail option is not applicable to Bundle field");     
    static_assert(!ParsedOptions::HasMissingOnInvalid,
            "comms::option::def::MissingOnInvalid option is not applicable to Bundle field");          
};
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
bool operator==(
    const Bundle<TFieldBase, TMembers, TOptions...>& field1,
    const Bundle<TFieldBase, TMembers, TOptions...>& field2) noexcept
{
    return field1.value() == field2.value();
}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
bool operator!=(
    const Bundle<TFieldBase, TMembers, TOptions...>& field1,
    const Bundle<TFieldBase, TMembers, TOptions...>& field2) noexcept
{
    return field1.value() != field2.value();
}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
bool operator<(
    const Bundle<TFieldBase, TMembers, TOptions...>& field1,
    const Bundle<TFieldBase, TMembers, TOptions...>& field2) noexcept
{
    return field1.value() < field2.value();
}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
bool operator<=(
    const Bundle<TFieldBase, TMembers, TOptions...>& field1,
    const Bundle<TFieldBase, TMembers, TOptions...>& field2) noexcept
{
    return field1.value() <= field2.value();
}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
bool operator>(
    const Bundle<TFieldBase, TMembers, TOptions...>& field1,
    const Bundle<TFieldBase, TMembers, TOptions...>& field2) noexcept
{
    return field1.value() > field2.value();
}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
bool operator>=(
    const Bundle<TFieldBase, TMembers, TOptions...>& field1,
    const Bundle<TFieldBase, TMembers, TOptions...>& field2) noexcept
{
    return field1.value() >= field2.value();
}
 
template <typename T>
constexpr bool isBundle()
{
    return std::is_same<typename T::CommsTag, tag::Bundle>::value;
}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
inline
Bundle<TFieldBase, TMembers, TOptions...>&
toFieldBase(Bundle<TFieldBase, TMembers, TOptions...>& field)
{
    return field;
}
 
template <typename TFieldBase, typename TMembers, typename... TOptions>
inline
const Bundle<TFieldBase, TMembers, TOptions...>&
toFieldBase(const Bundle<TFieldBase, TMembers, TOptions...>& field)
{
    return field;
}
 
}  // namespace field
 
}  // namespace comms