Wt

There are issues with the self() function if Inheriting from a Wt::Dbo::Dbo

class BaseClass : public Wt::Dbo::Dbo<BaseClass
{
};
class NextClass : public BaseClass
{
Wt::Dbo::ptr<NextClass> me(){ return self(); } // call to self is ambiguous
};
class NextDboClass : public BaseClass, public Wt::Dbo::Dbo<NextDboClass>
{
Wt::Dbo::ptr<NextDboClass> me(){ return self(); } // call to self is ambiguous // in both variations
};

error: reference to 'self' is ambiguous
/usr/local/include/Wt/Dbo/ptr_impl.h:692:8: note: candidates are: 'Wt::Dbo::ptr<C> Wt::Dbo::Dbo<C>::self() const [with C = NextClass]'
  692 | ptr<C> Dbo<C>::self() const
      |        ^~~~~~
/usr/local/include/Wt/Dbo/ptr_impl.h:692:8: note:                 'Wt::Dbo::ptr<C> Wt::Dbo::Dbo<C>::self() const [with C = BaseClass]'

error: request for member 'meta_' is ambiguous
  502 |   static void setMeta(C& obj, MetaDbo<C> *m) { obj.meta_ = m; }
      |                                                ~~~~^~~~~
/usr/local/include/Wt/Dbo/ptr.h:494:15: note: candidates are: 'Wt::Dbo::MetaDbo<NextClass>* Wt::Dbo::Dbo<NextClass>::meta_'
  494 |   MetaDbo<C> *meta_;
      |               ^~~~~
/usr/local/include/Wt/Dbo/ptr.h:494:15: note:                 'Wt::Dbo::MetaDbo<BaseClass>* Wt::Dbo::Dbo<BaseClass>::meta_'

I managed to implement something:

// ConnectorTable.h
template <class Base, class Derived>
class ConnectorTable
{
protected:
  Wt::Dbo::ptr<Base> basePtr;
  Wt::Dbo::ptr<Derived> derivedPtr;

public:
  static std::string fieldName()
  {
    return Wt::WString("derived_{1}_to_{2}")
    .arg(Base::refName())
    .arg(Derived::refName())
    .toUTF8();
  }
  static std::string refName()
  {
    return Wt::WString("{1}_{2}_Connector")
    .arg(Base::refName())
    .arg(Derived::refName())
    .toUTF8();
  }

  ConnectorTable() { }
  ConnectorTable(Wt::Dbo::ptr<Base> bPtr, Wt::Dbo::ptr<Derived> dPtr)
    : basePtr(bPtr), derivedPtr(dPtr) {}

  virtual ~ConnectorTable() {}

  Wt::Dbo::ptr<Derived> getDerived() const { return derivedPtr; }
  Wt::Dbo::ptr<Base> getBase() const { return basePtr; }

  template <class Action>
  void persist(Action &a)
  {
    Wt::Dbo::belongsTo(
        a, 
        basePtr, 
        "base", 
        Wt::Dbo::OnDeleteCascade | Wt::Dbo::OnUpdateCascade
    );
    Wt::Dbo::belongsTo(
        a, 
        derivedPtr, 
        fieldName(),
        Wt::Dbo::OnDeleteCascade | Wt::Dbo::OnUpdateCascade
    );
  }
};

// Extra Functions to get direct Relation Objects

template <class Base, class Derived>
Wt::Dbo::ptr<Derived> getDerived(Wt::Dbo::ptr<Base> bPtr)
{
  Wt::Dbo::Transaction t(dataSession());
  auto query = t.session().find<ConnectorTable<Base, Derived>>().where("base_id = ?").bind(bPtr);
  auto result = query.resultValue(); // either 1 or 0 results

  if(!result)
    return {};

  return result->getDerived();
}

template <class Base, class Derived>
Wt::Dbo::ptr<Base> getBase(Wt::Dbo::ptr<Derived> dPtr)
{
  Wt::Dbo::Transaction t(dataSession());

  auto query = 
    t.session().find<ConnectorTable<Base, Derived>>().where(
        ConnectorTable<Base,Derived>::fieldName() + "_id = ?"
    ).bind(dPtr);

  auto result = query.resultValue();

  if(!result)
    return {};

  return result->getBase();
}

This class can be defined for Dbo at the same time as the Derived Class and then added in the mapClass calls

//Derived.h

#include "Base.h"
#include "ConnectorTable.h"

class Derived;

typedef ConnectorTable<Base, Derived> BaseDerivedConnector

class Derived : public Base
{
  Derived() {}
  static std::string refName() { return {"Derived"}; }

  virtual Wt::Dbo::ptr<Base> getBase() const;

  template <class Action>
  void persist(Action &a);

private:
  Wt::Dbo::weak_ptr<BaseDerivedConnector> baseConPtr;
  Wt::Dbo::ptr<Base> basePtr;

protected:
  bool has_derived = false;
  void updateValues(const Derived* values);
};

DBO_EXTERN_TEMPLATES(BaseDerivedConnector)
DBO_EXTERN_TEMPLATES(Derived)

With a few tweaks in the persist function:

// Derived.cpp
template <class Action>
void Derived::persist(Action &a)
{
  if (typeid(a) == typeid(Wt::Dbo::SessionAddAction))
  {
    // Insert action
    // Add the current Object as a Base
    basePtr = dataSession().addNew<Base>(this);
  }

  // Define the fields and connections
  Wt::Dbo::hasOne(
    a, 
    baseConPtr,        
    BaseSpecialConnector::fieldName()
  );
  Wt::Dbo::belongsTo(a, basePtr);

  if (typeid(a) == typeid(Wt::Dbo::LoadDbAction<Derived>))
  {
    // Load action, after the fields Definition
    // Fill the current Base Object with Values from DB
    Base::updateValues(basePtr.get());
    // like Copy Constructor, but just updating Values
  }
}

The Only important functions within each Class that wants to enable the use of Inheritance with this ConnectTable Template are:

private:
  Wt::Dbo::ptr<BaseClass> basePtr; // might be optional, but easier to set Internal Values
protected:
  bool has_derived; // To be set from next Inheriting // enables looping through selection and looking for more
  void updateValues(const Class* values); // called from next Inheriting
public:
  static std::string refName(); //with the Name of The Class // Called for RelationNames