Блог

Я пытаюсь создать типобезопасную абстракцию для регистров. Кратко объяснено, что регистр может содержать поле битов, которые имеют какое-то особое значение, и рассматриваемые биты обычно могут быть либо установлены в диапазон допустимых значений (указанных перечислением), либо в любое целое значение (если оно указано). Поля в одном регистре описываются перечислением.

С чем у меня возникли некоторые проблемы, так это с тем, как мне создать шаблон, который позволяет мне указывать допустимые комбинации, чтобы это ЗНАЧЕНИЕ перечисления могло быть сопряжено только с а) значением, указанным перечислением б) любым целочисленным значением. Фактическая функция set одинакова для любой комбинации (она будет преобразована в базовое значение из значений класса enum). Следует также отметить, что я бы хотел, чтобы метод set() был универсальным таким образом, чтобы он находился в отдельном файле от фактических определений регистров, Поэтому добавление static_asserts() Туда и т. Д. Для предотвращения некоторых комбинаций типов и т. Д. Не Является хорошим решением. У меня есть решение, которое очень близко к тому, что я хочу, но я не уверен, как я могу заставить вычет типа шаблона работать, чтобы мне не нужно было вводить имя типа перечисления дважды за вызов.

 enum class Definitions : uint32_t
{
    kBit0       = 1UL << 0,
    kBit1       = 1UL << 1,
    kField0     = 0xF0,
    kField1     = 0xF00,
    kField2     = 0xF000
};

enum class Field0Values
{
    Setting1    = 0x01,
    Setting2    = 0x02,
};
enum class Field1Values
{
    Setting1    = 0x01,
    Setting2    = 0x02,
};

template<class MaskType, MaskType value> struct allowed_type;
template<> struct allowed_type<Definitions, Definitions::kField0> {
    using type = Field0Values;
};
template<> struct allowed_type<Definitions, Definitions::kField1> {
    using type = Field1Values;
};
template<> struct allowed_type<Definitions, Definitions::kField2> {
    using type = uint32_t;
};

template<class MaskType, MaskType maskValue>
constexpr void set(typename allowed_type<MaskType, maskValue>::type value) {}

int main()
{
    // Valid set operations
    set<Definitions, Definitions::kField0>(Field0Values::Setting1);
    set<Definitions, Definitions::kField1>(Field1Values::Setting1);
    set<Definitions, Definitions::kField2>(42);
    // Mistakes, will not compile
    set<Definitions, Definitions::kField0>(Field1Values::Setting1);
    set<Definitions, Definitions::kField1>(Field0Values::Setting1);
    set<Definitions, Definitions::kField1>(7);
}
  

Это почти то, что я хочу, за исключением того, что я хотел бы иметь возможность просто сказать set<Definitions::kField0>(Field0Values::Setting1) . Я МОГУ это сделать, если я объявлю специализацию шаблона, например:

 template<Definitions mask>
constexpr void set(typename allowed_type<Definitions, mask>::type value);
  

Но проблема в том, что я не хочу предоставлять реализацию для этой специализации, я просто хочу, чтобы она использовала базовую функцию шаблона, не уверен, как я могу это сделать. Как я могу получить вывод типа шаблона для определения типа без необходимости создания специализации шаблона?

Также интересно, есть ли у кого-нибудь другой подход, в котором нет проблемы с вычетом этого типа.

Как насчет установки аргумента шаблона auto в обоих allowed_type и set ?

 template<auto value> struct allowed_type;

template<> struct allowed_type<Definitions::kField0> {
    using type = Field0Values;
};

template<auto maskValue>
constexpr void set(typename allowed_type<maskValue>::type) {}
  

В качестве альтернативы, если вы предпочитаете сохранить allowed_type как есть, вы также можете изменить только set :

 template<auto maskValue>
constexpr void set(typename allowed_type<decltype(maskValue), maskValue>::type value) {}