C++ brain teaser - filtering a parameter pack

Question

0.00/5 (No votes)

See more:

Disclaimer: I am targeting embedded, and the STL isn't always available/compliant/responsible on those platforms, so my code doesn't use it at all. Furthermore, I am self taught in this arena so my terminology may be wrong. I will do my best to describe what I want so even if my vocabulary is off kilter hopefully you'll still understand it. I'd ideally like to target C++14, but C++17 is acceptable. No compiler specific extensions are acceptable, nor is any code that may break a particular compiler from a major vendor.

I have a pixel<> template struct, itself composed of one or more channel_trait<> template structs that are passed in via a variadic template argument.

C++

// represents the pixel base class
template<typename... ChannelTraits> 
struct pixel {
    // this type
    using type = pixel<ChannelTraits...>;
...

It has several constructors, some with hateful but unavoidable dummy bool arguments.

C++

// initializes the pixel
constexpr inline pixel() : native_value(0) {
    helpers::pixel_init_impl<type,0,ChannelTraits...>::init(*this);
}
constexpr inline pixel(int_type native_value,bool dummy) : native_value(native_value) {
}
// initializes the pixel with a set of channel values
constexpr inline pixel(typename ChannelTraits::int_type... values) : native_value(0) {
    helpers::pixel_init_impl<type,0,ChannelTraits...>::init(*this,values...);
}
// initializes the pixel with a set of floating point values between 0 and 1.0
constexpr inline pixel(
    bool dummy,
    typename ChannelTraits::real_type... values) : native_value(0) {
    helpers::pixel_init_impl<type,0,ChannelTraits...>::initf(*this,values...);
}

These constructors - two in fact are what are vexing me.

Say I declare a pixel with some padding bits in it that aren't used:

C++

// creates a 24-bit pixel, 6 bits
// unused, the other 18 are RGB666 
// color
using rgb18_pixel = pixel<
    // red channel
    channel_traits<channel_name::R,6>,
    // unused
    channel_traits<channel_name::nop,2>,
    // green channel
    channel_traits<channel_name::G,6>,
    // unused
    channel_traits<channel_name::nop,2>,
    // blue channel
    channel_traits<channel_name::B,6>,
    // unused
    channel_traits<channel_name::nop,2>
>;

This forces me to use 6 values in the constructor, 3 of which are never going to be used for anything (all the ::nop traits)

C++

#define UNUSED 0
rgb18_pixel foo(1,UNUSED,3,UNUSED,5,UNUSED);

Now, it's easy to query each channel_trait to find out if it's an unused channel or not. But what I can't do is get any kind of ::int_type... values off of a subset of ChannelTraits... that only has the used channels.

I can run a separate query to get that, but I can't repack a parameter pack as far as I know?

What I have tried:

I tried swapping out ::int_type for another alias I make ::initializer_int_type

I set it to void for the nop channels. I got a compiler error, so clearly I can't coerce it into dropping those arguments from the constructor that way.

I'm not sure where to go with this? Some kind of templatized ctor?

Posted 23-Jun-24 8:24am

honey the codewitch

Add a Solution

Comments

Peter_in_2780 23-Jun-24 22:03pm

I don't know if this sword can be beaten into a plowshare, but in the good 'ol K&R C days, a bit-field struct could include unnamed (and therefore unreferencable) fields.
K&R 1978 p 138:
...Fields need not be named; unnamed fields (a colon and width only) are used for padding....

honey the codewitch 23-Jun-24 22:04pm

unfortunately, there's no such corollary with values... here in C++ as the same name is essentially applied to every argument.

honey the codewitch 23-Jun-24 22:06pm

Oh and as far as me representing pixels as bitfield structs, that's not practical here for a number of reasons.

Josef Schroettle 24-Jun-24 4:15am

The best way to deal with parameter packs is using std::tuple, you can create a tuple type from the parameter pack type and then filter the tuple type. Later the tuple can be converted back to a parameter pack or used directly. All those operations can be found on stackoverflow. C++17 might be needed...

honey the codewitch 24-Jun-24 4:46am

Interesting. I did not know it was possible to produce a parameter pack in these versions of C++. That's what I need. I can't use std::tuple but it's using C++ language features so I just need to figure it out.

Josef Schroettle 24-Jun-24 4:56am

Why can't you use std::tuple when you use c++14 (std::tuple is c++11)?

Josef Schroettle 24-Jun-24 5:01am

If you really can't use std::tuple then you should search for 'typelist' (or similar). They are pretty old (c++11) and were before std::tuple. But I would definitely recommend std::tuple, there are many algorithms (e.g. filter, flatten) for tuple available (on the internet)

honey the codewitch 24-Jun-24 5:03am

hazards of embedded, if I use std::tuple<> I've got to enumerate all the embedded platforms that don't support it properly so I can make it work for those. 8 and 16 bit AVRs are a good example of a platform whose STL implementation is incomplete and/or non-compliant. Not using it is a lot less work.

Josef Schroettle 24-Jun-24 5:09am

Ah', yes. That can be hard. In my world (embedded safety critical) we now use 32-bit ARM which can use the 'normal' gcc toolchain. But c++ is still a pain in safety critical devices...

honey the codewitch 24-Jun-24 5:11am

I'd love to tie my graphics library to ARM, but alas, it would greatly narrow its use for IoT and hobbyist endeavors which is probably where other people use it the most. I wrote it for use in professional projects because I needed a lib I could add features to. Plus when I wrote it, Mine was the only lib to support TTF in under 192KB of SRAM total system memory. (I don't know how little it requires actually, and it kind of depends on the font). It also supports SVG, and is the only embedded lib to do so, to my knowledge.

