public static int open(ref pom x, string naz, flaga l, ref int o, ref string Out) // o- ilość zajętych bloków na dysku
//Out-zmienna potrzebna do zapisu odczytanego pliku l-flaga decyduje czy chcemy coś odczytać czy coś zapisać
//funkcja służąca do odczytu lub zapisu
{
bool ok = false;
string odkod = null;
Out = odkod;
int v = 0, b = 0;
List <int> LBP = new List <int>();
for (int i = 0; i < x.LK.Count(); i++)
{
for (int j = 0; j < x.LK[i].Count(); j++)
{
if (x.LK[i][j].nazwa == naz) // znajdowanie pliku o nazwie zapisanej w parametrze 'naz'
{
v = x.LK[i][j].nriwezla; b = x.LK[i][0].nriwezla; ok = true; break;
}
}
}
if (ok == false)
{
Console.WriteLine("Nie ma takiego pliku");
return(-1);
}
LBP = iwezel.listazblok(ref x, v);
if (l == flaga.ronly && ok == true) //funkcja odczytuje plik
{
if (x.tabi[v].Typ == 'p' && ((x.tabi[v].prawa1 == 1) || (x.tabi[v].prawa1 == 3) || (x.tabi[v].prawa1 == 7) || (x.tabi[v].prawa1 == 5)))
{
if (x.tabi[v].pierwszyblok == -1)
{ // domyślnie pierwszy blok ma -1 co oznacza ze plik jest pusty
Console.WriteLine("Plik jest pusty");
return(-1);
}
else
{
byte[] q = new byte[LBP.Count * 32];
int ileb = LBP.Count;
int nowa = 0;
int r = 0;
int[] taby = new int[ileb];
for (int i = 0; i < ileb; i++)
{
taby[i] = LBP[i];
}
while (nowa != ileb)
{
if (nowa > 5)
{
Console.WriteLine("Plik może mieć maksymalnie 6 bloków!");
break;
}
for (int i = 0; i < 32; i++)
{
if (x.dysk[taby[nowa]].bl[i] == 0)
{
break;
}
q[r] = x.dysk[taby[nowa]].bl[i];
r++;
}
if (ileb - 1 == nowa)
{
odkod = Encoding.ASCII.GetString(q, 0, r);
}
nowa++;
}
Out = odkod;
}
}
if (x.tabi[v].Typ == 'k')
{
WpisK.wyswk1(naz, ref x); //open z flaga ronly dla katalogu wyswietla wpisy danego katalogu
}
}
if (l == flaga.wonly && ok == true)
{ //sprawdzamy czy jest to plik o odpowiednich prawach do ktorego mozemy cos zapisac
if (x.tabi[v].Typ == 'p' && ((x.tabi[v].prawa1 == 2) || (x.tabi[v].prawa1 == 3) || (x.tabi[v].prawa1 == 7) || (x.tabi[v].prawa1 == 6)))
{
Console.WriteLine("Pisz do pliku o nazwie: " + naz);
string dane;
dane = Console.ReadLine();
byte[] q;
q = Encoding.ASCII.GetBytes(dane);
int ileb = q.Length / 32;
int u = x.tabi[v].blokindeksowy;
int r = 0;
int nowa = 0, koncz = 0;
if (x.tabi[v].pierwszyblok == -1) //jeśli plik jest pusty to zapis przebiega tak
{
if (q.Length % 32 == 0)
{
int[] taby = new int[ileb];
while (nowa != ileb)
{
if (koncz == 1 && r == 192)
{
Console.WriteLine("Plik może mieć maksymalnie 6 bloków!");
break;
}
if (koncz == 1)
{
break;
}
taby[nowa] = iwezel.wolnemiejsce(ref o, ref x);
for (int i = 0; i < 32; i++)
{
if (r == q.Length || r == 192)
{
koncz = 1; break;
}
x.dysk[taby[nowa]].bl[i] = q[r];
r++;
}
if (nowa == 0)
{
x.tabi[v].pierwszyblok = taby[nowa];
}
if (nowa == 1)
{
x.tabi[v].drugiblok = taby[nowa];
x.dysk[taby[nowa - 1]].nast = taby[nowa];
}
if (nowa == 2)
{
u = iwezel.wolnemiejsce(ref o, ref x);
x.dysk[taby[nowa - 1]].nast = u;
x.tabi[v].blokindeksowy = u;
for (int i = 0; i < 32; i++)
{
x.dysk[u].bl[i] = 65; //wypelnienie bloku indeksowego liczbą(indeksem) nie nazlezącą do dysku
}
//potrzebne do odczytania z bloku indeksowego kolejnych zajmowanych bloków
x.dysk[u].bl[0] = (byte)taby[nowa];
}
if (nowa == 3)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[1] = (byte)taby[nowa];
}
if (nowa == 4)
{
//x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[2] = (byte)taby[nowa];
}
if (nowa == 5)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[3] = (byte)taby[nowa];
}
nowa++;
if (r == 192)
{
koncz = 1;
}
}
}
if (q.Length % 32 != 0)
{
int[] taby2 = new int[ileb + 1];
while (nowa != ileb + 1)
{
if (koncz == 1 && r == 192)
{
Console.WriteLine("Plik może mieć maksymalnie 6 bloków!");
break;
}
if (koncz == 1)
{
break;
}
taby2[nowa] = iwezel.wolnemiejsce(ref o, ref x);
for (int i = 0; i < 32; i++)
{
if (r == q.Length || r == 192)
{
koncz = 1; break;
}
x.dysk[taby2[nowa]].bl[i] = q[r];
r++;
}
if (nowa == 0)
{
x.tabi[v].pierwszyblok = taby2[nowa];
}
if (nowa == 1) //2 bloki danych
{
x.tabi[v].drugiblok = taby2[nowa];
x.dysk[taby2[nowa - 1]].nast = taby2[nowa];
}
if (nowa == 2)
{
u = iwezel.wolnemiejsce(ref o, ref x);
x.dysk[taby2[nowa - 1]].nast = u;
x.tabi[v].blokindeksowy = u;
for (int i = 0; i < 32; i++)
{
x.dysk[u].bl[i] = 65;
}
x.dysk[u].bl[0] = (byte)taby2[nowa];
}
if (nowa == 3)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[1] = (byte)taby2[nowa];
}
if (nowa == 4)
{
//x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[2] = (byte)taby2[nowa];
}
if (nowa == 5)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[3] = (byte)taby2[nowa];
}
if (r == 192)
{
koncz = 1;
}
nowa++;
}
}
x.tabi[v].rozmiar = r;
x.tabi[b].rozmiar += x.tabi[v].rozmiar;
}
if (x.tabi[v].pierwszyblok != -1 && r == 0) //jeśli chcemy coś dopisać do pliku
{
byte[] q2 = null;
int ostbl = 0;
int poj = (LBP.Count - 1) * 32;
ostbl = LBP.Last();
nowa = LBP.Count;
q2 = x.dysk[ostbl].bl;
for (int i = 0; i < 32; i++)
{
if (q2[i] != 0)
{
poj++;
}
if (q2[i] == 0)
{
x.dysk[ostbl].bl[i] = q[r];
r++;
poj++;
if (r == q.Length || poj == 192)
{
break;
}
}
}
if (q.Length - r <= 0)
{
goto skok;
}
ileb = ((q.Length - r) / 32);
if (q.Length - r % 32 == 0)
{
int m = 0;
int[] taby = new int[ileb];
while (nowa != ileb + nowa)
{
if (poj == 192)
{
koncz = 1;
}
if (koncz == 1 && poj == 192)
{
Console.WriteLine("Plik może mieć maksymalnie 6 bloków!");
break;
}
if (koncz == 1)
{
break;
}
taby[m] = iwezel.wolnemiejsce(ref o, ref x);
for (int i = 0; i < 32; i++)
{
if (r == q.Length || poj == 192)
{
koncz = 1; break;
}
x.dysk[taby[m]].bl[i] = q[r];
r++;
poj++;
}
if (nowa == 0)
{
x.tabi[v].pierwszyblok = taby[m];
}
if (nowa == 1)
{
x.tabi[v].drugiblok = taby[m];
x.dysk[LBP.First()].nast = taby[m];
}
if (nowa == 2)
{
u = iwezel.wolnemiejsce(ref o, ref x);
x.dysk[taby[m - 1]].nast = u;
x.tabi[v].blokindeksowy = u;
for (int i = 0; i < 32; i++)
{
x.dysk[u].bl[i] = 65; //wypelnienie bloku indeksowego liczbą(indeksem) nie nazlezącą do dysku
}
//potrzebne do odczytania z bloku indeksowego kolejnych zajmowanych bloków
x.dysk[u].bl[0] = (byte)taby[m];
}
if (nowa == 3)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[1] = (byte)taby[m];
}
if (nowa == 4)
{
//x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[2] = (byte)taby[m];
}
if (nowa == 5)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[3] = (byte)taby[m];
}
m++;
nowa++;
}
}
if (q.Length - r % 32 != 0)
{
int m = 0;
int[] taby2 = new int[ileb + 1];
while (nowa != ileb + 1 + nowa)
{
if (poj == 192)
{
koncz = 1;
}
if (koncz == 1 && poj == 192)
{
Console.WriteLine("Plik może mieć maksymalnie 6 bloków!");
break;
}
if (koncz == 1)
{
break;
}
taby2[m] = iwezel.wolnemiejsce(ref o, ref x);
for (int i = 0; i < 32; i++)
{
if (r == q.Length || poj == 192)
{
koncz = 1; break;
}
x.dysk[taby2[m]].bl[i] = q[r];
r++;
poj++;
}
if (nowa == 0)
{
x.tabi[v].pierwszyblok = taby2[m];
}
if (nowa == 1) //2 bloki danych
{
x.tabi[v].drugiblok = taby2[m];
x.dysk[LBP.First()].nast = taby2[m];
}
if (nowa == 2)
{
u = iwezel.wolnemiejsce(ref o, ref x);
x.dysk[taby2[m - 1]].nast = u;
x.tabi[v].blokindeksowy = u;
for (int i = 0; i < 32; i++)
{
x.dysk[u].bl[i] = 65;
}
x.dysk[u].bl[0] = (byte)taby2[m];
}
if (nowa == 3)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[1] = (byte)taby2[m];
}
if (nowa == 4)
{
//x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[2] = (byte)taby2[m];
}
if (nowa == 5)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[3] = (byte)taby2[m];
}
m++;
nowa++;
}
}
skok:
x.tabi[b].rozmiar += r;
x.tabi[v].rozmiar = x.tabi[v].rozmiar + r;
}
//kon dopis
}
}
return(0);
}
// o- ilość zajętych bloków na dysku
//Out-zmienna potrzebna do zapisu odczytanego pliku l-flaga decyduje czy chcemy coś odczytać czy coś zapisać
//funkcja służąca do odczytu lub zapisu
public static int open(ref pom x, string naz, flaga l, ref int o, ref string Out)
{
bool ok = false;
string odkod = null;
Out = odkod;
int v = 0, b = 0;
List<int> LBP = new List<int>();
for (int i = 0; i < x.LK.Count(); i++)
{
for (int j = 0; j < x.LK[i].Count(); j++)
{
if (x.LK[i][j].nazwa == naz) // znajdowanie pliku o nazwie zapisanej w parametrze 'naz'
{ v = x.LK[i][j].nriwezla; b = x.LK[i][0].nriwezla; ok = true; break; }
}
}
if (ok == false)
{
Console.WriteLine("Nie ma takiego pliku");
return -1;
}
LBP = iwezel.listazblok(ref x, v);
if (l == flaga.ronly && ok == true) //funkcja odczytuje plik
{
if (x.tabi[v].Typ == 'p' && ((x.tabi[v].prawa1 == 1) || (x.tabi[v].prawa1 == 3) || (x.tabi[v].prawa1 == 7) || (x.tabi[v].prawa1 == 5)))
{
if (x.tabi[v].pierwszyblok == -1)
{ // domyślnie pierwszy blok ma -1 co oznacza ze plik jest pusty
Console.WriteLine("Plik jest pusty");
return -1;
}
else
{
byte[] q = new byte[LBP.Count * 32];
int ileb = LBP.Count;
int nowa = 0;
int r = 0;
int[] taby = new int[ileb];
for (int i = 0; i < ileb; i++)
taby[i] = LBP[i];
while (nowa != ileb)
{
if (nowa > 5)
{
Console.WriteLine("Plik może mieć maksymalnie 6 bloków!");
break;
}
for (int i = 0; i < 32; i++)
{
if (x.dysk[taby[nowa]].bl[i] == 0)
break;
q[r] = x.dysk[taby[nowa]].bl[i];
r++;
}
if (ileb - 1 == nowa)
odkod = Encoding.ASCII.GetString(q, 0, r);
nowa++;
}
Out = odkod;
}
}
if (x.tabi[v].Typ == 'k')
{
WpisK.wyswk1(naz, ref x); //open z flaga ronly dla katalogu wyswietla wpisy danego katalogu
}
}
if (l == flaga.wonly && ok == true)
{ //sprawdzamy czy jest to plik o odpowiednich prawach do ktorego mozemy cos zapisac
if (x.tabi[v].Typ == 'p' && ((x.tabi[v].prawa1 == 2) || (x.tabi[v].prawa1 == 3) || (x.tabi[v].prawa1 == 7) || (x.tabi[v].prawa1 == 6)))
{
Console.WriteLine("Pisz do pliku o nazwie: "+naz);
string dane;
dane = Console.ReadLine();
byte[] q;
q = Encoding.ASCII.GetBytes(dane);
int ileb = q.Length / 32;
int u = x.tabi[v].blokindeksowy;
int r = 0;
int nowa = 0,koncz=0;
if (x.tabi[v].pierwszyblok == -1) //jeśli plik jest pusty to zapis przebiega tak
{
if (q.Length % 32 == 0)
{
int[] taby = new int[ileb];
while (nowa != ileb)
{
if (koncz == 1 && r == 192)
{
Console.WriteLine("Plik może mieć maksymalnie 6 bloków!");
break;
}
if (koncz == 1)
break;
taby[nowa] = iwezel.wolnemiejsce(ref o, ref x);
for (int i = 0; i < 32; i++)
{
if (r == q.Length || r == 192)
{ koncz = 1; break; }
x.dysk[taby[nowa]].bl[i] = q[r];
r++;
}
if (nowa == 0)
{
x.tabi[v].pierwszyblok = taby[nowa];
}
if (nowa == 1)
{
x.tabi[v].drugiblok = taby[nowa];
x.dysk[taby[nowa - 1]].nast = taby[nowa];
}
if (nowa == 2)
{
u = iwezel.wolnemiejsce(ref o, ref x);
x.dysk[taby[nowa - 1]].nast = u;
x.tabi[v].blokindeksowy = u;
for (int i = 0; i < 32; i++)
x.dysk[u].bl[i] = 65; //wypelnienie bloku indeksowego liczbą(indeksem) nie nazlezącą do dysku
//potrzebne do odczytania z bloku indeksowego kolejnych zajmowanych bloków
x.dysk[u].bl[0] = (byte)taby[nowa];
}
if (nowa == 3)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[1] = (byte)taby[nowa];
}
if (nowa == 4)
{
//x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[2] = (byte)taby[nowa];
}
if (nowa == 5)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[3] = (byte)taby[nowa];
}
nowa++;
if (r == 192)
koncz = 1;
}
}
if (q.Length % 32 != 0)
{
int[] taby2 = new int[ileb + 1];
while (nowa != ileb + 1)
{
if (koncz == 1 && r == 192)
{
Console.WriteLine("Plik może mieć maksymalnie 6 bloków!");
break;
}
if (koncz == 1)
{ break; }
taby2[nowa] = iwezel.wolnemiejsce(ref o, ref x);
for (int i = 0; i < 32; i++)
{
if (r == q.Length || r==192)
{ koncz = 1; break; }
x.dysk[taby2[nowa]].bl[i] = q[r];
r++;
}
if (nowa == 0)
{
x.tabi[v].pierwszyblok = taby2[nowa];
}
if (nowa == 1) //2 bloki danych
{
x.tabi[v].drugiblok = taby2[nowa];
x.dysk[taby2[nowa - 1]].nast = taby2[nowa];
}
if (nowa == 2)
{
u = iwezel.wolnemiejsce(ref o, ref x);
x.dysk[taby2[nowa - 1]].nast = u;
x.tabi[v].blokindeksowy = u;
for (int i = 0; i < 32; i++)
x.dysk[u].bl[i] = 65;
x.dysk[u].bl[0] = (byte)taby2[nowa];
}
if (nowa == 3)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[1] = (byte)taby2[nowa];
}
if (nowa == 4)
{
//x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[2] = (byte)taby2[nowa];
}
if (nowa == 5)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[3] = (byte)taby2[nowa];
}
if (r == 192)
koncz = 1;
nowa++;
}
}
x.tabi[v].rozmiar = r;
x.tabi[b].rozmiar += x.tabi[v].rozmiar;
}
if (x.tabi[v].pierwszyblok != -1 && r == 0) //jeśli chcemy coś dopisać do pliku
{
byte[] q2 = null;
int ostbl = 0;
int poj = (LBP.Count - 1) * 32;
ostbl = LBP.Last();
nowa =LBP.Count;
q2 = x.dysk[ostbl].bl;
for (int i = 0; i < 32; i++)
{
if (q2[i] != 0)
poj++;
if (q2[i] == 0)
{
x.dysk[ostbl].bl[i] = q[r];
r++;
poj++;
if (r == q.Length || poj==192)
break;
}
}
if (q.Length - r <= 0)
goto skok;
ileb = ((q.Length - r) / 32) ;
if (q.Length-r % 32 == 0)
{
int m = 0;
int[] taby = new int[ileb];
while (nowa != ileb+nowa)
{
if (poj == 192)
koncz = 1;
if (koncz == 1 && poj == 192)
{
Console.WriteLine("Plik może mieć maksymalnie 6 bloków!");
break;
}
if (koncz == 1)
break;
taby[m] = iwezel.wolnemiejsce(ref o, ref x);
for (int i = 0; i < 32; i++)
{
if (r == q.Length || poj==192)
{ koncz = 1; break; }
x.dysk[taby[m]].bl[i] = q[r];
r++;
poj++;
}
if (nowa == 0)
{
x.tabi[v].pierwszyblok = taby[m];
}
if (nowa == 1)
{
x.tabi[v].drugiblok = taby[m];
x.dysk[LBP.First()].nast = taby[m];
}
if (nowa == 2)
{
u = iwezel.wolnemiejsce(ref o, ref x);
x.dysk[taby[m - 1]].nast = u;
x.tabi[v].blokindeksowy = u;
for (int i = 0; i < 32; i++)
x.dysk[u].bl[i] = 65; //wypelnienie bloku indeksowego liczbą(indeksem) nie nazlezącą do dysku
//potrzebne do odczytania z bloku indeksowego kolejnych zajmowanych bloków
x.dysk[u].bl[0] = (byte)taby[m];
}
if (nowa == 3)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[1] = (byte)taby[m];
}
if (nowa == 4)
{
//x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[2] = (byte)taby[m];
}
if (nowa == 5)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[3] = (byte)taby[m];
}
m++;
nowa++;
}
}
if (q.Length-r % 32 != 0)
{ int m=0;
int[] taby2 = new int[ileb+1];
while (nowa != ileb+1+nowa)
{
if (poj == 192)
koncz = 1;
if (koncz==1 && poj==192)
{
Console.WriteLine("Plik może mieć maksymalnie 6 bloków!");
break;
}
if (koncz == 1)
break;
taby2[m] = iwezel.wolnemiejsce(ref o, ref x);
for (int i = 0; i < 32; i++)
{
if (r == q.Length || poj==192)
{ koncz = 1; break; }
x.dysk[taby2[m]].bl[i] = q[r];
r++;
poj++;
}
if (nowa == 0)
{
x.tabi[v].pierwszyblok = taby2[m];
}
if (nowa == 1) //2 bloki danych
{
x.tabi[v].drugiblok = taby2[m];
x.dysk[LBP.First()].nast = taby2[m];
}
if (nowa == 2)
{
u = iwezel.wolnemiejsce(ref o, ref x);
x.dysk[taby2[m - 1]].nast = u;
x.tabi[v].blokindeksowy = u;
for (int i = 0; i < 32; i++)
x.dysk[u].bl[i] = 65;
x.dysk[u].bl[0] = (byte)taby2[m];
}
if (nowa == 3)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[1] = (byte)taby2[m];
}
if (nowa == 4)
{
//x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[2] = (byte)taby2[m];
}
if (nowa == 5)
{
// x.dysk[taby[nowa - 1]].nast = taby[nowa];
x.dysk[u].bl[3] = (byte)taby2[m];
}
m++;
nowa++;
}
}
skok:
x.tabi[b].rozmiar += r;
x.tabi[v].rozmiar = x.tabi[v].rozmiar + r;
}
//kon dopis
}
}
return 0;
}
