file system c++

#include « filesystem.h »

#include < sstream>
#include <fstream>#include <vector>

#include <iostream>

Utilisation de l’espace de noms std ;

bool File_System::load_file(string file_location) {

fichier(file_location) ifstream; Charger le fichier

si(!file.good() || !file.is_open()) renvoie false; Si le fichier est introuvable ou n’a pas pu s’ouvrir

// Obtenir la taille du
fichier file.seekg(0, ios::end);
int length = file.tellg();
file.seekg(0, ios::beg);

if(length <= 0) renvoie false; Erreur lors du chargement du fichier

Charger le fichier dans data data.reserve
(length);
copie(istreambuf_iterator<char>(fichier), istreambuf_iterator<char>(), back_inserter(données));
reset();

return true;
}

bool File_System::save_file(string file_location, unsigned int max_size) {
if(data.size() > max_size) renvoie false; Juste au cas où il y aurait une erreur afin que nous n’enregistrions pas un fichier volumineux

Ouvrir le fichier
ofstream;
fichier.ouvre(file_location);

if(!file.is_open() || !file) renvoie false; Si le fichier ne s’ouvre pas

Enregistrer les données dans une chaîne de fichier
str = « »;
for(unsigned int i=0; i < data.size(); i++) str += données[i];
fichier << str;
fichier.close();

return true;
}

void File_System::reset() {
pointer = 0;
eof = faux;
ovr = faux;
}

bool File_System::read_bit() {
if(eof) return 0; Si la fin du fichier ne lit pas les octets indésirables
if(pointer+1 >= data.size()*8) eof = true; Définir la fin du fichier sur true si à la fin du fichier

Read bit
bool val = (data[(pointeur / 8)] >> (pointeur % 8)) & 0x01;
pointeur++;
retour val;

}

unsigned char File_System::read_nibble() {if(eof) return 0; Si la fin du fichier ne lit pas les octets indésirables

// Read each bit 1 by 1
unsigned char val = 0x0;

for(unsigned char i=0; i < 4; i++) {
if(read_bit()) { // If bit is set set bit in return byte
val |= (char)(1 << (3 – i));
}
}

return val;
}

unsigned char File_System::read_char() {
if(eof) return 0; // If end of file don’t read junk bytes

if(pointer % 8 == 0) { // Fast read, we can just read the byte if pointer is byte aligned
if(pointer+8 >= data.size()*8) eof = true;
unsigned char val = data[(pointer) / 8];
pointer += 8;
return val;
}

// Slow read, read each bit 1 by 1
unsigned char val = 0x00;

for(unsigned char i=0; i < 8; i++) {
if(read_bit()) { // If bit is set set bit in return byte
val |= (char)(1 << (7 – i));
}
}

return val;
}

unsigned short File_System::read_short() {
if(eof) return 0;

// Read 2 bytes and combine to short
return ((unsigned short)read_char() << 8) | (unsigned short)read_char();
}

string File_System::read_string(unsigned int bytes) {
string val = “”;
for(unsigned int i=0; i < bytes && !eof; i++) {
val += read_char();
}
return val;
}

string File_System::data_string() {
string str = “”;
for(unsigned int i=0; i < data.size(); i++) {
str += data[i];
}
return str;
}

void File_System::write_bit(bool val) {
unsigned int ind = pointer / 8;
unsigned char shift = pointer % 8;

if(ind >= data.size()) { // Add another byte to the end of the data if it’s at the data limit
data.push_back(0x00);
ovr = true; // And update this flag accordingly
}

if(inc) pointer++; // Increment pointer if inc flag is set

// Toggle bit if bit doesn’t equal value
if((bool)((data[ind] >> shift) & 0x01) != val) data[ind] ^= 0x01 << shift;
}

void File_System::write_nibble(unsigned char val) {
for(unsigned char i=0; i < 4; i++) { // We can just write 4 bits
write_bit(((val & (1 << i)) != 0));
}
}

void File_System::write_char(unsigned char val) {
if(pointer % 8 == 0) { // Fast write, we can just set the byte if pointer is byte aligned
if(pointer >= data.size()*8) { // Add the val to the end of the data if it’s at the data limit
data.push_back(val);
ovr = true; // And update this flag accordingly
} else {
data[pointer / 8] = val;
}
if(inc) pointer += 8;
return;
}

for(unsigned char i=0; i < 8; i++) { // We can just write 8 bits
write_bit(((val & (1 << i)) != 0));
}
}

void File_System::write_short(unsigned short val) {
write_char(val); // Just split the value into 2 bytes then write those
write_char(val >> 8);
}

void File_System::write_string(string val) {
for(unsigned int i=0; i < val.length(); i++) {
write_char(val[i]);
}
}

unsigned char File_System::pop() {
unsigned char val = data[data.size()-1];
data.pop_back();
return val;
}

unsigned char File_System::align() {
unsigned char dist = pointer % 8;
pointer -= dist;
return dist;
}

本文为原创文章，转载请注明出处！