libs/vr/libpdx/private/pdx/rpc/argument_encoder.h

#ifndef ANDROID_PDX_RPC_ARGUMENT_ENCODER_H_
#define ANDROID_PDX_RPC_ARGUMENT_ENCODER_H_

#include <cstdint>
#include <tuple>
#include <type_traits>

#include <pdx/rpc/serialization.h>
#include <pdx/service.h>

namespace android {
namespace pdx {
namespace rpc {

// Provides automatic serialization of argument lists and return
// values by analyzing the supplied function signature types.
// Examples:
//     ArgumentEncoder<int(int, float)> encoder(writer);
//     encoder.EncodeArguments(1, 1.0);

template <typename T>
class ArgumentEncoder;

// Specialization of ArgumentEncoder for void return types.
template <typename... Args>
class ArgumentEncoder<void(Args...)> {
 public:
  explicit ArgumentEncoder(MessageWriter* writer) : writer_{writer} {}

  // Serializes the arguments as a tuple.
  void EncodeArguments(Args... args) {
    Serialize(std::forward_as_tuple(args...), writer_);
  }

 private:
  MessageWriter* writer_;
};

// Specialization of ArgumentEncoder for non-void return types.
template <typename Return, typename... Args>
class ArgumentEncoder<Return(Args...)> {
 public:
  // Simplified types with reference and cv removed.
  using ReturnType = typename std::decay<Return>::type;

  explicit ArgumentEncoder(MessageWriter* writer) : writer_{writer} {}

  // Serializes the arguments as a tuple.
  void EncodeArguments(Args... args) {
    Serialize(std::forward_as_tuple(args...), writer_);
  }

  // Serializes the return value for rvalue references.
  void EncodeReturn(const ReturnType& return_value) {
    Serialize(return_value, writer_);
  }

 private:
  MessageWriter* writer_;
};

// Utility to build an ArgumentEncoder from a function pointer and a message
// writer.
template <typename Return, typename... Args>
inline ArgumentEncoder<Return(Args...)> MakeArgumentEncoder(
    Return (*)(Args...), MessageWriter* writer) {
  return ArgumentEncoder<Return(Args...)>(writer);
}

// Utility to build an ArgumentEncoder from a method pointer and a message
// writer.
template <typename Class, typename Return, typename... Args>
inline ArgumentEncoder<Return(Args...)> MakeArgumentEncoder(
    Return (Class::*)(Args...), MessageWriter* writer) {
  return ArgumentEncoder<Return(Args...)>(writer);
}

// Utility to build an ArgumentEncoder from a const method pointer and a
// message writer.
template <typename Class, typename Return, typename... Args>
inline ArgumentEncoder<Return(Args...)> MakeArgumentEncoder(
    Return (Class::*)(Args...) const, MessageWriter* writer) {
  return ArgumentEncoder<Return(Args...)>(writer);
}

// Utility to build an ArgumentEncoder from a function type and a message
// writer.
template <typename Signature>
inline ArgumentEncoder<Signature> MakeArgumentEncoder(MessageWriter* writer) {
  return ArgumentEncoder<Signature>(writer);
}

//////////////////////////////////////////////////////////////////////////////
// Provides automatic deserialization of argument lists and return
// values by analyzing the supplied function signature types.
// Examples:
//     auto decoder = MakeArgumentDecoder<std::string(void)>(reader);
//     ErrorType error = decoder.DecodeReturn(&return_value);

template <typename T>
class ArgumentDecoder;

// Specialization of ArgumentDecoder for void return types.
template <typename... Args>
class ArgumentDecoder<void(Args...)> {
 public:
  // Simplified types with reference and cv removed.
  using ArgsTupleType = std::tuple<typename std::decay<Args>::type...>;

  explicit ArgumentDecoder(MessageReader* reader) : reader_{reader} {}

  // Deserializes arguments into a tuple.
  ArgsTupleType DecodeArguments(ErrorType* error) {
    ArgsTupleType value;
    *error = Deserialize(&value, reader_);
    return value;
  }

 private:
  MessageReader* reader_;
};

// Specialization of ArgumentDecoder for non-void return types.
template <typename Return, typename... Args>
class ArgumentDecoder<Return(Args...)> {
 public:
  // Simplified types with reference and cv removed.
  using ArgsTupleType = std::tuple<typename std::decay<Args>::type...>;
  using ReturnType = typename std::decay<Return>::type;

  explicit ArgumentDecoder(MessageReader* reader) : reader_{reader} {}

  // Deserializes arguments into a tuple.
  ArgsTupleType DecodeArguments(ErrorType* error) {
    ArgsTupleType value;
    *error = Deserialize(&value, reader_);
    return value;
  }

  // Deserializes the return value.
  ErrorType DecodeReturn(ReturnType* value) {
    return Deserialize(value, reader_);
  }

 private:
  MessageReader* reader_;
};

// Utility to build an ArgumentDecoder from a function pointer and a message
// reader.
template <typename Return, typename... Args>
inline ArgumentDecoder<Return(Args...)> MakeArgumentDecoder(
    Return (*)(Args...), MessageReader* reader) {
  return ArgumentDecoder<Return(Args...)>(reader);
}

// Utility to build an ArgumentDecoder from a method pointer and a message
// reader.
template <typename Class, typename Return, typename... Args>
inline ArgumentDecoder<Return(Args...)> MakeArgumentDecoder(
    Return (Class::*)(Args...), MessageReader* reader) {
  return ArgumentDecoder<Return(Args...)>(reader);
}

// Utility to build an ArgumentDecoder from a const method pointer and a
// message reader.
template <typename Class, typename Return, typename... Args>
inline ArgumentDecoder<Return(Args...)> MakeArgumentDecoder(
    Return (Class::*)(Args...) const, MessageReader* reader) {
  return ArgumentDecoder<Return(Args...)>(reader);
}

// Utility to build an ArgumentDecoder from a function type and a message
// reader.
template <typename Signature>
inline ArgumentDecoder<Signature> MakeArgumentDecoder(MessageReader* reader) {
  return ArgumentDecoder<Signature>(reader);
}

}  // namespace rpc
}  // namespace pdx
}  // namespace android

#endif  // ANDROID_PDX_RPC_ARGUMENT_ENCODER_H_