typedef struct FairingContext {
  /* Get coordinates of vertices which are adjacent to the loop with specified index.
   * Order of coordinates is <specify whether order is important or can be random>. */
  void (*adjacents_coords_from_loop)(struct FairingContext *context,
                                     const int loop,
                                     float r_adj_a[3],
                                     float r_adj_b[3]);
} FairingContext;

/* Subclass of FairingContext for the Mesh input data type. */
typedef struct MeshFairingContext {
  FairingContext context;

  Mesh *mesh;
} MeshFairingContext;

/* Subclass of FairingContext for the BMesh input data type. */
typedef struct BMeshFairingContext {
  FairingContext context;

  BMesh *bmesh;
} BMeshFairingContext;

static void mesh_adjacents_coords_from_loop_get(FairingContext *context,
                                                const int loop,
                                                float r_adj_a[3],
                                                float r_adj_b[3])
{
  MeshFairingContext *mesh_context = (MeshFairingContext *)context;
  /* The logic to access coordinates of adjacent coordinates. */
}

static void bmesh_adjacents_coords_from_loop_get(FairingContext *context,
                                                 const int loop,
                                                 float r_adj_a[3],
                                                 float r_adj_b[3])
{
  BMeshFairingContext *bmesh_context = (BMeshFairingContext *)context;
  /* The logic to access coordinates of adjacent coordinates. */
}

void BKE_mesh_prefair_and_fair_vertices(struct Mesh *mesh,
                                        struct MVert *deform_mverts,
                                        bool *affected_vertices,
                                        const int order);
{
  MeshFairingContext mesh_context;
  mesh_context.context.adjacents_coords_from_loop = mesh_adjacents_coords_from_loop_get;
  run_main_fairing_logic(&mesh_context.context);
}

void BKE_bmesh_prefair_and_fair_vertices(struct BMesh *bm,
                                         bool *affected_vertices,
                                         const int order)
{
  BMeshFairingContext bmesh_context;
  bmesh_context.context.adjacents_coords_from_loop = bmesh_adjacents_coords_from_loop_get;
  run_main_fairing_logic(&bmesh_context.context);
}

class FairingContext {
public:
  /* Get coordinates of vertices which are adjacent to the loop with specified index.
  * Order of coordinates is <specify whether order is important or can be random>. */
  virtual void adjacents_coords_from_loop(const int loop, float r_adj_a[3], float r_adj_b[3]) = 0;
};

class MeshFairingContext : public FairingContext {
public:
  explicit MeshFairingContext(Mesh *mesh) : mesh_(mesh)
  {
  }

  virtual void adjacents_coords_from_loop(const int loop,
                                          float r_adj_a[3],
                                          float r_adj_b[3]) override
  {
    /* Get adjacent coordinates using mesh_. */
  }

  void run_main_fairing_logic()
  {
    /* Implementation of algorithm which simply uses adjacents_coords_from_loop(loop, coord_a,
    * coord_b). */
  }

protected:
  Mesh *mesh_;
};

class BMeshFairingContext : public FairingContext {
public:
  explicit MeshFairingContext(Mesh *mesh) : mesh_(mesh)
  {
  }

  virtual void adjacents_coords_from_loop(const int loop,
                                          float r_adj_a[3],
                                          float r_adj_b[3]) override
  {
    /* Get adjacent coordinates using bmesh_. */
  }

protected:
  BMesh *bmesh_;
};

void BKE_mesh_prefair_and_fair_vertices(struct Mesh *mesh,
                                        struct MVert *deform_mverts,
                                        bool *affected_vertices,
                                        const int order);
{
  MeshFairingContext mesh_context(mesh);
  mesh_context.run_main_fairing_logic();
}

void BKE_bmesh_prefair_and_fair_vertices(struct BMesh *bm,
                                        bool *affected_vertices,
                                        const int order)
{
  BMeshFairingContext bmesh_context;
  mesh_context.run_main_fairing_logic();
}