Change behavior based on template enum parameter - c++

Question

I've got a communication class which can handle 2 different protocols. The protocol is chosen by a enum template variable.
Now 1 of the 2 protocols only supports 2-byte values while the other supports 4-byte values.
Communicating is done via a template member function. How to change the static_assert so it takes 2 or 4 bytes depending on the class specialization (= chosen protocol)?
#include <iostream>
#include <math.h>
enum Protocol { P1, P2 };
template <Protocol P>
class Communicator {
public:
template <typename T>
void communicate(T arg) {
static_assert(sizeof(arg) <= sizeof(float), "argument size must be <= 4 bytes");
float value = (float)arg;
uint8_t length = sizeof(arg); //length in bytes
_communicate(value, length);
}
void _communicate(float f, uint8_t length) {
std::cout << f;
}
};
EDIT: I can just pick 1 answer as correct. And although I learned the most from Roy, I picked MM's answer because it keeps things as simple as possible. (upvoted both though)

Answer 1

There's several ways to approach this... here is one:
template<Protocol P>
size_t value_size();
template<> size_t value_size<P1>() { return 2; }
template<> size_t value_size<P2>() { return 4; }
// ... inside your other function
static_assert(sizeof(arg) <= value_size<P>(),

Answer 2

Here's a different approach
#include <iostream>
#include <math.h>
#include <cstdint>
// enum Protocol { P1, P2 }; // let's use types with traits instead.
struct P1
{
constexpr static const int protocol_id = 1;
//^^ or maybe use an enum
// type, this may need refactoring
// to fit your code and style.
using data_type = uint16_t; //< or whatever your 2-byte datatype is.
// can add more data traits and even static member functions here
// you could also add protocol specific non-static data if you add a
// P1 data member to your Communicator class.
// A struct with traits is a very good entry point for many compile-time
// polymorphism techniques.
};
struct P2
{
constexpr static const int protocol_id = 2;
using data_type = uint32_t; //< or whatever your 4-byte datatype is.
};
template <typename _Proto>
class Communicator {
public:
using data_type = typename _Proto::data_type;
constexpr static const int proto_id = typename _Proto::protocol_id;
public:
void communicate(data_type arg) // we can use the trait from either P1 or P2
{
float value = (float)arg;
uint8_t length = sizeof(data_type); //length in bytes
_communicate(value, length);
}
void _communicate(float f, uint8_t length)
{
std::cout << f;
}
};
Here's code to convert an enum (If that's what you already have to a class.
enum protocol_t { p1, p2 };
template <protocol_t _p> struct Protocol {};
// simply derive the template specialization from the desired type
template <> struct Protocol<p1> : P1 {};
// simply derive the template specialization from the desired type
template <> struct Protocol<p2> : P2 {};
You can also derive from P1, P2 to help organize code.
struct P1
{
// ... + specialized functions:
void _communicate(value_type x) { ... } // that you'll call from Communicator
void _communicate(const value_type* begin, const value_type* end) { ... }
};
struct P2 { /* same thing */ };
template <typename _Proto>
class Communicator : _Proto // < can control visibility here.
{ ... };