public bool Remove(T removeOne)
{
var hash = removeOne.Hash();
var konkretnyNode = Find(hash);
if (konkretnyNode == null)
{
return(false);
}
var konkretnyBlok = new Blok <T>(1);
konkretnyBlok.NacitajBlok(konkretnyNode.Seek, NazovSuboru);
foreach (var item in konkretnyBlok.Data)
{
if (item.CompareTo(removeOne))
{
konkretnyBlok.Zmaz(removeOne);
konkretnyNode.PocetZaznamov--;
konkretnyBlok.ZapisBlok(konkretnyNode.Seek, NazovSuboru);
var novyBlokNaZapis = Zluc(ref konkretnyNode);
if (novyBlokNaZapis != null)
{
if (novyBlokNaZapis.PocetValidnych != 0)
{
novyBlokNaZapis.ZapisBlok(konkretnyNode.Seek, NazovSuboru);
}
}
ZmazAdresy();
return(true);
}
}
return(false);
}
private void Zapis(T prvok, ref ZnakNodeExterny nodeBloku)
{
if (nodeBloku.Seek == -1)
{
var spravnySeek = DajAdresu();
nodeBloku.Seek = spravnySeek;
var blok = new Blok <T>();
blok.Vloz(prvok);
nodeBloku.PocetZaznamov++;
blok.ZapisBlok(nodeBloku.Seek, NazovSuboru);
}
else
{
//pozriet ci je v bloku dostatok volneho miesta
// var blok = new Blok<T>(1);
Blok <T> blok = null;
if (nodeBloku.PocetZaznamov == 0)
{
blok = new Blok <T>();
blok.Vloz(prvok);
nodeBloku.PocetZaznamov++;
blok.ZapisBlok(nodeBloku.Seek, NazovSuboru);
}
else
{
blok = new Blok <T>(1);
blok.NacitajBlok(nodeBloku.Seek, NazovSuboru);
blok.Vloz(prvok);
nodeBloku.PocetZaznamov++;
blok.ZapisBlok(nodeBloku.Seek, NazovSuboru);
}
}
}
private Blok <T> Zluc(ref ZnakNodeExterny mazanyNodeBlok)
{
if (mazanyNodeBlok.Parent != null)
{
var tmpParent = mazanyNodeBlok.Parent as ZnakNodeInterny;
while (true)
{
Blok <T> zlucenyBlok = new Blok <T>();
Blok <T> lavyBlok = new Blok <T>(1);
Blok <T> pravyBlok = new Blok <T>(1);
var seekVpravo = -2;
var seekVlavo = -2;
bool mamExternehoBrata = false;
bool somPravySyn = false;
if (tmpParent.Right == mazanyNodeBlok)
{
//som pravy syn
seekVpravo = (tmpParent.Right as ZnakNodeExterny).Seek;
somPravySyn = true;
//je moj brat tiez externy
if (tmpParent.Left is ZnakNodeExterny)
{
seekVlavo = (tmpParent.Left as ZnakNodeExterny).Seek;
mamExternehoBrata = true;
}
}
else
{
//som lavy syn
seekVlavo = (tmpParent.Left as ZnakNodeExterny).Seek;
//je moj brat tiez externy
if (tmpParent.Right is ZnakNodeExterny)
{
seekVpravo = (tmpParent.Right as ZnakNodeExterny).Seek;
mamExternehoBrata = true;
}
}
//som pravy syn ktory zatial nic nevie
if (somPravySyn)
{
//mam brata ktory je externy node ALE nemusi mat priradenu adresu
if (mamExternehoBrata)
{
var mojBrat = tmpParent.Left as ZnakNodeExterny;
//mozu sa zlucit
if ((mazanyNodeBlok.PocetZaznamov + mojBrat.PocetZaznamov) <= Konstanty.BlokovaciFaktor)
{
var pouzitaAdresa = seekVpravo;
pravyBlok.NacitajBlok(mazanyNodeBlok.Seek, NazovSuboru);
for (int i = 0; i < pravyBlok.PocetValidnych; i++)
{
//vkladam v druhej otocke do rovnakeho bloku ale uz su tam tie iste zaznamy
zlucenyBlok.Vloz(pravyBlok.Data[i]);
}
if (seekVlavo >= 0)
{
lavyBlok.NacitajBlok(mojBrat.Seek, NazovSuboru);
for (int i = 0; i < lavyBlok.PocetValidnych; i++)
{
zlucenyBlok.Vloz(lavyBlok.Data[i]);
}
//pridadenie adresz do adresy nepouzityc
lavyBlok.PocetValidnych = 0;
if (seekVlavo > seekVpravo)
{
VolneAdresy.Add(seekVlavo);
pouzitaAdresa = seekVpravo;
lavyBlok.ZapisBlok(seekVlavo, NazovSuboru);
}
else
{
VolneAdresy.Add(seekVpravo);
pouzitaAdresa = seekVlavo;
lavyBlok.ZapisBlok(seekVpravo, NazovSuboru);
}
}
mazanyNodeBlok = new ZnakNodeExterny()
{
Hlbka = tmpParent.Hlbka, Parent = tmpParent.Parent, PocetZaznamov = zlucenyBlok.PocetValidnych, Seek = pouzitaAdresa
};
if (tmpParent.Parent == null)
{
Root = mazanyNodeBlok as ZnakNodeExterny;
IndexVSubore = VelkostBloku;
return(zlucenyBlok);
}
else
{
if ((tmpParent.Parent as ZnakNodeInterny).Left == tmpParent)
{
(tmpParent.Parent as ZnakNodeInterny).Left = mazanyNodeBlok;
}
else
{
(tmpParent.Parent as ZnakNodeInterny).Right = mazanyNodeBlok;
}
tmpParent = tmpParent.Parent as ZnakNodeInterny;
zlucenyBlok.ZapisBlok(mazanyNodeBlok.Seek, NazovSuboru);
if (VolneAdresy.Count != 0 && VolneAdresy.Last() == IndexVSubore - VelkostBloku)
{
IndexVSubore -= VelkostBloku;
}
}
}
else
{
// nemozu sa zlucit lebo maju viac zaznamov ako blokovaci faktor
return(zlucenyBlok);
}
}
else
{
//moj brat neni externy mozem rovno skoncit
return(zlucenyBlok);
}
}
else
{
//som Lavy syn a neviem nic ine
if (mamExternehoBrata)
{
var mojBrat = tmpParent.Right as ZnakNodeExterny;
//mozu sa zlucit
if ((mazanyNodeBlok.PocetZaznamov + mojBrat.PocetZaznamov) <= Konstanty.BlokovaciFaktor)
{
var pouzitaAdresa = seekVlavo;
lavyBlok.NacitajBlok(mazanyNodeBlok.Seek, NazovSuboru);
for (int i = 0; i < lavyBlok.PocetValidnych; i++)
{
zlucenyBlok.Vloz(lavyBlok.Data[i]);
}
if (seekVpravo >= 0)
{
pravyBlok.NacitajBlok(mojBrat.Seek, NazovSuboru);
for (int i = 0; i < pravyBlok.PocetValidnych; i++)
{
zlucenyBlok.Vloz(pravyBlok.Data[i]);
}
pravyBlok.PocetValidnych = 0;
if (seekVlavo > seekVpravo)
{
VolneAdresy.Add(seekVlavo);
pouzitaAdresa = seekVpravo;
pravyBlok.ZapisBlok(seekVlavo, NazovSuboru);
}
else
{
VolneAdresy.Add(seekVpravo);
pouzitaAdresa = seekVlavo;
pravyBlok.ZapisBlok(seekVpravo, NazovSuboru);
}
}
mazanyNodeBlok = new ZnakNodeExterny()
{
Hlbka = tmpParent.Hlbka, Parent = tmpParent.Parent, PocetZaznamov = zlucenyBlok.PocetValidnych, Seek = pouzitaAdresa
};
if (tmpParent.Parent == null)
{
Root = mazanyNodeBlok as ZnakNodeExterny;
IndexVSubore = VelkostBloku;
return(zlucenyBlok);
}
else
{
if ((tmpParent.Parent as ZnakNodeInterny).Left == tmpParent)
{
(tmpParent.Parent as ZnakNodeInterny).Left = mazanyNodeBlok;
}
else
{
(tmpParent.Parent as ZnakNodeInterny).Right = mazanyNodeBlok;
}
tmpParent = tmpParent.Parent as ZnakNodeInterny;
zlucenyBlok.ZapisBlok(mazanyNodeBlok.Seek, NazovSuboru);
if (VolneAdresy.Count != 0 && VolneAdresy.Last() == IndexVSubore - VelkostBloku)
{
IndexVSubore -= VelkostBloku;
}
}
}
else
{
// nemozu sa zlucit lebo maju viac zaznamov ako blokovaci faktor
return(zlucenyBlok);
}
}
else
{
//moj brat neni externy mozem rovno skoncit
return(zlucenyBlok);
}
}
}
}
else
{
if ((Root as ZnakNodeExterny).PocetZaznamov == 0)
{
VolneAdresy.Add(0);
ZmazAdresy();
IndexVSubore = 0;
Root = null;
}
else
{
IndexVSubore = VelkostBloku;
}
}
return(null);
}
// var pocetHashu = BitConverter.GetBytes(tmpParet.Blok[i]);
// var pos = nadKtorym.Hlbka % 8;
// var konkretnyByte = nadKtorym.Hlbka / 8;
// if (IsBitSet(pocetHashu[konkretnyByte], pos))
private void Rozsir(ref ZnakNode nadKtorym, T novyPrvok)
{
var parentNodu = nadKtorym.Parent;
var tmpExternyNodeCopy = nadKtorym as ZnakNodeExterny;
var seekParent = tmpExternyNodeCopy.Seek;
//--------------------------------------------------------------------------------------------------------------------- TU SA ROBILA UPRAVA
if (seekParent != IndexVSubore)
{
VolneAdresy.Add(seekParent);
}
else
{
IndexVSubore -= VelkostBloku;
}
var poleByyyte = new List <byte>(Konstanty.BlokovaciFaktor);
//nacitja list byte na kontrolu vytovrenie noveho bloku
var blokExt = new Blok <T>(1);
blokExt.NacitajBlok(seekParent, NazovSuboru);
//pridanie dalsieho bloku to pomocneho bloku podla ktoreho sa najde hladane 2 bloky kam sa tento blok ulozi
blokExt.Data.Add(novyPrvok);
//HOTFIX
var zapisDummyData = new Blok <T>();
zapisDummyData.ZapisBlok(seekParent, NazovSuboru);
var novyInternyNode = new ZnakNodeInterny();
var novyPravy = new ZnakNodeExterny()
{
Hlbka = nadKtorym.Hlbka + 1, Parent = novyInternyNode
};
var novyLavy = new ZnakNodeExterny()
{
Hlbka = nadKtorym.Hlbka + 1, Parent = novyInternyNode
};
// vytvorenie noveho nodu s dvama externymy synmi
novyInternyNode.Hlbka = nadKtorym.Hlbka;
novyInternyNode.Left = novyLavy;
novyInternyNode.Right = novyPravy;
// priradenie noveho potomka
if (parentNodu != null)
{
novyInternyNode.Parent = parentNodu;
if ((parentNodu as ZnakNodeInterny).Left == nadKtorym)
{
(parentNodu as ZnakNodeInterny).Left = novyInternyNode;
}
else
{
(parentNodu as ZnakNodeInterny).Right = novyInternyNode;
}
}
//nahradenie stareho externeho nodu novym internym
nadKtorym = novyInternyNode;
var tmpKtory = novyInternyNode;
//priradenie starych blokov do novych
var posByte = tmpExternyNodeCopy.Hlbka / 8;
var pos = tmpExternyNodeCopy.Hlbka % 8;
while (true)
{
var poleByt = new List <byte>();
for (int i = 0; i < blokExt.Data.Count; i++)
{
//zahesovany konkretny jeden block
// toto tu bolo pred tym Old VErsion var konkretnyBlockHash= BitConverter.GetBytes(tmpExternyNodeCopy.Blok[i]);
var konkretnyBlockHash = blokExt.Data[i].Hash();
var konkretnyByte = konkretnyBlockHash[posByte];
if (IsBitSet(konkretnyByte, pos))
{
poleByt.Add(1);
}
else
{
poleByt.Add(0);
}
}
var pocetJed = poleByt.Count(x => x == 1);
if (pocetJed != 0 && pocetJed != poleByt.Count)
{
var lavyBlok = new Blok <T>();
var pravyBlok = new Blok <T>();
for (int l = 0; l < blokExt.Data.Count; l++)
{
if (poleByt[l] == 0)
{
lavyBlok.Vloz(blokExt.Data[l]);
(tmpKtory.Left as ZnakNodeExterny).PocetZaznamov++;
}
else
{
pravyBlok.Vloz(blokExt.Data[l]);
(tmpKtory.Right as ZnakNodeExterny).PocetZaznamov++;
}
}
//------------------------------------------------------------------------------------------------------------------------------------TUNAK SA RNAO POZRI A SKUS HOTFIX NA ZAPISANIE STARYCH BLOKOV DO SUBORU
//lavy bude mat vzdy adresu po parentovy z prveho externeho nodu
var adresaLaveho = DajAdresu();
(tmpKtory.Left as ZnakNodeExterny).Seek = adresaLaveho;
// pravy si ju musi prepocitat lebo nejde cez metodu Zapis
var adresaPraveho = DajAdresu();
(tmpKtory.Right as ZnakNodeExterny).Seek = adresaPraveho;
lavyBlok.ZapisBlok(adresaLaveho, NazovSuboru);
pravyBlok.ZapisBlok(adresaPraveho, NazovSuboru);
return;
}
else
{
if (poleByt[0] == 0)
{
//vytvorit strom dolava
tmpKtory.Left = new ZnakNodeInterny()
{
Hlbka = tmpKtory.Hlbka + 1, Parent = tmpKtory
};
var novyVrcholStromu = tmpKtory.Left as ZnakNodeInterny;
var lavy = new ZnakNodeExterny()
{
Hlbka = novyVrcholStromu.Hlbka + 1, Parent = novyVrcholStromu
};
var pravy = new ZnakNodeExterny()
{
Hlbka = novyVrcholStromu.Hlbka + 1, Parent = novyVrcholStromu
};
novyVrcholStromu.Left = lavy;
novyVrcholStromu.Right = pravy;
tmpKtory = novyVrcholStromu;
}
else
{
//vytvorit strom doprava
tmpKtory.Right = new ZnakNodeInterny()
{
Hlbka = tmpKtory.Hlbka + 1, Parent = tmpKtory
};
var novyVrcholStromu = tmpKtory.Right as ZnakNodeInterny;
var lavy = new ZnakNodeExterny()
{
Hlbka = novyVrcholStromu.Hlbka + 1, Parent = novyVrcholStromu
};
var pravy = new ZnakNodeExterny()
{
Hlbka = novyVrcholStromu.Hlbka + 1, Parent = novyVrcholStromu
};
novyVrcholStromu.Left = lavy;
novyVrcholStromu.Right = pravy;
tmpKtory = novyVrcholStromu;
}
//zvysenie porovnavacieho bytu
if (pos == 7)
{
pos = 0;
// ASi ????????????????????????????
posByte++;
}
else
{
pos++;
}
}
}
}
private T Find(T prvok)
{
var hash = prvok.Hash();
if (Root is ZnakNodeExterny)
{
if ((Root as ZnakNodeExterny).Seek != -1)
{
var konkretny = (Root as ZnakNodeExterny);
var tmpBlok = new Blok <T>(1);
tmpBlok.NacitajBlok(konkretny.Seek, NazovSuboru);
foreach (var item in tmpBlok.Data)
{
if (item.CompareTo(prvok))
{
return(item);
}
}
}
}
else
{
var tmpNode = Root as ZnakNodeInterny;
for (int i = 0; i < hash.Length; i++)
{
for (int j = 0; j < 8; j++)
{
if (IsBitSet(hash[i], j))
{
if (tmpNode.Right is ZnakNodeExterny)
{
var konkretny = (tmpNode.Right as ZnakNodeExterny);
if (konkretny.Seek != -1)
{
var tmpBlok = new Blok <T>(1);
tmpBlok.NacitajBlok(konkretny.Seek, NazovSuboru);
foreach (var item in tmpBlok.Data)
{
if (item.CompareTo(prvok))
{
return(item);
}
}
}
else
{
konkretny.Seek = DajAdresu();
}
return(default(T));
}
else
{
tmpNode = tmpNode.Right as ZnakNodeInterny;
}
}
else
{
if (tmpNode.Left is ZnakNodeExterny)
{
var konkretny = (tmpNode.Left as ZnakNodeExterny);
if (konkretny.Seek != -1)
{
var tmpBlok = new Blok <T>(1);
tmpBlok.NacitajBlok(konkretny.Seek, NazovSuboru);
foreach (var item in tmpBlok.Data)
{
if (item.CompareTo(prvok))
{
return(item);
}
}
}
else
{
konkretny.Seek = DajAdresu();
}
return(default(T));
}
else
{
tmpNode = tmpNode.Left as ZnakNodeInterny;
}
}
}
}
return(default(T));
}
return(default(T));
}