====== Adapter ====== Ein Adapter ist ein Codestück, was vergleichbar mit einem Workflow ist, da er über zwei Wege bedient wird. Gewissermaßen ein Cast in zwei Richtungen Folgendes Problem:


    bool IndexPolygon::completeHullPolygons( const Array& faces,
                                             Array& halfEdges,
                                             Array>* nonUniques,
                                             Array* nonCorresponding )
    {
        IndexPolygon::extractHalfEdgesFromPolygons( faces, halfEdges );

//ATR64FIXME

        return IndexHalfEdge::unique( halfEdges, nonUniques ) &&
               IndexHalfEdge::hasCompleteCorrespondencies( halfEdges, nonCorresponding );
    }

Die Funktion unique erwartet als 2. Parameter ein Array>*. Nun steht hier nicht klar fest, ob das ein Ein- oder Ausgabeparameter ist. Man könnte nun einen Adapter formulieren, der Werte von Array> nach Array> konvertiert und - sobald die Funktion fertig gelaufen ist, das resultierende Array wieder nach nonUniques zurückspielt.


adapt
{
  std::size_t get int = static_cast< std::size_t >( value );
  int set( std::size_t rhs ) = value : static_cast< int >( rhs );

  int get std::size_t = static_cast< int >( value );
  std::size_t set( int rhs ) = value : static_cast< std::size_t >( rhs );

  Array> get( Array> )
  {
    return Array>( ... );
  }
  
  Array> set( Array> )
  {
    return Array>( ... )
  }
  
  // Man könnte nun auch überlegen, virtuelle Funktionen umzubelegen:
  
  std::pair< int, int > Array>::operator[](size_t index) get Array>::operator[]( size_t )
  {
    pair is ref : this[index];
    return std::pair< std::size_t, std::size_t >( adapt pair.left, adapt pair.right ); // Werte werden nach Rückkehr der Funktoin anschließend ins pair zurückgeschrieben
  }
}