在C ++中使用类型作为枚举包装C-API

Question

Currently, I write a C++ Wrapper for a C-Library which acts as the driver for a camera. The camera can be set with properties that can be float , bool or int . Each property has an ID which is member of an enum PropId . For each of these types, there is an attribute information struct , a function to get and set the value:

GetPropertyAttribsI
GetPropertyAttribsB
GetPropertyAttribsF
PropAttribsI
PropAttribsF
PropAttribsB
SetPropertyValueI
SetPropertyValueF
SetPropertyValueB

My problem is now that I want to write code to:

1. Check whether the property value to set is in bounds , else sets it to default. The bounds and default can be looked up in the PropAttribs struct , which can be initialized with the respective GetPropertyAttribs function.
2. Set the property with the corresponding SetPropertyValue(I,B,F)

I can look up the type of the property, it is in an enum (PROP_TYPE_INT, PROP_TYPE_FLOAT, PROP_TYPE_BOOL) .

So what I want is a function :

checkAndSanitizeProperty(T& value, PropId property)

that checks whether a given property is in bounds, else sets it to default.

The skeleton would be the following, but I do not know how I can make it so generic with template parameters that it is usable for bool and float without copying. The function for setting parameters is very similar to that, and should have the same solution if any is found.

void CameraHandle::checkAndSanitizeProperty(int& value, VRmPropId property, std::string name) {
  VRmPropInfo propInfo;
  VRM_CHECK(VRmUsbCamGetPropertyInfo(device, property, &propInfo));

  if (VRM_PROP_TYPE_INT != propInfo.m_type) {
    ROS_ERROR("Invalid type of property!");
  }

  VRmPropAttribsI attribs;
  VRmUsbCamGetPropertyAttribsI(device, property, &attribs);
  if (value < attribs.m_min || value > attribs.m_max) {
    ROS_WARN("Invalid value for parameter %s, has to be in [%d,%d], but was: %d",
             name.c_str(),
             attribs.m_min,
             attribs.m_max,
             value);

    ROS_WARN("Default will be used for %s: %d", name.c_str(), attribs.m_default);
    value = attribs.m_default;
  }
}

What gets on my nerves is that I have to repeat a lot of code, so I search for a cleaner solution. I do not mainly use C++, so I haven't got too much experience with template magic or C++ idioms.

Answer 1

Macro hackery.

#define CONCAT2( A, B ) A##B
#define CONCAT(A,B) CONCAT2(A,B)

#define MAP_STRUCT( X ) \
  template<class T> struct X; \
  template<class T> using CONCAT(X,_t) = typename X<T>::type; \
  template<> struct X<int> { \
    using type= CONCAT(X, I); \
  }; \
  template<> struct X<float> { \
    using type= CONCAT(X, F); \
  }; \
  template<> struct X<bool> { \
    using type= CONCAT(X, B); \
  };

takes a base structure name like VRmPropAttribs and makes it so that VRmPropAttribs_t<int> is VRmPropAttribsI .

#define CALL(X) CONCAT( call_, X )
#define MAP_FUNC_CALL(X) \
  template<class T> \
  struct CALL( X ); \
  template<> struct CALL(X)<int> { \
    template<class...Args> \
    auto operator()(Args&&...args)const \
    -> decltype( CONCAT(X,I)(std::declval<Args>()...) ) { \
      return CONCAT(X,I)(std::forward<Args>(args)...); \
    } \
  }; \

etc for B and F.

 #define MAP_FUNC(X) \
    MAP_FUNC_CALL(X) \
    template<class T, class...Args> \
    auto X(Args&&...args) \
    -> typename std::result_of< CALL(X)(Args...) > \
    { return CALL(X)<T>{}(std::forward<Args>(args)...); }

which defines a function template named X that, when passed int , calls XI with the same arguments.

Now, this doesn't handle your %d format strings and the like, but you can do things like:

VRmPropAttribs attribs; VRmUsbCamGetPropertyAttribs(device, property, &attribs); after you use the above macros. And once you can do the above, you can replace int with T and make your method a template method.

You'll also want a better version of VRM_PROP_TYPE_INT :

template<class T> struct vrm_prop_type{};
template<> struct vrm_prop_type<int>:
  std::integral_constant<int, VRM_PROP_TYPE_INT>
{};

etc lets you do:

vrm_prop_type<T>{} != propInfo.m_type

checks.