tuple.hpp¶

Namespaces¶

Name
sgns
sgns::scale
sgns::scale::detail
sgns::scale::detail::tuple_impl

Classes¶

	Name
class	sgns::scale::detail::tuple_impl::TupleEncoder
class	sgns::scale::detail::tuple_impl::TupleDecoder

Functions¶

	Name
template <class F ,uint8_t index> void	apply_once(F & f)
template <uint8_t i,class F ,class Head ,class... T> void	for_each_apply_impl(F & f)
template <uint8_t i,class F > void	for_each_apply_impl(F & f)
template <class F ,class... T> void	for_each_apply(F & f)
template <class Stream ,class... T> Stream &	encodeTuple(const std::tuple< T... > & v, Stream & s) encodes std::tuple value
template <class Stream ,class... T> Stream &	decodeTuple(Stream & stream, std::tuple< T... > & result) decodes std::tuple value

Functions Documentation¶

function apply_once¶

template <class F ,
uint8_t index>
void apply_once(
    F & f
)

function for_each_apply_impl¶

template <uint8_t i,
class F ,
class Head ,
class... T>
void for_each_apply_impl(
    F & f
)

function for_each_apply_impl¶

template <uint8_t i,
class F >
void for_each_apply_impl(
    F & f
)

function for_each_apply¶

template <class F ,
class... T>
void for_each_apply(
    F & f
)

function encodeTuple¶

template <class Stream ,
class... T>
Stream & encodeTuple(
    const std::tuple< T... > & v,
    Stream & s
)

encodes std::tuple value

Parameters:

v tuple value
s encoder stream

Template Parameters:

Stream output stream type
T... sequence of types of the tuple

function decodeTuple¶

template <class Stream ,
class... T>
Stream & decodeTuple(
    Stream & stream,
    std::tuple< T... > & result
)

decodes std::tuple value

Parameters:

stream source stream
result destination tuple

Template Parameters:

Stream input stream type
T... sequence of types of the tuple

Return: decoded value or error

Source code¶

#ifndef SUPERGENIUS_SCALE_DETAIL_TUPLE_HPP
#define SUPERGENIUS_SCALE_DETAIL_TUPLE_HPP

#include <cstdint>
#include <tuple>

namespace sgns::scale::detail {
  namespace tuple_impl {
    template <class F, uint8_t index>
    void apply_once(F &f) {
      f.template apply<index>();
    }

    template <uint8_t i, class F, class Head, class... T>
    void for_each_apply_impl(F &f) {
      apply_once<F, i>(f);
      for_each_apply_impl<i + 1, F, T...>(f);
    }

    template <uint8_t i, class F>
    void for_each_apply_impl(F &f) {
      // do nothing, end of recursion
    }

    template <class Stream, class... T>
    class TupleEncoder {
     public:
      using tuple_type_t = std::tuple<T...>;
      TupleEncoder(const tuple_type_t &v, Stream &s) : v_{v}, s_{s} {}

      template <uint8_t index>
      void apply() {
        s_ << std::get<index>(v_);
      }

     private:
      const tuple_type_t &v_;
      Stream &s_;
    };

    template <class Stream, class... T>
    class TupleDecoder {
     public:
      using tuple_type_t = std::tuple<T...>;
      TupleDecoder(tuple_type_t &v, Stream &s) : v_{v}, s_{s} {}

      template <uint8_t index>
      void apply() {
        s_ >> std::get<index>(v_);
      }

     private:
      tuple_type_t &v_;
      Stream &s_;
    };

    template <class F, class... T>
    void for_each_apply(F &f) {
      tuple_impl::for_each_apply_impl<0, F, T...>(f);
    }
  }  // namespace tuple_impl

  template <class Stream, class... T>
  Stream &encodeTuple(const std::tuple<T...> &v, Stream &s) {
    auto &&encoder = tuple_impl::TupleEncoder(v, s);
    tuple_impl::for_each_apply<decltype(encoder), T...>(encoder);
    return s;
  }

  template <class Stream, class... T>
  Stream &decodeTuple(Stream &stream, std::tuple<T...> &result) {
    auto &&decoder = tuple_impl::TupleDecoder(result, stream);
    tuple_impl::for_each_apply<decltype(decoder), T...>(decoder);

    return stream;
  }

}  // namespace sgns::scale::detail

#endif  // SUPERGENIUS_SCALE_DETAIL_TUPLE_HPP

Updated on 2026-03-04 at 13:10:45 -0800