BinaryReader.h

Go to the documentation of this file.

/*
 * Copyright (C) 2022 The V-Gears Team
 *
 * This file is part of V-Gears
 *
 * V-Gears is free software: you can redistribute it and/or modify it under
 * terms of the GNU General Public License as published by the Free Software
 * Foundation, version 3.0 (GPLv3) of the License.
 *
 * V-Gears is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 */
 
#pragma once
 
#include <fstream> 
#include <sstream>
#include <iterator>
 
#include "installer/decompiler/DecompilerException.h"
 
class BinaryReader{
 
    public:
 
        static std::vector<unsigned char> ReadAll(std::string file_name){
            std::ifstream file(file_name.c_str(), std::ios::binary | std::ios::ate);
            if (file.is_open()){
                size_t file_size_in_bytes = size_t(file.tellg());
                std::vector<unsigned char> file_contents(file_size_in_bytes);
                file.seekg(0, std::ios::beg);
                file.read(reinterpret_cast<char*>(file_contents.data()), file_contents.size());
                return file_contents;
            }
            else throw std::runtime_error("Can't open file");
        }
 
        BinaryReader(std::vector<unsigned char>&& data){
            size_ = data.size();
            std::copy(data.begin(), data.end(), std::ostream_iterator<unsigned char>(stream_));
            stream_.seekg(std::ios::beg);
        }
 
        size_t GetSize() const{return size_;}
 
        void Seek(unsigned int position){
            if (!stream_.seekg(position)) throw DecompilerException();
        }
 
        unsigned int GetPosition(){return static_cast<unsigned int>(stream_.tellg());}
 
        unsigned int ReadU32(){return InternalRead<unsigned int>();}
 
        signed int ReadS32(){return InternalRead<signed int>();}
 
        signed short int ReadS16(){return InternalRead<signed short int>();}
 
        unsigned short int ReadU16(){return InternalRead<unsigned short int>();}
 
        unsigned char ReadU8(){return InternalRead<unsigned char>();}
 
        signed char ReadS8(){return InternalRead<signed char>();}
 
    private:
 
        template<class T> T InternalRead(){
            T r = {};
            if (!stream_.read(reinterpret_cast<char*>(&r), sizeof(r)))
                throw DecompilerException();
            return r;
        }
 
        std::stringstream stream_;
 
        size_t size_ = 0;
};