We have a class with a integer member, and a BMI container for instances of this class.

That member is supposed to be unique, *except* for a special "invalid" value (-1),

which several instances can use.

Right now, we use an ordered_non_unique index, because of the -1's, but that leaves

the door open for other duplicate "valid" values, which should be forbidden.

So my question is whether one can index this member uniquely, thanks to a custom

comparator, such that the comparator does not violate the usual strict-weak-ordering

requirement of ordered containers? I'm thinking kinda like SQL NULLs, which don't

compare equal to each other, i.e. in this case -1 would never equal another -1, and use

another arbitrary (but stable) ordering specifically for those -1's. This assumes though

I can know which instance the int member is part of, i.e. will the comparator get the integer

by value or reference, and if a reference, is that a reference to the "internal" element,

such that the arbitrary order can be the address of the element for example? Or to avoid

element movement in case of reallocs in the container, can the comparator access an

iterator to project it into another random-access index of the same container, to use that

index's integer-index as the arbitrary order?

I'd appreciate some feedback/insights into the above. Thanks, --DD