slice.hpp

Go to the documentation of this file.

// Copyright (c) 2024 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Apache Software License 2.0 which is available at
// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
// which is available at https://opensource.org/licenses/MIT.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
 
#ifndef IOX2_BB_SLICE_HPP
#define IOX2_BB_SLICE_HPP
 
#include "iox2/bb/detail/assertions.hpp"
 
#include <cstdint>
#include <type_traits>
 
namespace iox2 {
namespace bb {
 
template <typename T>
class Slice {
  public:
    using Iterator = T*;
    using ConstIterator = const T*;
    using ValueType = std::remove_const_t<T>;
 
    Slice(T* data, uint64_t number_of_elements);
 
    auto number_of_bytes() const -> uint64_t;
 
    auto number_of_elements() const -> uint64_t;
 
    auto operator[](uint64_t n) const -> const ValueType&;
 
    auto operator[](uint64_t n) -> std::conditional_t<std::is_const<T>::value, const ValueType&, ValueType&>;
 
    auto begin() const -> ConstIterator;
 
    auto begin() -> Iterator;
 
    auto end() const -> ConstIterator;
 
    auto end() -> Iterator;
 
    auto data() const -> ConstIterator;
 
    auto data() -> Iterator;
 
  private:
    T* m_data;
    uint64_t m_number_of_elements;
};
 
template <typename T>
using MutableSlice = Slice<T>;
 
template <typename T>
using ImmutableSlice = Slice<const T>;
 
template <typename T>
Slice<T>::Slice(T* data, uint64_t number_of_elements)
    : m_data { data }
    , m_number_of_elements { number_of_elements } {
    static_assert(!std::is_same<T, void>::value, "Slice<void> is not allowed");
}
 
template <typename T>
auto Slice<T>::number_of_bytes() const -> uint64_t {
    return ((sizeof(ValueType) * m_number_of_elements) + alignof(ValueType) - 1) & ~(alignof(ValueType) - 1);
}
 
template <typename T>
auto Slice<T>::number_of_elements() const -> uint64_t {
    return m_number_of_elements;
}
 
template <typename T>
auto Slice<T>::operator[](const uint64_t n) const -> const ValueType& {
    IOX2_ASSERT(n < m_number_of_elements, "Index out of bounds");
    return *(m_data + n);
}
 
template <typename T>
auto Slice<T>::operator[](const uint64_t n)
    -> std::conditional_t<std::is_const<T>::value, const ValueType&, ValueType&> {
    IOX2_ASSERT(n < m_number_of_elements, "Index out of bounds");
    return *(m_data + n);
}
 
template <typename T>
auto Slice<T>::begin() -> Iterator {
    return m_data;
}
 
template <typename T>
auto Slice<T>::begin() const -> ConstIterator {
    return m_data;
}
 
template <typename T>
auto Slice<T>::end() -> Iterator {
    return m_data + m_number_of_elements;
}
 
template <typename T>
auto Slice<T>::end() const -> ConstIterator {
    return m_data + m_number_of_elements;
}
 
template <typename T>
auto Slice<T>::data() -> Iterator {
    return m_data;
}
 
template <typename T>
auto Slice<T>::data() const -> ConstIterator {
    return m_data;
}
 
template <typename>
struct IsSlice {
    static constexpr bool VALUE = false;
};
 
template <typename T>
struct IsSlice<Slice<T>> {
    static constexpr bool VALUE = true;
};
 
} // namespace bb
} // namespace iox2
 
#endif // IOX2_BB_SLICE_HPP