Optional.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 "comms/Assert.h"
#include "comms/ErrorStatus.h"
#include "details/OptionsParser.h"
#include "OptionalMode.h"
#include "basic/Optional.h"
#include "details/AdaptBasicField.h"
 
namespace comms
{
 
namespace field
{
 
template <typename TField, typename... TOptions>
class Optional : public details::AdaptBasicFieldT<basic::Optional<TField>, TOptions...>
{
    using BaseImpl = details::AdaptBasicFieldT<basic::Optional<TField>, TOptions...>;
public:
    using Endian = typename BaseImpl::Endian;
 
    using VersionType = typename BaseImpl::VersionType;
 
    using ParsedOptions = details::OptionsParser<TOptions...>;
 
    using CommsTag = typename BaseImpl::CommsTag;
 
    using Field = TField;
 
    using ValueType = Field;
 
    using Mode = OptionalMode;
 
    using FieldType = typename ParsedOptions::FieldType;    
 
    Optional() = default;
 
    explicit Optional(const Field& fieldSrc)
      : BaseImpl(fieldSrc)
    {
    }
 
    explicit Optional(Field&& fieldSrc)
      : BaseImpl(std::move(fieldSrc))
    {
    }
 
    Optional(const Optional&) = default;
 
    Optional(Optional&&) = default;
 
    ~Optional() noexcept = default;
 
    Optional& operator=(const Optional&) = default;
 
    Optional& operator=(Optional&&) = 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 hasFixedValue()
    {
        return ParsedOptions::HasFixedValue;
    }       
 
    static constexpr bool hasName()
    {
        return ParsedOptions::HasName;
    } 
 
    bool isTentative() const
    {
        return BaseImpl::getMode() == Mode::Tentative;
    }
 
    void setTentative()
    {
        BaseImpl::setMode(Mode::Tentative);
    }
 
    bool isMissing() const
    {
        return BaseImpl::getMode() == Mode::Missing;
    }
 
    void setMissing()
    {
        BaseImpl::setMode(Mode::Missing);
    }
 
    bool doesExist() const
    {
        return BaseImpl::getMode() == Mode::Exists;
    }
 
    void setExists()
    {
        BaseImpl::setMode(Mode::Exists);
    }
 
    Field& field()
    {
        return BaseImpl::field();
    }
 
    const Field& field() const
    {
        return BaseImpl::field();
    }
 
    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));
    }          
 
    Mode getMode() const
    {
        return BaseImpl::getMode();
    }
 
    void setMode(Mode val)
    {
        BaseImpl::setMode(val);
    }
 
    std::size_t length() const
    {
        return BaseImpl::length();
    }
 
    static constexpr std::size_t minLength()
    {
        return BaseImpl::minLength();
    }
 
    static constexpr std::size_t maxLength()
    {
        return BaseImpl::maxLength();
    }
 
    bool valid() const
    {
        return BaseImpl::valid();
    }
 
    bool refresh()
    {
        return BaseImpl::refresh();
    }
 
    template <typename TIter>
    ErrorStatus read(TIter& iter, std::size_t len)
    {
        return BaseImpl::read(iter, len);
    }
 
    static constexpr bool hasReadNoStatus()
    {
        return BaseImpl::hasReadNoStatus();
    }
 
    template <typename TIter>
    void readNoStatus(TIter& iter)
    {
        BaseImpl::readNoStatus(iter);
    }
 
    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 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::HasInvalidByDefault,
        "comms::option::def::InvalidByDefault option is not applicable to Optional field");
};
 
template <typename TField, typename... TOptions>
bool operator==(
    const Optional<TField, TOptions...>& field1,
    const Optional<TField, TOptions...>& field2) noexcept
{
    if (field1.getMode() != field2.getMode()) {
        return false;
    }
    
    if (field1.isMissing()) {
        return true;
    }
    
    return field1.field() == field2.field();
}
 
template <typename TField, typename... TOptions>
bool operator!=(
    const Optional<TField, TOptions...>& field1,
    const Optional<TField, TOptions...>& field2) noexcept
{
    return !(field1 == field2);
}
 
template <typename TField, typename... TOptions>
bool operator<(
    const Optional<TField, TOptions...>& field1,
    const Optional<TField, TOptions...>& field2) noexcept
{
    if (field1.isMissing()) {
        return !field2.isMissing();
    }
    
    if (field2.isMissing()) {
        return false;
    }
    
    return field1.field() < field2.field();
}
 
template <typename TField, typename... TOptions>
bool operator>(
    const Optional<TField, TOptions...>& field1,
    const Optional<TField, TOptions...>& field2) noexcept
{
    return (field2 < field1);
}
 
template <typename TField, typename... TOptions>
bool operator<=(
    const Optional<TField, TOptions...>& field1,
    const Optional<TField, TOptions...>& field2) noexcept
{
    return (field1 < field2) || (field1 == field2);
}
 
template <typename TField, typename... TOptions>
bool operator>=(
    const Optional<TField, TOptions...>& field1,
    const Optional<TField, TOptions...>& field2) noexcept
{
    return field2 <= field1;
}
 
template <typename T>
constexpr bool isOptional()
{
    return std::is_same<typename T::CommsTag, tag::Optional>::value;
}
 
template <typename TField, typename... TOptions>
inline
Optional<TField, TOptions...>&
toFieldBase(Optional<TField, TOptions...>& field)
{
    return field;
}
 
template <typename TField, typename... TOptions>
inline
const Optional<TField, TOptions...>&
toFieldBase(const Optional<TField, TOptions...>& field)
{
    return field;
}
 
}  // namespace field
 
}  // namespace comms