with TEXT_IO ; use TEXT_IO ;
with GENERIC_SORT_PACKAGE ;
with GENERIC_SEARCH_PACKAGE ;

procedure GENERIC_SEARCH_PACKAGE_DEMO is  -- a test of record sorting

  FOUND : BOOLEAN ;
  INTEGER_INDEX : INTEGER ;
  subtype MY_STRING is STRING ( 1 .. 3 ) ;

  type A_ARRAY is array ( 1 .. 1000 ) of INTEGER ;
  type B_ARRAY is array ( 1 .. 200 ) of FLOAT ;

  type BIG_RECORD is
    record
      A : A_ARRAY ;
      B : B_ARRAY ;
    end record ;

  subtype MY_INDEX is INTEGER range -2 .. 2 ; 
  MY_INDEX_INDEX : MY_INDEX ;

  type MY_BIG_ARRAY is array ( MY_INDEX range <> ) of BIG_RECORD ;

  BIG_RECORD_ITEM : BIG_RECORD ;
  BIG_RECORD_DATA : MY_BIG_ARRAY ( MY_INDEX'FIRST .. MY_INDEX'LAST ) := (
      ( (1 => 2 , others => 0 ), ( others => 2.0 ) ),
      ( (1 => 3 , others => 0 ), ( others => 3.0 ) ),
      ( (1 => 1 , others => 0 ), ( others => 1.0 ) ),
      ( (1 => 5 , others => 0 ), ( others => 5.0 ) ),
      ( (1 => 4 , others => 0 ), ( others => 4.0 ) ) ) ;

-- The following declaration is for using a vector sort on the above
  type BIG_ARRAY_VECTOR is array ( MY_INDEX range <> ) of MY_INDEX ;
  RECORD_INDEX : BIG_ARRAY_VECTOR ( MY_INDEX'FIRST .. MY_INDEX'LAST ) ;

  type MY_ENUM is ( FIRST , SECOND , THIRD , FOURTH ) ;
  MY_ENUM_INDEX : MY_ENUM ;

  type MY_RECORD is
    record
      I : INTEGER ;
      ENUM_PART : MY_ENUM ;
      X : FLOAT ;
      STRING_PART : MY_STRING ;
    end record ;

  type MY_ENUM_ARRAY is array ( MY_ENUM range <> ) of MY_RECORD ;

  ENUM_RECORD_DATA : MY_ENUM_ARRAY ( MY_ENUM ) := ( 
     ( 1 , THIRD  , 3.0 , "BBB" ) ,
     ( 2 , FOURTH , 1.0 , "AAA" ) ,
     ( 3 , SECOND , 2.0 , "BBB" ) ,
     ( 4 , THIRD  , 4.0 , "CCC" ) ) ;



  type MY_RECORD_ARRAY is array ( INTEGER range <> ) of MY_RECORD ;

  RECORD_DATA : MY_RECORD_ARRAY ( 1 .. 4 ) := ( 
     ( 1 , THIRD  , 3.0 , "BBB" ) ,
     ( 2 , FOURTH , 1.0 , "AAA" ) ,
     ( 3 , SECOND , 2.0 , "BBB" ) ,
     ( 4 , THIRD  , 4.0 , "CCC" ) ) ;

  function MY_BIG_COMPARE ( SMALL , LARGE : BIG_RECORD ) return BOOLEAN is
  begin
    -- as much as needed for the comparison
    return SMALL.A(1) > LARGE.A(1) ;
  end MY_BIG_COMPARE ;