Josef Schroettle 24-Jun-24 5:13am

This might be relevant: https://aherrmann.github.io/programming/2016/02/28/unpacking-tuples-in-cpp14/

honey the codewitch 24-Jun-24 5:37am

Thanks. Looking now.

Josef Schroettle 26-Jun-24 9:22am

Regarding your question in the lounge, the pixel::channel function can also have a template parameter pack. If the class 'pixel' has a parameter pack every function in the class is independent of that and can have a parameter pack again. So yes, there can only be one parameter pack for every 'template' keyword but you have here two 'template' keywords, one for the class and one for the function.
I have created a short reproducer to show the concept but cannot attach a file here.
I did not answer in the Lounge as programming questions are not liked there :-)

honey the codewitch 26-Jun-24 10:23am

The problem isn't there. It's when I actually go to use it, I ended up needing two. One for the names, and one to get the info for each channel so I can actually set it.

Josef Schroettle 26-Jun-24 10:39am

Ok, but I don't get that. The channel() function has only template parameters 'Name1'... which could be a parameter pack. As I wrote, template parameter packs are very limited (will be slightly better in c++23) and everyone I know converts them to std::tuple, does the processing on std::tuple and then unpacks the tuple again (std::apply). And no, this is not 'obscure' :-)
What do you mean with 'when I actually go to use it'?

honey the codewitch 26-Jun-24 10:41am

template<typename name="">
constexpr inline void channel(typename channel_by_index<channel_index_by_name<name>::value>::int_type value) {
constexpr const int index = channel_index_by_name<name>::value;
channel<index>(value);
}

and then

template<typename name=""> using channel_index_by_name = typename helpers::channel_index_by_name_impl<0,Name,ChannelTraits...>;

Josef Schroettle 26-Jun-24 10:46am

Ok, thanks. I see if I can come up with an idea.

honey the codewitch 26-Jun-24 10:49am

actually someone just solved it for me. Thanks!

and it was simple. so simple I feel dumb. LOL

// sets the integer channel value by name
template<typename name="">
constexpr inline void channel(typename channel_by_index<channel_index_by_name<name>::value>::int_type value) {
constexpr const int index = channel_index_by_name<name>::value;
channel<index>(value);
}

// sets the integer channel values by name
template<typename name1,="" typename...="" names="">
constexpr inline void channel(typename channel_by_index<type::channel_index_by_name<name1>::value>::int_type value1,
typename type::channel_by_index<channel_index_by_name<names>::value>::int_type... values) {
constexpr const int index1 = type::channel_index_by_name<name1>::value;
channel<index1>(value1);
channel<names...>(values...);
}

Josef Schroettle 26-Jun-24 10:52am

Yep, that is the problem in software :-)
The solution is most of the time simple. But finding it is hard...

Josef Schroettle 26-Jun-24 9:38am

And btw, you don't need that 'dummy bool'. You can selectively enable overloaded functions on its types using std::enable_if (in <type_traits>). In c++20 you could use concepts which are easier to write (and read) but they are more or less syntactic sugar similar to std::enable_if

honey the codewitch 26-Jun-24 10:23am

I'll have to figure out SFINAE with std to do that.

1 solution

Add a Solution

Add your solution here

Treat my content as plain text, not as HTML

Preview 0

…

Existing Members

Sign in to your account

...or Join us

Download, Vote, Comment, Publish.

Your Email
Password
Forgot your password?

Your Email
This email is in use. Do you need your password?
Optional Password

I have read and agree to the Terms of Service and Privacy Policy
Please subscribe me to the CodeProject newsletters

When answering a question please:

Read the question carefully.
Understand that English isn't everyone's first language so be lenient of bad spelling and grammar.
If a question is poorly phrased then either ask for clarification, ignore it, or edit the question and fix the problem. Insults are not welcome.
Don't tell someone to read the manual. Chances are they have and don't get it. Provide an answer or move on to the next question.

Let's work to help developers, not make them feel stupid.

This content, along with any associated source code and files, is licensed under The Code Project Open License (CPOL)

honey the codewitch · Accepted Answer · 2024-06-26T04:50:00

Someone on reddit solved it for me. Not with the constructor though, but this allows me to set multiple channels, by name with one call.

C++

// sets the integer channel value by name
template<typename Name>
constexpr inline void channel(typename channel_by_index<channel_index_by_name<Name>::value>::int_type value) {
    constexpr const int index = channel_index_by_name<Name>::value;
    channel<index>(value);
}
        
// sets the integer channel values by name
template<typename Name1, typename... Names>
constexpr inline void channel(typename channel_by_index<type::channel_index_by_name<Name1>::value>::int_type value1,
                                typename type::channel_by_index<channel_index_by_name<Names>::value>::int_type... values) {
    constexpr const int index1 = type::channel_index_by_name<Name1>::value;
    channel<index1>(value1);
    channel<Names...>(values...);
}