Container of points - c++

Question

I'm writing a class that stores points with X, Y, Z coordinates, where the specific definition of point is templated:
template<class T>
class Foo {
void add_point(T point);
}
Some functions in my class require to access the X,Y,Z components. The issue is that point types (defined by 3rd party libraries) don't have any common interface to access the coordinates. Some of them allow operator[] or operator(), others access by .x or .x().
What approach is better to address that? Should I add another template parameter with a function to access the coordinates? Or should I give up and keep an internal copy of the 3D point in the format I prefer?

Answer 1

Create a template function class who's job is to homogenise the interfaces between all types of point.
Like this:
#include <iostream>
// One kind of point
struct PointA
{
double& operator[](int which) {
return data[which];
};
double data[3];
};
// Another kind of point
struct PointB {
double& x() { return data[0]; }
double& y() { return data[1]; }
double& z() { return data[2]; }
double data[3];
};
// An object which homogenises interfaces
template<class Point>
struct get_coordinate {
double& x() const {
return get_x(p);
}
Point& p;
};
// some overloads
double& get_x(PointA& p) {
return p[0];
}
double& get_x(PointB& p) {
return p.x();
}
template<class Point>
struct Foo
{
void add_point(Point point) { p = point; }
double& x() {
// call through the homogeniser
return get_coordinate<Point>{p}.x();
}
Point p;
};
// test
int main()
{
Foo<PointA> fa;
fa.add_point(PointA{{1,2,3}});
std::cout << fa.x() << std::endl;
Foo<PointB> fb;
fb.add_point(PointB{{1,2,3}});
std::cout << fb.x() << std::endl;
}