MFC to QT conversion

Vote count:

0

I need to convert a class of MFC to QT. What I've done so far. I created a project in Visual Studio -> QT Console Application. But I'm still a bit lost on how to convert.

See my code:

#include <stdafx.h>
#include "afx.h"
#include <CARFile.h>
#include "AR_Parametros.h"



/************** STL ************/
#pragma warning(disable:4786)
#include <string>
#include <fstream>

using namespace std;
//******************************

/** * Abre arquivo em disco */

int CARFile::Abre_Leitura_Disco(string& a_NameOfFile){

        m_fileName.exceptions ( ifstream::eofbit | ifstream::failbit | ifstream::badbit );

        try {
        m_fileName.open(a_NameOfFile.c_str(), fstream::in | ios::binary );
        }
        catch (ifstream::failure ErrBit){

                string ErrMsg =  ErrBit.what();
                TRACE("\nTRACE > CARFile::Abre_Leitura_Disco(%s)\n\n", ErrMsg.c_str());
                return AROPENERR;
        }
        return ARSUCCESS;
}

/** * Abre arquivo em disco para gravação */

int CARFile::Abre_Gravacao_Disco(string& a_NameOfFile){

        try {
                m_fileNameWri.open (a_NameOfFile.c_str(), ofstream::out | ofstream::binary/*app*/);
        }
                catch (ofstream::failure ErrBit){

                string ErrMsg =  ErrBit.what();
                TRACE("\nTRACE > CARFile::Abre_Gravacao_Disco(%s)\n\n", ErrMsg.c_str());
                return AROPENERR;
        }      
        return ARSUCCESS;
}

/** * Abre arquivo em formato binario para ser armazenado */

int CARFile::Abre_Bin_Leitura_Disco(string& a_NameOfFile){
        m_fileName.exceptions ( fstream::eofbit | fstream::failbit | fstream::badbit );

        try {
        m_fileName.open(a_NameOfFile.c_str (), fstream::in |  fstream::binary);
        }
        catch (fstream::failure ErrBit){

                string ErrMsg =  ErrBit.what();
                TRACE("\nTRACE > CARFile::Abre_Bin_Leitura_Disco(%s)\n\n", ErrMsg.c_str());
                return AROPENERR;
        }
        return ARSUCCESS;
}

/** * Fecha arquivo de leitura em disco */

int CARFile::Fecha_Leitura_Disco(){

        if(m_fileName.is_open()){

                m_fileName.clear ();
                m_fileName.close ();
                return ARSUCCESS;
        }
        else{
                return ARCLOSERR;
        }
}

/** * Fecha o arquivo em disco após a recuperação de seus registros */

int CARFile::Fecha_Gravacao_Disco(){    // antes CloseOut

        if(m_fileNameWri.is_open()){

                m_fileNameWri.clear ();
                m_fileNameWri.close ();
                return ARSUCCESS;
        }
        else{
                return ARCLOSERR;
        }
}

/** * Armazena em disco pacotes de dados */

int CARFile::StoreDataPck( char * a_RegDataPacket, int a_sizeReg){

        try{

                m_fileNameWri.write (a_RegDataPacket,a_sizeReg);
        }
        catch (ofstream::failure ErrBit){
                        string ErrMsg =  ErrBit.what();
                        TRACE("\nTRACE > CARFile::StoreDataPck, Erro escrita de registro(%s)\n",ErrMsg.c_str());
                        return ARWRITERR;
        }
        return ARSUCCESS;
}

/** * Obter pacote de dados binários de arquivo em disco */

int CARFile::GetPacket(char * a_Packet, int a_size){

        try {
            m_fileName.read(a_Packet,a_size);
        }
        catch (fstream::failure ErrBit){
                string ErrMsg =  ErrBit.what();
                if(m_fileName.eof()){
                        TRACE("\nTRACE > CARFile::GetPacket FIM DO ARQUIVO Detectado\n\n");
                        return AREOF;
                }
                else{
                        TRACE("\nTRACE > CARFile::GetPacket(%s)\n\n", ErrMsg.c_str());

                return ARINVDATA;       // Falha na leitura do registro
                }
        }
        return ARSUCCESS;
}

/** * Armazena em um arquivo em disco um registro recuperado */

int CARFile::Store(string& a_LinhaReg){
        string pula="\n";
        try{

                m_fileNameWri.write (a_LinhaReg.c_str(),a_LinhaReg.size());
        }
        catch (ofstream::failure ErrBit){
                        string ErrMsg =  ErrBit.what();
                        TRACE("\nTRACE > CARFile::Store, Erro escrita de registro(%s)\n",ErrMsg.c_str());
                        return ARWRITERR;       //
        }
        m_fileNameWri.write (pula.c_str(),1);
        return ARSUCCESS;
}

/** * Verificar se final de arquivo foi atingido */

bool CARFile::eof()
{
        if(m_fileName.eof())
                return true;
        else
                return false;
}

/** * Ler uma linha de dados em um arquivo texto */

int CARFile::LerLinhaString(string& a_LinhaReg)
{
        try{
                getline(m_fileName,a_LinhaReg);
                return ARSUCCESS;
        }
        catch (ifstream::failure& e) {
                if (m_fileName.eof()){
                        TRACE("\nTRACE > CARFile::LerLinhaString EOF() detectado\n\n",e.what());
                        return AREOF;
                }
                else
                        return ARERRLEREG;
        }
}

/** * Construtor da classe CARFile */

CARFile::CARFile(){

}

/** * Destrutor da classe CARFile */

CARFile::~CARFile(){

}

asked 2 mins ago

David

57