Feature request: etl::constant_map

[relativityspace-jsmith]

Hi! I would like to put in a request for a new collection in etl. My coworkers and I have seen the need for this several times now, and it would be really incredible if it could be added.

What I would love is a collection that works like an etl::map, except:

• The map must be populated with elements when initialized
• The map keys and values are constant and cannot be added, removed, or modified
• The map can be declared constexpr if you have compiler support (Hoping for C++17 compatibility🙏)

This collection would be super useful for storing constant mappings between one thing and another thing, which is a problem that comes up quite often in embedded development.

For a simple example of why this would be useful, let's look at a basic system for pin mapping:

typedef uint32_t PinNumber;
typedef uint8_t PinFunction;

// Maps a pin number to the needed pin function number to use it for PWM
const etl::map<PinNumber, PinFunction, 50> PWM_PINMAP = {
     {10, 3},
     {2, 5},
     {7, 6},
     ...
};

An etl::map is very useful for this kind of thing, because it gives us an efficient way to search the map based on a given pin number. However, etl::map is not constexpr -- it has to be constructed in RAM, at runtime, based on the initialization data. This leads to two pretty major downsides:

1. This constant pinmapping data now takes up space in both RAM (for the map object) and flash (for the initialization data). Since it's constant, it would be ideal for the data to live only in flash. Plus, the map has a fair amount of overhead compared to a constant array containing the same data -- understandable for a mutable container but unneeded for this use case.
2. Because the map has a constructor that needs to be run, it's unsafe to use from any other global constructor. This kind of thing can be a major landmine -- you write code that works fine for months and then all of the sudden you get a hard fault when you call it from something that is called from a global object's constructor. It's bitten me personally multiple times with etl::map specifically.

Hopefully you see why the etl::constant_map (or whatever you'd like to call it) would be useful: it would solve both of these downsides by allowing the compiler to construct the entire map in memory at compile time and then put it into flash memory instead of RAM. I'd really love it if we had a tool like this, as currently we need to use constexpr arrays of pairs, linear searched at runtime, in applications like what I discussed. Alternately, if it's possible to accomplish this using something else in libstdc++ or etl, please let me know, as I'm not aware of a readily available method.

P.S. As for how to implement etl::constant_map, I think the easiest way would be to create an array of pairs that gets sorted at compile time. Then find() could be implemented as a binary search, providing O(logn) runtime.

[relativityspace-jsmith]

Update: Looks like this may already exist 🤦
https://www.etlcpp.com/const_map.html

We will give this a shot, looks like you're way ahead of us!

[jwellbelove]

It was added 10th July!