socket_option.hpp

Go to the documentation of this file.

/* Copyright 2025 Kevin Exton
 *
 * 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.
 */
 
#pragma once
#ifndef IO_SOCKET_OPTION_HPP
#define IO_SOCKET_OPTION_HPP
#include <cassert>
#include <cstring>
#include <span>
#include <type_traits>
namespace io::socket {
template <typename T>
  requires std::is_trivially_copyable_v<T>
class socket_option {
public:
  using value_type = std::decay_t<T>;
  using size_type = std::size_t;
 
  template <size_type Size = sizeof(value_type)>
    requires(Size <= sizeof(value_type))
  constexpr socket_option(size_type size = Size) noexcept : size_{size}
  {}
 
  socket_option(const socket_option &) = default;
  socket_option(socket_option &&) = default;
 
  socket_option(const value_type &val) noexcept : size_{sizeof(val)}
  {
    std::memcpy(storage_.data(), &val, size_);
  }
 
  template <size_type Size>
    requires(Size <= sizeof(value_type) || Size == std::dynamic_extent)
  socket_option(std::span<const std::byte, Size> option) noexcept
      : size_{option.size()}
  {
    assert(option.size() <= sizeof(value_type) &&
           "option.size() must be <= sizeof(value_type)");
    assert(option.size() > 0 && option.data() != nullptr &&
           "If option.size() > 0 then option.data() must not be NULL.");
    std::memcpy(storage_.data(), option.data(), size_);
  }
 
  template <size_type Size>
    requires(Size <= sizeof(value_type) || Size == std::dynamic_extent)
  socket_option(std::span<std::byte, Size> option) noexcept
      : socket_option(std::span<const std::byte, Size>(option))
  {}
 
  auto operator=(const socket_option &) -> socket_option & = default;
 
  auto operator=(socket_option &&) -> socket_option & = default;
 
  ~socket_option() = default;
 
  [[nodiscard]] constexpr auto operator*() noexcept -> value_type &
  {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    return *reinterpret_cast<value_type *>(storage_.data());
  }
 
  [[nodiscard]] constexpr auto operator->() noexcept -> value_type *
  {
    // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
    return reinterpret_cast<value_type *>(storage_.data());
  }
 
  [[nodiscard]] constexpr auto begin() noexcept -> std::byte *
  {
    return storage_.begin();
  }
 
  [[nodiscard]] constexpr auto begin() const noexcept -> const std::byte *
  {
    return storage_.cbegin();
  }
 
  [[nodiscard]] constexpr auto end() noexcept -> std::byte *
  {
    return storage_.begin() + size_;
  }
 
  [[nodiscard]] constexpr auto end() const noexcept -> const std::byte *
  {
    return storage_.cbegin() + size_;
  }
 
  auto
  operator<=>(const socket_option &other) const noexcept -> std::strong_ordering
  {
    using std::memcmp;
    return (size_ == other.size_)
               ? memcmp(storage_.data(), other.storage_.data(), size_) <=> 0
               : size_ <=> other.size_;
  }
 
  auto operator==(const socket_option &other) const noexcept -> bool
  {
    return size_ == other.size_ &&
           std::memcmp(storage_.data(), other.storage_.data(), size_) == 0;
  }
 
private:
  std::array<std::byte, sizeof(value_type)> storage_{};
  size_type size_{sizeof(value_type)};
};
 
} // namespace io::socket
#endif // IO_SOCKET_OPTION_HPP