unlimited-storage

chunk.cpp (10213B)

---

 # include "../include/chunk.h"
 # include "filesystem"
 # include <iostream>
 # include <fstream>
 # include <bitset>
 # include "../include/debug.h"
 
 
 const int IMAGE_HEADER_SIZE = 48;
 
 // read in saved chunk from file
 Chunk::Chunk(std::string filename) {
 
     std::ifstream file;
 
     file.open(filename);
 
     std::string fileString = "";
 
     char byte;
 
     while (file.read(&byte, 1)) {
         fileString += byte;
     }
 
     file.close();
 
     // header (.pbm header), comment (.pbm comment), dims (.pbm spec)
 
     std::string header = "";
     std::string comment = "";
     std::string dims  = "";
 
     uint itr = 0;
     while (fileString[itr] != '\n') {
         header += fileString[itr];
         itr += 1;
     }
 
     itr += 1;
 
     while (fileString[itr] != '\n') {
         comment += fileString[itr];
         itr += 1;
     }
 
 
     itr += 1;
 
     while (fileString[itr] != '\n') {
         dims += fileString[itr];
         itr += 1;
     }
 
     itr += 1;
 
 
     std::string content = "";
 
     // this would be better if we didn't preallocate a size for this section
     // but that requires quite a bit more work for what I think is minimal benefit.
 
     // ENCODED HEADER (this data is encoded in the image itself):
     // chunk number  4 bytes (16 bits)
     // characters    4 bytes (16 bits)
     // fnamelen      4 bytes (16 bits)
     // filename      fnamelen 
     //
     // 16 + 16 + 16 = 48
 
 
 
     this->header.chunkNumber = 0;
     this->header.characters = 0;
     this->header.fnameLength = 0;
     this->header.filename = "";
 
     std::string encodedCNum = extractEncodedSection(fileString, itr, 4 * 8);
     std::string encodedCharacters = extractEncodedSection(fileString, itr, 4 * 8);
     std::string encodedFnameLength = extractEncodedSection(fileString, itr, 4 * 8);
 
     this->header.characters = std::bitset<4*8>(encodedCharacters).to_ullong();
     this->header.chunkNumber = std::bitset<4*8>(encodedCNum).to_ullong();
     this->header.fnameLength = std::bitset<4*8>(encodedFnameLength).to_ullong();
 
     std::string encodedFname = extractEncodedSection(fileString, itr, this->header.fnameLength);
     this->header.filename = binaryToAscii(encodedFname);
 
     LOG("ENCODED CNUM: " << encodedCNum)
     LOG("CNUM: " << this->header.chunkNumber)
 
     LOG("ENCODED CHARACTERS: " << encodedCharacters)
     LOG("CHARACTERS: " << this->header.characters)
 
     LOG("ENCODED FNAMELENGTH: " << encodedFnameLength)
     LOG("FNAMELENGTH: " << this->header.fnameLength)
 
 
     LOG("ENCODED FNAME: " << encodedFname)
     LOG("FNAME: " << this->header.filename)
 
     while(itr < fileString.size()) {
         if (fileString[itr] != ' ' && fileString[itr] != '\n') {
             content += fileString[itr];
         }
         itr += 1;
     }
 
     std::vector<char> bytes;
 
 
     for (uint i = 0 ; i < this->header.characters; ++i) {
 
         std::string current = "";
 
         for (int itr = 0; itr < 8; ++itr) {
 
             current += content[i * 8 + itr];
         }
 
         std::bitset<8> bits(current);
 
         char recovered_char = static_cast<char>(bits.to_ulong());
 
         bytes.push_back(recovered_char);
     }
 
     this->chunk = bytes;
 }
 
 Chunk::Chunk(std::vector<char> chunkData) {
     this->chunk = chunkData;
 }
 
 Chunk::Chunk(std::string filename, uint start, uint x, uint y) {
 
     std::ifstream file;
 
     file.open(filename, std::ios::binary);
     LOG("SEEKING: " + std::to_string(start))
     file.seekg(start);
 
     std::string filenameEncoded = "";
 
     for (std::size_t i = 0; i < filename.size(); ++i) {
         filenameEncoded += std::bitset<8>(filename.c_str()[i]).to_string();
     }   
 
     uint bytesToLoad = ((x * y) / 8) - (IMAGE_HEADER_SIZE + filenameEncoded.size());
     uint fSize = std::filesystem::file_size(filename) - start;
 
     if (fSize < bytesToLoad){
         bytesToLoad = fSize;
     }
 
     LOG("FILE SIZE: " + std::to_string(fSize))
     LOG("LOADING IN " + std::to_string(bytesToLoad) + " BYTES")
 
     std::vector<char> bytes(bytesToLoad);
 
     LOG("LOADED IN " + std::to_string(bytes.size()) + " BYTES")
 
     file.read(bytes.data(), bytesToLoad);
 
     file.close();
     this->chunk = bytes;
 }
 
 
 bool Chunk::operator<(const Chunk& other) const {
 
     if (this->header.filename == other.header.filename){
         return this->header.chunkNumber < other.header.chunkNumber;
     }
 
     return this->header.filename < other.header.filename;
 }
 
 
 int Chunk::getChunkNumber() const{
     return this->header.chunkNumber;
 }
 
 std::string Chunk::getFilename() const{
     return this->header.filename;
 }
 
 std::vector<char> Chunk::getChunk() {
     return this->chunk;
 }
 
 // use if header info is populated in the object
 // and you are trying to write back out what you read in.
 // append if not the first chunk.
 
 void Chunk::writeChunk() {
 
     LOG(this->header.filename)
 
     if(this->header.chunkNumber == 0){
         bool deleteExisting = std::filesystem::remove(this->header.filename);
         if(deleteExisting){
             LOG("FILE DELETED")
         }
         else{
             LOG("NO FILE TO DELETE, CONTINUING")
         }
     }
 
     std::ofstream outFile;
     std::vector<char> bytes = this->chunk;
 
     if(this->header.chunkNumber != 0) {
         outFile.open(this->header.filename, std::ios::binary | std::ios::app);
         LOG("FILE APPENDING")
     } else {
         outFile.open(this->header.filename, std::ios::binary | std::ios::out);
     }
 
     for(uint i = 0 ; i < bytes.size(); ++i) {
         outFile.write(&bytes[i], 1);
     }
     LOG("WROTE " + std::to_string(bytes.size()) + " CHARS")
     LOG("HEADER STATES " + std::to_string(this->header.characters) + " CHARS")
 }
 
 void Chunk::writeChunk(std::string filename) {
 
     LOG("Writing chunk")
     LOG(filename)
     std::ofstream outFile;
     std::vector<char> bytes = this->chunk;
 
 
     if(this->header.chunkNumber != 0) {
         outFile.open(filename, std::ios::binary | std::ios::app);
     } else {
         outFile.open(filename, std::ios::binary | std::ios::out);
     }
 
     for(uint i = 0 ; i < bytes.size(); ++i) {
         outFile.write(&bytes[i], 1);
     }
 }
 
 // HEADER:
 // - chunk number  4 bytes
 // - characters    4 bytes
 // - fnamelen      4 bytes
 // - filename      fnamelen
 
 void Chunk::writeImage(std::string filename, uint chunkNumber, std::string originalFilename, uint x, uint y) {
 
     Chunk chunk = this->chunk;
 
     std::vector<char> data = chunk.getChunk();
 
     std::string firstLine = "P1\n";
     std::string comment = "# Encoded with Andrew's awesome .pbm encoder.\n";
 
     std::string chunkNumberEncoded = std::bitset<8*4>(chunkNumber).to_string();
     std::string charactersEncoded = std::bitset<8*4>(data.size()).to_string();
 
     LOG(data.size())
 
     std::string dims = std::to_string(x);
 
     std::string filenameEncoded = "";
 
     // ascii encoding
     // todo:
     // create function for this.
 
     for (std::size_t i = 0; i < originalFilename.size(); ++i) {
         filenameEncoded += std::bitset<8>(originalFilename.c_str()[i]).to_string();
     }
 
     LOG(filenameEncoded)
 
     dims += " ";
     dims += std::to_string(y);
     dims += ("\n");
 
     std::string filenameLengthEncoded = std::bitset<8*4>(filenameEncoded.size()).to_string();
 
 
     std::string image = firstLine + comment + dims;
 
 
     std::string header = chunkNumberEncoded + charactersEncoded + filenameLengthEncoded + filenameEncoded;
 
     LOG(chunkNumberEncoded.size() + " - " + chunkNumberEncoded)
     LOG(charactersEncoded.size() + " - " + charactersEncoded)
     LOG(filenameLengthEncoded.size() + " - " + filenameLengthEncoded)
     LOG(filenameEncoded.size() + " - " + filenameEncoded)
 
     this->header.chunkNumber = chunkNumber;
     this->header.filename = filename;
     this->header.fnameLength = filenameEncoded.size();
     this->header.characters = data.size();
 
 
     uint xPos = 0;
 
     for (char bit : header) {
         if (xPos == x) {
             image.append("\n");
             xPos = 0;
         }
         image += bit;
         image.append(" ");
         xPos += 1;
     }
 
     int target = x * y;
     int added = 0;
 
     for (char chr : data) {
         if (added > target){
             LOG("BREAKING")
             break;
         }
         std::string current = std::bitset<8>(chr).to_string();
         for (int i = 0 ; i < 8; ++i) {
             if (xPos == x) {
                 image.append("\n");
                 xPos = 0;
             }
             image += current[i];
             added += 1;
             image.append(" ");
 
             xPos += 1;
         }
     }
 
     LOG("FINISHED WRITING " + std::to_string(added) + " CHARACTER BITS")
 
     // these are the bits that have been added.
     this->written = added / 8;
     LOG("ADDED TO IMAGE: " + std::to_string(this->written))
     LOG("FINISHED WRITING " + std::to_string(added / 8) + " CHARACTER BYTES")
 
     if (added<target){
         LOG("PADDING WITH ZEROES")
     }
 
     while (added < target) {
         if (xPos == x) {
             image += "\n";
             xPos = 0;
         }
         image += "0 ";
         added += 1;
         xPos += 1;
     }
 
     std::ofstream file = std::ofstream(filename);
 
     file << image;
 }
 
 
 std::string Chunk::toString() {
 
     std::string str = "";
 
     for(uint i = 0 ; i < this->chunk.size(); ++i) {
         str += chunk[i];
     }
     return str;
 }
 
 void Chunk::print() {
     for(uint i = 0 ; i < this->chunk.size(); ++i) {
         std::cout << chunk[i];
     }
 }
 
 std::string Chunk::extractEncodedSection(const std::string& fileString, uint& itr, int count) {
     std::string result;
     int collected = 0;
 
     while (collected < count && itr < fileString.size()) {
         char ch = fileString[itr];
 
         if (!std::isspace(static_cast<unsigned char>(ch))) {
             result += ch;
             collected += 1;
         }
         itr += 1;
     }
 
     return result;
 }
 
 std::string Chunk::binaryToAscii(const std::string& binaryStr) {
     std::string asciiStr;
 
     if (binaryStr.size() % 8 != 0) {
         throw std::invalid_argument("Length must be multiple of 8");
     }
 
     for (size_t i = 0; i < binaryStr.size(); i += 8) {
         std::string byteString = binaryStr.substr(i, 8);
         char c = static_cast<char>(std::stoi(byteString, nullptr, 2));
         asciiStr += c;
     }
 
     return asciiStr;
 }