bool db::SaveTab(FILE* savefile, int ntab)
{
    if (savefile == NULL)
        return false;
    WriteString(savefile, Tabs[ntab].name, strlen(Tabs[ntab].name)); // nazwa
    WriteInt(savefile, Tabs[ntab].column_count); // liczba kolumn

    for (int i=0; i< Tabs[ntab].column_count; i++) // kolejnosc kolumn
        WriteInt(savefile, Tabs[ntab].column_order[i]);

    for (int i=0; i< Tabs[ntab].column_count; i++) // typy kolumn
        WriteULLI(savefile, Tabs[ntab].column_types[i]);

    for (int i=0; i< Tabs[ntab].column_count; i++) // nazwy kolumn
        WriteString(savefile, Tabs[ntab].column_names[i], strlen(Tabs[ntab].column_names[i]));

    for (int i=0; i< Tabs[ntab].column_count; i++) // mutexy column , false
        WriteBool(savefile, Tabs[ntab].column_mutex[i]);

    WriteInt(savefile, Tabs[ntab].max_data_count); // max data count
    WriteInt(savefile, Tabs[ntab].data_count); // data count
    WriteInt(savefile, Tabs[ntab].data_ptr); // data ptr

    for(int i=0; i<Tabs[ntab].max_data_count; i++) // czy istnieja dane
        WriteBool(savefile, Tabs[ntab].data_exist[i]);

    for (int i=0; i<Tabs[ntab].max_data_count; i++)
    {
        if (!Tabs[ntab].data_exist[i])
            continue;
        for (int c=0; c<Tabs[ntab].column_count; c++)
        {
            switch(Tabs[ntab].column_types[c] % TYP::MASK::START)
            {
            case TYP::INCINT:
            case TYP::INT:
            case TYP::CLAMP:
                WriteInt(savefile, ((int*)Tabs[ntab].column_data[c])[i]);
                break;
            case TYP::STRING:
                WriteString(savefile, ((char**)Tabs[ntab].column_data[c])[i], strlen(((char**)Tabs[ntab].column_data[c])[i]));
                break;
            case TYP::DOUBLE:
                WriteDouble(savefile, ((double*)Tabs[ntab].column_data[c])[i]);
                break;
            case TYP::BOOL:
                WriteBool(savefile, ((bool*)Tabs[ntab].column_data[c])[i]);
                break;
            default:
                cout << "nie rozpoznay typ danych przy zapisywaniu\n";
                break;
            }
        }
    }
    return true;
}

void db::WriteInt(FILE* savefile, int param)
{
    fwrite(&param, sizeof(int), 1, savefile);
}

void db::WriteULLI(FILE* savefile, unsigned long long int param)
{
    fwrite(&param, sizeof(unsigned long long int), 1, savefile);
}

void db::WriteString(FILE* savefile, char* param, int strlen)
{
    WriteInt(savefile, strlen);
    fwrite(param, strlen*sizeof(char), 1, savefile);
}

void db::WriteBool(FILE* savefile, bool param)
{
    fwrite(&param, sizeof(bool), 1, savefile);
}

void db::WriteDouble(FILE* savefile, double param)
{
    fwrite(&param, sizeof(double), 1, savefile);
}

bool db::ReadInt(FILE* readfile, int* output)
{
    return fread(output, sizeof(int), 1, readfile) == 1;
}

bool db::ReadULLI(FILE* readfile, unsigned long long int* output)
{
    return fread(output, sizeof(unsigned long long int), 1, readfile) == 1;
}

bool db::ReadString(FILE* readfile, char** output)
{
    int len;
    if (!ReadInt(readfile, &len))
        return false;

    *output = (char*)malloc(sizeof(char)*(len+1));
    (*output)[len] = 0;
    return fread(*output, sizeof(char), len, readfile) == len;
}

bool db::ReadBool(FILE* readfile, bool* output)
{
    return fread(output, sizeof(bool), 1, readfile) == 1;
}

bool db::ReadDouble(FILE* readfile, double* output)
{
    return fread(output, sizeof(double), 1, readfile) == 1;
}

bool db::LoadTab(FILE* readfile, int ntab)
{
    if (readfile == NULL)
        return false;
    char* strbuff;

    if (!ReadString(readfile, &strbuff)) // nazwa
        return false;
    if (strcmp(strbuff, Tabs[ntab].name)!=0) // nazwa sie nie zgadza
        return false;

    free(strbuff);
    ReadInt(readfile, &Tabs[ntab].column_count); // ilosc kolumn

    for (int i=0; i< Tabs[ntab].column_count; i++) // kolejnosc kolumn
        ReadInt(readfile, &Tabs[ntab].column_order[i]);
    for (int i=0; i< Tabs[ntab].column_count; i++) // typy kolumn
        ReadULLI(readfile, &Tabs[ntab].column_types[i]);
    for (int i=0; i< Tabs[ntab].column_count; i++) // nazwy kolumn
        ReadString(readfile, &Tabs[ntab].column_names[i]);
    for (int i=0; i< Tabs[ntab].column_count; i++) // mutexy column , false
        ReadBool(readfile, &Tabs[ntab].column_mutex[i]);

    ReadInt(readfile, &Tabs[ntab].max_data_count); // max data count
    ReadInt(readfile, &Tabs[ntab].data_count); // data count
    ReadInt(readfile, &Tabs[ntab].data_ptr); // data ptr

    for(int i=0; i<Tabs[ntab].max_data_count; i++) // czy istnieja dane
        ReadBool(readfile, &Tabs[ntab].data_exist[i]);

    for (int i=0; i<Tabs[ntab].max_data_count; i++)
    {
        if (!Tabs[ntab].data_exist[i])
            continue;
        for (int c=0; c<Tabs[ntab].column_count; c++)
        {
            switch(Tabs[ntab].column_types[c] % TYP::MASK::START)
            {
            case TYP::INCINT:
            case TYP::INT:
            case TYP::CLAMP:
                ReadInt(readfile, &((int*)Tabs[ntab].column_data[c])[i]);
                break;
            case TYP::STRING:
                ReadString(readfile, &((char**)Tabs[ntab].column_data[c])[i]);
                break;
            case TYP::DOUBLE:
                ReadDouble(readfile, &((double*)Tabs[ntab].column_data[c])[i]);
                break;
            case TYP::BOOL:
                ReadBool(readfile, &((bool*)Tabs[ntab].column_data[c])[i]);
                break;
            default:
                cout << "nie rozpoznay typ danych przy zapisywaniu\n";
                break;
            }
        }
    }
    return true;
}