overrides bei Mehrfachvererbung

Wird ein Methode überladen, so muss der Klassenname vorangesetzt werden:

bitmap contains
{
  update is public virtual code := print "bitmap update";
};

signal contains
{
  update is public virtual code := print "signal update";;
};

test is implicit bitmap, signal
{
  override bitmap
  {
    update is code := print "overriden bitmap update";
  };
  
  override signal
  {
    /* implicit sagt aus, dass diese Funktion im Namensraum test auffindbar ist */
      
    update is code := print "overriden signal update";
  }
  
  // update ist hier unbekannt.
};

override kann auch Funktionen spezialisieren:

SegmentInterface contains
{
  Create is abstract code() as SegmentInterface ptr;
};

SegmentImpl contains implicit SegmentInterface
{
  /* Diese Funktion implementiert Create als code() as SegmentInterface ptr, überschreibt jedoch
     Rückgaben und out-Parameter so, dass Ableitungen zurückgegeben werden können.
     
     Damit steht fest, dass SegmentImpl::Create() ein SegmentImpl zurück gibt, was ein SegmentInterface
     ist. Es ist so aber spezifischer. Die Funktion SegmentImpl::Create() kann hiermit nur noch SegmentImpl ptr
     zurückgeben. */    
   
  Create is code() as SegmentInterface ptr
    override (void) as SegmentImpl ptr;  
};

Das Problem:

        // Atr: Ursprüngliche Fassung gab DkRend::RenderData & zurück, 
        //      renderMesh garantiert also intern, dass hier ein valider Zeiger zurück zu kommen hat
        //      Die Basisklasse RenderAtom garantiert das nicht!
        const DkRend::RenderData * data() const
        {
            return &_representations->data( _levelOfDetail );
        }

Eine Klasse kann eine Methode der Basisklasse überschreiben, die einen Ptr zurückgibt in dem er eine Referenz zurückgibt.

base contains
{
  data is virtual() as int ptr;
};

derived is base contains
{
  data overwrites ptr() as int ref;
};

ptr hinter overrides erklärt, dass hier keine int ref Signatur überschrieben wird, sondern eine int ptr.

Derived garantiert also dass data eine Referenz auf ein valides Objekt liefert. Wer also derived direkt fragt, muss nicht prüfen, ob ein nullptr geliefert bekommt. Wer die Basisklasse fragt, muss vorher validate ausführen.