//---------------------------------------------------------------------------
#pragma hdrstop
//-----------------------------Update funktioner------------------------------//
///Funktionen indsætter et objekt på listen
template <class type>
bool Klyngeliste<type>::Indsaet(type indsat)
{
    if (Brugt < MaxAntal)
    {
      Liste[Brugt] = indsat;
      Brugt++;
      Pladsering++;
      return true;
    }
    else
    {
      cout << "\nListen er fyldt";
      return false;
    }
}//
///Funktionen nulstiller IntSlot[3] variablen til 0...
template <class type>
void Klyngeliste<type>::NulstilLokaleType()
{
	for(int i = 0; i < Brugt; i++)
      Liste[i].IntSlot[3] = 0;
}//
//-----------------------------Find funktioner--------------------------------//
///Funktionen Finder en given streng på listen ved et givent datanr, som står
///for slotfocus'et. Funktionen returnere det fundne objekt i det overførte objekt
template <class type>
bool Klyngeliste<type>::Find(Klyngeliste<type>& Fundet, string Find, int dataNr)
{
    int Indsaet(0), index_start(0), index_slut(0);

    data FindObj;
    FindObj.StringSlot[(dataNr-1)] = Find;

    TilData.SkiftSlotFocus(dataNr);

    if(TilSoegning.sectionsearch(Liste, Brugt, FindObj, index_start, index_slut, 1, 0))
      {
      for(int i = index_start; i <= index_slut; i++)
         {
          Fundet.Indsaet(Liste[i]);
          Indsaet++;
         }
      return true;
      }
    return false;
}//
///Funktionen finder en given integer ved et givent daranr, der står for det
///det slot focus som variablen tilhører. Funktionen returnere det fundneobjekt
///i det overførte.
template <class type>
bool Klyngeliste<type>::Find(Klyngeliste<type>& Fundet, int Find, int dataNr)
{
    int Indsaet(0), index_start(0), index_slut(0);

    data FindObj;
    FindObj.IntSlot[(dataNr-6)] = Find;

    TilData.SkiftSlotFocus(dataNr);

    if(TilSoegning.sectionsearch(Liste, Brugt, FindObj, index_start, index_slut, 1, 0))
      {
      for(int i = index_start; i <= index_slut; i++)
         {
          Fundet.Indsaet(Liste[i]);
          Indsaet++;
         }
      return true;
      }
    return false;
}//
///Funktionen finder et givent decimal tal i et givent slotnr (datanr). Hvis
///tallet findes returneres dennes objekt i FUndet.
template <class type>
bool Klyngeliste<type>::Find(Klyngeliste<type>& Fundet, double Find, int dataNr)
{
    int Indsaet(0), index_start(0), index_slut(0);

    data FindObj;
    FindObj.DoubleSlot[(dataNr-10)] = Find;

    TilData.SkiftSlotFocus(dataNr);

    if(TilSoegning.sectionsearch(Liste, Brugt, FindObj, index_start, index_slut, 1, 0))
      {
      for(int i = index_start; i <= index_slut; i++)
         {
          Fundet.Indsaet(Liste[i]);
          Indsaet++;
         }
      return true;
      }
    return false;
}//
///Funktionen finder et givent objekt (d), i slotfocuset, indenfor intervallet
///[fra,til] i listen..
template <class type>
bool Klyngeliste<type>::Find(int SlotFocus, data d, int fra, int til)
{
    int i;
    TilData.SkiftSlotFocus(SlotFocus);
    return TilSoegning.binarysearch(Liste+fra, til, d, i);
}//
///Funktionen søger efter den sektion [start, slut] som et givent objekt (Find) dækker i
///listen. Der skelnes imellem om listen iforvejen er sorteret i stigende eller
///faldende orden (type = 0/1).
template <class type>
bool Klyngeliste<type>::SektionSoegning(int SlotFocus, data Find, int& start,
										int& slut, char type)
{
    TilData.SkiftSlotFocus(SlotFocus);
    if(type == 'd')
	  return(TilSoegning.sectionsearch(Liste+start, slut, Find, start, slut, 0));
    else if(type == 'h')
      return(TilSoegning.sectionsearch(Liste, Brugt, Find, start, slut, 0));
}//
///Funktionen søger lineært igennem listen for at finde indekset på det søgte
///objekt.
template <class type>
bool Klyngeliste<type>::LinearSoegning(int SlotFocus, data find, int& index)
{
    TilData.SkiftSlotFocus(SlotFocus);
    return TilSoegning.linearsearch(Liste, Brugt, find, index, 0);
}//
//------------------------------Hent funktioner-------------------------------//
///Funktionen henter det objekt på listen som er identisk med det overførte ("find")
template <class type>
bool Klyngeliste<type>::Hent(data*& d, data find, int dataNr)
{
    int index = 0;
    TilData.SkiftSlotFocus(dataNr);
    if(TilSoegning.binarysearch(Liste, Brugt, find, index))
    {
      d = &Liste[index];
      return true;
    }
    return false;
}//
///Funktionen henter næste objekt på listen dersom der er flere.
template <class type>
bool Klyngeliste<type>::HentNaeste(data*& d)
{
    if(PejerPaa < Brugt)
    {
       d = &Liste[PejerPaa++];
       return true;
    }
    return false;
}//
///Funktionen henter det objekt som variablen PEjer På pejer på i listen.
template <class type>
bool Klyngeliste<type>::HentPejerPaa(data* ptr)
{
	ptr = &Liste[PejerPaa];
    return true;
}//
//----------------------------sorterings funktioner---------------------------//
///Funktionen sortere listen i stigene orden efter efter det angivne slotfocus
template <class type>
void Klyngeliste<type>::SorterKL(int SlotFocus)
{
    TilData.SkiftSlotFocus(SlotFocus);
    TilSortering.quicksort(Liste, Brugt, 0);
}//
///Funktionen sortere en del af listen i intervallet [fra,til] i den angiven
///orden (type), med et givent slot focus.
template <class type>
void Klyngeliste<type>::SorterDel(int SlotFocus, int fra, int til, int type)
{
    TilData.SkiftSlotFocus(SlotFocus);
    TilSortering.quicksort(Liste+fra, til, type);
}//
///Funktionen udskiller alle stamlokaler på lægge listen... Kan kun anvendes i denne
///forbindelse.
template <class type>
int Klyngeliste<type>::UdskilStamLokaler()
{
    int index = 0;
    TilData.StringSlot[3] = "stam";
    TilData.SkiftSlotFocus(4);
	index = TilSortering.partsort(Liste, Brugt, TilData, 1);
    return index;
}//
///Funktionen udskiller det søgte objekt således at alle identiske objekter
///enten kommer til at ligge i første del (b) eller den sidste del(s) af
///listen.
template <class type>
int Klyngeliste<type>::Udskil(int SlotFocus, data& Find, char del)
{
    int type;
    TilData.SkiftSlotFocus(SlotFocus);
    if(del == 'b')
      type = 0;
    else
      type = 1;

    return TilSortering.partsort(Liste, Brugt, Find, type);
}//
//--------------------------Bi funktioner-------------------------------------//
///Funktionen optæller alle der er identiske med objektet indenfor et bestemt
///interval af lisen [fra,til]..
template <class type>
int Klyngeliste<type>::Optael(int SlotFocus, data d, int fra, int til)
{
    int count(0);
    TilData.SkiftSlotFocus(SlotFocus);
    for(int i = fra; i < til; i++)
      if(Liste[i] == d)
        count++;
    return count;
}//
//--------------------------udskrivs funktion---------------------------------//
///FUnktionen udskriver indeholdet af listen.
template <class type>
void Klyngeliste<type>::Udskriv()
{
    TilData.SkiftSlotFocus(0);
    for(int i = 0; i < Brugt; i++)
    {  cout << Liste[i]; cout << endl; }
}//
//----------------------------------------------------------------------------//
///konstruktør
template <class type>
Klyngeliste<type>::Klyngeliste()
{
    PejerPaa = 0;
    Brugt = 0;
    Pladsering = 0;
}//
//----------------------------------------------------------------------------//











