how to make my own container indexed and assignable - c++

Question

I have a container class like this:
class A {
public:
// assuming all the other operators used below
// have been defined.
// ...
A operator()(const A& a) const {
A r(a.size());
for (int i = 0;i < a.size();++i) r[i] = data[a[i]];
return r;
}
private:
std::vector<int> data;
};
so I can do things like this:
A a, b, c;
// ... initialize data here...
c = a(b); // I can index a by b
Now I want to make the indexed container a(b) assignable, e.g.
a(b) = c;
for example, if a is {1, 2, 3, 4} and b is {0,2}, c is {0,0}, the above line should give me a = {0,2,0,4}. because a indexed by {0,2} is {1,3} in a, and set them to c {0,0} will give me this.
how to do that?

Answer 1

You can't do it directly with the type A. You would need an intermediate type that maps or references back to the object. As a simple, non-optimal example:
#include <functional>
#include <vector>
class A
{
public:
class Ref
{
private:
friend class A;
std::vector<std::reference_wrapper<int>> refs;
Ref( A & obj, A & idx )
{
refs.reserve( idx.data.size() );
auto val_it = obj.data.begin();
for( auto i : idx.data ) {
ref.emplace_back( std::ref( data[i] ) );
}
}
public:
Ref & operator=( const A & obj )
{
auto obj_it = obj.data.begin();
for( auto ref : refs ) {
ref.get() = *obj_it++;
}
return this;
}
};
// ...
Ref operator()( const A & idx )
{
return Ref( *this, idx );
}
private:
std::vector<int> data;
};
And then things start getting fiddly, because you'll want to be able to convert between these reference-based views and the original type.
The easy way is to keep your const operator as you implemented (note that my one is non-const): i.e. it still returns type A, which makes sense. But you will probably want to be able to build a new A from a A::Ref, and so you'd want a constructor like:
A::A( const Ref & r )
{
data.reserve( r.refs.size() );
auto r_it = r.refs.begin();
for( auto ref : r.refs ) {
data.push_back( ref.get() );
}
}
Anyway, that's an easy concept to get you started, and something to play around with.

Answer 2

An array view is a view into a contiguous buffer of T:
template<class T>
struct array_view {
T* b=0;
T* e=0;
T* begin() const { return b; }
T* end() const { return e; }
std::size_t size() const { return end()-begin(); }
bool empty() const { return end()==begin(); }
T& operator[](std::size_t i)const { return begin()[i]; }
array_view( array_view const& ) = default;
array_view& operator=( array_view const& ) = default;
array_view() = default;
array_view( T* s, T* f ):b(s),e(f) {}
array_view( T* s, std::size_t n ):array_view(s, s+n) {}
};
template<class Src>
array_view< std::remove_reference_t<
decltype(*(std::declval<Src&>().data()))
> >
make_array_view( Src& src ) {
return {src.data(), src.size()};
}
(To make it better, do general "range" upgrades. const in the above case refers to "changing what range is viewed" not the contents -- if you want const contents, make an array_view<const T>. Another improvement would be to hvae constructors that do what make_array_view does, also supporting initializer_list, rvalues, and raw C arrays).
Given that, here is a permuted view of an array view of T.
First a permutation is a function from a bounded set of size_t to a different set of size_t.
struct permutation {
std::function< std::size_t(std::size_t) > mapping;
std::size_t count = 0;
std::size_t size() const { return count; }
permutation( std::function< std::size_t(std::size_t) > m, std::size_t c):
mapping(std::move(m)),
count(c)
{}
std::size_t operator()( std::size_t i )const {
return mapping(i);
}
};
This isn't the safest, because we don't check that the output range is reasonable.
A factory function:
template<class T>
permutation make_permutation_from( T src ) {
auto size = src.size();
return {
[src = std::move(src)]( std::size_t in ) {
return src[in];
},
size
};
}
// optimization
permutation make_permutation_from( permutation src ) {
return src;
}
and one to compose two permutations. The validity of the size field is not checked.
// if they don't align, we are screwed, but...
permutation chain_permutation( permutation first, permutation second ) {
auto first_size = first.size();
return {
[first=std::move(first), second=std::move(second)](std::size_t i){
return second(first(i));
},
first_size
};
}
This leads us to the permuted view, which is a view of an array_view that permutes indexes.
template<class T>
struct permuted_view {
array_view<T> source;
permutation permute;
std::size_t size() const { return permute.size(); }
T& operator[]( std::size_t i ) const {
return source[ permute(i) ];
}
template<class Src>
void assign_from( Src const& src ) {
if (src.size() != size()) exit(-1);
for (std::size_t i = 0; i < size(); ++i)
(*this)[i] = src[i];
}
void operator=( permuted_view const& src ) { assign_from(src); }
template<class U>
void operator=( U const& src ) { assign_from(src); }
template<class U,
std::enable_if_t< !std::is_integral<U>{}, int> =0
>
permuted_view<T> operator[]( U u )const {
return {
source,
chain_permutation( make_permutation_from(std::move(u)), permute )
};
}
};
Now a permuted_view<int> is a permutation on an array of int.
Note that permuted_view doesn't own anything. It just refers to someone else's storage. Ownership is something you'll have to work out for yourself. Maybe through smart pointers, or some other means.
Efficient libraries for this purpose probably have copy-on-write sparse arrays. To get this, it is a lot of work, or you should find a library like Eigen.
live example.
You'll want to add an iterator and begin/end to permuted_view. I'd make the iterator store a pointer to the view and an index, and have it use operator[] on the view when you dereference.
If you refactor array_view<T> into range_view<Iterator> with a specialization or subclass for T* iterators, you can then refactor range_view<Iterator> into range_helper<Iterator, Derived> with CRTP. Then reuse range_helper for permuted_view and for range_view, and range_view for array_view. But that is getting a bit off the reservation.
Various libraries, including Rangesv3 and boost and C++17 std and C++20 std::experimental and the like, have either written these types or make writing these types easier.