Skip to content

iceoryx_hoofs/cxx/newtype.hpp🔗

Namespaces🔗

Name
iox
building block to easily create free function for logging in a library context
iox::cxx

Classes🔗

Name
class iox::cxx::NewType
Implementation of the haskell NewType pattern: https://wiki.haskell.org/Newtype Lets say you would like to have an index which is in the end an integer but with certain restraints. The users should be forced to set it when they are creating it but afterwards it should be immutable. You would like to be able to compare the type as well as to sort it so that it can be stored in a map for instance. An example could be that you would like to have an index class with those properties and some additional methods. Then you can inherit from NewType and add your methods.

Source code🔗

// Copyright (c) 2020 by Robert Bosch GmbH. All rights reserved.
// Copyright (c) 2021 by Apex.AI Inc. All rights reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// SPDX-License-Identifier: Apache-2.0
#ifndef IOX_HOOFS_CXX_NEWTYPE_HPP
#define IOX_HOOFS_CXX_NEWTYPE_HPP

#include "iceoryx_hoofs/cxx/algorithm.hpp"
#include "iceoryx_hoofs/internal/cxx/newtype/assignment.hpp"
#include "iceoryx_hoofs/internal/cxx/newtype/comparable.hpp"
#include "iceoryx_hoofs/internal/cxx/newtype/constructor.hpp"
#include "iceoryx_hoofs/internal/cxx/newtype/convertable.hpp"
#include "iceoryx_hoofs/internal/cxx/newtype/internal.hpp"
#include "iceoryx_hoofs/internal/cxx/newtype/protected_constructor.hpp"
#include "iceoryx_hoofs/internal/cxx/newtype/sortable.hpp"

#include <type_traits>

namespace iox
{
namespace cxx
{
template <typename T, template <typename> class... Policies>
class NewType : public Policies<NewType<T, Policies...>>...
{
  protected:
    NewType(newtype::internal::ProtectedConstructor_t, const T& rhs) noexcept;

  public:
    using ThisType = NewType<T, Policies...>;
    using value_type = T;

    NewType() noexcept;

    explicit NewType(const T& rhs) noexcept;

    NewType(const NewType& rhs) noexcept;

    NewType(NewType&& rhs) noexcept;

    NewType& operator=(const NewType& rhs) noexcept;

    NewType& operator=(NewType&& rhs) noexcept;

    NewType& operator=(const T& rhs) noexcept;

    NewType& operator=(T&& rhs) noexcept;

    explicit operator T() const noexcept;

    template <typename Type>
    friend typename Type::value_type newtype::internal::newTypeAccessor(const Type&) noexcept;

  private:
    T m_value;
};
} // namespace cxx
} // namespace iox

#include "iceoryx_hoofs/internal/cxx/newtype.inl"

#endif

Updated on 17 March 2022 at 12:15:57 CET