#define DBG 0
#define ARG 0
#include "frmwrk/inc/main.h"
/* ---------------------------------------------------------------------
   (c) ED 2004
   Project      : CLIB
   Function     : Flexible array
   Module       : FARR
   File         : tfarr.c
   Created      : 15-12-2004
   Modified     : 15-12-2004
   --------------------------------------------------------------------- */

/* ---------------------------------------------------------------------
   Log

   0.0 15-12-2004 Created

   --------------------------------------------------------------------- */
#ifdef __cplusplus
#error This is not C++. Please use a C compiler.
#endif

#include "ed/inc/farr.h"
#include "ed/inc/sysalloc.h"
#include "ed/inc/sys.h"

/* private macro definitions =========================================== */

#define ID "FARR"
#define VER "0.0"

#define TERR(e)                              \
do                                           \
{                                            \
   if (e != FARR_OK)                         \
   {                                         \
      printf ("ERR : %s (%d) at line %d\n"   \
              ,farr_serr (e)                 \
              ,(int) e                       \
              , __LINE__);                   \
   }                                         \
}                                            \
while (0)

/* constants =========================================================== */

/* types =============================================================== */

typedef long Tdata;

/* structures ========================================================== */

/* private functions =================================================== */

/* ---------------------------------------------------------------------
   cb_print ()
   ---------------------------------------------------------------------

   ---------------------------------------------------------------------
   I:
   O:
   --------------------------------------------------------------------- */
static int cb_print (void const *p_data, void *p_user)
{
   int fin = 0;
   Tdata const *pd = p_data;

   if (pd != NULL)
   {
      uint *pi = p_user;

      if (pi != NULL)
      {
         printf ("[%u] = %lXh\n", (unsigned) *pi, (unsigned long) *pd);

         (*pi)++;

      }
      else
      {
         fin = 1;
      }
   }
   else
   {
      fin = 1;
   }
   return fin;
}

/* ---------------------------------------------------------------------
   cb_sort ()
   ---------------------------------------------------------------------

   ---------------------------------------------------------------------
   I:
   O:
   --------------------------------------------------------------------- */
static int cb_sort (void const *va, void const *vb)
{
   Tdata const *pa = va;
   Tdata const *pb = vb;

   return *pa - *pb;
}


/* ---------------------------------------------------------------------
   test ()
   ---------------------------------------------------------------------

   ---------------------------------------------------------------------
   I:
   O:
   --------------------------------------------------------------------- */
static int test (void)
{
   int ret = EXIT_SUCCESS;

/* identification test */
   printf ("Testing: %s %s\n", farr_sid (), farr_sver ());

/* dynamic test */
   {
      farr_s *p_obj = farr_create (sizeof (Tdata));

      if (p_obj != NULL)
      {
         farr_err_e err = farr_init (p_obj);
         TERR (err);
         if (err == FARR_OK)
         {
            size_t nb = farr_nb_cur (p_obj);
            if (nb == 0)
            {
               static Tdata const a_data[] =
               {0x1234, 0x5678, 0x9ABC};
               err = farr_add (p_obj, a_data + 0);
               TERR (err);
               if (err == FARR_OK)
               {
                  err = farr_add (p_obj, a_data + 1);
                  TERR (err);
                  if (err == FARR_OK)
                  {
                     err = farr_add (p_obj, a_data + 2);
                     TERR (err);
                     if (err == FARR_OK)
                     {
                        size_t i;
                        for (i = 0; i < NELEM (a_data); i++)
                        {
                           Tdata data;
                           err = farr_get (p_obj, i, &data);
                           TERR (err);
                           if (err == FARR_OK)
                           {
                              if (data != a_data[i])
                              {
                                 printf ("ERR: %lu, %lu\n", data, a_data[i]);
                                 break;
                              }
                           }
                           else
                           {
                              break;
                           }
                        }
                        /* ecriture au-dela de la position courante */
                        if (i == NELEM (a_data))
                        {
                           size_t n = farr_nb_max (p_obj);
                           printf ("nb_max = %u\n", (unsigned) n);
                           if (i < n)
                           {
                              Tdata data = 0xDEF0;
                              Tdata r_data;
                              err = farr_put (p_obj, i, &data);
                              TERR (err);
                              if (err == FARR_OK)
                              {
                                 farr_get (p_obj, i, &r_data);
                                 if (data == r_data)
                                 {
                                    puts ("\nP A S S E D\n");
                                 }
                              }
                           }
                        }
                     }
                  }
               }
            }
         }

         {
            /* lister */
            size_t const n = farr_nb_cur (p_obj);
            size_t i;
            for (i = 0; i < n; i++)
            {
               Tdata data;
               err = farr_get (p_obj, i, &data);
               TERR (err);
               printf ("[%u] = %lXh\n", (unsigned) i, (unsigned long) data);
            }
            printf ("\n");
         }

         {
            /* lister tout */
            size_t const n = farr_nb_max (p_obj);
            size_t i;
            for (i = 0; i < n; i++)
            {
               Tdata data;
               err = farr_get (p_obj, i, &data);
               TERR (err);
               printf ("[%u] = %lXh\n", (unsigned) i, (unsigned long) data);
            }
            printf ("\n");
         }

         {
            /* modifier [2] */
            Tdata data;
            puts("modifier [2]");
            err = farr_get (p_obj, 2, &data);
            TERR (err);
            data = ~data;
            farr_put (p_obj, 2, &data);
         }

         {
            /* re lister tout */
            size_t n = farr_nb_max (p_obj);
            size_t i;
            for (i = 0; i < n; i++)
            {
               Tdata data;
               err = farr_get (p_obj, i, &data);
               TERR (err);
               printf ("[%u] = %lXh\n", (unsigned) i, (unsigned long) data);
            }
            printf ("\n");
         }

         {
            /* trier */
            err = farr_qsort (p_obj, cb_sort);
            TERR (err);
         }

         {
            /* lister avec 'traverse' */
            uint i = 0;
            err = farr_traverse (p_obj, cb_print, &i);
            TERR (err);
         }

         {
            /* liste des erreurs */
            farr_err_e e;
            for (e = 0; e < FARR_ERR_NB; e++)
            {
               TERR (e);
            }
         }
         farr_delete (p_obj);
      }
   }

   return ret;
}

/* entry points ======================================================== */

/* ---------------------------------------------------------------------
   main ()
   ---------------------------------------------------------------------

   ---------------------------------------------------------------------
   I:
   O:
   --------------------------------------------------------------------- */
int main (void)
{
   int ret = EXIT_SUCCESS;

   ret = test ();

   return ret;
}

/* ---------------------------------------------------------------------
   Generated by NEW (c) ED 2.4
   Powered by C-code generator (c) ED 2003 1.0
   --------------------------------------------------------------------- */