-- The following function is for using a vector sort on the above
  function VECTOR_COMPARE ( SMALL , LARGE : MY_INDEX ) return BOOLEAN is
  begin
    -- as much as needed for the comparison
    return BIG_RECORD_DATA(SMALL).A(1) > BIG_RECORD_DATA(LARGE).A(1) ;
  end VECTOR_COMPARE ;

  function MY_ENUM_COMPARE ( SMALL , LARGE :  MY_RECORD ) return BOOLEAN  is
  begin
    return ( SMALL.ENUM_PART > LARGE.ENUM_PART ) or
       ( SMALL.ENUM_PART = LARGE.ENUM_PART and
         SMALL.STRING_PART > LARGE.STRING_PART ) ;
  end MY_ENUM_COMPARE ;

  function MY_COMPARE ( SMALL , LARGE :  MY_RECORD ) return BOOLEAN  is
  begin
    return ( SMALL.STRING_PART > LARGE.STRING_PART ) or
       ( SMALL.STRING_PART = LARGE.STRING_PART and
         SMALL.ENUM_PART > LARGE.ENUM_PART ) ;
  end MY_COMPARE ;

  package BIG_RECORD_SORT is new GENERIC_SORT_PACKAGE ( BIG_RECORD , MY_INDEX ,
      MY_BIG_ARRAY , MY_BIG_COMPARE ) ;

  package BIG_RECORD_SEARCH is new GENERIC_SEARCH_PACKAGE ( BIG_RECORD , MY_INDEX ,
      MY_BIG_ARRAY , MY_BIG_COMPARE ) ;

  package VECTOR_RECORD_SORT is new GENERIC_SORT_PACKAGE ( MY_INDEX , MY_INDEX ,
      BIG_ARRAY_VECTOR , VECTOR_COMPARE ) ;

  package VECTOR_RECORD_SEARCH is new GENERIC_SEARCH_PACKAGE ( MY_INDEX , MY_INDEX ,
      BIG_ARRAY_VECTOR , VECTOR_COMPARE ) ;

  package ENUM_RECORD_SORT is new GENERIC_SORT_PACKAGE ( MY_RECORD , MY_ENUM ,
      MY_ENUM_ARRAY , MY_ENUM_COMPARE ) ;

  package ENUM_RECORD_SEARCH is new GENERIC_SEARCH_PACKAGE ( MY_RECORD , MY_ENUM ,
      MY_ENUM_ARRAY , MY_ENUM_COMPARE ) ;

  package RECORD_SORT is new GENERIC_SORT_PACKAGE ( MY_RECORD , INTEGER ,
      MY_RECORD_ARRAY , MY_COMPARE ) ;

  package RECORD_SEARCH is new GENERIC_SEARCH_PACKAGE ( MY_RECORD , INTEGER ,
      MY_RECORD_ARRAY , MY_COMPARE ) ;

  package INT_IO is new INTEGER_IO ( INTEGER ) ;
  use INT_IO ;

  package FLT_IO is new FLOAT_IO ( FLOAT ) ;
  use FLT_IO ;

  package ENU_IO is new ENUMERATION_IO ( MY_ENUM ) ;
  use ENU_IO ;

