BionxControl/main.cpp

/***************************************************************************

  BionxControl
  © 2025 -2026 christoph holzheuer
  christoph.holzheuer@gmail.com

  Using:

  mhs_can_drv.c
  © 2011 - 2023 by MHS-Elektronik GmbH & Co. KG, Germany
  Klaus Demlehner, klaus@mhs-elektronik.de
  @see www.mhs-elektronik.de

  Based on Bionx data type descriptions from:

  BigXionFlasher USB V 0.2.4 rev. 97
  © 2011-2013 by Thomas Koenig <info@bigxionflasher.org>
  @see www.bigxionflasher.org

  Bionx Bike Info
  © 2018 Thorsten Schmidt (tschmidt@ts-soft.de)
  @see www.ts-soft.de

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 3 of the License, or
  (at your option) any later version.
  @see https://github.com/bikemike/bionx-bikeinfo

 ***************************************************************************/


#include <QApplication>
#include <QFile>
#include <QDebug>

#include <QPushButton>
#include <QStatusBar>

#include <bcmainwindow.h>

/*
#ifdef _WIN32
#include <stdlib.h> // Stellt sicher, dass die Makros __argc und __argv bekannt sind

extern "C" {
// Wir definieren die fehlenden Import-Pointer manuell und
// leiten sie auf die echten Variablen der neuen MinGW-Laufzeitumgebung um.
int* __imp___argc = &__argc;
char*** __imp___argv = &__argv;
}
#endif
*/

/*
// Intermediäre CRTP-Schicht übernimmt die generische Implementierung
template <typename Derived, typename Base>
struct cloneable : public Base
{
  Derived* clone() override
  {
    return new Derived(static_cast<Derived const&>(*this));
  }
};


// Base bleibt sauber – nur pure virtual
struct base
{
  virtual base* clone() = 0;
  virtual void  moo() const = 0;
  virtual ~base() = default;
};

// Abgeleitete Klassen erben clone() automatisch
struct derived1 : public cloneable<derived1, base>
{
  void  moo() const override { qDebug() << " -- derived1 moo"; }
};

struct derived2 : public cloneable<derived2, base>
{
  void  moo() const override { qDebug() << " -- derived2 moo"; }
};
*/

// ---

/*
struct base
{
  virtual base* clone() = 0;
  virtual void moo() const = 0;
  virtual ~base() = default;
};


// CRTP-Schicht
template <typename Derived, typename Base>
struct cloneable : public Base
{
  Base* clone() override  // Base* statt Derived*
  {
    return new Derived(static_cast<Derived const&>(*this));
  }
};
*/

/*
 // Der Rückgabetyp wird exakt nach deinen Vorgaben zur Kompilierzeit ermittelt
 template <typename Self>
 auto makeD3(this Self&& self) -> std::conditional_t<
   std::is_const_v<std::remove_reference_t<Self>>,
   const derived3&,
   derived3&>
 {
   // Da der Rückgabetyp in der Signatur festgeschrieben ist,
   // reicht ein einfaches return. Der Compiler bindet die Referenz automatisch korrekt.
   return self;
 }

 - 2. Der CRTP-Klon-Automatismus

 - Das NVI-Pattern (Non-Virtual Interface) in Kombination mit CRTP ist eine der elegantesten Architekturen im modernen C++, um dieses Problem zu lösen.
 */

/*
// Abgeleitete Klassen erben clone() automatisch
struct derived1 //: public cloneable<derived1, base>
{

  // Eine einzige Methode für beide Value Categories
  auto& nimmMich(this auto& self)
  {
    return self;
  }

};


struct derived2 : public cloneable<derived2, base>
{
  void moo() const override { qDebug() << " -- derived2 moo"; }

  void mooDerived2() const { qDebug() << " -- derived2 moo"; }






  void machWasKonstantes() const
  {

    const derived1& d3 = d1.nimmMich();
  }

  void machWasSchmutziges()
  {
    derived1& d3 = d1.nimmMich();
  }


private:

  derived1 d1;

};



struct derived3 : public cloneable<derived3, base>
{
  void moo() const override { qDebug() << " -- derived3 moo"; }

  derived3* clone() override  // Base* statt Derived*
  {
    return new derived3;
  }


  derived2 m_myD2;

};
*/

/*
  Das NVI-Pattern (Non-Virtual Interface) in Kombination mit CRTP ist eine der elegantesten Architekturen
  im modernen C++, um dieses Problem zu lösen. Der Trick dabei beruht auf einer C++-Eigenheit: Die Sprache unterstützt "Kovarianz"
  (Covariant Return Types) nativ nur bei rohen Zeigern und Referenzen, nicht aber bei Templates wie std::unique_ptr.
*/

int main(int argc, char *argv[])
{

  qDebug() << "Starting NtxNode XML Test Suite...";

  /*
  derived2 myDerived2;
  base& d2 = *myDerived2.clone();
  d2.moo();

  derived3 myDerived3;
  derived3& d3 = *myDerived3.clone();
  d3.moo();

  return 0;
*/

  QApplication app(argc, argv);


  BCMainWindow w;
  w.show();

  return app.exec();

  // 🌙☀️ !
}