C++11 mapping for IDL sequence

I would prefer not to introduce any custom container types unless absolutely necessary, especially since any conversion operators would require deep copies of underlying data. Move semantics would not help in this case as both the "real" template container and the std::vector conversion would need to exist so there could be no safe moving.

At a minimum I think there should be a solution like the Java mapping where the check would be at marshaling time. The middleware could then throw a CORBA::MARSHAL (or similar) exception if encountering a bounded sequence which has more than its maximum number of elements.

A possible additional check could be made by creating a set of traits for sequences (and perhaps other types) where the bound is one of the traits.

For example:


// IDL
module Example
{
typedef sequence<double> UnboundedDoubleSeq;
typedef sequence<double, 32> BoundedDoubleSeq;
};



// specialization of a template standard in mapping
template<>
struct SequenceTraits<Example::UnboundedDoubleSeq>
{
typedef double value_type ;
static constexpr bool is_bounded = false;
static constexpr uint32_t bound = std::numeric_limits<uint32_t>::max();
};



// specialization of a template standard in mapping
template<>
struct SequenceTraits<Example::BoundedDoubleSeq>
{
typedef double value_type ;
static constexpr bool is_bounded = true;
static constexpr uint32_t bound = 32;
};


Then users could just compare SequenceTraits<T>::bound to the return value of size(). This would also be useful to the middleware itself as the implementation could use the same traits for its marshaling checks.

The reason lots of STL functions take iterators is that you can write generic template functions that do not care what the types of the iterators are. That clearly won't apply when passing sequences as arguments in CORBA operations, because they can't sensibly be template functions.