begin

  BIG_RECORD_SORT.SORT ( BIG_RECORD_DATA ) ;

  PUT_LINE ( " SORTED DATA " ) ;
  for I in BIG_RECORD_DATA'RANGE loop
    PUT ( BIG_RECORD_DATA( I ) . A(1) ) ;
    PUT ( ' ' ) ;
    PUT ( BIG_RECORD_DATA( I ) . B(1)) ;
    NEW_LINE ;
    BIG_RECORD_SEARCH.
    SEARCH ( BIG_RECORD_DATA(I) , BIG_RECORD_DATA , INTEGER_INDEX , FOUND ) ;
    BIG_RECORD_ITEM := BIG_RECORD_DATA ( INTEGER_INDEX ) ;
    PUT ( BIG_RECORD_ITEM . A(1) ) ;
    PUT ( ' ' ) ;
    PUT ( BIG_RECORD_ITEM . B(1)) ;
    PUT ( ' ' ) ;
    PUT ( BOOLEAN'IMAGE ( FOUND ) ) ;
    NEW_LINE ;
  end loop ;
  BIG_RECORD_SORT.NN_SORT ( BIG_RECORD_DATA ) ;

  for I in MY_INDEX'FIRST .. MY_INDEX'LAST loop
    RECORD_INDEX ( I ) := I ;
  end loop ; -- vector initialized for VECTOR SORT
  VECTOR_RECORD_SORT.SORT ( RECORD_INDEX ) ;

  PUT_LINE ( " SORTED DATA " ) ;
  for I in MY_INDEX'FIRST .. MY_INDEX'LAST loop
    PUT ( BIG_RECORD_DATA( RECORD_INDEX ( I ) ) . A(1) ) ;
    PUT ( ' ' ) ;
    PUT ( BIG_RECORD_DATA( RECORD_INDEX ( I ) ) . B(1)) ;
    NEW_LINE ;
    VECTOR_RECORD_SEARCH.
    SEARCH ( RECORD_INDEX(I), RECORD_INDEX , MY_INDEX_INDEX , FOUND ) ;
    PUT ( BIG_RECORD_DATA( RECORD_INDEX ( MY_INDEX_INDEX )) . A(1) ) ;
    PUT ( ' ' ) ;
    PUT ( BIG_RECORD_DATA( RECORD_INDEX ( MY_INDEX_INDEX )) . B(1)) ;
    PUT ( ' ' ) ;
    PUT ( BOOLEAN'IMAGE ( FOUND ) ) ;
    NEW_LINE ;
  end loop ;
  VECTOR_RECORD_SORT.NN_SORT ( RECORD_INDEX ) ;

  RECORD_SORT.SORT ( RECORD_DATA ) ;

  PUT_LINE ( " SORTED DATA " ) ;
  for I in RECORD_DATA'RANGE loop
    PUT ( RECORD_DATA( I ) . I ) ;
    PUT ( ' ' ) ;
    PUT ( RECORD_DATA( I ) . ENUM_PART ) ;
    PUT ( ' ' ) ;
    PUT ( RECORD_DATA( I ) . X ) ;
    PUT ( ' ' ) ;
    PUT ( RECORD_DATA( I ) . STRING_PART ) ;
    NEW_LINE ;
    RECORD_SEARCH.
    SEARCH ( RECORD_DATA ( I ) , RECORD_DATA , INTEGER_INDEX , FOUND ) ;
    PUT ( RECORD_DATA( INTEGER_INDEX ) . I ) ;
    PUT ( ' ' ) ;
    PUT ( RECORD_DATA( INTEGER_INDEX ) . ENUM_PART ) ;
    PUT ( ' ' ) ;
    PUT ( RECORD_DATA( INTEGER_INDEX ) . X ) ;
    PUT ( ' ' ) ;
    PUT ( RECORD_DATA( INTEGER_INDEX ) . STRING_PART ) ;
    PUT ( ' ' ) ;
    PUT ( BOOLEAN'IMAGE ( FOUND ) ) ;
    NEW_LINE ;
  end loop ;
  RECORD_SORT.NN_SORT ( RECORD_DATA ) ;

  ENUM_RECORD_SORT.SORT ( ENUM_RECORD_DATA ) ;

  PUT_LINE ( " SORTED DATA " ) ;
  for I in ENUM_RECORD_DATA'RANGE loop
    PUT ( ENUM_RECORD_DATA( I ) . I ) ;
    PUT ( ' ' ) ;
    PUT ( ENUM_RECORD_DATA( I ) . ENUM_PART ) ;
    PUT ( ' ' ) ;
    PUT ( ENUM_RECORD_DATA( I ) . X ) ;
    PUT ( ' ' ) ;
    PUT ( ENUM_RECORD_DATA( I ) . STRING_PART ) ;
    NEW_LINE ;
    ENUM_RECORD_SEARCH.
    SEARCH ( ENUM_RECORD_DATA(I), ENUM_RECORD_DATA , MY_ENUM_INDEX , FOUND ) ;
    PUT ( ENUM_RECORD_DATA( MY_ENUM_INDEX ) . I ) ;
    PUT ( ' ' ) ;
    PUT ( ENUM_RECORD_DATA( MY_ENUM_INDEX ) . ENUM_PART ) ;
    PUT ( ' ' ) ;
    PUT ( ENUM_RECORD_DATA( MY_ENUM_INDEX ) . X ) ;
    PUT ( ' ' ) ;
    PUT ( ENUM_RECORD_DATA( MY_ENUM_INDEX ) . STRING_PART ) ;
    PUT ( ' ' ) ;
    PUT ( BOOLEAN'IMAGE ( FOUND ) ) ;
    NEW_LINE ;
  end loop ;
  ENUM_RECORD_SORT.NN_SORT ( ENUM_RECORD_DATA ) ;
end GENERIC_SEARCH_PACKAGE_DEMO ;