/***********************************************************************
*
*               Projet   : DilibPro
*               Module   : StrDict
*               Fichier  : StrDict.c
*               Auteur   : J. DUCLOY
*               Date     : Aout 93
*               Modifications
*                        20 Octobre 93 (fonction StrDictTableFree)
*    $Id: StrDict.c,v 1.3 2005/06/22 15:35:28 parmentf Exp $
************************************************************************
*
* Copyright (c) 1995 CNRS/CRIN & INRIA Lorraine
* 
************************************************************************/

#include "StrDict.h"
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
       
void qsort();

char *StrDictLastKey;

int StrDictCompare(node1,node2) 
const void *node1;
const void *node2;
{
 return (strcmp(  ((StrDictDatum*)node1)->key,
		  ((StrDictDatum*)node2)->key   ));
}

/* 
int StrDictCompare(n1, n2)
     StrDictDatum *n1;
     StrDictDatum *n2;
{
  return strcmp(n1->key, n2->key);
} */

void StrDictReset(StrDict* curTable)
{
  curTable->etat=0;	
  curTable->numberOfElements=0;
  curTable->currentPos=-1;
}







void StrDictTableFreeValue(StrDictTable *t)
{
  char *key;
  char *value;
  if(t)
    {
      StrDictIteratorReset(t);
      while ((key=StrDictNext(t)))
	{
	  if((value=StrDictValue(t)))free(value);
	}
      StrDictTableFree(t);
    }
}


void StrDictTableFreeKey(StrDictTable *t)
{
  char *key;
  if(t)
    {
      StrDictIteratorReset(t);
      while ((key=StrDictNext(t)))
	{
	  free(key);
	}
      StrDictTableFree(t);
    }
}

int StrDictTableToFile(StrDictTable *t, char  *f)
{
  FILE *f1;
  char *key;
  char *value;
  if((f1=fopen(f,"w")))
    {
      StrDictIteratorReset(t);
      while ((key=StrDictNext(t)))
	{
	  fprintf(f1, "%s", key);
	  if((value=StrDictValue(t)))fprintf(f1, "\t%s", value);
	  fprintf(f1, "\n");
	}
      fclose(f1);
    }
  else return 0;
  return 1;
}



/* verification de l'etat de la table avant une operation et tri
   eventuel */
int StrDictSortTable(StrDictTable *t)
{

}



void StrDictIteratorReverseReset(StrDictTable* curTable)
{
  curTable->currentPos=curTable->numberOfElements;
  StrDictSortTable(curTable);
}




/* external iterator */

StrDictTableIter *StrDictTableIterCreate(StrDictTable *tab)
{
  StrDictTableIter *iter;
  iter=(StrDictTableIter *)malloc(sizeof(StrDictTableIter));
  if(iter)
    {
      iter->ssTab=tab;
      iter->currentPos=tab->currentPos;
    }
  return iter;
}

void StrDictTableIterFree(StrDictTableIter *iter)
{
  if(iter)free((char *)iter);
}

char *StrDictTableIterNext(StrDictTableIter *curTable)
{
  if(curTable->currentPos+2>curTable->ssTab->numberOfElements)return NULL;
  curTable->currentPos++;
  return curTable->ssTab->table[curTable->currentPos].key;
}

/* external iterator v2 */

int StrDictIndicReset(StrDictTable *t1)
{
  StrDictSortTable(t1);
  return -1;
}

int StrDictIndicNext(StrDictTable *t1, int i1)
{
  if(i1+2>t1->numberOfElements)return StrDictOutOfRange;
  return i1+1;
}