doc/efun/sort_array

sort_array(E)

FUNKTION:
     mixed *sort_array(mixed *arr, mixed func [, mixed ob])

PARAMETER:
     arr  - zu sortierendes Array
     func - zu rufende Methode; kann als String (Funktionsname) oder 
            Closure uebergeben werden
     ob   - Objekt, an dem Methode gerufen werden soll; kann als String
            (Filename) oder Objektpointer uebergeben werden

BESCHREIBUNG
     Erzeugt eine (flache) Kopie des Arrays 'arr' und sortiert diese mit der
     Sortierfunktion 'func'. Die sortierte Kopie wird dann zurueckgegeben.

     Die Elemente des zu sortierenden Arrays werden paarweise an die
     Sortierfunktion als Argumente uebergeben.
     Die Sortierfunktion sollte eine Zahl
     - >0 zurueckgeben, wenn die Elemente in der falschen
       Reihenfolge sind
     - <=0 zurueckgeben, wenn die Elemente in der richtigen
       Reihenfolge sind.

     Verwendung von Methoden:
       Wenn bei der Angabe von 'func' kein Objekt 'ob' in Form eines Strings
       oder Objekts angegeben wird, wird this_object() angenommen.

     Verwendung von Closures:
       Es koennen Lfun-, Lambda- und Inline-Closures verwendet werden. 
       Lfun-Closures koennen, wenn im selben Objekt vorhanden, auch
       'private' oder/und 'static' deklariert sein, muessen aber zu dem
       Zeitpunkt der Verwendung bekannt sein (Funktionsprototypen benutzen).
       Von der Verwendung von Lambda-Closures wird ausdruecklich abgeraten.

BEMERKUNGEN:
     (1) sort_array() unterstuetzt keinen extra-Parameter

     (2) Achtung, die Elemente in 'arr' werden nicht tief kopiert, sind sie
     also selbst Arrays oder Mappings, so fuehrt eine Aenderung im Rueckgabe-
     Array zur Aenderung im Ursprungsarray:

     int *i, *j;
     i=({({1}),({2,3}),({4,5,6})});
     j=sort_array(i,        // sortiert der Groesse nach absteigend
         function int ( mixed x, mixed y ) {
           return sizeof(x) < sizeof(y); }
         );
     
     Zu diesem Zeitpunkt ist  i == ({ ({1}),({2,3}),({4,5,6}) })
                              j == ({ ({4,5,6}),({2,3}),({1}) })
     
     Fuehrt man jetzt die Zuweisung j[0][0]=8; aus

     resultieren folgende Arrays: i == ({ ({1}),({2,3}),({8,5,6}) })
                                  j == ({ ({8,5,6}),({2,3}),({1}) })

BEISPIELE:
     ### Sortieren von Zahlen in aufsteigender Reihenfolge ###
     
     int *arr = ({ 3, 8, 1, 3 })

     // Folgend identische Resultate, aber andere Ansaetze:

     #1: nutzt die 'Efun' > als Lfun-Closure (ideal hier):
         sort_array(arr, #'>);

     #2: mit Sortierfunktion im selben Objekt:
         int is_greater (int a, int b) {
           return a > b;
         }
         
         #2a: sortiert mittels der Lfun im selben Objekt die Elemente in das
              Rueckgabearray
              sort_array(arr, "is_greater", this_object())
              sort_array(arr, "is_greater")

         #2b: nutzt die Lfun is_greater() als Lfun-Closure (Funktionspointer)
              sort_array(arr, #'is_greater)

     #3: nutzt eine Lambda-Closure (langsamer, nicht fuer alle leserlich)
         sort_array(arr, lambda(({'a, 'b}), ({#'>, 'a, 'b})))

     #4: analog zu 3, mit Inline-Closure
         sort_array(arr, function int (int a, int b) {
           return a > b; } );

     Resultat in allen Faellen: ({1,3,3,8})

     ### Sortieren von geschachtelten Arrays ###

     arr = ({ ({ "foo", 3 }), ({ "quux", 1 }), ... })

     // Vorgehen identisch, allerdings muss die Sortierfunktion
     // angepasst werden (siehe auch das Beispiel unter Verwendung von
     // Inline-Closures oben unter "Bemerkungen"):
     
     int is_greater (mixed *a, mixed *b) {
       return a[1] > b[1];
     }

SIEHE AUCH:
     Arrays:        filter(E), map(E)
     Objektarrays:  filter_objects(E), map_objects(E)
     Mappings:      filter_indices(E), map_indices(E)

     Sonstiges:     unique_array()
                    alist, transpose_array(E)

----------------------------------------------------------------------------
Last modified: Mon Feb 18 23:09 2008 by Arathorn