Agfdhyk

I have the following MWE:

#include <iostream>

#include <vector>



using namespace std;



class LegacyWidgetData

{

  private:

    double _a;

    double _b;



  public:

    LegacyWidgetData()

      : _a(0), _b(0)

    {}



    LegacyWidgetData(const double &a, const double &b) 

      : _a(a), _b(b)

    {}



    LegacyWidgetData(const LegacyWidgetData& w)

      : _a(w.a()), _b(w.b())

    {}



    inline double &a()

    {

      return _a;

    }



    inline double a() const

    {

      return _a;

    }



    inline double &b()

    {

      return _b;

    }



    inline double b() const

    {

      return _b;

    }

};



template <std::size_t D>

class GenericWidgetData

{

private:

  double data[D];



public:

  GenericWidgetData(double a, double b)

  {

    data[0] = a;

    data[1] = b;

  }



  GenericWidgetData(double a, double b, double c)

  {

    data[0] = a;

    data[1] = b;

    data[2] = c;

  }



  double get(int idx)

  {

    return data[idx];

  }



  void set(int idx, const double& v)

  {

    data[idx] = v;

  }

};



template <typename Iterator>

void dummyFunction(Iterator begin, Iterator end)

{

  for (auto it = begin; it != end; it++)

  {

    cout << "Before: " << it->a() << "," << it->b() << "t";

    it->a() += 1;

    it->b() -= 1;

    cout << "After: " << it->a() << "," << it->b() << "n";

  }

}



int main()

{

  vector<LegacyWidgetData> c1{{1, 2}, {3, 4}, {5, 6}};

  dummyFunction(c1.begin(), c1.end());



  vector<GenericWidgetData<3>> c2{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};



  // dummyFunction(c2.begin(), c2.end());  // Will not compile

  return 0;

}

I have the following assumptions/restrictions:

1. I cannot modify the implementation of LegacyWidgetData or dummyFunction
   


2. I can add methods to GenericWidgetData, and add any iterator adaptors as may be needed.

What I'd like to have is some sort of a iterator adaptor that when applied to any kind of iterator of GenericWidgetData gives me an iterator that acts like an iterator of LegacyWidgetData, without any caching/creation of intermediate object involved. Big props if this can be done in compile-time using template meta programming!

What you could do is add a template specialization to GenericWidgetData for when D == 2 and then implement the .a() and .b() functions to match LegacyWidgetData's interface.

Even if an iterator adapter that could switch at compile-time with some metaprogramming tricks could be written, it would be very complicated to be understood by anyone but its own writer.

If you have iterator adaptor, then you would typically need two such objects.

And if you have a lot of those algorithms, then it would make sense to hide the vector inside another class whose begin/end method would returns adaptors instead. Something more or less like that:

templace <std::size_t D> class MyContainer

{

public:

    MyAdaptor<D> begin();

    MyAdaptor<D> end();

private:

    std::vector<GenericWidgetData<D>> data;

};

However, it might make sense to simply add the appropriate functions to GenericWidgetData. In that case, you might want to have some specializations so that for example b() is only available if size is 2 or more etc.

Neverthless, the best solution would probably be to modify the 1000 functions so that instead of accessing directly members of LegacyWidgetData, then would call a free function.

double& b(LegacyWidgetData &data) { return data.b(); }

const double& b(const LegacyWidgetData &data) { return data.b(); }

And you would then add overloads for GenericWidgetData as appropriate. Using static_assertfor validation might work relatively well in that case:

template <std::size_t D> double& b(GenericWidgetData<D> &widgetData)

{

    static_assert(D > 1, "b is available only if D is big enough");

    return widgetData.data[D]; // Or an accessor function to avoid making it public

}

You would then add the const variation too.

It is more works but it is more flexible. For example, you can have proper validation of the dimension per function.

Alternatively, another solution is to have extra parameters to your algorithm for the transformation to apply.

template <typename Iterator, typename FA, typename FB>

void dummyFunction(Iterator begin, Iterator end, FA fa, FB fb)

{

  for (auto it = begin; it != end; it++)

  {

    cout << "Before: " << fa(*it) << "," << fb(*it) << "t";

    fa(*it) += 1;

    fa(*it) -= 1;

    cout << "After: " << fa(*it) << "," << fb(*it) << "n";

  }

}

This might seems a lot of work but then you are very flexible. So maybe, you can reconsider which code you want to modify.

It might be better to make such change now and have cleaner code in the future than to create an adaptor or add many functions to GenericWidgetData that are intended to be used only by the algorithms.